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 __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 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 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_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 clear(self): """ Clears the canvas with the current color. Color can be chnages by - `set_color` - `set_color_rgb` """ sdl2.SDL_RenderClear(self.renderer)
def cls(self): ''' Очищает экран * @returns {self} ''' tmp = self.Draw['color'] self.setColor(255, 255, 255, 255) SDL.SDL_RenderClear(self.ctx) self.setColor(tmp) return self
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 fill(self, colour): self.type = "rect" if len(colour) == 3: colour = (colour[0] % 256, colour[1] % 256, colour[2] % 256, 255) elif len(colour) == 4: colour = (colour[0] % 256, colour[1] % 256, colour[2] % 256, colour[3] % 256) sdl2.SDL_SetRenderDrawColor(self.renderer, colour[0], colour[1], colour[2], colour[3]) sdl2.SDL_RenderClear(self.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 pulse_render(screen, scrno, data, colours=[(000, 000, 000, 255), (255, 255, 255, 255)]): ratio = sum([sum(data[0]), sum(data[1])]) / len(data[0]) / SCALE_DOWN def segratio(i): return int( min((colours[1][i] - colours[0][i]) * ratio + colours[0][i]), 255) colour = (segratio(0), segratio(1), segratio(2), segratio(3)) screen.setcolour(colour) sdl2.SDL_RenderClear(screen.sdlrenderer)
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 do_redraw(self): if self.renderer is None: return import sdl2 as sdl c = Color((100, 100, 100)) if self.style != None: c = Color(self.style.get("topbar_bg")) sdl.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 0) sdl.SDL_RenderClear(self.renderer) # Draw topbar background: topbar_actual_height = max( round(self.padding_vertical * self.dpi_scale) * 2, self.topbar_height) draw_rectangle(self.renderer, 0, 0, self._width, topbar_actual_height, color=c) # Draw topbar items: self.topbar_box.draw( self.topbar_box.x, self.topbar_box.y) # Draw border: c = Color((100, 100, 100)) if self.style != None: c = Color(self.style.get("border")) if self.style.has("topbar_border"): c = Color(self.style.get("topbar_border")) draw_rectangle(self.renderer, 0, topbar_actual_height, self._width, self.border_size, color=c) # Draw background of below-topbar area: c = Color((255, 255, 255)) if self.style != None: c = Color(self.style.get("window_bg")) draw_rectangle(self.renderer, 0, self.topbar_height + self.border_size, self._width, self._height - topbar_actual_height - self.border_size, color=c) # Draw below-topbar items: for child in self._children: child.draw(child.x, child.y)
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 clear_background(self, color=None): renderer = self._renderer sdl2.SDL_RenderClear(renderer) ret = 0 if color is None and self._bg_color is not None: ret = gfx.boxColor(renderer, 0, self.height, self.width, 0, self._bg_color) else: R, G, B, A = Color(color) ret = gfx.boxRGBA(renderer, 0, self.height, self.width, 0, R, G, B, A) if ret != 0: msg = sdl2.SDL_GetError() raise RuntimeError('SDL error: %s' % msg)
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 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 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 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 fill(self, colour): colour = (colour[0] % 256, colour[1] % 256, colour[2] % 256) sdl2.SDL_SetRenderDrawColor(self.renderer, colour[0], colour[1], colour[2], 255) sdl2.SDL_RenderClear(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()
# Instantiate Scenes gameScene = scene() gameScene.init_as_game(renderer) menuScene = scene() menuScene.init_as_menu(renderer) sceneList = [gameScene, menuScene] # Scene Indexes game_scene_index = 0 menu_scene_index = 1 current_scene_index = menu_scene_index sceneList[current_scene_index].Pause = False # Clear Screen to Black sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255) sdl2.SDL_RenderClear(renderer) # Main Game Loop while sceneList[current_scene_index].Running: # Process Events sceneList[current_scene_index].process_events() if sceneList[current_scene_index].RequestChange: sceneList[current_scene_index].RequestChange = False if current_scene_index == menu_scene_index: current_scene_index = game_scene_index sceneList[current_scene_index].init_as_game(None) else: current_scene_index = menu_scene_index # Render Graphics
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 post_tick(self): sdl2.SDL_RenderClear(self._sdlrenderer) self.write_memory() self.render_text() sdl2.SDL_RenderPresent(self._sdlrenderer)