def __init__(self, label_text, icon, on_disk=False, **kwargs): super().__init__(**kwargs) self._icon = icon if on_disk: self._file = open(self._icon, "rb") image = OnDiskBitmap(self._file) tile_grid = TileGrid(image, pixel_shader=ColorConverter()) else: image, palette = adafruit_imageload.load(icon) tile_grid = TileGrid(image, pixel_shader=palette) self.append(tile_grid) _label = bitmap_label.Label( terminalio.FONT, scale=1, text=label_text, anchor_point=(0.5, 0), anchored_position=(image.width // 2, image.height), ) self.append(_label) self.touch_boundary = ( 0, 0, image.width, image.height + _label.bounding_box[3], )
def __init__(self, map_json_file): super().__init__() f = open("good_map_2.json", "r") self._map_obj = json.loads(f.read()) f.close() self.player_loc = {"x": 1, "y": 1} self._tile_properties = {0: {"can_walk": True}} if "tiles" in self.map_obj['tilesets'][0]: print("has tiles") for _tile in self.map_obj['tilesets'][0]['tiles']: _tile_id = _tile["id"] if _tile_id not in self.tile_properties: self.tile_properties[_tile_id] = {} for _property in _tile["properties"]: self.tile_properties[_tile_id][_property["name"]] = _property["value"] _sprite_sheet_image = self.map_obj["tilesets"][0]["image"] # Load the sprite sheet (bitmap) self._sprite_sheet, self._palette = adafruit_imageload.load(_sprite_sheet_image, bitmap=Bitmap, palette=Palette) self._palette.make_transparent(0) # Create the background TileGrid self._background_tilegrid = TileGrid(self._sprite_sheet, pixel_shader=self._palette, width=10, height=8, tile_width=16, tile_height=16, default_tile=15) # Create the castle TileGrid self._entity_tilegrid = TileGrid(self._sprite_sheet, pixel_shader=self._palette, width=10, height=8, tile_width=16, tile_height=16, default_tile=17) # Create the sprite TileGrid self._sprite_tilegrid = TileGrid(self._sprite_sheet, pixel_shader=self._palette, width=1, height=1, tile_width=16, tile_height=16, default_tile=0) self.append(self._background_tilegrid) self.append(self._entity_tilegrid) self.append(self._sprite_tilegrid) self._load_tilegrids() # put the sprite somewhere in the castle self._sprite_tilegrid.x = 16 * self.player_loc["x"] self._sprite_tilegrid.y = 16 * self.player_loc["y"]
def _create_background_box(self, lines: int, y_offset: int) -> TileGrid: """Private Class function to create a background_box :param lines: int number of lines :param y_offset: int y pixel bottom coordinate for the background_box""" left = self._bounding_box[0] if self._background_tight: # draw a tight bounding box box_width = self._bounding_box[2] box_height = self._bounding_box[3] x_box_offset = 0 y_box_offset = self._bounding_box[1] else: # draw a "loose" bounding box to include any ascenders/descenders. ascent, descent = self._ascent, self._descent if self._label_direction in ("UPR", "DWR", "TTB"): box_height = (self._bounding_box[3] + self._padding_top + self._padding_bottom) x_box_offset = -self._padding_bottom box_width = ((ascent + descent) + int( (lines - 1) * self._width * self._line_spacing) + self._padding_left + self._padding_right) else: box_width = (self._bounding_box[2] + self._padding_left + self._padding_right) x_box_offset = -self._padding_left box_height = ((ascent + descent) + int( (lines - 1) * self._height * self._line_spacing) + self._padding_top + self._padding_bottom) if self._base_alignment: y_box_offset = -ascent - self._padding_top else: y_box_offset = -ascent + y_offset - self._padding_top box_width = max(0, box_width) # remove any negative values box_height = max(0, box_height) # remove any negative values if self._label_direction == "UPR": movx = left + x_box_offset movy = -box_height - x_box_offset elif self._label_direction == "DWR": movx = left + x_box_offset movy = x_box_offset elif self._label_direction == "TTB": movx = left + x_box_offset movy = x_box_offset else: movx = left + x_box_offset movy = y_box_offset background_bitmap = Bitmap(box_width, box_height, 1) tile_grid = TileGrid( background_bitmap, pixel_shader=self._background_palette, x=movx, y=movy, ) return tile_grid
def show_image(path): with open(path, 'rb') as f: bitmap = OnDiskBitmap(f) pixel_shader = ColorConverter() sprite = TileGrid(bitmap, pixel_shader=pixel_shader) group = Group() group.append(sprite) board.DISPLAY.show(group) board.DISPLAY.wait_for_frame()
def __init__(self, bitmap, palette): super().__init__(scale=1) self.tilegrid = TileGrid(bitmap, pixel_shader=palette, width=1, height=1, tile_width=16, tile_height=16) self.append(self.tilegrid) self._source_index = 0 self.animating = False
def _update_text(self, new_text: str) -> None: # pylint: disable=too-many-branches,too-many-statements x = 0 y = 0 if self._added_background_tilegrid: i = 1 else: i = 0 tilegrid_count = i if self._base_alignment: self._y_offset = 0 else: self._y_offset = self._ascent // 2 if self._label_direction == "RTL": left = top = bottom = 0 right = None elif self._label_direction == "LTR": right = top = bottom = 0 left = None else: top = right = left = 0 bottom = 0 for character in new_text: if character == "\n": y += int(self._height * self._line_spacing) x = 0 continue glyph = self._font.get_glyph(ord(character)) if not glyph: continue position_x, position_y = 0, 0 if self._label_direction in ("LTR", "RTL"): bottom = max(bottom, y - glyph.dy + self._y_offset) if y == 0: # first line, find the Ascender height top = min(top, -glyph.height - glyph.dy + self._y_offset) position_y = y - glyph.height - glyph.dy + self._y_offset if self._label_direction == "LTR": right = max(right, x + glyph.shift_x, x + glyph.width + glyph.dx) if x == 0: if left is None: left = glyph.dx else: left = min(left, glyph.dx) position_x = x + glyph.dx else: left = max( left, abs(x) + glyph.shift_x, abs(x) + glyph.width + glyph.dx ) if x == 0: if right is None: right = glyph.dx else: right = max(right, glyph.dx) position_x = x - glyph.width elif self._label_direction == "TTB": if x == 0: if left is None: left = glyph.dx else: left = min(left, glyph.dx) if y == 0: top = min(top, -glyph.dy) bottom = max(bottom, y + glyph.height, y + glyph.height + glyph.dy) right = max( right, x + glyph.width + glyph.dx, x + glyph.shift_x + glyph.dx ) position_y = y + glyph.dy position_x = x - glyph.width // 2 + self._y_offset elif self._label_direction == "UPR": if x == 0: if bottom is None: bottom = -glyph.dx if y == 0: # first line, find the Ascender height bottom = min(bottom, -glyph.dy) left = min(left, x - glyph.height + self._y_offset) top = min(top, y - glyph.width - glyph.dx, y - glyph.shift_x) right = max(right, x + glyph.height, x + glyph.height - glyph.dy) position_y = y - glyph.width - glyph.dx position_x = x - glyph.height - glyph.dy + self._y_offset elif self._label_direction == "DWR": if y == 0: if top is None: top = -glyph.dx top = min(top, -glyph.dx) if x == 0: left = min(left, -glyph.dy) left = min(left, x, x - glyph.dy - self._y_offset) bottom = max(bottom, y + glyph.width + glyph.dx, y + glyph.shift_x) right = max(right, x + glyph.height) position_y = y + glyph.dx position_x = x + glyph.dy - self._y_offset if glyph.width > 0 and glyph.height > 0: face = TileGrid( glyph.bitmap, pixel_shader=self._palette, default_tile=glyph.tile_index, tile_width=glyph.width, tile_height=glyph.height, x=position_x, y=position_y, ) if self._label_direction == "UPR": face.transpose_xy = True face.flip_x = True if self._label_direction == "DWR": face.transpose_xy = True face.flip_y = True if tilegrid_count < len(self._local_group): self._local_group[tilegrid_count] = face else: self._local_group.append(face) tilegrid_count += 1 if self._label_direction == "RTL": x = x - glyph.shift_x if self._label_direction == "TTB": if glyph.height < 2: y = y + glyph.shift_x else: y = y + glyph.height + 1 if self._label_direction == "UPR": y = y - glyph.shift_x if self._label_direction == "DWR": y = y + glyph.shift_x if self._label_direction == "LTR": x = x + glyph.shift_x i += 1 if self._label_direction == "LTR" and left is None: left = 0 if self._label_direction == "RTL" and right is None: right = 0 if self._label_direction == "TTB" and top is None: top = 0 while len(self._local_group) > tilegrid_count: # i: self._local_group.pop() if self._label_direction == "RTL": # pylint: disable=invalid-unary-operand-type # type-checkers think left can be None self._bounding_box = (-left, top, left - right, bottom - top) if self._label_direction == "TTB": self._bounding_box = (left, top, right - left, bottom - top) if self._label_direction == "UPR": self._bounding_box = (left, top, right, bottom - top) if self._label_direction == "DWR": self._bounding_box = (left, top, right, bottom - top) if self._label_direction == "LTR": self._bounding_box = (left, top, right - left, bottom - top) self._text = new_text if self._background_color is not None: self._set_background_color(self._background_color)
def zoom_animation(self, touch_point): """Performs zoom animation when icon is pressed. :param touch_point: x,y location of the screen. :type touch_point: Tuple[x,y] :return: None """ if self._animation_time > 0: try: _image, _palette = adafruit_imageload.load(self._icon) if len(self.__class__.palette_buffer) < len(_palette) + 1: self._animation_time = 0 # skip any animation print( "Warning: IconAnimated - icon bitmap exceeds IconAnimated.max_color_depth;" " defaulting to no animation") except NotImplementedError: self._animation_time = 0 # skip any animation print( "Warning: IconAnimated - True color BMP unsupported for animation;" " defaulting to no animation") if self._animation_time > 0: animation_bitmap = self.__class__.bitmap_buffer animation_palette = self.__class__.palette_buffer # store the current display refresh setting refresh_status = self.__class__.display.auto_refresh ### ## Update the zoom palette and bitmap buffers and append the tilegrid ### # copy the image palette, add a transparent color at the end for i, color in enumerate(_palette): animation_palette[i] = color animation_palette[len(animation_palette) - 1] = 0x000000 animation_palette.make_transparent(len(animation_palette) - 1) # create the zoom bitmap larger than the original image to allow for zooming animation_bitmap.fill(len(animation_palette) - 1) # transparent fill animation_bitmap.blit( (animation_bitmap.width - _image.width) // 2, (animation_bitmap.height - _image.height) // 2, _image, ) # blit the image into the center of the zoom_bitmap # place zoom_bitmap at same location as image animation_tilegrid = TileGrid(animation_bitmap, pixel_shader=animation_palette) animation_tilegrid.x = -(animation_bitmap.width - _image.width) // 2 animation_tilegrid.y = -(animation_bitmap.height - _image.height) // 2 self.__class__.display.auto_refresh = False # set auto_refresh off self[0].hidden = True # hide the original icon self.append(animation_tilegrid) # add to the self group. # Animation: zoom larger start_time = time.monotonic() while True: elapsed_time = time.monotonic() - start_time position = min( 1.0, easein(elapsed_time / self._animation_time)) # fractional position animation_bitmap.fill(len(animation_palette) - 1) bitmaptools.rotozoom( dest_bitmap=animation_bitmap, ox=animation_bitmap.width // 2, oy=animation_bitmap.height // 2, source_bitmap=_image, px=_image.width // 2, py=_image.height // 2, scale=1.0 + position * (self._scale - 1.0), # start scaling at 1.0 angle=position * self._angle, ) self.__class__.display.refresh() if elapsed_time > self._animation_time: break # set display.auto_refresh back to original value self.__class__.display.auto_refresh = refresh_status del _image del _palette gc.collect() self._zoomed = True
if cam.width > width: continue if cam.height > height: continue try: bitmap = Bitmap(cam.width, cam.height, 65535) break except MemoryError: continue print(width, height, cam.width, cam.height) if bitmap is None: raise SystemExit("Could not allocate a bitmap") g = Group(scale=1, x=(width - cam.width) // 2, y=(height - cam.height) // 2) tg = TileGrid( bitmap, pixel_shader=ColorConverter(input_colorspace=Colorspace.RGB565_SWAPPED)) g.append(tg) display.show(g) t0 = time.monotonic_ns() display.auto_refresh = False while True: cam.capture(bitmap) bitmap.dirty() display.refresh(minimum_frames_per_second=0) t1 = time.monotonic_ns() print("fps", 1e9 / (t1 - t0)) t0 = t1