def __init__(self, rend, inv): entity.__init__(self) if inv: self.texture = sdl2.SDL_CreateTextureFromSurface( rend, IMG_Load(pipe_path_inv)) self.surface = sdl2.SDL_Rect(pipeBaseX, -175, pipeWidth, pipeHeight) else: self.texture = sdl2.SDL_CreateTextureFromSurface( rend, IMG_Load(pipe_path)) self.surface = sdl2.SDL_Rect(pipeBaseX, 275, pipeWidth, pipeHeight)
def __init__(self, rend): entity.__init__(self) self.texture = [sdl2.SDL_CreateTextureFromSurface(rend, IMG_Load(img0)), sdl2.SDL_CreateTextureFromSurface(rend, IMG_Load(blank)), sdl2.SDL_CreateTextureFromSurface(rend, IMG_Load(blank))] self.isScore = True self.surface0 = sdl2.SDL_Rect(300, 25, 97-70, 129-80) self.surface1 = sdl2.SDL_Rect(300 - 40, 25, 97-70, 129-80) self.surface2 = sdl2.SDL_Rect(300 - (2 * 40), 25, 97-70, 129-80) self.count = 0 self.rend = rend self.update_textures()
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 LoadTexture(self, filepath): surface = sdl2.sdlimage.IMG_Load(filepath) texture = sdl2.SDL_CreateTextureFromSurface(self.sdl_renderer, surface) sdl2.SDL_FreeSurface(surface) self.loaded_textures[filepath] = texture return texture
def create_text(self, renderer, font): # Create font surface meters_surface = sdl2.sdlttf.TTF_RenderText_Solid( font, str.encode(self.meters_text), self.text_color) time_surface = sdl2.sdlttf.TTF_RenderText_Solid( font, str.encode(self.time_text), self.text_color) # Create texture from surface self.meters_texture = sdl2.SDL_CreateTextureFromSurface( renderer, meters_surface) self.time_texture = sdl2.SDL_CreateTextureFromSurface( renderer, time_surface) # Free surface sdl2.SDL_FreeSurface(meters_surface) sdl2.SDL_FreeSurface(time_surface)
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 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 _create_inverted_texture(self, surface): # copy the pixels in sdl2.SDL_LockSurface(surface) surface_p = ctypes.c_void_p.from_address(surface.contents.pixels) pixelsize = surface.contents.format.contents.BytesPerPixel assert pixelsize == 3 bytecount = surface.contents.w * surface.contents.h * pixelsize # create memory for copy of pixel data new_p = (ctypes.c_uint8 * bytecount)() ref_p = ctypes.byref(new_p) ctypes.memmove(ref_p, ctypes.byref(surface_p), bytecount) sdl2.SDL_UnlockSurface(surface) # swap pixels m = memoryview(new_p).cast('B') i = 0 j = pixelsize while j < bytecount: if m[i:j] == b'\xee\xe8\xe8': m[i:j] = b'\x10\x10\x10' else: m[i:j] = b'\xee\xe8\xe8' i += pixelsize j += pixelsize new_surface = sdl2.SDL_CreateRGBSurfaceWithFormatFrom( ref_p, surface.contents.w, surface.contents.h, surface.contents.format.contents.BitsPerPixel, surface.contents.pitch, surface.contents.format.contents.format) texture = sdl2.SDL_CreateTextureFromSurface(self.renderer, new_surface) sdl2.SDL_FreeSurface(new_surface) return texture
def _create_texture_from_pict(self, pict): print(f'Initializing pict: {pict.stringname}') width = 128 height = 64 pixelsize = 3 bytecount = width * height * pixelsize assert len(pict.image_bits) * pixelsize >= bytecount # create memory for pixel data new_p = (ctypes.c_uint8 * bytecount)() ref_p = ctypes.byref(new_p) # set pixels m = memoryview(new_p).cast('B') i = 0 j = pixelsize for pixel in pict.image_bits[:width * height]: if pixel: m[i:j] = b'\x10\x10\x10' else: m[i:j] = b'\xee\xe8\xe8' i += pixelsize j += pixelsize new_surface = sdl2.SDL_CreateRGBSurfaceWithFormatFrom( ref_p, width, height, 8 * pixelsize, width * pixelsize, sdl2.SDL_PIXELFORMAT_BGR24) texture = sdl2.SDL_CreateTextureFromSurface(self.renderer, new_surface) sdl2.SDL_FreeSurface(new_surface) return texture
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 render_object_from_surface(cls, renderer: sdl2.SDL_Renderer, surface: sdl2.SDL_Surface) -> RenderObject: texture = sdl2.SDL_CreateTextureFromSurface(renderer, surface) if not texture: raise RuntimeError( "Unable to create texture from surface! SDL Error: " + str(sdl2.SDL_GetError())) return RenderObject(texture)
def __init__(self, rend): entity.__init__(self) self.texture = sdl2.SDL_CreateTextureFromSurface( rend, IMG_Load(image_path)) self.surface = sdl2.SDL_Rect(80, 270, birdWidth, birdHeight) self.acc = 7.0 self.vel = 0.0 pass
def load(self, text, renderer, size=None, color=None): """Update a Text object.""" if self.texture: sdl2.SDL_DestroyTexture(self.texture) #That does the trick. surf = Text.font_manager.render(text, size=size, color=color) sprite = sdl2.ext.SoftwareSprite(surf, True) self.size = (surf.w, surf.h) self.texture = sdl2.SDL_CreateTextureFromSurface( renderer.renderer, sprite.surface)
def _load_texture(self, filename): filepath = path_join(dirname(__file__), filename).encode() surface = sdl2.SDL_LoadBMP(filepath) texture = sdl2.SDL_CreateTextureFromSurface(self.renderer, surface) # create a copy of inverted pixels inverted_texture = self._create_inverted_texture(surface) # free the surface sdl2.SDL_FreeSurface(surface) return texture, inverted_texture
def load(self, path, canvas: Canvas): """ Load the image from the specified filename. """ self.surface = img.IMG_Load(str.encode(path)) self.w = self.surface.contents.w self.h = self.surface.contents.h self.texture = sdl2.SDL_CreateTextureFromSurface( canvas.renderer, self.surface)
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 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 __convert_PIL_to_SDL(self, image): # Copied from sdl2.ext.image.load_image() # Thanks to Marcus von. Appen! endian = sdl2.endian mode = image.mode width, height = image.size rmask = gmask = bmask = amask = 0 if mode in ("1", "L", "P"): # 1 = B/W, 1 bit per byte # "L" = greyscale, 8-bit # "P" = palette-based, 8-bit pitch = width depth = 8 elif mode == "RGB": # 3x8-bit, 24bpp if endian.SDL_BYTEORDER == endian.SDL_LIL_ENDIAN: rmask = 0x0000FF gmask = 0x00FF00 bmask = 0xFF0000 else: rmask = 0xFF0000 gmask = 0x00FF00 bmask = 0x0000FF depth = 24 pitch = width * 3 elif mode in ("RGBA", "RGBX"): # RGBX: 4x8-bit, no alpha # RGBA: 4x8-bit, alpha if endian.SDL_BYTEORDER == endian.SDL_LIL_ENDIAN: rmask = 0x000000FF gmask = 0x0000FF00 bmask = 0x00FF0000 if mode == "RGBA": amask = 0xFF000000 else: rmask = 0xFF000000 gmask = 0x00FF0000 bmask = 0x0000FF00 if mode == "RGBA": amask = 0x000000FF depth = 32 pitch = width * 4 else: # We do not support CMYK or YCbCr for now raise TypeError("unsupported image format") pxbuf = image.tobytes() surface = sdl2.SDL_CreateRGBSurfaceFrom(pxbuf, width, height, depth, pitch, rmask, gmask, bmask, amask) return sdl2.SDL_CreateTextureFromSurface(self._renderer, surface)
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 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 run(args): sdl2.ext.init() window = sdl2.ext.Window( "Live scan", (800, 600), flags=(sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE), ) scanner_event_type = sdl2.SDL_RegisterEvents(1) if scanner_event_type == -1: raise RuntimeError() scanner_event = sdl2.SDL_Event() scanner_event.type = scanner_event_type factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) scanner = Scanner(args, scanner_event, factory) scanner.start() renderer = sdl2.ext.Renderer(window, logical_size=scanner.sprite.size) window.size = renderer.logical_size[0] * 20, renderer.logical_size[1] * 20 running = True tex = None while running: for event in sdl2.ext.get_events(): if event.type == sdl2.SDL_QUIT: running = False break if event.type == scanner_event_type: tex = sdl2.SDL_CreateTextureFromSurface( renderer.sdlrenderer, scanner.sprite.surface).contents renderer.copy(tex) renderer.present() if event.type == sdl2.SDL_WINDOWEVENT: win_ev = event.window if win_ev.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED: renderer.clear() if tex is not None: renderer.copy(tex) renderer.present() if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_s: im = contrast_enhance( surface_to_pil(scanner.completed_part.surface), args.contrast) im.save(args.image_out) window.refresh() scanner.join()
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 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 loadImageFile(imageFile, renderer): # Load into a surface surf = sdl2.sdlimage.IMG_Load(imageFile) if surf is None: print "IMG_Load failed" return None # Create a texture from the surface with the image texture = sdl2.SDL_CreateTextureFromSurface(renderer, surf) if texture is None: print "SDL_CreateTextureFromSurface failed" # Clean up the surface sdl2.SDL_FreeSurface(surf) return texture
def draw_rect(surface, x, y, w, h, angle=0, colour=(0, 0, 0, 0)): if len(colour) == 3: colour = (colour[0] % 256, colour[1] % 256, colour[2] % 256, 255) elif len(colour) == 4: colour = (colour[0] % 256, colour[1] % 256, colour[2] % 256, colour[3] % 256) surf = Surface(w, h) surf.fill((colour[0], colour[1], colour[2], colour[3])) text = sdl2.SDL_CreateTextureFromSurface(surface.renderer, surf.surface) dstrect = sdl2.SDL_Rect(x, y, w, h) sdl2.SDL_RenderCopyEx(surface.renderer, text, None, dstrect, -angle, sdl2.SDL_Point(0, 0), sdl2.SDL_FLIP_NONE)
def blit(self, surface, src=None, dest=None, angle=0): if src: srcrect = sdl2.SDL_Rect(src[0][0], src[0][1], src[1][0] - src[0][0], src[1][1] - src[0][1]) else: srcrect = None if dest: if len(dest) == 2: if src: dstrect = sdl2.SDL_Rect(dest[0] - srcrect.w / 2, dest[1] - srcrect.h / 2, srcrect.w, srcrect.h) else: dstrect = sdl2.SDL_Rect(dest[0] - surface.w / 2, dest[1] - surface.h / 2, surface.w, surface.h) elif len(dest) == 4: dstrect = sdl2.SDL_Rect() dstrect.w = dest[1][0] - dest[0][0] dstrect.h = dest[1][1] - dest[0][1] dstrect.x = dest[0][0] - dstrect.w / 2 dstrect.y = dest[0][1] - dstrect.h / 2 else: raise IndexError("\'dest\' should have 2 or 4 values. ") else: if src: dstrect = sdl2.SDL_Rect(dest[0] - srcrect.w / 2, dest[1] - srcrect.h / 2, srcrect.w, srcrect.h) else: dstrect = sdl2.SDL_Rect(0 - surface.w / 2, 0 - surface.h / 2, surface.w, surface.h) text = sdl2.SDL_CreateTextureFromSurface(self.renderer, surface.surface) sdl2.SDL_RenderCopyEx( self.renderer, text, srcrect, dstrect, -surface.angle - angle, sdl2.SDL_Point(round(surface.w / 2), round(surface.h / 2)), sdl2.SDL_FLIP_NONE)
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 renderText(message, font, color, renderer): # Render to a surface surf = sdl2.sdlttf.TTF_RenderUTF8_Blended(font, message.encode('utf8'), color) if surf is None: sdl2.sdlttf.TTF_CloseFont(font) print "TTF_RenderText failed" return None # Create a texture from the surface with the text texture = sdl2.SDL_CreateTextureFromSurface(renderer, surf) if texture is None: print "SDL_CreateTextureFromSurface failed" # Clean up the surface sdl2.SDL_FreeSurface(surf) return texture
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 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