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