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("SCORE 123456780", '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