def stop(self):
if __debug__:
sdl2.SDL_DestroyWindow(self.tileDataWindow.window)
sdl2.SDL_DestroyWindow(self.tileView1Window.window)
sdl2.SDL_DestroyWindow(self.tileView2Window.window)
sdl2.SDL_DestroyWindow(self.spriteWindow.window)
sdl2.SDL_DestroyWindow(self._window.window)
sdl2.ext.quit()
def destroy(self):
"""
Gracefully close the window
"""
sdl2.SDL_GL_DeleteContext(self.context)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit()
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 close(self):
sdl2.SDL_DestroyWindow(self._native_window)
del __windows__[self._native_id]
for i in range(len(self._timer_stack)):
handler, interval = self._timer_stack[i]
self._clock.unschedule(handler)
self.dispatch_event('on_close')
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 initialize(self):
if os.name == "nt":
ctypes.windll.shcore.SetProcessDpiAwareness(1)
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
IMG_Init(IMG_INIT_PNG)
# Ugly hack to determine resolution scaling factor as early as possible.
win = sdl2.SDL_CreateWindow(
"ResolutionTest".encode("utf-8"),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
100,
100,
sdl2.SDL_WINDOW_HIDDEN | sdl2.SDL_WINDOW_ALLOW_HIGHDPI,
)
rend = sdl2.SDL_CreateRenderer(win, -1, sdl2.SDL_RENDERER_ACCELERATED)
win_w = ctypes.c_int()
rend_w = ctypes.c_int()
sdl2.SDL_GetWindowSize(win, ctypes.byref(win_w), None)
sdl2.SDL_GetRendererOutputSize(rend, ctypes.byref(rend_w), None)
# Windows HiDPI is silly like this. You get back different window sizes than you put in.
self.win_scale = win_w.value / 100.0
Environment.scale.default = rend_w.value / 100.0
sdl2.SDL_DestroyRenderer(rend)
sdl2.SDL_DestroyWindow(win)
# Initialize our font cache and calculate DPI scaling.
Font.initialize()
def shutdown(self):
"""Shut down the renderer."""
renderer_shutdown()
sdl.SDL_GL_DeleteContext(self.ctx)
self.ctx = None
sdl.SDL_DestroyWindow(self.win)
self.win = None
def terminate(self):
"""Cleanup the GUI resources."""
self._renderer.cleanup()
if hienoi.renderer.get_info().api == GraphicsAPI.OPENGL:
sdl2.SDL_GL_DeleteContext(self._handles.renderer.context)
sdl2.SDL_DestroyWindow(self._handles.window)
sdl2.SDL_Quit()
def clear(self):
# release resources
if self.context:
sdl2.SDL_GL_DeleteContext(self.context)
self.context = None
if self.window:
sdl2.SDL_DestroyWindow(self.window)
self.window = None
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 _vispy_close(self):
# Force the window or widget to shut down
if self._id is not None:
_id = self._id.window
self._vispy_canvas = None
self._id = None
sdl2.SDL_DestroyWindow(_id)
del _VP_SDL2_ALL_WINDOWS[self._sdl_id]
self._sdl_id = None
gc.collect() # enforce gc to help context get destroyed
def quit(self):
self.is_running = False
# Give time for the other thread to end
ti.sleep(0.05)
# Destroy the SDL context
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_HideWindow(self.window)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit()
def __del__(self):
del self.joysticks_interface
if self.has_sdl_gamecontroller:
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_GAMECONTROLLER)
if self.has_sdl_joystick:
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_JOYSTICK)
if self.has_sdl_audio:
sdl2.SDL_CloseAudioDevice(self.audio_dev)
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_AUDIO)
sdl2.SDL_DestroyTexture(self.texture)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_DestroyWindow(self.screen)
sdl2.SDL_Quit()
def _do_create_window(self, width, height):
"""Create a new SDL window """
flags = sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_SHOWN
if self.fullscreen:
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP | sdl2.SDL_WINDOW_BORDERLESS
sdl2.SDL_DestroyWindow(self.display)
self.display = sdl2.SDL_CreateWindow(self.caption,
sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
width, height, flags)
self._set_icon()
self.display_surface = sdl2.SDL_GetWindowSurface(self.display)
self.screen_changed = True
self.window_width, self.window_height = width, height
def __exit__(self, exc_type, exc_value, traceback):
sdl2.SDL_DestroyTexture(self.texture_graph)
sdl2.SDL_DestroyTexture(self.texture_text)
sdl2.SDL_DestroyTexture(self.texture_scroll)
sdl2.SDL_DestroyTexture(self.font_text)
sdl2.SDL_DestroyTexture(self.font_text_inverted)
sdl2.SDL_DestroyTexture(self.font_graph)
sdl2.SDL_DestroyTexture(self.font_graph_inverted)
# clean up stored picts
for pict in list(self.picts.values()):
sdl2.SDL_DestroyTexture(pict)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_Quit()
def dispose(self):
if self._window is not None:
sdl2.SDL_HideWindow(self._window)
if self._timer is not None:
self._loop.destroy_timer(self._timer)
self._timer = None
if self._window is not None:
sdl2.SDL_DestroyWindow(self._window)
self._window = None
if self._glcontext is not None:
sdl2.SDL_GL_DeleteContext(self._glcontext)
self._glcontext = None
def __init__(self, config):
"""Constructor.
Instantiates a window and sets up an OpenGL context for it, which is
immediately made active, using the given configuration data.
:param config: Renderer-specific configuration.
:type config: mapping-like interface.
"""
try:
width = int(config['width'])
height = int(config['height'])
gl_major, gl_minor = [
int(v) for v in config.get('openglversion', '3.3').split('.')
]
except (KeyError, TypeError, ValueError) as err:
raise ConfigError(err)
# create a SDL window
self.win = sdl.SDL_CreateWindow(b'Surviveler',
sdl.SDL_WINDOWPOS_CENTERED,
sdl.SDL_WINDOWPOS_CENTERED, width,
height, sdl.SDL_WINDOW_OPENGL)
if self.win is None:
raise RuntimeError('failed to create SDL window')
# create an OpenGL context
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_PROFILE_MASK,
sdl.SDL_GL_CONTEXT_PROFILE_CORE)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_MAJOR_VERSION, gl_major)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_CONTEXT_MINOR_VERSION, gl_minor)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DOUBLEBUFFER, 1)
sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DEPTH_SIZE, 24)
self.ctx = sdl.SDL_GL_CreateContext(self.win)
if self.ctx is None:
sdl.SDL_DestroyWindow(self.win)
raise RuntimeError('failed to initialize OpenGL context')
# initialize renderer
renderer_init()
self._width = width
self._height = height
LOG.info('renderer initialized; created {}x{} window'.format(
width, height))
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 close(self):
""" Close the SDL2 interface. """
video.VideoPlugin.close(self)
if sdl2 and numpy:
# free windows
sdl2.SDL_DestroyWindow(self.display)
# free surfaces
for s in self.canvas:
sdl2.SDL_FreeSurface(s)
sdl2.SDL_FreeSurface(self.work_surface)
sdl2.SDL_FreeSurface(self.overlay)
# free palettes
for p in self.show_palette:
sdl2.SDL_FreePalette(p)
sdl2.SDL_FreePalette(self.composite_palette)
# close SDL2
sdl2.SDL_Quit()
def cleanup(self):
"""
destroys opengl and sdl resources allocated
"""
for val in self.all_filters.itervalues():
val.cleanup_shader()
self.filters = []
if self.final_filter:
self.final_filter.cleanup_shader()
if self.console:
self.console.cleanup()
self.final_filter = None
self.cleanup_img_fb()
self.cleanup_image_texture()
if self.window:
sdl2.SDL_DestroyWindow(self.window)
self.window = None
self.view.reset()
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 __exit__(self, type, value, traceback):
"""Close the SDL2 interface."""
base.VideoPlugin.__exit__(self, type, value, traceback)
if sdl2 and numpy and self._has_window:
# free windows
sdl2.SDL_DestroyWindow(self.display)
# free surfaces
for s in self.canvas:
sdl2.SDL_FreeSurface(s)
sdl2.SDL_FreeSurface(self.work_surface)
sdl2.SDL_FreeSurface(self.overlay)
# free palettes
for p in self.show_palette:
sdl2.SDL_FreePalette(p)
sdl2.SDL_FreePalette(self.composite_palette)
# close IME
sdl2.SDL_StopTextInput()
# close SDL2
sdl2.SDL_Quit()
def __buildWindow(self):
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise Exception(sdl2.SDL_GetError())
sdlimage.IMG_Init(sdlimage.IMG_INIT_PNG | sdlimage.IMG_INIT_JPG)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK,
sdl2.SDL_GL_CONTEXT_PROFILE_CORE)
self.window = sdl2.SDL_CreateWindow(b'ETGG2801 Example', 0, 0,
self.size[0], self.size[1],
sdl2.SDL_WINDOW_OPENGL)
self.glcontext = sdl2.SDL_GL_CreateContext(self.window)
if not self.glcontext:
sdl2.SDL_DestroyWindow(self.window)
raise Exception(sdl2.SDL_GetError())
# keep application from receiving text input events
sdl2.SDL_StopTextInput()
def __buildWindow(self):
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
raise Exception(sdl2.SDL_GetError())
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.major)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.minor)
self.window = sdl2.SDL_CreateWindow(b'ETGG2801 Example',
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
self.size[0], self.size[1],
sdl2.SDL_WINDOW_OPENGL)
self.glcontext = sdl2.SDL_GL_CreateContext(self.window)
if not self.glcontext:
sdl2.SDL_DestroyWindow(self.window)
raise Exception(sdl2.SDL_GetError())
# keep application from receiving text input events
sdl2.SDL_StopTextInput()
def run(self):
event = sdl2.SDL_Event()
while self.running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
self.running = False
elif event.type == sdl2.SDL_KEYDOWN:
self.keyPressed[event.key.keysym.scancode] = True
self.onKeyDown(event.key.keysym.scancode)
elif event.type == sdl2.SDL_KEYUP:
self.keyPressed[event.key.keysym.scancode] = False
self.onKeyUp(event.key.keysym.scancode)
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
self.mouseButtonPressed[event.button.button] = True
self.onMouseButtonDown(event.button.button)
elif event.type == sdl2.SDL_MOUSEBUTTONUP:
self.mouseButtonPressed[event.button.button] = False
self.onMouseButtonUp(event.button.button)
elif event.type == sdl2.SDL_MOUSEMOTION:
self.mouseX = event.motion.x
self.mouseY = event.motion.y
self.currentTime = sdl2.SDL_GetTicks()
elapsedTime = self.currentTime - self.lastTime
self.lastTime = self.currentTime
dt = elapsedTime * 0.001
self.timer += dt
if (self.timer >= self.fixedTimeStep):
self.timer -= self.fixedTimeStep
self.update(self.fixedTimeStep)
self.render()
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit()
def stop(self):
sdl2.SDL_DestroyWindow(self._window)
sdl2.SDL_Quit()
def finish(self):
if self.window:
sdl2.SDL_DestroyTexture(self.texture)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit()
def main():
if len(sys.argv) != 2:
print("usage: 3dwf.py REMOTE_ADDRESS", file=sys.stderr)
sys.exit(1)
nbins = 256
overlap = 192
rem_address = (sys.argv[1], 3731)
conn = socket.create_connection(rem_address)
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_AUDIO)
window = sdl2.SDL_CreateWindow(b"3D Waterfall", sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, 800, 600,
sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_OPENGL)
context = sdl2.SDL_GL_CreateContext(window)
wf = WFViewer(nbins)
wf.init(800, 600)
wf.shift = 0
filt = interp_fir_filter(lowpass(np.pi / 4, 512) * np.hamming(512), 4)
freqx = freq_translator((0.8/8.0) * np.pi)
headlen = max(filt.nhistory, overlap)
ringbuf = RingBuf(headlen, np.zeros(headlen + (nbins - overlap) * 512, dtype=np.complex64))
# FIXME
global audio_edge
audio_edge = 0
def callback(unused, buf, buflen):
global audio_edge
bufbuf = pybuf_from_memory(buf, buflen, 0x200) # PyBUF_WRITE
array = np.frombuffer(bufbuf, np.float32)
assert len(array) % filt.interp == 0 # TODO
nreqframes = len(array) // filt.interp
loc_ringbuf_edge = ringbuf.fill_edge
if loc_ringbuf_edge < 0 or (loc_ringbuf_edge - audio_edge) % len(ringbuf) < nreqframes:
print("audio underrun", file=sys.stderr)
array.fill(0)
return
# TODO
if audio_edge + nreqframes > len(ringbuf):
audio_edge = 0
slic = ringbuf.slice(audio_edge - filt.nhistory, audio_edge + nreqframes)
array[:] = np.real(freqx(filt(slic))) * wf.volume
audio_edge += nreqframes
sdl2.SDL_PushEvent(UPDATE_EVENT)
audio_spec = sdl2.SDL_AudioSpec(8000,
sdl2.AUDIO_F32,
1,
512,
sdl2.SDL_AudioCallback(callback))
audio_dev = sdl2.SDL_OpenAudioDevice(None, 0, audio_spec, None, 0)
if audio_dev == 0:
raise Error('could not open audio device')
err_queue = queue.Queue()
def readfunc(nbytes):
bytes = b''
while len(bytes) < nbytes:
ret = conn.recv(nbytes - len(bytes))
if not ret:
raise Exception('end of stream')
bytes += ret
return bytes
def thread_target():
try:
input_thread(readfunc, ringbuf, nbins, overlap, wf)
except Exception as e:
err_queue.put(e)
event = sdl2.SDL_Event()
event.type = sdl2.SDL_QUIT
sdl2.SDL_PushEvent(event)
other_thread = threading.Thread(target=thread_target)
other_thread.setDaemon(True)
other_thread.start()
sdl2.SDL_PauseAudioDevice(audio_dev, 0)
running = True
event = sdl2.SDL_Event()
while running:
sdl2.SDL_WaitEvent(ctypes.byref(event))
while True:
if event.type == sdl2.SDL_QUIT:
running = False
break
wf.event(event)
if sdl2.SDL_PollEvent(ctypes.byref(event)) == 0:
break
# FIXME
wf.shift = ((ringbuf.fill_edge - audio_edge) % len(ringbuf)) / (nbins - overlap)
wf.draw()
sdl2.SDL_GL_SwapWindow(window)
try:
for exc in iter(err_queue.get_nowait, None):
sdl2.SDL_ShowSimpleMessageBox(sdl2.SDL_MESSAGEBOX_ERROR, b"Exception", str(exc).encode("ascii"), None)
except queue.Empty:
pass
sdl2.SDL_CloseAudioDevice(audio_dev)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
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
perform_rendering(renderer, sceneList[current_scene_index].entities)
pass
# Clean up
for scene in sceneList:
scene.stop_entities()
sdl2.SDL_DestroyRenderer(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def destroy(self):
'''Destroy and quit SDL2 window'''
sdl2.SDL_DestroyWindow(self.window) # Close and destroy SDL2 window
sdl2.SDL_Quit() # Clean up SDL2
logging.info('Destroyed SDL2 window and quited SDL2')
