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(self, components):
global camera, stars
# Draw stars
tmp = self.renderer.color
self.renderer.color = BLACK
self.renderer.clear()
self.renderer.color = BLUISH_GRAY
star_coords = [] # stars is a global list of Star objects... for now.
for s in stars:
coords = camera.star_to_screen_space(s.direction)
star_coords.extend(coords)
self.renderer.draw_point(star_coords)
self.renderer.color = tmp
# Draw sprites
r = sdl2.SDL_Rect(0, 0, 0, 0)
rcopy = sdl2.SDL_RenderCopy
renderer = self.sdlrenderer
for sp in components:
if sp.depth >= 0:
r.x, r.y, r.w, r.h = -1, -1, 1, 1
else:
r.w = int(max(2, (sp.size[0] / (-sp.depth / 15e9))))
r.h = int(max(2, sp.size[1] / (-sp.depth / 15e9)))
r.x = sp.x - r.w // 2
r.y = sp.y - r.h // 2
if rcopy(renderer, sp.texture, None, r) == -1:
raise SDLError()
sdl2.SDL_RenderPresent(self.sdlrenderer)
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 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 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 repaint(self):
''' Производит отрисовку на экран ранее произведенных действий
* В стандартной реализации ничего не делает
* @returns {self}
'''
SDL.SDL_RenderPresent(self.ctx)
return self
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 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 _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 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 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 run(self):
self.running.set()
stime = now()
last_update = now()
target_fps = self.target_fps / 2. # todo: hu, why do we need / 2 here ?
target_delay = 1 / float(target_fps)
i = 0
while self.running.is_set():
events = sdl2.ext.get_events()
for event in events:
self.handle_event(event)
if event.type == sdl2.SDL_QUIT:
self.running.clear()
break
current = now()
elapsed = current - last_update
last_update = current
if self._need_update:
i += 1
if i >= target_fps * 2:
self.i += i
elapsed2 = current - stime
self.fps = float(i) / elapsed2
i = 0
stime = current
with self._lock:
#sdl2.SDL_RenderClear(self.renderer.sdlrenderer)
sdl2.SDL_UpdateTexture(
self.texture, None, self._pixel.ctypes.data,
self.img_size[1] * self._bytes_per_pix)
sdl2.SDL_RenderCopy(self.renderer.sdlrenderer,
self.texture, None, None)
sdl2.SDL_RenderPresent(self.renderer.sdlrenderer)
self._pix_written.set() # TODO: if ...
self._need_update = False
self.i += 1
if target_delay > elapsed:
#print("Times", target_delay, elapsed, int((target_delay - elapsed) * 1000))
#print("%.2f" % (i / (current - stime)))
sdl2.SDL_Delay(int((target_delay - elapsed) * 1000))
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 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 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 run():
out_blocks = ""
out_images = ""
all_blocks = []
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING)
sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG)
window = sdl2.ext.Window("BAConv", size=(1024, 384))
window.show()
ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED)
# makes zoomed graphics blocky (for retro effect)
sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest")
# makes the graphics look and act like the desired screen size, even though they may be rendered at a different one
sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96)
frames = []
count = 0
limit = 8000 # only deal with this many frames
pass1 = True # True means calculate blocks, False means load from pre-calculated file
if pass1:
# pass 1 - gather all the blocks
for i in range(0, int(6565 / 4)):
# for i in range(43, int(600 / 4)):
count += 1
if count > limit: # stop early
break
events = sdl2.ext.get_events() # otherwise window doesn't update
for event in events:
if event.type == sdl2.SDL_QUIT:
exit(0)
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
frame = processImage(
file, ren) # also draws left hand side pre-processed
frames.append(frame)
renderImage(frame, ren) # right hand side post-process
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
print(f"Processed {count} frames.")
values = 0
size = 0
for frame in frames:
values += len(frame)
size += frame[1] * (len(frame) - 2) + 1
print(frame)
print(f"Raw values: {values}")
print(f"Average values per frame: {values/len(frames)}")
print(f"Theoretical size: {size/8}")
exit(0)
# store blocks in file
file_lines = []
for block in all_blocks:
file_lines.append(block.serialize())
with open("data_file.txt", "w") as write_file:
write_file.writelines("\n".join(file_lines))
else:
# read in blocks from file (quicker)
with open("data_file.txt", "r") as read_file:
file_lines = read_file.readlines()
all_blocks = []
for line in file_lines:
all_blocks.append(Block.fromData(line.split(",")))
# sort and choose top blocks
all_blocks.sort(reverse=True)
# 1024 is currently all you're planning to store
# todo: choose final number of blocks to use
# all_blocks=all_blocks[0:1024]
for i, b in enumerate(all_blocks):
print(f"Block {i}: {b.count}")
# pass 2 - build new images with top blocks
all_images = []
count = 0
# for i in range(43, int(6509 / 4)):
for i in range(0, int(6565 / 4)):
# for i in range(43, int(600 / 4)):
count += 1
if count > limit: # stop early
break
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image = reprocessImage(
file, ren, all_blocks) # also draws left hand side pre-processed
all_images.append(image)
renderImage(image, all_blocks, ren) # right hand side post-process
events = sdl2.ext.get_events() # otherwise window doesn't update
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
# play back final frames in loop
fr = 0
while True:
fr = (fr + 1) % len(all_images)
events = sdl2.ext.get_events() # otherwise window doesn't update
for event in events:
if event.type == sdl2.SDL_QUIT:
exit(0)
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
renderImage(all_images[fr], all_blocks, ren)
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
def update(self):
sdl2.SDL_RenderPresent(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()
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 VSync(self):
sdl2.SDL_RenderPresent(self.renderer)
def main():
sdl2.sdl2_load(
ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib'
ttf_libpath=ctypes.util.find_library('SDL2_ttf'))
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
WINDOW_W = 640
WINDOW_H = 360
window = sdl2.SDL_CreateWindow(b"Minimal SDL_TTF Test via python-sdl2", 0,
0, WINDOW_W, WINDOW_H,
sdl2.SDL_WINDOW_OPENGL)
renderer = sdl2.SDL_CreateRenderer(window, -1, 0)
rect = sdl2.SDL_Rect()
rect.x = 0
rect.y = 0
rect.w = WINDOW_W
rect.h = WINDOW_H
sdl2.TTF_Init()
rwops_ptr = sdl2.SDL_RWFromFile(
bytes(sys.argv[1], 'utf-8'), b"rb"
) # rwops = ctypes.cast(rwops_ptr, ctypes.POINTER(sdl2.SDL_RWops)).contents
font = sdl2.TTF_OpenFontRW(rwops_ptr, 0, 42)
fg = sdl2.SDL_Color()
fg.r = 96
fg.g = 96
fg.b = 96
fg.a = 255
bg = sdl2.SDL_Color()
bg.r = 0xE0
bg.g = 0xE0
bg.b = 0xE0
bg.a = 255
pos = [
sdl2.SDL_Rect(),
sdl2.SDL_Rect(),
]
pos[0].x = 20
pos[0].y = 120
pos[0].w = 600
pos[0].h = 60
pos[1].x = 20
pos[1].y = 180
pos[1].w = 600
pos[1].h = 60
surfaces = [
sdl2.TTF_RenderUTF8_Shaded(font, bytes("志於道、據於徳、依於仁、游於藝", 'utf-8'), fg,
bg),
sdl2.TTF_RenderUTF8_Shaded(font, bytes("ＳＣＯＲＥ １２３４５６７８０", 'utf-8'), fg,
bg),
]
texture = [
sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[0]),
sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[1]),
]
sdl2.SDL_SetRenderDrawColor(renderer, bg.r, bg.g, bg.b, bg.a)
sdl2.SDL_RenderFillRect(renderer, ctypes.byref(rect))
sdl2.SDL_RenderCopy(renderer, texture[0], None, ctypes.byref(pos[0]))
sdl2.SDL_RenderCopy(renderer, texture[1], None, ctypes.byref(pos[1]))
sdl2.SDL_RenderPresent(renderer)
sdl2.SDL_FreeSurface(surfaces[0])
sdl2.SDL_FreeSurface(surfaces[1])
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_Delay(fpsdelay)
sdl2.TTF_Quit()
sdl2.SDL_DestroyRenderer(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def resize(self):
self._clear_draw_field()
InscribedShapes(self).draw()
sdl2.SDL_RenderPresent(self.sdl_renderer)
# 3 rendering modes:
# mode 1: useYuv + useTexture == True
# -> upload yuv data to graphic card + hardware scaling
# mode 2: useTexture == True, useYuv == False
# -> yuv to rgb in software, upload rgb to graphic card + hardware scaling
# mode 3: useTexture + useYuv == False
# -> uyv to rgb + scaling in software
# note: in this example, we don't perform scaling
if useTexture == True:
# select clear color
sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
# clear screen
sdl2.SDL_RenderClear(renderer)
sdl2.SDL_RenderPresent(renderer)
# mode 1
if rendererYuv == True and streamInfo['pixelFormat'] == 'yuv420p':
print('mode 1: fast yuv rendering...')
useYuv = True
# texture will change frequently so use streaming access
yuvTexture = sdl2.SDL_CreateTexture(
renderer, sdl2.SDL_PIXELFORMAT_YV12,
sdl2.SDL_TEXTUREACCESS_STREAMING, size[0], size[1])
else:
print('mode 2: basic rgb rendering (slow)...')
def post_tick(self):
sdl2.SDL_RenderClear(self._sdlrenderer)
self.write_memory()
self.render_text()
sdl2.SDL_RenderPresent(self._sdlrenderer)
