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)
