def init(self, hide_window): self._ticks = sdl2.SDL_GetTicks() # Should be less... https://wiki.libsdl.org/SDL_Init sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) self._window = sdl2.SDL_CreateWindow(b"PyBoy", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self._scaledresolution[0], self._scaledresolution[1], sdl2.SDL_WINDOW_RESIZABLE) self._sdlrenderer = sdl2.SDL_CreateRenderer( self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) self._sdltexturebuffer = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, COLS, ROWS) self.blank_screen() if hide_window: sdl2.SDL_HideWindow(self._window) else: sdl2.SDL_ShowWindow(self._window)
def setup_colors(self): texture = sdl2.SDL_CreateTexture(self.renderer.sdlrenderer, sdl2.SDL_PIXELFORMAT_BGRA32, sdl2.SDL_TEXTUREACCESS_STREAMING, self.img_size[1], self.img_size[0]) pixel = np.zeros(self.img_size + (4, ), dtype=np.uint8) return texture, pixel, 4
def __init__(self, lcd, w, h, scale, title, pos=(sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED)): self.lcd = lcd self.width = w self.height = h self.mouse_hover_x = -1 self.mouse_hover_y = -1 self.mouse_x = -1 self.mouse_y = -1 self.scale = scale self.window = sdl2.SDL_CreateWindow(title, pos[0], pos[1], w * scale, h * scale, sdl2.SDL_WINDOW_RESIZABLE) self.buf, self.buf0, self.buf_p = make_buffer(w, h) self.sdlrenderer = sdl2.SDL_CreateRenderer( self.window, -1, sdl2.SDL_RENDERER_ACCELERATED) self.sdl_texture_buffer = sdl2.SDL_CreateTexture( self.sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, w, h) sdl2.SDL_ShowWindow(self.window)
def renderImage(image, blocks, ren): # create all the blocks ren_blocks = [] for block in blocks: ren_block = sdl2.SDL_CreateTexture(ren.sdlrenderer, sdl2.SDL_PIXELFORMAT_ABGR8888, sdl2.SDL_TEXTUREACCESS_STATIC, 8, 8) pixels = bytearray() for p in range(64): if block[p] == 1: pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) else: pixels.append(0) pixels.append(0) pixels.append(0) pixels.append(0) pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels) sdl2.SDL_UpdateTexture(ren_block, None, pointer, 8 * 4) ren_blocks.append(ren_block) # draw the image from the blocks for y in range(12): for x in range(16): texture = ren_blocks[image[y * 16 + x]] # texture=ren_blocks[0] sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 8, 8), sdl2.SDL_Rect(128 + x * 8, y * 8, 8, 8))
def __init__(self, display_scale: int = 10): self._display_scale = display_scale self._width = self._display_scale * Display._original_width self._height = self._display_scale * Display._original_height self._pixels = np.zeros(Display._original_width * Display._original_height, dtype=np.uint32) if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) < 0: raise sdl2.ext.SDLError() self._window = sdl2.SDL_CreateWindow(b'pychip8', sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self._width, self._height, sdl2.SDL_WINDOW_SHOWN) if not self._window: raise sdl2.ext.SDLError() self._renderer = sdl2.SDL_CreateRenderer(self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) if not self._renderer: raise sdl2.ext.SDLError() self._texture = sdl2.SDL_CreateTexture( self._renderer, sdl2.SDL_PIXELFORMAT_ARGB8888, sdl2.SDL_TEXTUREACCESS_STREAMING, Display._original_width, Display._original_height) if not self._texture: raise sdl2.ext.SDLError() sdl2.SDL_RenderClear(self._renderer) sdl2.SDL_RenderPresent(self._renderer)
def renderImage(image, ren): # create all the blocks frame = sdl2.SDL_CreateTexture(ren.sdlrenderer, sdl2.SDL_PIXELFORMAT_ABGR8888, sdl2.SDL_TEXTUREACCESS_STATIC, 64, 48) pixels = bytearray() col = image[0] # first value is whether black or not for val in image[2:]: for count in range(val + 1): if col: pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) else: pixels.append(0) pixels.append(0) pixels.append(0) pixels.append(0) col = not col pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels) sdl2.SDL_UpdateTexture(frame, None, pointer, 64 * 4) # draw the frame sdl2.SDL_RenderCopy(ren.sdlrenderer, frame, sdl2.SDL_Rect(0, 0, 64, 48), sdl2.SDL_Rect(128, 0, 128, 96)) sdl2.SDL_DestroyTexture(frame)
def render_object_from_color(cls, renderer: sdl2.SDL_Renderer, color: Color) -> RenderObject: texture = sdl2.SDL_CreateTexture(renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 1, 1) sdl2.SDL_SetRenderTarget(renderer, texture) sdl2.SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a) sdl2.SDL_RenderClear(renderer) sdl2.SDL_SetRenderTarget(renderer, None) return RenderObject(texture)
def setupWindow(self, width, height): self.window = sdl2.SDL_CreateWindow( "%s: %s" % (config.sdl_window_caption, self.clientName), sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, width, height, sdl2.SDL_WINDOW_SHOWN) self.renderer = sdl2.SDL_CreateRenderer( self.window, -1, sdl2.SDL_RENDERER_ACCELERATED) self.texture = sdl2.SDL_CreateTexture( self.renderer, sdl2.SDL_PIXELFORMAT_YV12, sdl2.SDL_TEXTUREACCESS_STREAMING, width, height)
def __init__(self, entities, timer): self.entities = entities self.timer = timer self.window = sdle.Window("Game", size=(self.WINDOW_X, self.WINDOW_Y)) self.renderer = sdle.Renderer(self.window, flags=sdl.SDL_RENDERER_ACCELERATED) self.texture = sdl.SDL_CreateTexture(self.renderer.renderer, sdl.SDL_PIXELFORMAT_ARGB8888, sdl.SDL_TEXTUREACCESS_STREAMING, self.WINDOW_X, self.WINDOW_Y) self.window.show()
def _save_pict(self, num): pict = self.picts.get(num) if not pict: pict = sdl2.SDL_CreateTexture(self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64) self.picts[num] = pict # render current texture to pict sdl2.SDL_SetRenderTarget(self.renderer, pict) sdl2.SDL_RenderCopy(self.renderer, self.texture_graph, None, None) sdl2.SDL_SetRenderTarget(self.renderer, None)
def _initialize_sdl2(self): sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) self.window = sdl2.SDL_CreateWindow( b'CASINT: CASIO Basic Interpreter', sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, 512, 256, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE) self.renderer = sdl2.SDL_CreateRenderer(self.window, -1, sdl2.SDL_RENDERER_ACCELERATED) sdl2.SDL_RenderSetLogicalSize(self.renderer, 128, 64) self.texture_graph = sdl2.SDL_CreateTexture( self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64) self.texture_text = sdl2.SDL_CreateTexture( self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64) # for scrolling the text screen self.texture_scroll = sdl2.SDL_CreateTexture( self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64) # init with a clear screen self._render_begin(self.texture_graph) self._clear_screen() self._render_end() self._render_begin(self.texture_text) self._clear_screen() self._render_end() self.font_graph, self.font_graph_inverted = self._load_texture( 'img/font_graph.bmp') self.font_text, self.font_text_inverted = self._load_texture( 'img/font_text.bmp')
def setup(self, fmt): if fmt.codec == VideoCodec.H264: pixel_fmt = sdl2.SDL_PIXELFORMAT_YV12 elif fmt.codec == VideoCodec.YUV: raise TypeError("YUV format not implemented") elif fmt.codec == VideoCodec.RGB: raise TypeError("RGB format not implemented") else: raise TypeError("Unknown video codec: %d" % fmt.codec) self._decoder = FrameDecoder.video(fmt.codec) self._texture = sdl2.SDL_CreateTexture( self._renderer.sdlrenderer, pixel_fmt, sdl2.SDL_TEXTUREACCESS_STREAMING, fmt.width, fmt.height)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.NCOLS = 60 self.NROWS = 36 self.shift_down = False self.start_address = 0x0000 self.bg_color = [0xFF, 0xFF, 0xFF] self.fg_color = [0x00, 0x00, 0x00] self._text_buffer_raw = array("B", [0x20] * (self.NROWS * self.NCOLS)) if cythonmode: self.text_buffer = memoryview(self._text_buffer_raw).cast( "B", shape=(self.NROWS, self.NCOLS)) else: view = memoryview(self._text_buffer_raw) self.text_buffer = [ view[i:i + self.NCOLS] for i in range(0, self.NROWS * self.NCOLS, self.NCOLS) ] # self.text_buffer = [bytearray([0x20]*self.NCOLS) for _ in range(self.NROWS)] self.write_border() self.write_addresses() font_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "font.txt") with open(font_path) as font_file: font_lines = font_file.readlines() font_blob = "".join( line.strip() for line in font_lines[font_lines.index("BASE64DATA:\n") + 1:]) font_bytes = zlib.decompress(b64decode(font_blob.encode())) self.fbuf, self.fbuf0, self.fbuf_p = make_buffer(8, 16 * 256) for y, b in enumerate(font_bytes): for x in range(8): self.fbuf0[y][x] = 0xFFFFFFFF if ((0x80 >> x) & b) else 0x00000000 self.font_texture = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, 8, 16 * 256) self._prepare_font_texture() # Persistent to make Cython happy... self.src = sdl2.SDL_Rect(0, 0, 8, 16) self.dst = sdl2.SDL_Rect(0, 0, 8, 16)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.NCOLS = 60 self.NROWS = 36 self.shift_down = False self.start_address = 0x0000 self.bg_color = [0xFF, 0xFF, 0xFF] self.fg_color = [0x00, 0x00, 0x00] self._text_buffer_raw = array("B", [0x20] * (self.NROWS * self.NCOLS)) if cythonmode: self.text_buffer = memoryview(self._text_buffer_raw).cast( "B", shape=(self.NROWS, self.NCOLS)) else: view = memoryview(self._text_buffer_raw) self.text_buffer = [ view[i:i + self.NCOLS] for i in range(0, self.NROWS * self.NCOLS, self.NCOLS) ] # self.text_buffer = [bytearray([0x20]*self.NCOLS) for _ in range(self.NROWS)] self.write_border() self.write_addresses() font_path = os.path.join("font", "ter-16b-ibm437.txt.gz") with gzip.open(font_path) as font_file: font_bytes = b"".join( bytes.fromhex(x.strip().decode()) for x in font_file.readlines()) self.fbuf, self.fbuf0, self.fbuf_p = make_buffer(8, 16 * 256) for y, b in enumerate(font_bytes): for x in range(8): self.fbuf0[y][x] = 0xFFFFFFFF if ((0x80 >> x) & b) else 0x00000000 self.font_texture = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, 8, 16 * 256) self._prepare_font_texture() # Persistent to make Cython happy... self.src = sdl2.SDL_Rect(0, 0, 8, 16) self.dst = sdl2.SDL_Rect(0, 0, 8, 16)
def __init__(self, pyboy, mb, pyboy_argv, *, scale, title, width, height, pos_x, pos_y): super().__init__(pyboy, mb, pyboy_argv) self.scale = scale self.width, self.height = width, height self.base_title = title self.hover_x = -1 self.hover_y = -1 self._window = sdl2.SDL_CreateWindow( self.base_title.encode("utf8"), pos_x, pos_y, width * scale, height * scale, sdl2.SDL_WINDOW_RESIZABLE ) self.window_id = sdl2.SDL_GetWindowID(self._window) self.buf, self.buf0, self.buf_p = make_buffer(width, height) self._sdlrenderer = sdl2.SDL_CreateRenderer(self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) self._sdltexturebuffer = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_STATIC, width, height )
def __init__(self, pyboy, mb, pyboy_argv): super().__init__(pyboy, mb, pyboy_argv) if not self.enabled(): return sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) self._ftime = 0.0 self._window = sdl2.SDL_CreateWindow( b"PyBoy", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self._scaledresolution[0], self._scaledresolution[1], sdl2.SDL_WINDOW_RESIZABLE ) self._sdlrenderer = sdl2.SDL_CreateRenderer(self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) self._sdltexturebuffer = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_STATIC, COLS, ROWS ) sdl2.SDL_ShowWindow(self._window)
def run_raw(): global renderer, bg_texture, maze, vmp, walls_texture sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.SDL_CreateWindow(b"Eye of the Beholder 2", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, 800, 600, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE) renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED + sdl2.SDL_RENDERER_TARGETTEXTURE + sdl2.SDL_RENDERER_PRESENTVSYNC) sdl2.SDL_SetRenderDrawBlendMode(renderer, sdl2.SDL_BLENDMODE_BLEND) render_target = sdl2.SDL_CreateTexture(renderer, sdl2.SDL_PIXELFORMAT_RGB888, sdl2.SDL_TEXTUREACCESS_TARGET, VP_WIDTH_PIXELS, VP_HEIGHT_PIXELS) sdl2.SDL_SetTextureBlendMode(render_target, sdl2.SDL_BLENDMODE_BLEND) sdl2.sdlimage.IMG_Init(sdl2.sdlimage.IMG_INIT_PNG) maze = load_maze('build/level1.maz') vmp = load_vmp('build/dung.vmp.json') bg_texture = get_vmp_bg_texture() walls_texture = get_vmp_wall_texture() party_position = (5, 28) party_direction = Direction.North running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == KEY_W: party_position = party_direction.update_pos(party_position) elif event.key.keysym.sym == KEY_S: party_position = party_direction.opposite().update_pos(party_position) elif event.key.keysym.sym == KEY_A: party_position = party_direction.previous_dir().update_pos(party_position) elif event.key.keysym.sym == KEY_D: party_position = party_direction.next_dir().update_pos(party_position) elif event.key.keysym.sym == KEY_Q: party_direction = party_direction.previous_dir() elif event.key.keysym.sym == KEY_E: party_direction = party_direction.next_dir() print(f'position: {party_position[0]}, {party_position[1]}, direction: {party_direction.symbol}') sdl2.SDL_SetRenderTarget(renderer, render_target) sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255) sdl2.SDL_RenderClear(renderer) draw_bg() draw_walls(party_position, party_direction) sdl2.SDL_SetRenderTarget(renderer, None) sdl2.SDL_RenderCopy(renderer, render_target, None, None) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
# select clear color sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255) # clear screen sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderPresent(renderer) # mode 1 if rendererYuv == True and streamInfo['pixelFormat'] == 'yuv420p': print('mode 1: fast yuv rendering...') useYuv = True # texture will change frequently so use streaming access yuvTexture = sdl2.SDL_CreateTexture( renderer, sdl2.SDL_PIXELFORMAT_YV12, sdl2.SDL_TEXTUREACCESS_STREAMING, size[0], size[1]) else: print('mode 2: basic rgb rendering (slow)...') # mode 2 m.addScaler(vstream, *size) else: print('mode 3: software rendering (very slow)...') # mode 3 m.addScaler(vstream, *size)
width, height = 640, 320 if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) < 0: raise sdl2.SDL_GetError() window = sdl2.SDL_CreateWindow(b'pychip8', sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, sdl2.SDL_WINDOW_SHOWN) if not window: raise sdl2.SDL_GetError() renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED) if not renderer: raise sdl2.SDL_GetError() #sdl2.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255) texture = sdl2.SDL_CreateTexture(renderer, sdl2.SDL_PIXELFORMAT_ARGB8888, sdl2.SDL_TEXTUREACCESS_STREAMING, 64, 32) if not texture: raise sdl2.ext.SDLError() sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderPresent(renderer) buf = np.zeros(64 * 32, dtype=np.uint32) #buf[:] = 0xFFFF0000 #sdl2.SDL_UpdateTexture( # texture, # None, # buf.ctypes.data_as(ctypes.c_void_p), # ctypes.c_int(4*64) #) c_p = ctypes.POINTER(ctypes.c_void_p) c_i = ctypes.POINTER(ctypes.c_int)
def __init__(self, perhiperal_type=Input.Type.JOYSTICK, verbosity=0, silent=False): self.atari = jigo2600.Atari2600() self.speed = 1 self.max_fps = 60. self.aspect = 1.8 self.paused = False self.done = False self.verbosity = verbosity self.cart_db = None self.cart_sha1 = None self.cart_meta = None self.peripheral_type = Input.Type.JOYSTICK self.switches_interface = SwitchesInterface() self.joysticks_interface = JoystickInterface() self.paddles_interface = PaddleInterface() self.input_stream = InputStream() self.has_sdl_audio = False self.has_sdl_gamecontroller = False self.has_sdl_joystick = False # Load the cartridge database. try: data = pkgutil.get_data('jigo2600', 'cartridges.json').decode("utf8") self.cart_db = json.loads(data) del data except FileNotFoundError: if self.verbosity > 0: print(f'Warning: could not open the cartridge metadata file') # Setup the graphics. frame = self.atari.get_current_frame() if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) sys.exit(-1) self.screen = sdl2.SDL_CreateWindow( b"Atari2600", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, int(frame.width * self.aspect * 2), int(frame.height * 2), sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE) if not self.screen: print(sdl2.SDL_GetError()) sys.exit(-1) self.renderer = sdl2.SDL_CreateRenderer(self.screen, -1, sdl2.SDL_RENDERER_PRESENTVSYNC) self.texture = sdl2.SDL_CreateTexture(self.renderer, sdl2.SDL_PIXELFORMAT_BGRA32, sdl2.SDL_TEXTUREACCESS_STREAMING, frame.width, frame.height) # Setup the audio. self.has_sdl_audio = not silent and (sdl2.SDL_InitSubSystem( sdl2.SDL_INIT_AUDIO) == 0) if self.has_sdl_audio: self.audio_spec = sdl2.SDL_AudioSpec( 44100, sdl2.AUDIO_U8, 1, 1024, sdl2.SDL_AudioCallback(self.play_audio)) self.audio_dev = sdl2.SDL_OpenAudioDevice(None, 0, self.audio_spec, self.audio_spec, 0) self.audio_buffer_rate = self.audio_spec.freq / self.audio_spec.samples assert self.audio_spec.channels == 1 # Setup the joysticks. self.has_sdl_joystick = (sdl2.SDL_InitSubSystem( sdl2.SDL_INIT_JOYSTICK) == 0) if self.has_sdl_joystick: sdl2.SDL_SetHint(sdl2.SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, b"1") sdl2.SDL_JoystickEventState(sdl2.SDL_ENABLE) # Setup the game controllers. self.has_sdl_gamecontroller = (sdl2.SDL_InitSubSystem( sdl2.SDL_INIT_GAMECONTROLLER) == 0) if self.has_sdl_gamecontroller: sdl2.SDL_GameControllerEventState(sdl2.SDL_ENABLE) data = pkgutil.get_data("jigo2600", "gamecontrollerdb.txt") rw = sdl2.SDL_RWFromConstMem(data, len(data)) n = sdl2.SDL_GameControllerAddMappingsFromRW(rw, False) if self.verbosity > 0: if n == -1: print( f"Warning: could not load the controller database file" ) else: print(f"Loaded {n} game controller mappings")