def main(): sdl2.sdl2_load(ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib' ttf_libpath = ctypes.util.find_library('SDL2_ttf'), img_libpath = ctypes.util.find_library('SDL2_image') ) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 640 WINDOW_H = 360 window = sdl2.SDL_CreateWindow(b"Minimal SDL_Image Test via python-sdl2", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) sdl2.IMG_Init(sdl2.IMG_INIT_JPG|sdl2.IMG_INIT_PNG|sdl2.IMG_INIT_TIF|sdl2.IMG_INIT_WEBP) rwops_ptr = sdl2.SDL_RWFromFile(bytes(sys.argv[1], 'utf-8'), b"rb") print("PNG?: %s" % ('true' if sdl2.IMG_isPNG(rwops_ptr) else 'false')) texture = sdl2.IMG_LoadTexture_RW(renderer, rwops_ptr, 1) wh = 300 pos = sdl2.SDL_Rect() pos.x = int((WINDOW_W - wh) / 2) pos.y = int((WINDOW_H - wh) / 2) pos.w = wh pos.h = wh sdl2.SDL_RenderCopy(renderer, texture, None, ctypes.byref(pos)) sdl2.SDL_RenderPresent(renderer) fpsdelay = 100 count = 0 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type event_timestamp = event.common.timestamp # print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) ) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF) sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderCopy(renderer, texture, None, ctypes.byref(pos)) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_Delay(fpsdelay) sdl2.IMG_Quit() sdl2.SDL_DestroyRenderer(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def render(self, components): global camera, stars # Draw stars tmp = self.renderer.color self.renderer.color = BLACK self.renderer.clear() self.renderer.color = BLUISH_GRAY star_coords = [] # stars is a global list of Star objects... for now. for s in stars: coords = camera.star_to_screen_space(s.direction) star_coords.extend(coords) self.renderer.draw_point(star_coords) self.renderer.color = tmp # Draw sprites r = sdl2.SDL_Rect(0, 0, 0, 0) rcopy = sdl2.SDL_RenderCopy renderer = self.sdlrenderer for sp in components: if sp.depth >= 0: r.x, r.y, r.w, r.h = -1, -1, 1, 1 else: r.w = int(max(2, (sp.size[0] / (-sp.depth / 15e9)))) r.h = int(max(2, sp.size[1] / (-sp.depth / 15e9))) r.x = sp.x - r.w // 2 r.y = sp.y - r.h // 2 if rcopy(renderer, sp.texture, None, r) == -1: raise SDLError() sdl2.SDL_RenderPresent(self.sdlrenderer)
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 run(): boxes = [Box(sdl2.SDL_Rect(0, int(1080 * 0.8 / 2) - 50, 100, 100))] last_tick = sdl2.SDL_GetTicks() while App.running: for box in boxes: box.update() for window in App.windows: renderer = window["renderer"] sdl2.SDL_SetRenderDrawColor(renderer, 30, 30, 30, 255) sdl2.SDL_RenderClear(renderer) for box in boxes: box.render() for window in App.windows: renderer = window["renderer"] sdl2.SDL_RenderPresent(renderer) Events.handle_events() current_tick = sdl2.SDL_GetTicks() last_tick = last_tick + App.FRAME_DURATION delay = last_tick - current_tick sdl2.SDL_Delay(int(max(0, delay)))
def run(self) -> None: e = sdl2.SDL_Event() while not self.context.quit: while sdl2.SDL_PollEvent(ctypes.byref(e)) != 0: if e.type == sdl2.SDL_QUIT: self.context.quit = True self.world.handle_event(e) self.world.handle_keyboard(sdl2.SDL_GetKeyboardState(None)) self.world.clean() self.world.process_physics() self.world.detect_collisions() self.world.animate() sdl2.SDL_SetRenderDrawColor(self.context.renderer, 0xff, 0xff, 0xff, 0xff) sdl2.SDL_RenderClear(self.context.renderer) self.world.render(self.world.frame.center, self.world.camera.global_position(), self.world.camera.frame.size) self.ui.render(self.ui.frame.center, Vector2D(), self.world.camera.originalSize) sdl2.SDL_RenderPresent(self.context.renderer) self.exit()
def draw(self, data): for screen in self.screens: screen.setcolour(self.bg) sdl2.SDL_RenderClear(screen.sdlrenderer) # pulse_render(screen, len(self.screens), data) updown_render(screen, len(self.screens), data) # oscillo_render(screen, len(self.screens), data) sdl2.SDL_RenderPresent(screen.renderer.sdlrenderer)
def repaint(self): ''' Производит отрисовку на экран ранее произведенных действий * В стандартной реализации ничего не делает * @returns {self} ''' SDL.SDL_RenderPresent(self.ctx) return self
def render_frame(self, pixels): sdl2.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, sdl2.SDL_ALPHA_OPAQUE) sdl2.SDL_RenderClear(self.renderer) for x, y, colour in pixels: self.render_pixel(x, y, colour) # show current frame sdl2.SDL_RenderPresent(self.renderer)
def RenderAll(self, world, render_dt): sdl2.SDL_RenderClear(self.sdl_renderer) self.RenderRoom(world) self.RenderDebug(world, render_dt) self.RenderEntities(world) sdl2.SDL_RenderPresent(self.sdl_renderer)
def update_pixel_grid(self, pixel_buffer: np.array): """Updates graphical output to show the current game state. """ self._pixels[:] = pixel_buffer[:] * 0xFF00FF00 sdl2.SDL_UpdateTexture(self._texture, None, self._pixels.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(4 * Display._original_width)) sdl2.SDL_RenderClear(self._renderer) sdl2.SDL_RenderCopy(self._renderer, self._texture, None, None) sdl2.SDL_RenderPresent(self._renderer)
def _refresh(self): """ Draws the entire GUI when it needs to be updated """ # Clear with white sdl2.SDL_SetRenderDrawColor(self.renderer, 255, 255, 255, 255) sdl2.SDL_RenderClear(self.renderer) # TODO # For each element of the layout, call its draw method for el in self.layout_elements: el.draw(self.renderer) # Render to the screen sdl2.SDL_RenderPresent(self.renderer)
def render(self, force=False): if not self.needs_render and not force: return # Set this up front, so that the act of rendering can request another render. self.needs_render = False sdl2.SDL_SetRenderDrawColor(self.renderer, *self.background, sdl2.SDL_ALPHA_OPAQUE) sdl2.SDL_RenderClear(self.renderer) self.view.render(self.renderer) focus_view = self.view.resolve(self.focus) if focus_view and focus_view.draws_focus: focus_rect = focus_view.frame + Insets(focus_view.env.scaled(1)) self.view.env.draw(self.renderer, "focus", focus_rect) if self.menu: self.menu.render(self.renderer) sdl2.SDL_RenderPresent(self.renderer)
def render(self, data): renderer = self._renderer.sdlrenderer try: for frame in self._decoder.decode(data): self._lock.acquire() intp = POINTER(c_ubyte) sdl2.SDL_UpdateYUVTexture( self._texture, None, cast(frame.planes[0].buffer_ptr, intp), frame.planes[0].line_size, cast(frame.planes[1].buffer_ptr, intp), frame.planes[1].line_size, cast(frame.planes[2].buffer_ptr, intp), frame.planes[2].line_size, ) self._lock.release() sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderCopy(renderer, self._texture, None, None) sdl2.SDL_RenderPresent(renderer) except Exception as e: log.debug('SDLVideoRenderer.render: {0}'.format(e))
def draw( self, waveform: list, colors: tuple # background and foreground colors ): # Compute a Fourier Transform on the Waveform to # divide the sound into several "bins". To # visualise them as points on the render window. self.fft_spectrum = fft_abs(fft(waveform))[:self.fft_bins] x = 0 # reset the coordinate on each call for idx, bin in enumerate(self.fft_spectrum): self.data_points.contents[idx] = sdl2.SDL_Point( round(x), int(maprange(bin, 0, NP_FFT_MAXVAL, 0, self.viewport['width']))) x += self.bar_width # Clear the canvas with our selected colour. # What it does is repaints the screen # the previous frame is overlapped by it. sdl2.SDL_SetRenderDrawColor(self.renderer, colors[0][0], colors[0][1], colors[0][2], colors[0][3]) sdl2.SDL_RenderClear(self.renderer) # Draw the visualization using connected paths which # are stroked. When percepted they represent themeselves # as "lines". sdl2.SDL_SetRenderDrawColor(self.renderer, colors[1][0], colors[1][1], colors[1][2], colors[1][3]) sdl2.SDL_RenderDrawLines(self.renderer, self.data_points.contents, self.fft_bins) # Display the contents on the screen which # was rendered off-screen. sdl2.SDL_RenderPresent(self.renderer) # Look for the event when the user closes # the render window. sdl2.SDL_PollEvent(self.event) if self.event.type == sdl2.SDL_QUIT: self.close() return True
def run(self): self.running.set() stime = now() last_update = now() target_fps = self.target_fps / 2. # todo: hu, why do we need / 2 here ? target_delay = 1 / float(target_fps) i = 0 while self.running.is_set(): events = sdl2.ext.get_events() for event in events: self.handle_event(event) if event.type == sdl2.SDL_QUIT: self.running.clear() break current = now() elapsed = current - last_update last_update = current if self._need_update: i += 1 if i >= target_fps * 2: self.i += i elapsed2 = current - stime self.fps = float(i) / elapsed2 i = 0 stime = current with self._lock: #sdl2.SDL_RenderClear(self.renderer.sdlrenderer) sdl2.SDL_UpdateTexture( self.texture, None, self._pixel.ctypes.data, self.img_size[1] * self._bytes_per_pix) sdl2.SDL_RenderCopy(self.renderer.sdlrenderer, self.texture, None, None) sdl2.SDL_RenderPresent(self.renderer.sdlrenderer) self._pix_written.set() # TODO: if ... self._need_update = False self.i += 1 if target_delay > elapsed: #print("Times", target_delay, elapsed, int((target_delay - elapsed) * 1000)) #print("%.2f" % (i / (current - stime))) sdl2.SDL_Delay(int((target_delay - elapsed) * 1000))
def render(self, data): renderer = self._renderer.sdlrenderer try: for frame in self._decoder.decode(data): frame = frame.reformat(width=1920, height=1080, format='yuv420p') # self._lock.acquire() intp = POINTER(c_ubyte) sdl2.SDL_UpdateYUVTexture( self._texture, None, cast(frame.planes[0].buffer_ptr, intp), frame.planes[0].line_size, cast(frame.planes[1].buffer_ptr, intp), frame.planes[1].line_size, cast(frame.planes[2].buffer_ptr, intp), frame.planes[2].line_size, ) # self._lock.release() sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderCopy(renderer, self._texture, None, None) sdl2.SDL_RenderPresent(renderer) except Exception as e: log.debug('SDLVideoRenderer.render: {0}'.format(e)) traceback.print_exc()
def run(): db.connect() db.create_tables([Rom, System, Asset], safe=True) window = sdl2.SDL_CreateWindow(b"Nostalgo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 1280, 720, sdl2.SDL_WINDOW_SHOWN) renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC) sdl2.SDL_SetRenderDrawBlendMode(renderer, sdl2.SDL_BLENDMODE_BLEND) currentState = CurrentState(window=window, db=db) backdrop = Backdrop(currentState) gameList = GameList(currentState) running = True while running: events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym in [sdl2.SDLK_RETURN]: EmulatorRunner(currentState.getCurrentSystem(), currentState.getCurrentRom()).run() elif event.key.keysym.sym in [sdl2.SDLK_RIGHT, sdl2.SDLK_n]: currentState.incrementSystem() elif event.key.keysym.sym in [sdl2.SDLK_LEFT, sdl2.SDLK_p]: currentState.decrementSystem() elif event.key.keysym.sym in [sdl2.SDLK_UP, sdl2.SDLK_k]: currentState.decrementRom() elif event.key.keysym.sym in [sdl2.SDLK_DOWN, sdl2.SDLK_j]: currentState.incrementRom() elif event.key.keysym.sym in [sdl2.SDLK_ESCAPE, sdl2.SDLK_q]: running = False break sdl2.SDL_Delay(20) sdl2.SDL_RenderClear(renderer) backdrop.render(renderer) gameList.render(renderer) sdl2.SDL_RenderPresent(renderer)
def main(): sdl2.sdl2_load( ctypes.util.find_library('SDL2')) # '/usr/local/lib/libSDL2.dylib' sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) WINDOW_W = 640 WINDOW_H = 360 window = sdl2.SDL_CreateWindow( b"RenderDrawPoint/RenderDrawLine/RenderFillRect", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type event_timestamp = event.common.timestamp print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp)) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF) sdl2.SDL_RenderClear(renderer) draw_points(renderer) draw_lines(renderer) draw_rects(renderer) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_Quit()
def render(self, balls, paddles, score): offset = self.offset for screen in self.screens: # Clear the screen with the background colour screen.renderer.color = sdl2.ext.Color(self.bg[0], self.bg[1], self.bg[2], 255) sdl2.SDL_RenderClear(screen.renderer.sdlrenderer) # Set a muted foreground colour for drawing the score screen.renderer.color = sdl2.ext.Color(self.fg[0] / 3, self.fg[1] / 3, self.fg[2] / 3, 255) self.draw_score(screen, score) # Set the foreground colour for drawing screen.renderer.color = sdl2.ext.Color(self.fg[0], self.fg[1], self.fg[2], 255) # Draw the elements for ball in balls: self.draw_ball(screen, offset, ball) for paddle in paddles: self.draw_paddle(screen, offset, paddle) # Display this screen sdl2.SDL_RenderPresent(screen.renderer.sdlrenderer) # Increase the rendering offset offset += float(screen.width) / float(screen.height)
def draw(renderer, window_size): sdl2.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255) sdl2.SDL_RenderClear(renderer) a_base = min(window_size) a = A_COEFF_RELATION * a_base for part in PARTS: points_set = set() c_r, c_g, c_b, c_a = part[2] sdl2.SDL_SetRenderDrawColor(renderer, c_r, c_g, c_b, c_a) t = part[0] while t < part[1]: x = a * cos(t) * (1 + cos(t)) + window_size[0] / 2 - a y = a * sin(t) * (1 + cos(t)) + window_size[1] / 2 points_set.add((trunc(x), trunc(y))) t += STEP points_count = len(points_set) points_list = [sdl2.SDL_Point(p[0], p[1]) for p in points_set] points_array = (sdl2.SDL_Point * points_count)(*points_list) sdl2.SDL_RenderDrawPoints(renderer, points_array, points_count) sdl2.SDL_RenderPresent(renderer)
def run(): out_blocks = "" out_images = "" all_blocks = [] sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING) sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG) window = sdl2.ext.Window("BAConv", size=(1024, 384)) window.show() ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED) # makes zoomed graphics blocky (for retro effect) sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest") # makes the graphics look and act like the desired screen size, even though they may be rendered at a different one sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96) frames = [] count = 0 limit = 8000 # only deal with this many frames pass1 = True # True means calculate blocks, False means load from pre-calculated file if pass1: # pass 1 - gather all the blocks for i in range(0, int(6565 / 4)): # for i in range(43, int(600 / 4)): count += 1 if count > limit: # stop early break events = sdl2.ext.get_events() # otherwise window doesn't update for event in events: if event.type == sdl2.SDL_QUIT: exit(0) ren.clear() file = f"image-{i*4+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) frame = processImage( file, ren) # also draws left hand side pre-processed frames.append(frame) renderImage(frame, ren) # right hand side post-process sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh() print(f"Processed {count} frames.") values = 0 size = 0 for frame in frames: values += len(frame) size += frame[1] * (len(frame) - 2) + 1 print(frame) print(f"Raw values: {values}") print(f"Average values per frame: {values/len(frames)}") print(f"Theoretical size: {size/8}") exit(0) # store blocks in file file_lines = [] for block in all_blocks: file_lines.append(block.serialize()) with open("data_file.txt", "w") as write_file: write_file.writelines("\n".join(file_lines)) else: # read in blocks from file (quicker) with open("data_file.txt", "r") as read_file: file_lines = read_file.readlines() all_blocks = [] for line in file_lines: all_blocks.append(Block.fromData(line.split(","))) # sort and choose top blocks all_blocks.sort(reverse=True) # 1024 is currently all you're planning to store # todo: choose final number of blocks to use # all_blocks=all_blocks[0:1024] for i, b in enumerate(all_blocks): print(f"Block {i}: {b.count}") # pass 2 - build new images with top blocks all_images = [] count = 0 # for i in range(43, int(6509 / 4)): for i in range(0, int(6565 / 4)): # for i in range(43, int(600 / 4)): count += 1 if count > limit: # stop early break ren.clear() file = f"image-{i*4+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) image = reprocessImage( file, ren, all_blocks) # also draws left hand side pre-processed all_images.append(image) renderImage(image, all_blocks, ren) # right hand side post-process events = sdl2.ext.get_events() # otherwise window doesn't update sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh() # play back final frames in loop fr = 0 while True: fr = (fr + 1) % len(all_images) events = sdl2.ext.get_events() # otherwise window doesn't update for event in events: if event.type == sdl2.SDL_QUIT: exit(0) ren.clear() file = f"image-{i*2+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) renderImage(all_images[fr], all_blocks, ren) sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh()
def update(self): sdl2.SDL_RenderPresent(self.renderer)
def clear(self): sdl2.SDL_SetRenderDrawColor(self._renderer, 0, 0, 0, sdl2.SDL_ALPHA_OPAQUE) sdl2.SDL_RenderClear(self._renderer) sdl2.SDL_RenderPresent(self._renderer)
def main(): parser = argparse.ArgumentParser( description='PySDL2 / cefpython example', add_help=True ) parser.add_argument( '-v', '--verbose', help='Turn on debug info', dest='verbose', action='store_true' ) parser.add_argument( '-r', '--renderer', help='Specify hardware or software rendering', default='software', dest='renderer', choices=['software', 'hardware'] ) args = parser.parse_args() logLevel = logging.INFO if args.verbose: logLevel = logging.DEBUG logging.basicConfig( format='[%(filename)s %(levelname)s]: %(message)s', level=logLevel ) logging.info("Using PySDL2 %s" % sdl2.__version__) version = sdl2.SDL_version() sdl2.SDL_GetVersion(version) logging.info( "Using SDL2 %s.%s.%s" % (version.major, version.minor, version.patch) ) # The following variables control the dimensions of the window # and browser display area width = 800 height = 600 # headerHeight is useful for leaving space for controls # at the top of the window (future implementation?) headerHeight = 0 browserHeight = height - headerHeight browserWidth = width # Mouse wheel fudge to enhance scrolling scrollEnhance = 40 # desired frame rate frameRate = 100 # Initialise CEF for offscreen rendering sys.excepthook = cef.ExceptHook switches = { # Tweaking OSR performance by setting the same Chromium flags # as in upstream cefclient (Issue #240). "disable-surfaces": "", "disable-gpu": "", "disable-gpu-compositing": "", "enable-begin-frame-scheduling": "", } browser_settings = { # Tweaking OSR performance (Issue #240) "windowless_frame_rate": frameRate } cef.Initialize(settings={"windowless_rendering_enabled": True}, switches=switches) logging.debug("cef initialised") window_info = cef.WindowInfo() window_info.SetAsOffscreen(0) # Initialise SDL2 for video (add other init constants if you # require other SDL2 functionality e.g. mixer, # TTF, joystick etc. sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) logging.debug("SDL2 initialised") # Create the window window = sdl2.video.SDL_CreateWindow( 'cefpython3 SDL2 Demo', sdl2.video.SDL_WINDOWPOS_UNDEFINED, sdl2.video.SDL_WINDOWPOS_UNDEFINED, width, height, 0 ) # Define default background colour (black in this case) backgroundColour = sdl2.SDL_Color(0, 0, 0) renderer = None if args.renderer == 'hardware': # Create the renderer using hardware acceleration logging.info("Using hardware rendering") renderer = sdl2.SDL_CreateRenderer( window, -1, sdl2.render.SDL_RENDERER_ACCELERATED ) else: # Create the renderer using software acceleration logging.info("Using software rendering") renderer = sdl2.SDL_CreateRenderer( window, -1, sdl2.render.SDL_RENDERER_SOFTWARE ) # Set-up the RenderHandler, passing in the SDL2 renderer renderHandler = RenderHandler(renderer, width, height - headerHeight) # Create the browser instance browser = cef.CreateBrowserSync(window_info, url="https://www.google.com/", settings=browser_settings) browser.SetClientHandler(LoadHandler()) browser.SetClientHandler(renderHandler) # Must call WasResized at least once to let know CEF that # viewport size is available and that OnPaint may be called. browser.SendFocusEvent(True) browser.WasResized() # Begin the main rendering loop running = True # FPS debug variables frames = 0 logging.debug("beginning rendering loop") resetFpsTime = True fpsTime = 0 while running: # record when we started drawing this frame startTime = sdl2.timer.SDL_GetTicks() if resetFpsTime: fpsTime = sdl2.timer.SDL_GetTicks() resetFpsTime = False # Convert SDL2 events into CEF events (where appropriate) events = sdl2.ext.get_events() for event in events: if (event.type == sdl2.SDL_QUIT or (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE)): running = False logging.debug("SDL2 QUIT event") break if event.type == sdl2.SDL_MOUSEBUTTONDOWN: if event.button.button == sdl2.SDL_BUTTON_LEFT: if event.button.y > headerHeight: logging.debug( "SDL2 MOUSEBUTTONDOWN event (left button)" ) # Mouse click triggered in browser region browser.SendMouseClickEvent( event.button.x, event.button.y - headerHeight, cef.MOUSEBUTTON_LEFT, False, 1 ) elif event.type == sdl2.SDL_MOUSEBUTTONUP: if event.button.button == sdl2.SDL_BUTTON_LEFT: if event.button.y > headerHeight: logging.debug("SDL2 MOUSEBUTTONUP event (left button)") # Mouse click triggered in browser region browser.SendMouseClickEvent( event.button.x, event.button.y - headerHeight, cef.MOUSEBUTTON_LEFT, True, 1 ) elif event.type == sdl2.SDL_MOUSEMOTION: if event.motion.y > headerHeight: # Mouse move triggered in browser region browser.SendMouseMoveEvent(event.motion.x, event.motion.y - headerHeight, False) elif event.type == sdl2.SDL_MOUSEWHEEL: logging.debug("SDL2 MOUSEWHEEL event") # Mouse wheel event x = event.wheel.x if x < 0: x -= scrollEnhance else: x += scrollEnhance y = event.wheel.y if y < 0: y -= scrollEnhance else: y += scrollEnhance browser.SendMouseWheelEvent(0, 0, x, y) elif event.type == sdl2.SDL_TEXTINPUT: # Handle text events to get actual characters typed rather # than the key pressed. logging.debug("SDL2 TEXTINPUT event: %s" % event.text.text) keycode = ord(event.text.text) key_event = { "type": cef.KEYEVENT_CHAR, "windows_key_code": keycode, "character": keycode, "unmodified_character": keycode, "modifiers": cef.EVENTFLAG_NONE } browser.SendKeyEvent(key_event) key_event = { "type": cef.KEYEVENT_KEYUP, "windows_key_code": keycode, "character": keycode, "unmodified_character": keycode, "modifiers": cef.EVENTFLAG_NONE } browser.SendKeyEvent(key_event) elif event.type == sdl2.SDL_KEYDOWN: # Handle key down events for non-text keys logging.debug("SDL2 KEYDOWN event") if event.key.keysym.sym == sdl2.SDLK_RETURN: keycode = event.key.keysym.sym key_event = { "type": cef.KEYEVENT_CHAR, "windows_key_code": keycode, "character": keycode, "unmodified_character": keycode, "modifiers": cef.EVENTFLAG_NONE } browser.SendKeyEvent(key_event) elif event.key.keysym.sym in [ sdl2.SDLK_BACKSPACE, sdl2.SDLK_DELETE, sdl2.SDLK_LEFT, sdl2.SDLK_RIGHT, sdl2.SDLK_UP, sdl2.SDLK_DOWN, sdl2.SDLK_HOME, sdl2.SDLK_END ]: keycode = get_key_code(event.key.keysym.sym) if keycode is not None: key_event = { "type": cef.KEYEVENT_RAWKEYDOWN, "windows_key_code": keycode, "character": keycode, "unmodified_character": keycode, "modifiers": cef.EVENTFLAG_NONE } browser.SendKeyEvent(key_event) elif event.type == sdl2.SDL_KEYUP: # Handle key up events for non-text keys logging.debug("SDL2 KEYUP event") if event.key.keysym.sym in [ sdl2.SDLK_RETURN, sdl2.SDLK_BACKSPACE, sdl2.SDLK_DELETE, sdl2.SDLK_LEFT, sdl2.SDLK_RIGHT, sdl2.SDLK_UP, sdl2.SDLK_DOWN, sdl2.SDLK_HOME, sdl2.SDLK_END ]: keycode = get_key_code(event.key.keysym.sym) if keycode is not None: key_event = { "type": cef.KEYEVENT_KEYUP, "windows_key_code": keycode, "character": keycode, "unmodified_character": keycode, "modifiers": cef.EVENTFLAG_NONE } browser.SendKeyEvent(key_event) # Clear the renderer sdl2.SDL_SetRenderDrawColor( renderer, backgroundColour.r, backgroundColour.g, backgroundColour.b, 255 ) sdl2.SDL_RenderClear(renderer) # Tell CEF to update which will trigger the OnPaint # method of the RenderHandler instance cef.MessageLoopWork() # Update display sdl2.SDL_RenderCopy( renderer, renderHandler.texture, None, sdl2.SDL_Rect(0, headerHeight, browserWidth, browserHeight) ) sdl2.SDL_RenderPresent(renderer) # FPS debug code frames += 1 if sdl2.timer.SDL_GetTicks() - fpsTime > 1000: logging.debug("FPS: %d" % frames) frames = 0 resetFpsTime = True # regulate frame rate if sdl2.timer.SDL_GetTicks() - startTime < 1000.0 / frameRate: sdl2.timer.SDL_Delay( (1000 / frameRate) - (sdl2.timer.SDL_GetTicks() - startTime) ) # User exited exit_app()
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
def VSync(self): sdl2.SDL_RenderPresent(self.renderer)
def main(): sdl2.sdl2_load( ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib' ttf_libpath=ctypes.util.find_library('SDL2_ttf')) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 640 WINDOW_H = 360 window = sdl2.SDL_CreateWindow(b"Minimal SDL_TTF Test via python-sdl2", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) rect = sdl2.SDL_Rect() rect.x = 0 rect.y = 0 rect.w = WINDOW_W rect.h = WINDOW_H sdl2.TTF_Init() rwops_ptr = sdl2.SDL_RWFromFile( bytes(sys.argv[1], 'utf-8'), b"rb" ) # rwops = ctypes.cast(rwops_ptr, ctypes.POINTER(sdl2.SDL_RWops)).contents font = sdl2.TTF_OpenFontRW(rwops_ptr, 0, 42) fg = sdl2.SDL_Color() fg.r = 96 fg.g = 96 fg.b = 96 fg.a = 255 bg = sdl2.SDL_Color() bg.r = 0xE0 bg.g = 0xE0 bg.b = 0xE0 bg.a = 255 pos = [ sdl2.SDL_Rect(), sdl2.SDL_Rect(), ] pos[0].x = 20 pos[0].y = 120 pos[0].w = 600 pos[0].h = 60 pos[1].x = 20 pos[1].y = 180 pos[1].w = 600 pos[1].h = 60 surfaces = [ sdl2.TTF_RenderUTF8_Shaded(font, bytes("志於道、據於徳、依於仁、游於藝", 'utf-8'), fg, bg), sdl2.TTF_RenderUTF8_Shaded(font, bytes("SCORE 123456780", 'utf-8'), fg, bg), ] texture = [ sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[0]), sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[1]), ] sdl2.SDL_SetRenderDrawColor(renderer, bg.r, bg.g, bg.b, bg.a) sdl2.SDL_RenderFillRect(renderer, ctypes.byref(rect)) sdl2.SDL_RenderCopy(renderer, texture[0], None, ctypes.byref(pos[0])) sdl2.SDL_RenderCopy(renderer, texture[1], None, ctypes.byref(pos[1])) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_FreeSurface(surfaces[0]) sdl2.SDL_FreeSurface(surfaces[1]) fpsdelay = 100 count = 0 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type event_timestamp = event.common.timestamp # print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) ) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True sdl2.SDL_Delay(fpsdelay) sdl2.TTF_Quit() sdl2.SDL_DestroyRenderer(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def resize(self): self._clear_draw_field() InscribedShapes(self).draw() sdl2.SDL_RenderPresent(self.sdl_renderer)
# 3 rendering modes: # mode 1: useYuv + useTexture == True # -> upload yuv data to graphic card + hardware scaling # mode 2: useTexture == True, useYuv == False # -> yuv to rgb in software, upload rgb to graphic card + hardware scaling # mode 3: useTexture + useYuv == False # -> uyv to rgb + scaling in software # note: in this example, we don't perform scaling if useTexture == True: # 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)...')
def post_tick(self): sdl2.SDL_RenderClear(self._sdlrenderer) self.write_memory() self.render_text() sdl2.SDL_RenderPresent(self._sdlrenderer)