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
