def set_palette(self, rgb_palette_0, rgb_palette_1):
"""Build the palette."""
self.num_fore_attrs = min(16, len(rgb_palette_0))
self.num_back_attrs = min(8, self.num_fore_attrs)
rgb_palette_1 = rgb_palette_1 or rgb_palette_0
# fill up the 8-bit palette with all combinations we need
# blink states: 0 light up, 1 light down
# bottom 128 are non-blink, top 128 blink to background
show_palette_0 = rgb_palette_0[:self.num_fore_attrs] * (256//self.num_fore_attrs)
show_palette_1 = rgb_palette_1[:self.num_fore_attrs] * (128//self.num_fore_attrs)
for b in rgb_palette_1[:self.num_back_attrs] * (128//self.num_fore_attrs//self.num_back_attrs):
show_palette_1 += [b]*self.num_fore_attrs
colors_0 = (sdl2.SDL_Color * 256)(*(sdl2.SDL_Color(r, g, b, 255) for (r, g, b) in show_palette_0))
colors_1 = (sdl2.SDL_Color * 256)(*(sdl2.SDL_Color(r, g, b, 255) for (r, g, b) in show_palette_1))
sdl2.SDL_SetPaletteColors(self.show_palette[0], colors_0, 0, 256)
sdl2.SDL_SetPaletteColors(self.show_palette[1], colors_1, 0, 256)
self.screen_changed = True
def drawlevel(self):
levelstr = str(self.model.level)
self.leveltex = self.sfactory.from_surface(
sdlttf.TTF_RenderText_Solid(self.mainfont,
bytes(str(levelstr), "utf-8"),
sdl2.SDL_Color(255, 255, 255,
255)).contents, True)
self.leveltex.x, self.leveltex.y = 410, 530
def color(self, *rgba):
if not rgba or rgba[0] is None:
self.env.color = None
elif isinstance(rgba[0], sdl2.SDL_Color):
self.env.color = rgba[0]
else:
self.env.color = sdl2.SDL_Color(*rgba)
return self
def _init_thread(self):
""" Complete SDL2 interface initialisation. """
# initialise SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
# set clipboard handler to SDL2
backend.clipboard_handler = SDL2Clipboard()
# display palettes for blink states 0, 1
self.show_palette = [
sdl2.SDL_AllocPalette(256),
sdl2.SDL_AllocPalette(256)
]
# get physical screen dimensions (needs to be called before set_mode)
display_mode = sdl2.SDL_DisplayMode()
sdl2.SDL_GetCurrentDisplayMode(0, ctypes.byref(display_mode))
self.physical_size = display_mode.w, display_mode.h
# create the window initially, size will be corrected later
self.display = None
# create window in same thread that manipulates it
# "NOTE: You should not expect to be able to create a window, render, or receive events on any thread other than the main one"
# https://wiki.libsdl.org/CategoryThread
# http://stackoverflow.com/questions/27751533/sdl2-threading-seg-fault
self._do_create_window(640, 400)
# load an all-black 16-colour game palette to get started
self.set_palette([(0, 0, 0)] * 16, None)
self.move_cursor(1, 1)
self.set_page(0, 0)
self.set_mode(self.kwargs['initial_mode'])
# support for CGA composite
self.composite_palette = sdl2.SDL_AllocPalette(256)
composite_colors = video_graphical.composite_640.get(
self.composite_card, video_graphical.composite_640['cga'])
colors = (sdl2.SDL_Color * 256)(
*[sdl2.SDL_Color(r, g, b, 255) for (r, g, b) in composite_colors])
sdl2.SDL_SetPaletteColors(self.composite_palette, colors, 0, 256)
# check if we can honour scaling=smooth
if self.smooth:
# pointer to the zoomed surface
self.zoomed = None
pixelformat = self.display_surface.contents.format
if pixelformat.contents.BitsPerPixel != 32:
logging.warning(
'Smooth scaling not available on this display of %d-bit colour depth: needs 32-bit',
self.display_surface.format.contents.BitsPerPixel)
self.smooth = False
if not hasattr(sdl2, 'sdlgfx'):
logging.warning(
'Smooth scaling not available: SDL_GFX extension not found.'
)
self.smooth = False
# available joysticks
num_joysticks = sdl2.SDL_NumJoysticks()
for j in range(num_joysticks):
sdl2.SDL_JoystickOpen(j)
# if a joystick is present, its axes report 128 for mid, not 0
for axis in (0, 1):
backend.input_queue.put(
backend.Event(backend.STICK_MOVED, (j, axis, 128)))
def __init__(self):
self.top_text = ''
self.bottom_text = ''
self.text_color = sdl2.SDL_Color(0, 0, 0) # black
# Maps text to texture
# <str, SDL texture>
# Keeps track of textures that have already been created
# so that rendering does not require creating that texture again
self.texture_cache = {}
def render_font(
font: sdl2.sdlttf.TTF_Font,
text: str,
color: sdl2.SDL_Color = None,
bg_color: sdl2.SDL_Color = None,
):
text_b = bytes(text, "utf-8")
if color is None:
color = sdl2.SDL_Color(255, 255, 255)
if bg_color is None:
bg_color = sdl2.SDL_Color(0, 0, 0)
if bg_color == sdl2.SDL_Color(0, 0, 0):
sf = sdl2.sdlttf.TTF_RenderUTF8_Blended(font, text_b, color)
else:
sf = sdl2.sdlttf.TTF_RenderUTF8_Shaded(font, text_b, color, bg_color)
if not sf:
raise sdl2.ext.SDLError(sdl2.sdlttf.TTF_GetError())
return sf.contents
def drawtime(self, tick):
tick_ms = (50 * tick) // 3
tickstr = "{2:02d}:{1:02d}:{0:02d}"\
.format(tick_ms//10%100, tick_ms//1000%60, tick_ms//60000%100)
self.timertex = self.sfactory.from_surface(
sdlttf.TTF_RenderText_Solid(self.largefont,
bytes(tickstr, "utf-8"),
sdl2.SDL_Color(255, 255, 255,
255)).contents, True)
self.timertex.x, self.timertex.y = 410, 575
def glyph_size(self, ch):
assert isinstance(ch, int)
if ch in self.glyphs:
return self.glyphs[ch][1]
elif ch not in self.surfaces:
surface = TTF_RenderGlyph_Blended(self.font, ch,
sdl2.SDL_Color(255, 255, 255))
self.surfaces[ch] = (surface,
Size(surface.contents.w, surface.contents.h))
return self.surfaces[ch][1]
def draw(self, renderer, rect):
super().draw(renderer, rect)
self.env.draw(renderer, self.asset, self.frame)
# TODO: This is not great...
if "checked" in self.asset:
font = self.env.theme.font(self.env.font, self.env.font_size)
font.draw(renderer,
"✓",
rect + Insets(top=2, left=-6),
sdl2.SDL_Color(255, 255, 255),
wrap=False)
def RenderDebug(self, world, render_dt):
'''
This probably doesn't belong here... Should move into a subsystem elsewhere.
This is an easy light way of having a quick debugger that can print the hero's
stats.
Move this elsewhere later on.
Tutorial: https://egdev.wordpress.com/2014/03/14/python-sdl2-ttf-test/
'''
# Open font
font = sdl2.sdlttf.TTF_OpenFont(
'/home/prestonh/Desktop/Programming/gamedev/shoot/shoot/resources/fonts/computer_modern/cmunsx.ttf',
12)
color = sdl2.SDL_Color(40, 255, 40)
# Create debug text
entity = world.entity_manager.entities['hero_0']
debug_lines = []
debug_lines.append('fps:' + str(round(1. / render_dt)))
debug_lines.append('(x,y):' + str(round(entity.kinematics.x, 3)) +
', ' + str(round(entity.kinematics.y, 3)))
debug_lines.append('(vx,vy):' + str(round(entity.kinematics.vx, 3)) +
', ' + str(round(entity.kinematics.vy, 3)))
debug_text = ''
for debug_line in debug_lines:
debug_text += debug_line + '\n'
# Render the debug text
# Create surface and texture
debug_width = 200
text_surface = sdl2.sdlttf.TTF_RenderText_Blended_Wrapped(
font, debug_text, color, debug_width)
text_texture = sdl2.SDL_CreateTextureFromSurface(
self.sdl_renderer, text_surface)
# Render surface and texture
window_rect = self.GetWindowRect()
w = ctypes.pointer(ctypes.c_int(0))
h = ctypes.pointer(ctypes.c_int(0))
sdl2.SDL_QueryTexture(text_texture, None, None, w, h)
x = window_rect.w - debug_width
y = 50 #window_rect.h - h.contents.value
debug_rect = sdl2.SDL_Rect(x, y, w.contents.value, h.contents.value)
sdl2.SDL_RenderCopy(self.sdl_renderer, text_texture, None, debug_rect)
# Free resources
sdl2.SDL_FreeSurface(text_surface)
sdl2.sdlttf.TTF_CloseFont(font)
pass
def glyph(self, renderer, ch):
assert isinstance(ch, int)
if ch not in self.glyphs:
# Pop the surface out of the cache and load it into a texture and the glyph cache.
surface, size = self.surfaces.pop(ch, (None, None))
if surface is None:
surface = TTF_RenderGlyph_Blended(
self.font, ch, sdl2.SDL_Color(255, 255, 255))
size = Size(surface.contents.w, surface.contents.h)
self.glyphs[ch] = (sdl2.SDL_CreateTextureFromSurface(
renderer, surface), size)
sdl2.SDL_FreeSurface(surface)
return self.glyphs[ch]
def _set_icon(self):
"""Set the icon on the SDL window."""
mask = numpy.array(self.icon).T.repeat(2, 0).repeat(2, 1)
icon = sdl2.SDL_CreateRGBSurface(0, mask.shape[0], mask.shape[1], 8, 0, 0, 0, 0)
pixels2d(icon.contents)[:] = mask
# icon palette (black & white)
icon_palette = sdl2.SDL_AllocPalette(256)
icon_colors = [ sdl2.SDL_Color(x, x, x, 255) for x in [0, 255] + [255]*254 ]
sdl2.SDL_SetPaletteColors(icon_palette, (sdl2.SDL_Color * 256)(*icon_colors), 0, 2)
sdl2.SDL_SetSurfacePalette(icon, icon_palette)
sdl2.SDL_SetWindowIcon(self.display, icon)
sdl2.SDL_FreeSurface(icon)
sdl2.SDL_FreePalette(icon_palette)
def refresh(self):
"""
Refreshes the graphical representation of stored text.
"""
surface = ttf.TTF_RenderUTF8_Blended(
self.font.handle, bytes(self._text, "utf8"),
sdl2.SDL_Color(255, 255, 255, 255))
if not surface:
self.surface_size = (0, 0)
return
self.surface_size = (surface.contents.w, surface.contents.h)
self.texture = sdl2.SDL_CreateTextureFromSurface(
self.canvas.renderer, surface)
sdl2.SDL_SetTextureBlendMode(self.texture, sdl2.SDL_BLENDMODE_BLEND)
sdl2.SDL_FreeSurface(surface)
def draw(self, renderer, rect):
super().draw(renderer, rect)
self.env.draw(renderer, "textfield", self.frame)
if self.text.value:
self._line_cache = self._font.draw(
renderer,
self.text_representation(),
rect,
self.env.color,
selected=self.selection,
lines=self._line_cache,
)
elif self.placeholder:
self._font.draw(renderer, self.placeholder, rect,
sdl2.SDL_Color(150, 150, 150))
def __enter__(self):
"""Complete SDL2 interface initialisation."""
# set clipboard handler to SDL2
self.clipboard_handler = get_clipboard_handler()
# display palettes for blink states 0, 1
self.show_palette = [
sdl2.SDL_AllocPalette(256),
sdl2.SDL_AllocPalette(256)
]
# get physical screen dimensions (needs to be called before set_mode)
# load an all-black 16-colour game palette to get started
self.set_palette([(0, 0, 0)] * 16, None)
self.move_cursor(1, 1)
self.set_page(0, 0)
# set_mode should be first event on queue
# support for CGA composite
self.composite_palette = sdl2.SDL_AllocPalette(256)
composite_colors = video_graphical.composite_640.get(
self.composite_card, video_graphical.composite_640['cga'])
colors = (sdl2.SDL_Color * 256)(
*[sdl2.SDL_Color(r, g, b, 255) for (r, g, b) in composite_colors])
sdl2.SDL_SetPaletteColors(self.composite_palette, colors, 0, 256)
# check if we can honour scaling=smooth
if self.smooth:
# pointer to the zoomed surface
self.zoomed = None
pixelformat = self.display_surface.contents.format
if pixelformat.contents.BitsPerPixel != 32:
logging.warning(
'Smooth scaling not available on this display of %d-bit colour depth: needs 32-bit',
self.display_surface.format.contents.BitsPerPixel)
self.smooth = False
if not hasattr(sdl2, 'sdlgfx'):
logging.warning(
'Smooth scaling not available: SDL_GFX extension not found.'
)
self.smooth = False
# available joysticks
num_joysticks = sdl2.SDL_NumJoysticks()
for j in range(num_joysticks):
sdl2.SDL_JoystickOpen(j)
# if a joystick is present, its axes report 128 for mid, not 0
for axis in (0, 1):
self.input_queue.put(
signals.Event(signals.STICK_MOVED, (j, axis, 128)))
# enable IME
sdl2.SDL_StartTextInput()
return video_graphical.VideoGraphical.__enter__(self)
def content(self):
# fmt: off
fg = pyui.Environment(
"text").color if self.language.value else sdl2.SDL_Color(
150, 150, 150)
yield pyui.VStack(spacing=20)(
pyui.HStack()(
pyui.TextField(self.language, "Add a new language"),
pyui.Button(action=self.new_language)(pyui.Text(
"Add {}".format(self.language.value)).color(fg), ).disable(
self.language.value == ""),
pyui.Spacer(),
),
pyui.ForEach(self.languages.value, lambda lang:
(DescriptionView(lang=lang))),
)
def renderText(message, font, renderer, color, size=10, bgcolor=sdl2.SDL_Color(0,0,0) ):
#We need to first render to a surface as that's what TTF_RenderText
#returns, then load that surface into a texture
surf = sdl2.sdlttf.TTF_RenderUTF8_Solid(font, message.encode('utf-8'), color)
sdl2.sdlttf.TTF_CloseFont(font)
if surf is None:
print("TTF_RenderText")
return None
texture = sdl2.SDL_CreateTextureFromSurface(renderer.sdlrenderer, surf)
if texture is None:
print("CreateTexture")
#Clean up the surface and font
width = surf.contents.w
height = surf.contents.h
sdl2.SDL_FreeSurface(surf)
# sdl2.sdlttf.TTF_CloseFont(font)
return texture,width,height
def load(self, class_name):
for key, value in self.theme.env(class_name.lower()).items():
if key in ("padding", "border"):
value = Insets(*value).scaled(self.scale)
elif key in ("color", "background", "border_color", "text_shadow"):
value = sdl2.SDL_Color(*value)
elif key == "priority":
value = Priority[value.upper()]
elif key == "position":
value = Position[value.upper()]
elif key == "alignment":
value = Alignment[value.upper()]
elif key == "spacing":
value = self.scaled(value)
elif key == "size":
value = Size(self.scaled(value[0]), self.scaled(value[1]))
elif key == "opacity":
value = clamp(float(value), 0.0, 1.0)
setattr(self, key, value)
def __init__(self):
self.meters_text = ''
self.time_text = ''
self.text_color = sdl2.SDL_Color(0, 0, 0) # black
# Keep track of values so that
# a new texture is only created when the values change
self.current_money = 0
self.current_health = 0
self.current_morale = 0
self.current_day = 0
self.current_time = 0
# SDL textures for rendering
self.meters_texture = None
self.time_texture = None
# Whether to recreate the texture for the next frame
self.recreate_texture = False
class Gamewindow(sdl.Renderer):
'''
This class contains the window and renderer for the game
with methods to draw the objects in objects_to_display module
'''
YELLOW = sdl2.SDL_Color(255, 255, 0, 0)
WHITE = sdl2.SDL_Color(255, 255, 255, 0)
BLACK = sdl2.SDL_Color(0, 0, 0, 0)
Rscore = sdl2.SDL_Rect(0, 0, 250, 50)
def __init__(self):
self.w = sdl.Window("Adnesh's Snake vs Block Game",
(gameinfo.WINDOW_WIDTH, gameinfo.WINDOW_HEIGHT))
sdl.Renderer.__init__(self, self.w)
self.mode = gameinfo.BLOCK_IN_MOTION
self.t = ttf.TTF_OpenFont(b"support/font.ttf", 30)
def __rendercircle(self, xc, yc, r=ob.Snake.RADIUS):
'''function to draw circle of radius and XY coordinates'''
for x in range(r):
y = floor(sqrt(r**2 - x**2))
self.draw_line((xc + x, yc + y, xc + x, yc - y))
self.draw_line((xc - x, yc + y, xc - x, yc - y))
def __renderblock(self, number, val, y):
'''drawing blocks of color according the strength of blocks'''
if 0 < val < 10:
self.color = gameinfo.COLOR_GRID["white-green"]
elif 9 < val < 20:
self.color = gameinfo.COLOR_GRID["green"]
elif 19 < val < 30:
self.color = gameinfo.COLOR_GRID["blue-green"]
elif 29 < val < 40:
self.color = gameinfo.COLOR_GRID["blue"]
else:
self.color = gameinfo.COLOR_GRID["red"]
sx = gameinfo.BLOCKSTART[number]
self.fill((sx, y - gameinfo.BLOCKSIZE, gameinfo.BLOCKSIZE,
gameinfo.BLOCKSIZE))
texttodisplay = "%2d" % val
sur = ttf.TTF_RenderText_Solid(self.t, texttodisplay.encode(),
self.BLACK)
tex = sdl2.SDL_CreateTextureFromSurface(self.sdlrenderer, sur)
Rblock = sdl2.SDL_Rect(sx + gameinfo.RECTSTART_X,
y - gameinfo.RECTSTART_Y, gameinfo.RECTWIDTH,
gameinfo.RECTHEIGHT)
sdl2.SDL_RenderCopy(self.sdlrenderer, tex, None, Rblock)
sdl2.SDL_FreeSurface(sur)
sdl2.SDL_DestroyTexture(tex)
def __renderblockrows(self, br):
'''draw all the blocks in rows'''
for row in br.row:
for b in range(ob.Row.MAX_PER_ROW):
if row.a[b] != 0:
self.__renderblock(b, row.a[b], row.pos)
def rendersnake(self, snake):
'''drawing snake object'''
if snake.l > 0:
self.color = gameinfo.COLOR_GRID["red-blue"]
for i in range(0, len(snake.a)):
self.__rendercircle(snake.a[i][0], snake.a[i][1])
if i > ob.Snake.SHOWABLE:
break
sur = ttf.TTF_RenderText_Solid(self.t,
snake.l.__str__().encode(),
self.WHITE)
tex = sdl2.SDL_CreateTextureFromSurface(self.sdlrenderer, sur)
Rsnake = sdl2.SDL_Rect(snake.head[0] - gameinfo.TSPACE_X,
snake.head[1] - gameinfo.TSPACE_Y,
gameinfo.TWIDTH, gameinfo.THEIGHT)
sdl2.SDL_RenderCopy(self.sdlrenderer, tex, None, Rsnake)
sdl2.SDL_FreeSurface(sur)
sdl2.SDL_DestroyTexture(tex)
def rendergoodies(self, g_row):
'''draw the goodies in game'''
self.color = sdl.Color(random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255), 0)
for r in g_row:
for g in range(r.num):
self.__rendercircle(r.co[g], r.pos, gameinfo.BONUSRADIUS)
def renderall(self, snake, br, g):
'''
a function which calls all other functions
to render the objects in the game
'''
self.__renderblockrows(br)
self.rendersnake(snake)
self.rendergoodies(g)
if self.mode == gameinfo.BLOCK_IN_MOTION:
self.mode = br.advance(snake)
for gd in g:
gd.pos += snake.s
if gd.pos > gameinfo.WINDOW_HEIGHT:
g.remove(gd)
else:
self.mode = snake.advance(br)
texttodisplay = "score:"
texttodisplay += "%8d" % snake.score
texttodisplay = texttodisplay.encode()
sur = ttf.TTF_RenderText_Solid(self.t, texttodisplay, self.YELLOW)
tex = sdl2.SDL_CreateTextureFromSurface(self.sdlrenderer, sur)
sdl2.SDL_RenderCopy(self.sdlrenderer, tex, self.Rscore, self.Rscore)
sdl2.SDL_FreeSurface(sur)
sdl2.SDL_DestroyTexture(tex)
snake.adjust()
def main():
# 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 = 20
# Initialise CEF for offscreen rendering
sys.excepthook = cef.ExceptHook
cef.Initialize(settings={"windowless_rendering_enabled": True})
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)
# 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)
# Create the renderer using hardware acceleration
renderer = sdl2.SDL_CreateRenderer(window, -1,
sdl2.render.SDL_RENDERER_ACCELERATED)
# 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/")
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
while running:
# 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
break
if event.type == sdl2.SDL_MOUSEBUTTONDOWN:
if event.button.button == sdl2.SDL_BUTTON_LEFT:
if event.button.y > headerHeight:
# 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:
# 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:
# 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.
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
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
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)
# User exited
exit_app()
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()
import ctypes
import sdl2
import numpy as np
import sdl2.sdlttf
import sdl2.ext
from collections import defaultdict
from sets import Set
import time
from SudokuMath import SudokuSolver
RESOURCES = sdl2.ext.Resources(".", "resources")
GREY = sdl2.ext.Color(200, 200, 200)
WHITE = sdl2.ext.Color(225, 225, 225)
BLACK = sdl2.SDL_Color(0, 0, 0)
CYAN = sdl2.SDL_Color(0, 70, 90)
GREEN = sdl2.ext.Color(0, 255, 0)
RED = sdl2.SDL_Color(255, 0, 0)
WINDOW_WIDTH = 900
WINDOW_HEIGHT = 1000
class Sudoku:
def __init__(self):
self.input = defaultdict(lambda: None)
self.block = defaultdict(lambda: None)
self.digit = defaultdict(lambda: None)
self.grid = defaultdict(lambda: None)
self.matrix = np.zeros((9,9),dtype=np.int8)
self.selected = False
def __init__(self) -> None:
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) < 0:
raise RuntimeError("SDL could not initialize! SDL Error: " +
str(sdl2.SDL_GetError()))
if not sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"1"):
print("Warning: Linear texture filtering not enabled.")
img_flags = sdl2.sdlimage.IMG_INIT_PNG
if not (sdl2.sdlimage.IMG_Init(img_flags) & img_flags):
raise RuntimeError(
"SDL_image could not initialize! SDL_image Error: " +
str(sdl2.sdlimage.IMG_GetError()))
if sdl2.sdlttf.TTF_Init() == -1:
raise RuntimeError(
"SDL_ttf could not initialize! SDL_ttf Error: " +
str(sdl2.sdlttf.TTF_GetError()))
settings = GameSettings('Test game', 800, 600)
window = sdl2.SDL_CreateWindow(bytes(settings.name, 'utf-8'),
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
settings.windowWidth,
settings.windowHeight,
sdl2.SDL_WINDOW_SHOWN)
if not window:
raise RuntimeError("Window could not be created. SDL Error: " +
str(sdl2.SDL_GetError()))
self.context = GameContext(
sdl2.SDL_CreateRenderer(
window, -1, sdl2.SDL_RENDERER_ACCELERATED
| sdl2.SDL_RENDERER_PRESENTVSYNC), settings)
sdl2.SDL_SetRenderDrawColor(self.context.renderer, 0xff, 0xff, 0xff,
0xff)
self.world = World(
self.context,
Rect.make(0, 0, self.context.settings.windowWidth / 2,
self.context.settings.windowHeight / 2))
self.ui = GameObject(
self.context,
Rect(Vector2D(), self.world.camera.originalSize.copy()))
player = Player(self.context, Rect.make(0, 20, 10, 20))
player.idleAnimation = Animation.animation_with_single_render_object(
RenderObject.render_object_from_file(self.context.renderer,
b"img/idle.png"))
player.moveAnimation = Animation.animation_with_speed_and_texture_path(
80, self.context.renderer, b"img/move.png", 40, 80, 6)
player.jumpAnimation = Animation.animation_with_single_render_object(
RenderObject.render_object_from_file(self.context.renderer,
b"img/jump.png"))
player.crouchAnimation = Animation.animation_with_single_render_object(
RenderObject.render_object_from_file(self.context.renderer,
b"img/crouch.png"))
player.crouchMoveAnimation = Animation.animation_with_single_render_object(
RenderObject.render_object_from_file(self.context.renderer,
b"img/crouch.png"))
player.speed = 1.3
player.jumpSpeed = 2.5
player.physics.gravityForce = 0.1
player.add_child(self.world.camera)
self.world.add_child(
Frame(
self.context,
Rect.make(0, 0, self.world.frame.size.width,
self.world.frame.size.height), 10))
count = 200
power_count = 100
x = int(self.world.frame.size.width / 10 - 2)
y = int(self.world.frame.size.height / 10 - 2)
for pair in random.sample(set(pair_range(x, y)), count):
random_x = pair[0]
random_y = pair[1]
rect = Rect.make(
(self.world.frame.size.width / 2) - 15 - random_x * 10,
(self.world.frame.size.height / 2) - 15 - random_y * 10, 10,
10)
if power_count:
game_object = Consumable(self.context, rect)
game_object.renderObject = RenderObject.render_object_from_color(
self.context.renderer, Color(0, 0xff, 0, 0x80))
power_count -= 1
else:
game_object = Solid(self.context, rect)
game_object.renderObject = RenderObject.render_object_from_file(
self.context.renderer, b"img/brick.png")
self.world.add_child(game_object)
self.world.add_child(player)
self.ui = GameObject(self.context,
Rect(Vector2D(), self.world.camera.originalSize))
death_text = Text(self.context, Rect.make(0, 0, 100, 10))
death_text.set_text(b"You died! Game Over!")
death_text.set_font(b"fonts/Scratch_.ttf", 28)
death_text.set_color(sdl2.SDL_Color(0xff, 0, 0))
death_text.visible = False
self.ui.add_child(death_text)
player.deathText = death_text
win_text = Text(self.context, Rect.make(0, 0, 100, 10))
win_text.set_text(b"Congratulations! You won!")
win_text.set_font(b"fonts/Scratch_.ttf", 28)
win_text.set_color(sdl2.SDL_Color(0, 0xff, 0))
win_text.visible = False
self.ui.add_child(win_text)
player.winText = win_text
health_bar_holder = GameObject(
self.context,
Rect.make(-self.world.camera.originalSize.width / 2 + 16,
-self.world.camera.originalSize.height / 2 + 2.5, 30, 3))
health_bar_holder.renderObject = RenderObject.render_object_from_color(
self.context.renderer, Color.black())
self.ui.add_child(health_bar_holder)
power_bar_holder = GameObject(
self.context,
Rect.make(self.world.camera.originalSize.width / 2 - 16,
-self.world.camera.originalSize.height / 2 + 2.5, 30, 3))
power_bar_holder.renderObject = RenderObject.render_object_from_color(
self.context.renderer, Color.black())
self.ui.add_child(power_bar_holder)
health_bar = Bar(self.context, Rect.make(0, 0, 29, 2))
health_bar.renderObject = RenderObject.render_object_from_color(
self.context.renderer, Color.red())
health_bar_holder.add_child(health_bar)
player.healthBar = health_bar
power_bar = Bar(self.context, Rect.make(0, 0, 29, 2))
power_bar.renderObject = RenderObject.render_object_from_color(
self.context.renderer, Color.green())
power_bar.set_value(0)
power_bar_holder.add_child(power_bar)
player.powerBar = power_bar
def shadow(self, *rgba):
if not rgba or rgba[0] is None:
self.env.text_shadow = None
else:
self.env.text_shadow = sdl2.SDL_Color(*rgba)
return self
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 background(self, *rgba):
if not rgba or rgba[0] is None:
self.env.background = None
else:
self.env.background = sdl2.SDL_Color(*rgba)
return self
def border_color(self, *rgba):
if not rgba or rgba[0] is None:
self.env.border_color = None
else:
self.env.border_color = sdl2.SDL_Color(*rgba)
return self
import sdl2
import sdl2.sdlttf
from ctypes import byref, cast, POINTER, c_int
WHITE = sdl2.SDL_Color(255, 255, 255)
BLACK = sdl2.SDL_Color(0, 0, 0)
RED = sdl2.SDL_Color(255, 32, 32)
class GameList:
def __init__(self, currentState):
self.currentState = currentState
sdl2.sdlttf.TTF_Init()
self.font = sdl2.sdlttf.TTF_OpenFont(b"fonts/PTS55F.ttf", 28)
def render(self, renderer):
i = 0
for game in self.currentState.roms:
currentColor = WHITE
if self.currentState.getCurrentRom() == game:
currentColor = RED
surf = sdl2.sdlttf.TTF_RenderText_Blended(
self.font, game.name.encode("utf-8"), currentColor).contents
text = sdl2.SDL_CreateTextureFromSurface(renderer, surf)
sdl2.SDL_SetTextureBlendMode(text, sdl2.SDL_BLENDMODE_BLEND)
sdl2.SDL_FreeSurface(surf)
w, h = c_int(), c_int()
sdl2.SDL_QueryTexture(text, None, None, byref(w), byref(h))
def __init__(self):
self.messages = []
self.text_color = sdl2.SDL_Color(0, 0, 0) # black
