def process_events(self): if self.type == "game": while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0: if self.event.type == sdl2.SDL_QUIT: self.Running = False break if self.event.type == sdl2.SDL_KEYDOWN: if self.event.key.keysym.sym == sdl2.SDLK_SPACE: if not self.player.is_alive(): self.player.start() pass self.player.flap() if self.event.key.keysym.sym == sdl2.SDLK_ESCAPE: self.init_as_game(None) self.RequestChange = True pass pass elif self.type == "menu": while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0: if self.event.type == sdl2.SDL_QUIT: self.Running = False break if self.event.type == sdl2.SDL_KEYDOWN: if self.event.key.keysym.sym == sdl2.SDLK_SPACE: self.RequestChange = True pass pass
def run(self, screen, draw_func, update_func, fps=DEFAULT_FPS): self._screen = screen self._running = True self._fps = fps self._frame_time_ms = 1000 / fps event = sdl2.SDL_Event() time_accumulator_ms = 0 old_time = sdl2.SDL_GetPerformanceCounter() timer_resolution = sdl2.SDL_GetPerformanceFrequency() / 1000 # ms while self._running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: self._running = False # Adjust the loop speed based on the time passed current_time = sdl2.SDL_GetPerformanceCounter() delta_time_ms = (current_time - old_time) / timer_resolution time_accumulator_ms += delta_time_ms while time_accumulator_ms > self._frame_time_ms: update_func(delta_time_ms) time_accumulator_ms -= self._frame_time_ms old_time = current_time # Update the screen screen.begin_update() draw_func(screen) screen.end_update() self.stop()
def main(): window_size = (DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT) sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.SDL_CreateWindow( b"Lab 1 - Cardioid", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, window_size[0], window_size[1], sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE) # CREATE !!! renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED) running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED: new_width = event.window.data1 new_height = event.window.data2 print("Window {} resized to {}x{}".format( event.window.windowID, new_width, new_height)) window_size = (new_width, new_height) draw(renderer, window_size) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def refresh(self): event = sdl2.SDL_Event() self.update_data(self.lidar.get_image()) while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: self.running = False break elif event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: self.running = False elif event.key.keysym.sym == sdl2.SDLK_1: self.mode = RAW elif event.key.keysym.sym == sdl2.SDLK_2: self.mode = POLAR elif event.key.keysym.sym == sdl2.SDLK_3: self.mode = EUCLID_3D elif event.key.keysym.sym == sdl2.SDLK_4: self.mode = PRETTY_POLAR elif event.key.keysym.sym == sdl2.SDLK_5: self.mode = PRETTY_3D if self.mode == RAW: self.draw_raw() elif self.mode == POLAR: self.draw_polar() elif self.mode == EUCLID_3D: self.draw_3D() elif self.mode == PRETTY_POLAR: self.draw_pretty_polar() elif self.mode == PRETTY_3D: self.draw_pretty_3D() self.window.refresh()
def loop(window, renderer, inputfoo, renderfoo, choke_ms = 100): while True: loopstart = sdl2.SDL_GetTicks() while True: event = sdl2.SDL_Event() rv = sdl2.SDL_PollEvent(ctypes.byref(event)) if rv == 0: break elif event.type == sdl2.SDL_QUIT: return elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: if inputfoo(): return elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED: sz = Size2(event.window.data1, event.window.data2) sdl2.SDL_GetWindowSize(window, ctypes.byref(w_w), ctypes.byref(w_h)) elif sdl2.SDL_WINDOWEVENT_CLOSE: inputfoo() else: continue print(event.window.event) elif event.type == sdl2.SDL_MOUSEBUTTONDOWN: inputfoo() elapsed = sdl2.SDL_GetTicks() - loopstart if choke_ms > elapsed: sdl2.SDL_Delay(choke_ms - elapsed) renderfoo(window, renderer)
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 main(): sdl2.sdl2_load( ctypes.util.find_library('SDL2')) # '/usr/local/lib/libSDL2.dylib' sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 320 WINDOW_H = 240 window = sdl2.SDL_CreateWindow(b"1st SDL Window via Python-SDL2", 0, 0, WINDOW_W, WINDOW_H, 0) 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: print("\tSPACE key pressed.") count += 1 if count >= 100: done = True sdl2.SDL_Delay(fpsdelay) sdl2.SDL_Quit()
def _mainLoop(self): # Main loop running = True event = sdl2.SDL_Event() logging.info('SDL2 Main Loop: Executing.') #sdl2.SDL_ShowWindow(self.vulkan_window) while running: # Poll sdl2 window for currently pending events. while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: logging.info('Leaving SDL2 Main Loop: sdl2.SDL_QUIT.') running = False break if event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED: newWidth, newHeight = self.vulkan_window.getWindowSize() self.vulkan_base._recreateSwapChain() break # Renderer: Present Vulkan images onto sdl2 window. self.vulkan_base._drawFrame() vkDeviceWaitIdle( self.vulkan_base.logical_device ) logging.info('Checked all outstanding queue operations for all' ' queues in Logical Device have ceased.') return 0
def run(): sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.SDL_CreateWindow(b"Hello World", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, 592, 460, sdl2.SDL_WINDOW_SHOWN) fname = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources", "hello.bmp") image = sdl2.SDL_LoadBMP(fname.encode("utf-8")) windowsurface = sdl2.SDL_GetWindowSurface(window) sdl2.SDL_BlitSurface(image, None, windowsurface, None) sdl2.SDL_UpdateWindowSurface(window) sdl2.SDL_FreeSurface(image) running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break sdl2.SDL_Delay(10) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def main(): sdl2.sdl2_load(ctypes.util.find_library('SDL2')) # '/usr/local/lib/libSDL2.dylib' sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) 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 count += 1 if count >= 100: done = True sdl2.SDL_Delay(fpsdelay) sdl2.SDL_Quit()
def run(small=False): """SDL2 back end.""" target_board = board.Board(192, 32) # initialise renderer if small: target_renderer = renderer.SdlRendererActualSize() else: target_renderer = renderer.SdlRendererLarge() target_renderer.initialise((192, 32)) board_lock = threading.RLock() end_event = threading.Event() # initialise board animator animator_thread = animator.BoardAnimator( board=target_board, renderer=target_renderer, time_step_in_s=0.05, board_lock=board_lock, end_event=end_event, ) # initialise board updater (also initialises board with 3 rows) target_board_updater = ( board_updater.BoardUpdater_192_32_3_Rows_From_ProtocolBuffers( target_board=target_board, board_lock=board_lock)) # initialise gRPC server server = grpc.server(futures.ThreadPoolExecutor(max_workers=3)) departure_pb2_grpc.add_BoardManagerServicer_to_server( BoardManagerServicer(target_board_updater), server) server.add_insecure_port("[::]:50051") # start gRPC server and board animator animator_thread.start() server.start() running = True event = sdl2.SDL_Event() try: while running: if (sdl2.SDL_PollEvent(ctypes.byref(event)) != 0 and event.type == sdl2.SDL_QUIT): logger.info("received SDL QUIT event") running = False break end_event.wait(0.5) except KeyboardInterrupt: logger.info("received keyboard interrupt") end_event.set() server.stop(0) animator_thread.join() target_renderer.terminate()
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 main_loop(self, draw_frame): running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)): if event.type == sdl2.SDL_QUIT: running = False draw_frame() sdl2.SDL_Delay(160)
def run(self): event = sdl2.SDL_Event() while self.running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: self.onEvent(event) # sdl2.SDL_Delay(10) # uncomment this if you want to save CPU resources self.onLoop() self.onCleanup() sdl2.SDL_Quit()
def pump(self, world): # TODO: optimize eventloop to use more efficient functions like PeepEvents? event = sdl2.SDL_Event() while sdl2.SDL_PollEvent(event): for event_handler in event_handlers.get(event.type, ()): event_handler(event, world) if not self.keepRunning: break if not self.keepRunning: break
def run(self): event = sdl2.SDL_Event() running = True while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): running = False self.render()
def main(): init() joy = sdl2.SDL_JoystickOpen(0) print('Name: {}'.format(sdl2.SDL_JoystickName(joy))) print('Axes: {}'.format(sdl2.SDL_JoystickNumAxes(joy))) state = ControllerState() evt = sdl2.SDL_Event() running = True conn = SerialConnection( sys.argv[1] if len(sys.argv) >= 2 else '/dev/ttyACM0') # set to mode 1 so it will not attack conn.call(MD49_MODE, (0x00, 0x34, 0x01)) while running: while sdl2.SDL_PollEvent(ctypes.byref(evt)) != 0: if evt.type == sdl2.SDL_QUIT: running = False break elif evt.type == sdl2.SDL_JOYAXISMOTION: jaxis = evt.jaxis # print(state, jaxis.axis, jaxis.value) state.axis_state[jaxis.axis] = jaxis.value handle_axis_motion(conn, state, jaxis.axis, jaxis.value) elif evt.type == sdl2.SDL_JOYBUTTONUP: button = evt.jbutton if button.button == 0: # A: toggle independent state.ind = not state.ind print('Independent: {}'.format(state.ind)) elif button.button == 8: # B: log encoders print(conn.md49_get_encoders()) log_encoders(conn) elif button.button == 3: # Y: reset encoders conn.call(MD49_MODE, ( 0x00, 0x35, )) elif button.button == 4: # left shoulder: reverse state.r_rev = not state.r_rev print('Right reverse: {}'.format(state.r_rev)) elif button.button == 5: # right shoulder: reverse state.l_rev = not state.l_rev print('Left reverse: {}'.format(state.l_rev)) else: print('Button', button.button) time.sleep(0.01) sdl2.SDL_Quit()
def handle(self, frame, timestamp): if self.window is None: self.setupWindow(frame.width, frame.height) sdl2.SDL_UpdateYUVTexture(self.texture, None, self.__c(frame.y), frame.width, self.__c(frame.u), frame.width / 2, self.__c(frame.v), frame.width / 2) sdl2.render.SDL_RenderClear(self.renderer) sdl2.render.SDL_RenderCopy(self.renderer, self.texture, None, None) sdl2.render.SDL_RenderPresent(self.renderer) sdl2.SDL_PollEvent(None)
def poll_events(): ''' 1) checks for window quit events ''' event = sdl2.SDL_Event() if sdl2.SDL_PollEvent(ctypes.byref(event)): # check for escape key press if (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): return False # check for other forms of quit if (event.type == sdl2.SDL_QUIT): return False return True
def GetInputs(self): # Poll events inputs = [] while sdl2.SDL_PollEvent(ctypes.byref(self.input)) != 0: inputs.append(self.input) if self.input.type == sdl2.SDL_QUIT: self.running = False break else: pass return inputs
def run(): running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break context.dispatchUI(event) context.processWorld() context.render() return 0
def run(): if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 window = sdl2.SDL_CreateWindow(b"OpenGL demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600, sdl2.SDL_WINDOW_OPENGL) if not window: print(sdl2.SDL_GetError()) return -1 context = sdl2.SDL_GL_CreateContext(window) GL.glMatrixMode(GL.GL_PROJECTION | GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glOrtho(-400, 400, 300, -300, 0, 1) x = 0.0 y = 30.0 event = sdl2.SDL_Event() running = True while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False GL.glClearColor(0, 0, 0, 1) GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glRotatef(10.0, 0.0, 0.0, 1.0) GL.glBegin(GL.GL_TRIANGLES) GL.glColor3f(1.0, 0.0, 0.0) GL.glVertex2f(x, y + 90.0) GL.glColor3f(0.0, 1.0, 0.0) GL.glVertex2f(x + 90.0, y - 90.0) GL.glColor3f(0.0, 0.0, 1.0) GL.glVertex2f(x - 90.0, y - 90.0) GL.glEnd() sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def _handle_events(self, pump=True, delay=True): self._refresh_screen() if pump: event = sdl2.SDL_Event() setkey = False while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: raise InterpreterQuitException() elif event.type == sdl2.SDL_WINDOWEVENT: self._handle_windowevents(event) elif event.type == sdl2.SDL_KEYDOWN: self.key = event.key.keysym.sym setkey = True if not setkey: self.key = None if delay: sdl2.SDL_Delay(SDL_DELAY_MILLIS)
def run(): if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 window = sdl2.SDL_CreateWindow(b"OpenGL demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600, sdl2.SDL_WINDOW_OPENGL) if not window: print(sdl2.SDL_GetError()) return -1 # Force OpenGL 3.3 'core' context. # Must set *before* creating GL context! video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK, video.SDL_GL_CONTEXT_PROFILE_CORE) context = sdl2.SDL_GL_CreateContext(window) # Setup GL shaders, data, etc. initialize() event = sdl2.SDL_Event() running = True while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): running = False render() sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
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 _loopForEvents(self): event = sdl2.SDL_Event() sdl2.SDL_StartTextInput() while self.is_running: # Look at the event queue while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: self.onEvent(event) # Look for layout changes if self.need_update: # Rebuilt only what is needed for i in self.indices_to_be_built: self.buildElement(i) self.indices_to_be_built = [] # Draw the elements self._refresh() self.need_update = False sdl2.SDL_Delay(1)
def main(): Prog = SudokuGUI() event = sdl2.SDL_Event() while Prog.running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_Quit: print "Something" Prog.Quit() break if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.scancode < 39: Prog.digit = event.key.keysym.scancode - 29 else: Prog.digit = event.key.keysym.scancode - 88 Prog.KeyAction[event.key.keysym.scancode]() elif event.type == sdl2.SDL_MOUSEBUTTONDOWN: Prog.MouseAction(event.button) return 0
def checkEvents(self): """ This just acts as a var switch and calls the process function @type self.event: sdl2.SDL_Event() @return: None """ while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0: if (self.event.type == sdl2.SDL_QUIT): self.running = False if (self.event.type == sdl2.SDL_MOUSEBUTTONDOWN): self.mouseDown = True if (self.event.type == sdl2.SDL_MOUSEBUTTONUP): self.mouseDown = False if (self.event.type == sdl2.SDL_MOUSEMOTION): # print ("x: %i, y: %i" % (event.motion.x, event.motion.y)) self.mousePos[0] = self.event.motion.x self.mousePos[1] = self.event.motion.y # rend.mouseMove(self.event.motion.x, self.event.motion.y) sdl2.SDL_FlushEvent(sdl2.SDL_MOUSEMOTION) self.process() return self.running
def main(): window = SDLWindow() event = sdl2.SDL_Event() running = True while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False # on key up sym = event.key.keysym.sym if event.type == sdl2.SDL_KEYUP: if sym == sdl2.SDLK_w: glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) elif sym == sdl2.SDLK_s: glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) # on_key_press elif event.type == sdl2.SDL_KEYDOWN: if sym == sdl2.SDLK_ESCAPE: running = False window.render() window.cleanup()
def mainLoop(self): if not hasattr(self, "renderDelegate"): raise Exception("GLWindow's render delegate not set!") dtime = 0 event = sdl2.SDL_Event() running = True startTime = sdl2.SDL_GetTicks() while running: stopTime = sdl2.SDL_GetTicks() dtime += stopTime - startTime startTime = stopTime if self.printFPS: self.periodTime += dtime self.fpsDelay -= dtime self.numFrames += 1 if self.fpsDelay <= 0: self.fpsDelay = self.fpsPeriod print("FPS:", (self.numFrames / (self.periodTime / 1000.0))) self.numFrames = 0 self.periodTime = 0 while sdl2.SDL_PollEvent(byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False else: pass # self.renderDelegate.addEvent(event) while dtime >= self.timeStep: dtime -= self.timeStep self.renderDelegate.update(self.timeStep) self.renderDelegate.render() sdl2.SDL_GL_SwapWindow(self.window) self.cleanup()