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 __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 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 free(self):
"""
Free the image's data. Should be called when it is not needed anymore.
"""
if self.surface != None:
sdl2.SDL_FreeSurface(self.surface)
if self.texture != None:
sdl2.SDL_DestroyTexture(self.texture)
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 __exit__(self, exc_type, exc_value, traceback):
sdl2.SDL_DestroyTexture(self.texture_graph)
sdl2.SDL_DestroyTexture(self.texture_text)
sdl2.SDL_DestroyTexture(self.texture_scroll)
sdl2.SDL_DestroyTexture(self.font_text)
sdl2.SDL_DestroyTexture(self.font_text_inverted)
sdl2.SDL_DestroyTexture(self.font_graph)
sdl2.SDL_DestroyTexture(self.font_graph_inverted)
# clean up stored picts
for pict in list(self.picts.values()):
sdl2.SDL_DestroyTexture(pict)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_Quit()
def set(self, money, health, morale, day, time):
if self.different_values(money, health, morale, day, time):
self.recreate_texture = True
self.meters_text = "$" + str(money) + " - Health: "\
+ str(int(health)) + " / 100 - Morale: "\
+ str(int(morale)) + " / 100"
self.time_text = 'Day: ' + str(day) + ' - Time: '\
+ self.get_formatted_time(time)
# Free texture
sdl2.SDL_DestroyTexture(self.meters_texture)
sdl2.SDL_DestroyTexture(self.time_texture)
# Update current values
self.current_money = money
self.current_health = health
self.current_morale = morale
self.current_time = time
else:
self.recreate_texture = False
def __del__(self):
del self.joysticks_interface
if self.has_sdl_gamecontroller:
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_GAMECONTROLLER)
if self.has_sdl_joystick:
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_JOYSTICK)
if self.has_sdl_audio:
sdl2.SDL_CloseAudioDevice(self.audio_dev)
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_AUDIO)
sdl2.SDL_DestroyTexture(self.texture)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_DestroyWindow(self.screen)
sdl2.SDL_Quit()
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 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 renderImage(image, blocks, ren):
# create all the blocks
ren_blocks = []
for block in blocks:
pixels = bytearray()
for row in range(8):
val = block[row]
for digit in range(8):
if val & 1 == 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)
val = val >> 1
ren_block = sdl2.SDL_CreateTexture(ren.sdlrenderer,
sdl2.SDL_PIXELFORMAT_ABGR8888,
sdl2.SDL_TEXTUREACCESS_STATIC, 8, 8)
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(6):
for x in range(8):
texture = ren_blocks[image[y * 8 + 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))
for ren_block in ren_blocks:
sdl2.SDL_DestroyTexture(ren_block)
def render(self, renderer, font, screen_height):
self.remove_expired_messages()
row = 1
for message in self.messages:
# Create font surface
text_surface = sdl2.sdlttf.TTF_RenderText_Solid(
font, str.encode(message.text), self.text_color)
# Create texture from surface
text_texture = sdl2.SDL_CreateTextureFromSurface(
renderer, text_surface)
# Free surface
sdl2.SDL_FreeSurface(text_surface)
# Query dimensions
width, height = self.text_dimensions(text_texture)
# Render to window
sdl2.SDL_RenderCopyEx(
renderer, text_texture, None,
sdl2.SDL_Rect(MessageStack.x_offset,
screen_height - MessageStack.spacing * row,
width, height), 0.0, None, sdl2.SDL_FLIP_NONE)
# Free texture
sdl2.SDL_DestroyTexture(text_texture)
row += 1
def __del__(self):
if self.surface:
sdl2.SDL_FreeSurface(self.surface)
for texture in self.texture_cache.values():
if texture:
sdl2.SDL_DestroyTexture(texture)
def finish(self):
if self.window:
sdl2.SDL_DestroyTexture(self.texture)
sdl2.SDL_DestroyRenderer(self.renderer)
sdl2.SDL_DestroyWindow(self.window)
sdl2.SDL_Quit()
def OnPaint(self, element_type, paint_buffer, **_):
"""
Using the pixel data from CEF's offscreen rendering
the data is converted by PIL into a SDL2 surface
which can then be rendered as a SDL2 texture.
"""
if element_type == cef.PET_VIEW:
image = Image.frombuffer(
'RGBA',
(self.__width, self.__height),
paint_buffer.GetString(mode="rgba", origin="top-left"),
'raw',
'BGRA'
)
# Following PIL to SDL2 surface code from pysdl2 source.
mode = image.mode
rmask = gmask = bmask = amask = 0
depth = None
pitch = None
if mode == "RGB":
# 3x8-bit, 24bpp
if sdl2.endian.SDL_BYTEORDER == sdl2.endian.SDL_LIL_ENDIAN:
rmask = 0x0000FF
gmask = 0x00FF00
bmask = 0xFF0000
else:
rmask = 0xFF0000
gmask = 0x00FF00
bmask = 0x0000FF
depth = 24
pitch = self.__width * 3
elif mode in ("RGBA", "RGBX"):
# RGBX: 4x8-bit, no alpha
# RGBA: 4x8-bit, alpha
if sdl2.endian.SDL_BYTEORDER == sdl2.endian.SDL_LIL_ENDIAN:
rmask = 0x00000000
gmask = 0x0000FF00
bmask = 0x00FF0000
if mode == "RGBA":
amask = 0xFF000000
else:
rmask = 0xFF000000
gmask = 0x00FF0000
bmask = 0x0000FF00
if mode == "RGBA":
amask = 0x000000FF
depth = 32
pitch = self.__width * 4
else:
logging.error("ERROR: Unsupported mode: %s" % mode)
exit_app()
pxbuf = image.tobytes()
# Create surface
surface = sdl2.SDL_CreateRGBSurfaceFrom(
pxbuf,
self.__width,
self.__height,
depth,
pitch,
rmask,
gmask,
bmask,
amask
)
if self.texture:
# free memory used by previous texture
sdl2.SDL_DestroyTexture(self.texture)
# Create texture
self.texture = sdl2.SDL_CreateTextureFromSurface(self.__renderer,
surface)
# Free the surface
sdl2.SDL_FreeSurface(surface)
else:
logging.warning("Unsupport element_type in OnPaint")
def unload(self): for texture in self.textures: sdl2.SDL_DestroyTexture(self.textures[texture])
def close(self):
sdl2.SDL_DestroyTexture(self._texture)
del self._renderer
del self._window
sdl2.ext.quit()
def clear_renderer(self, renderer):
renderer_key = str(renderer.contents)
if renderer_key in self._sdl_textures and \
self._sdl_textures[renderer_key] != None:
sdl.SDL_DestroyTexture(self._sdl_textures[renderer_key])
self._sdl_textures[renderer_key] = None
def __del__(self):
if self._surface:
sdl2.SDL_FreeSurface(self._surface)
if self._texture:
sdl2.SDL_DestroyTexture(self._texture)
def __del__(self):
TTF_CloseFont(self.font)
for surface, size in self.surfaces.values():
sdl2.SDL_FreeSurface(surface)
for tex, size in self.glyphs.values():
sdl2.SDL_DestroyTexture(tex)
screen_width = ctypes.c_int(0) screen_height = ctypes.c_int(0) sdl2.SDL_GetRendererOutputSize(renderer.sdlrenderer, ctypes.byref(screen_width), ctypes.byref(screen_height)) # # #Get the texture w/h so we can center it in the screen x = screen_width.value / 2 - iW / 2 y = screen_height.value / 2 - iH / 2 r = True event = sdl2.SDL_Event() while r: if sdl2.SDL_PollEvent(event): if event.type == sdl2.SDL_QUIT: r = False elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED: sdl2.SDL_GetRendererOutputSize(renderer.sdlrenderer, ctypes.byref(screen_width), ctypes.byref(screen_height)) x = screen_width.value / 2 - iW / 2 y = screen_height.value / 2 - iH / 2 if r: sdl2.SDL_RenderClear(renderer.sdlrenderer) #We can draw our message as we do any other texture, since it's been #rendered to a texture renderTexture(image, renderer, int(x), int(y)) renderTexture(image2, renderer, int(x), int(y+iH)) sdl2.SDL_RenderPresent(renderer.sdlrenderer) sdl2.SDL_DestroyTexture(image) # sdl2.SDL_DestroyRenderer(renderer) # sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def delete(self):
sdl2.SDL_DestroyTexture(self.texture)
self.ref_count = 0
240 * ZOOM + 1))
xy = hue_wheel.hs_to_xy(hsbk[:HSBK_BR])
xy_frac, xy_int = numpy.modf(xy)
dot_surface, dot_data = image_to_surface(
hue_wheel.render_dot(hsbk_to_rgb.convert(hsbk), xy_frac[XY_x],
xy_frac[XY_y])[::-1, :, :])
dot_texture = sdl2.SDL_CreateTextureFromSurface(renderer, dot_surface)
assert dot_texture
sdl2.SDL_FreeSurface(dot_surface)
del dot_data
sdl2.SDL_RenderCopy(
renderer, dot_texture, None,
sdl2.SDL_Rect(16 * ZOOM - 15 + int(xy_int[XY_x]),
360 * ZOOM - 15 - int(xy_int[XY_y]), 31, 31))
sdl2.SDL_DestroyTexture(dot_texture)
sdl2.SDL_RenderPresent(renderer)
if sdl2.SDL_WaitEventTimeout(ctypes.byref(event), 1):
if event.type == sdl2.SDL_QUIT:
sdl2.SDL_Quit()
sys.exit(EXIT_SUCCESS)
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
if (event.button.button == sdl2.SDL_BUTTON_LEFT
and process_click_or_drag(event.button.x, event.button.y,
now) and redraw_timeout is None):
redraw_timeout = now + .001
elif event.type == sdl2.SDL_MOUSEMOTION:
if (event.motion.state & sdl2.SDL_BUTTON_LMASK
and process_click_or_drag(event.motion.x, event.motion.y,
def clear(self):
for k in self._sdl_textures:
if self._sdl_textures[k] != None:
sdl.SDL_DestroyTexture(self._sdl_textures[k])
self._sdl_textures[k] = None
