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, rend): if self.isScore: sdl2.SDL_RenderCopy(rend, self.texture[0], None, ctypes.byref(self.surface0)) sdl2.SDL_RenderCopy(rend, self.texture[1], None, ctypes.byref(self.surface1)) sdl2.SDL_RenderCopy(rend, self.texture[2], None, ctypes.byref(self.surface2)) else: sdl2.SDL_RenderCopy(rend, self.texture, None, ctypes.byref(self.surface)) pass
def draw(self, renderer, rect): self.load_surface() if self._texture is None: self._texture = sdl2.SDL_CreateTextureFromSurface( renderer, self._surface) sdl2.SDL_RenderCopy(renderer, self._texture, None, ctypes.byref(rect.sdl))
def renderImage(image, ren): # create all the blocks frame = sdl2.SDL_CreateTexture(ren.sdlrenderer, sdl2.SDL_PIXELFORMAT_ABGR8888, sdl2.SDL_TEXTUREACCESS_STATIC, 64, 48) pixels = bytearray() col = image[0] # first value is whether black or not for val in image[2:]: for count in range(val + 1): if col: pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) else: pixels.append(0) pixels.append(0) pixels.append(0) pixels.append(0) col = not col pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels) sdl2.SDL_UpdateTexture(frame, None, pointer, 64 * 4) # draw the frame sdl2.SDL_RenderCopy(ren.sdlrenderer, frame, sdl2.SDL_Rect(0, 0, 64, 48), sdl2.SDL_Rect(128, 0, 128, 96)) sdl2.SDL_DestroyTexture(frame)
def render_background(self, entities, textures): sdl2.SDL_RenderCopy(self.sdl_renderer, textures.get(TextureType.GRASS), None, sdl2.SDL_Rect( int(entities.map_rectangle[0] - self.camera.x), int(entities.map_rectangle[1] - self.camera.y), entities.map_rectangle[2], entities.map_rectangle[3]))
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 render(self, renderer, rect, alpha=255, scale=1.0): def _scale(v): return int(math.ceil(v / (self.scale / scale))) texture = self.get_texture(renderer) s = self.slice_rects mid_w = rect.width - _scale(s[0].width) - _scale(s[2].width) mid_h = rect.height - _scale(s[0].height) - _scale(s[6].height) x1 = rect.left + _scale(s[0].width) x2 = rect.right - _scale(s[2].width) y1 = rect.top + _scale(s[0].height) y2 = rect.bottom - _scale(s[6].height) rects = [ Rect([rect.left, rect.top], [_scale(s[0].width), _scale(s[0].height)]), Rect([x1, rect.top], [mid_w, _scale(s[1].height)]), Rect([x2, rect.top], [_scale(s[2].width), _scale(s[2].height)]), Rect([rect.left, y1], [_scale(s[3].width), mid_h]), Rect([x1, y1], [mid_w, mid_h]), Rect([x2, y1], [_scale(s[5].width), mid_h]), Rect([rect.left, y2], [_scale(s[6].width), _scale(s[6].height)]), Rect([x1, y2], [mid_w, _scale(s[7].height)]), Rect([x2, y2], [_scale(s[8].width), _scale(s[8].height)]), ] sdl2.SDL_SetTextureAlphaMod(texture, alpha) for idx in range(len(s)): src = s[idx] dst = rects[idx] sdl2.SDL_RenderCopy(renderer, texture, ctypes.byref(src.sdl), ctypes.byref(dst.sdl))
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 draw(self, renderer, text, rect, color, selected=None, kerning=True, wrap=True, lines=None): """ Renders text in the specified rect, using the specified color. If specified, selected is a set of indexes in text that should be highlighted. """ y = rect.top if lines is None: lines = list( self.layout(text, rect.width, kerning=kerning, wrap=wrap)) for line in lines: for idx, code, x, kern, extent in line: tex, size = self.glyph(renderer, code) sdl2.SDL_SetTextureColorMod(tex, color.r, color.g, color.b) sdl2.SDL_SetTextureAlphaMod(tex, color.a) dst = sdl2.SDL_Rect(rect.left + x + kern, y, size.w, size.h) sdl2.SDL_RenderCopy(renderer, tex, None, ctypes.byref(dst)) if selected and idx in selected: sdl2.SDL_SetRenderDrawColor(renderer, 20, 60, 120, 255) sdl2.SDL_SetRenderDrawBlendMode(renderer, sdl2.SDL_BLENDMODE_ADD) sdl2.SDL_RenderFillRect( renderer, sdl2.SDL_Rect(rect.left + x, y, size.w + kern, size.h)) y += self.line_height return lines
def renderImage(image, blocks, ren): # create all the blocks ren_blocks = [] for block in blocks: ren_block = sdl2.SDL_CreateTexture(ren.sdlrenderer, sdl2.SDL_PIXELFORMAT_ABGR8888, sdl2.SDL_TEXTUREACCESS_STATIC, 8, 8) pixels = bytearray() for p in range(64): if block[p] == 1: pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) pixels.append(0xff) else: pixels.append(0) pixels.append(0) pixels.append(0) pixels.append(0) pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels) sdl2.SDL_UpdateTexture(ren_block, None, pointer, 8 * 4) ren_blocks.append(ren_block) # draw the image from the blocks for y in range(12): for x in range(16): texture = ren_blocks[image[y * 16 + x]] # texture=ren_blocks[0] sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 8, 8), sdl2.SDL_Rect(128 + x * 8, y * 8, 8, 8))
def render_background(self, renderer, screen_width, screen_height): sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255) sdl2.SDL_RenderCopy( renderer, self.texture, None, sdl2.SDL_Rect(int(screen_width - self.size), int(screen_height - self.size), int(self.size), int(self.size)))
def reprocessImage(file, ren, all_blocks): surface = sdl_image.IMG_Load(file.encode("utf-8")) pixels = sdl2.ext.PixelView(surface.contents) image = Image() texture = sdl2.SDL_CreateTextureFromSurface(ren.sdlrenderer, surface) for y in range(0, 6): for x in range(0, 8): this_block = Block.fromPixels(pixels, x, y) # find match for block best_match = 64 match_index = -1 for index in range(len(all_blocks)): match = this_block.diffWithTolerance(all_blocks[index], best_match) if match <= best_match: # found best match so far match_index = index best_match = match if best_match == 0: # perfect match found so break # don't look further if match_index >= 0: image.append(match_index) # store best match else: print("no match found within tolerance - problem") exit(1) # draw source image sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 64, 48), sdl2.SDL_Rect(0, 0, 128, 96)) return image
def paint(self, canvas, x, y): """ Paints the frame with its top-left corner at the x,y. """ x, y = canvas.transform[-1].position(x, y) srcrect = sdl2.SDL_Rect(x=self.x, y=self.y, w=self.w, h=self.h) dstrect = sdl2.SDL_Rect(x=int(x), y=int(y), w=self.w, h=self.h) sdl2.SDL_RenderCopy(canvas.renderer, self.image.texture, srcrect, dstrect)
def processImage(file, ren): surface = sdl_image.IMG_Load(file.encode("utf-8")) pixels = sdl2.ext.PixelView(surface.contents) image = Image() blocks = [Block.black(), Block.white()] # w = surface.contents.w # h = surface.contents.h # print(f"Opened image - width:{w}, height:{h}.") # print("Processing image...") texture = sdl2.SDL_CreateTextureFromSurface(ren.sdlrenderer, surface) new_block = 0 for y in range(0, 12): for x in range(0, 16): this_block = Block() # get the next block from image for by in range(0, 8): for bx in range(0, 8): # print(f"0x{pixels[y][x]:01x}") if pixels[y * 8 + by][x * 8 + bx] == 0xffffffff: this_block.append(1) # print("1", end='') else: this_block.append(0) # print("0", end='') # print('') # this_block.append(pixels[y][x]) # check if this block has been used already found = False for index in range(len(blocks)): if this_block.diffWithTolerance(blocks[index], 5) < 5: # if this_block==old_block: found = True # store record of which block this is in output image.append(index) break if not found: # if not store it image.append(len(blocks)) # store record of which block this is in output blocks.append(this_block) # draw source image sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 128, 96), sdl2.SDL_Rect(0, 0, 128, 96)) # output # print(f"Image: {file}") # for y in range(0, 12): # for x in range(0, 16): # print(f" {image[x + y * 16]}", end="") # print("") # print("Blocks:",len(blocks)) return image, blocks
def _locate_out(self, message): # todo: wrap lines that are long if self.text_line > 7: # it's scroll time! Save the current texture sdl2.SDL_SetRenderTarget(self.renderer, self.texture_scroll) sdl2.SDL_RenderCopy(self.renderer, self.texture_text, None, None) # wipe the current texture self._render_begin(self.texture_text) self._clear_screen() # write the bottom of the scrolled texture to the top of out text screen src = sdl2.SDL_Rect(0, 8, 128, 56) dst = sdl2.SDL_Rect(0, 0, 128, 56) sdl2.SDL_RenderCopy(self.renderer, self.texture_scroll, src, dst) locate(self.renderer, self.font_text, 1, 7, message) else: self._render_begin(self.texture_text) locate(self.renderer, self.font_text, 1, self.text_line, message) self.text_line += 1 self._render_end()
def paint(self, canvas, x, y): """ Paint the image with its top-left corner residing in the x,y coordinates provided. """ x, y = canvas.transform[-1].position(x, y) w, h = self.w, self.h #canvas.transform[-1].size(self.w, self.h) dstrect = sdl2.SDL_Rect(x=int(x), y=int(y), w=int(self.w), h=int(self.h)) sdl2.SDL_RenderCopy(canvas.renderer, self.texture, None, dstrect)
def text(renderer, texture, x, y, message): i = 0 while i < len(message): c = message[i:i + 1] if c in (b'\x7f', b'\xe6', b'\xf7'): i += 1 c += message[i:i + 1] src = GRAPH_RECTS.get(c, GRAPH_RECT_DEFAULT) dst = sdl2.SDL_Rect(x, y, src.w, src.h) sdl2.SDL_RenderCopy(renderer, texture, src, dst) x += src.w i += 1
def locate(renderer, texture, x, y, message): i = 0 while i < len(message): c = message[i:i + 1] if c in (b'\x7f', b'\xe6', b'\xf7'): i += 1 c += message[i:i + 1] src = TEXT_RECTS.get(c, TEXT_RECT_DEFAULT) dst = sdl2.SDL_Rect((x - 1) * 6 + 1, (y - 1) * 8, src.w, src.h) sdl2.SDL_RenderCopy(renderer, texture, src, dst) x += 1 i += 1
def _save_pict(self, num): pict = self.picts.get(num) if not pict: pict = sdl2.SDL_CreateTexture(self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64) self.picts[num] = pict # render current texture to pict sdl2.SDL_SetRenderTarget(self.renderer, pict) sdl2.SDL_RenderCopy(self.renderer, self.texture_graph, None, None) sdl2.SDL_SetRenderTarget(self.renderer, None)
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 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 processImage(file, ren): surface = sdl_image.IMG_Load(file.encode("utf-8")) pixels = sdl2.ext.PixelView(surface.contents) image = Image() # w = surface.contents.w # h = surface.contents.h # print(f"Opened image - width:{w}, height:{h}.") # print("Processing image...") texture = sdl2.SDL_CreateTextureFromSurface(ren.sdlrenderer, surface) max_count = 0 count = 0 col = (pixels[0] == 0xffffffff) image.append(col) # store whether frame starts with black or white image.append(0) # for bits count for y in range(0, 48): for x in range(0, 64): pix = (pixels[y][x] == 0xffffffff) if col == pix: count += 1 else: image.append(count) max_count = max(count, max_count) count = 0 col = pix if count > 0: image.append(count) max_count = max(count, max_count) bits = 0 while 2**bits < max_count: bits += 1 image[1] = bits # draw source image sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 64, 48), sdl2.SDL_Rect(0, 0, 128, 96)) sdl2.SDL_DestroyTexture(texture) # output # print(f"Image: {file}") # for y in range(0, 12): # for x in range(0, 16): # print(f" {image[x + y * 16]}", end="") # print("") # print("Blocks:",len(blocks)) return image
def processImage(file, ren): surface = sdl_image.IMG_Load(file.encode("utf-8")) pixels = sdl2.ext.PixelView(surface.contents) image = Image() blocks = [Block.black(), Block.white()] # w = surface.contents.w # h = surface.contents.h # print(f"Opened image - width:{w}, height:{h}.") # print("Processing image...") texture = sdl2.SDL_CreateTextureFromSurface(ren.sdlrenderer, surface) new_block = 0 for y in range(0, 6): for x in range(0, 8): this_block = Block.fromPixels(pixels, x, y) # check if this block has been used already found = False num_blocks = len(blocks) for index in range(num_blocks): # if this_block.diffWithTolerance(blocks[index],5)<5: if this_block == blocks[index]: found = True # store record of which block this is in output image.append( index ) # storing images on first pass isn't needed, but let's me draw preview blocks[index].count += 1 break if not found: # if not store it image.append(len(blocks)) # store record of which block this is in output blocks.append(this_block) # draw source image sdl2.SDL_RenderCopy(ren.sdlrenderer, texture, sdl2.SDL_Rect(0, 0, 64, 48), sdl2.SDL_Rect(0, 0, 128, 96)) # output # print(f"Image: {file}") # for y in range(0, 12): # for x in range(0, 16): # print(f" {image[x + y * 16]}", end="") # print("") # print("Blocks:",len(blocks)) return image, blocks
def renderTexture(tex, ren, x, y): """ :type ren: SDL_Renderer :type tex: SDL_Texture """ #Setup the destination rectangle to be at the position we want dst = sdl2.SDL_Rect(x, y) w = ctypes.c_int() h = ctypes.c_int() #Query the texture to get its width and height to use sdl2.SDL_QueryTexture(tex, None, None, w, h) dst.w = w.value dst.h = h.value sdl2.SDL_RenderCopy(ren.sdlrenderer, tex, None, dst)
def draw(self, renderer, font, x, y, color=Color.white): global _reuse_rect tex = self.texture_for_renderer(renderer, font) w = ctypes.c_int32() h = ctypes.c_int32() w.value = 0 h.value = 0 sdl.SDL_QueryTexture(tex, None, None, ctypes.byref(w), ctypes.byref(h)) _reuse_rect.x = x _reuse_rect.y = y _reuse_rect.w = w.value _reuse_rect.h = h.value sdl.SDL_SetTextureColorMod(tex, color.red, color.green, color.blue) sdl.SDL_RenderCopy(renderer, tex, None, _reuse_rect)
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_text(self, x, y, text): self.dst.x = x self.dst.y = y for i, c in enumerate(text): if not 0 <= c < 256: logger.warn(f"Invalid character {c} in {bytes(text).decode('cp437')}") # This may error too... c = 0 self.src.y = 16 * c if self.dst.x > self.width - 8: logger.warn(f"Text overrun while printing {bytes(text).decode('cp437')}") break if cythonmode: sdl2.SDL_RenderCopy(self._sdlrenderer, self.font_texture, address(self.src), address(self.dst)) else: exec( "sdl2.SDL_RenderCopy(self._sdlrenderer, self.font_texture, self.src, self.dst)", globals(), locals() ) self.dst.x += 8
def raw_texture(self, texture, pos=(0, 0)): try: sdl_texture = texture.data except AttributeError: pil_data = texture.get_pil_data() if pil_data.mode not in 'RGBA': pil_data = pil_data.convert('RGBA') sdl_texture = self.__convert_PIL_to_SDL(pil_data) texture.set_backend_data(sdl_texture) dx = texture.width dy = texture.height x, y = pos y = self.height - y - dy rect_src = sdl2.SDL_Rect(0, 0, dx, dy) rect_dest = sdl2.SDL_Rect(int(x), int(y), dx, dy) source = sdl_texture sdl2.SDL_RenderCopy(self._renderer, source, rect_src, rect_dest)
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 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)) sdl2.SDL_RenderCopy(renderer, text, None, sdl2.SDL_Rect(50, 50 + (i * 40), w, h)) i += 1