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()
