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
