X-Git-Url: https://git.ayoreis.com/hackapet/Adafruit_Blinka_Displayio.git/blobdiff_plain/33accffa7278997a55e237473c33880813def934..HEAD:/displayio/_tilegrid.py diff --git a/displayio/_tilegrid.py b/displayio/_tilegrid.py index cd27662..a3f21eb 100644 --- a/displayio/_tilegrid.py +++ b/displayio/_tilegrid.py @@ -23,9 +23,12 @@ from circuitpython_typing import WriteableBuffer from ._bitmap import Bitmap from ._colorconverter import ColorConverter from ._ondiskbitmap import OnDiskBitmap -from ._shape import Shape from ._palette import Palette -from ._structs import TransformStruct, InputPixelStruct, OutputPixelStruct +from ._structs import ( + InputPixelStruct, + OutputPixelStruct, + null_transform, +) from ._colorspace import Colorspace from ._area import Area @@ -34,7 +37,7 @@ __repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git" class TileGrid: - # pylint: disable=too-many-instance-attributes + # pylint: disable=too-many-instance-attributes, too-many-statements """Position a grid of tiles sourced from a bitmap and pixel_shader combination. Multiple grids can share bitmaps and pixel shaders. @@ -43,7 +46,7 @@ class TileGrid: def __init__( self, - bitmap: Union[Bitmap, OnDiskBitmap, Shape], + bitmap: Union[Bitmap, OnDiskBitmap], *, pixel_shader: Union[ColorConverter, Palette], width: int = 1, @@ -60,7 +63,7 @@ class TileGrid: tile_width and tile_height match the height of the bitmap by default. """ - if not isinstance(bitmap, (Bitmap, OnDiskBitmap, Shape)): + if not isinstance(bitmap, (Bitmap, OnDiskBitmap)): raise ValueError("Unsupported Bitmap type") self._bitmap = bitmap bitmap_width = bitmap.width @@ -76,6 +79,7 @@ class TileGrid: self._hidden_tilegrid = False self._hidden_by_parent = False self._rendered_hidden = False + self._name = "Tilegrid" self._x = x self._y = y self._width_in_tiles = width @@ -105,7 +109,7 @@ class TileGrid: (self._width_in_tiles * self._height_in_tiles) * [default_tile] ) self._in_group = False - self._absolute_transform = TransformStruct(0, 0, 1, 1, 1, False, False, False) + self._absolute_transform = None self._current_area = Area(0, 0, self._pixel_width, self._pixel_height) self._dirty_area = Area(0, 0, 0, 0) self._previous_area = Area(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF) @@ -116,27 +120,36 @@ class TileGrid: self._tiles_in_bitmap = self._bitmap_width_in_tiles * ( bitmap_height // tile_height ) + self._needs_refresh = True def _update_transform(self, absolute_transform): """Update the parent transform and child transforms""" + self._in_group = absolute_transform is not None self._absolute_transform = absolute_transform if self._absolute_transform is not None: + self._moved = True self._update_current_x() self._update_current_y() def _update_current_x(self): + self._needs_refresh = True if self._transpose_xy: width = self._pixel_height else: width = self._pixel_width - if self._absolute_transform.transpose_xy: + absolute_transform = ( + null_transform + if self._absolute_transform is None + else self._absolute_transform + ) + + if absolute_transform.transpose_xy: self._current_area.y1 = ( - self._absolute_transform.y + self._absolute_transform.dy * self._x + absolute_transform.y + absolute_transform.dy * self._x ) - self._current_area.y2 = ( - self._absolute_transform.y - + self._absolute_transform.dy * (self._x + width) + self._current_area.y2 = absolute_transform.y + absolute_transform.dy * ( + self._x + width ) if self._current_area.y2 < self._current_area.y1: self._current_area.y1, self._current_area.y2 = ( @@ -145,11 +158,10 @@ class TileGrid: ) else: self._current_area.x1 = ( - self._absolute_transform.x + self._absolute_transform.dx * self._x + absolute_transform.x + absolute_transform.dx * self._x ) - self._current_area.x2 = ( - self._absolute_transform.x - + self._absolute_transform.dx * (self._x + width) + self._current_area.x2 = absolute_transform.x + absolute_transform.dx * ( + self._x + width ) if self._current_area.x2 < self._current_area.x1: self._current_area.x1, self._current_area.x2 = ( @@ -158,18 +170,24 @@ class TileGrid: ) def _update_current_y(self): + self._needs_refresh = True if self._transpose_xy: height = self._pixel_width else: height = self._pixel_height - if self._absolute_transform.transpose_xy: + absolute_transform = ( + null_transform + if self._absolute_transform is None + else self._absolute_transform + ) + + if absolute_transform.transpose_xy: self._current_area.x1 = ( - self._absolute_transform.x + self._absolute_transform.dx * self._y + absolute_transform.x + absolute_transform.dx * self._y ) - self._current_area.x2 = ( - self._absolute_transform.x - + self._absolute_transform.dx * (self._y + height) + self._current_area.x2 = absolute_transform.x + absolute_transform.dx * ( + self._y + height ) if self._current_area.x2 < self._current_area.x1: self._current_area.x1, self._current_area.x2 = ( @@ -178,11 +196,10 @@ class TileGrid: ) else: self._current_area.y1 = ( - self._absolute_transform.y + self._absolute_transform.dy * self._y + absolute_transform.y + absolute_transform.dy * self._y ) - self._current_area.y2 = ( - self._absolute_transform.y - + self._absolute_transform.dy * (self._y + height) + self._current_area.y2 = absolute_transform.y + absolute_transform.dy * ( + self._y + height ) if self._current_area.y2 < self._current_area.y1: self._current_area.y1, self._current_area.y2 = ( @@ -224,12 +241,17 @@ class TileGrid: # If no tiles are present we have no impact tiles = self._tiles - if self._hidden_tilegrid or self._hidden_by_parent: + if tiles is None or len(tiles) == 0: return False - overlap = Area() - if not self._current_area.compute_overlap(area, overlap): + if self._hidden_tilegrid or self._hidden_by_parent: return False + overlap = Area() # area, current_area, overlap + if not area.compute_overlap(self._current_area, overlap): + return False + # else: + # print("Checking", area.x1, area.y1, area.x2, area.y2) + # print("Overlap", overlap.x1, overlap.y1, overlap.x2, overlap.y2) if self._bitmap.width <= 0 or self._bitmap.height <= 0: return False @@ -250,6 +272,8 @@ class TileGrid: start += (area.y2 - area.y1 - 1) * y_stride y_stride *= -1 + # Track if this layer finishes filling in the given area. We can ignore any remaining + # layers at that point. full_coverage = area == overlap transformed = Area() @@ -276,6 +300,7 @@ class TileGrid: else: y_shift = overlap.y1 - area.y1 + # This untransposes x and y so it aligns with bitmap rows if self._transpose_xy != self._absolute_transform.transpose_xy: x_stride, y_stride = y_stride, x_stride x_shift, y_shift = y_shift, x_shift @@ -290,6 +315,7 @@ class TileGrid: ) # In Pixels local_y = input_pixel.y // self._absolute_transform.scale for input_pixel.x in range(start_x, end_x): + # Compute the destination pixel in the buffer and mask based on the transformations offset = ( row_start + (input_pixel.x - start_x + x_shift) * x_stride ) # In Pixels @@ -312,13 +338,19 @@ class TileGrid: input_pixel.tile // self._bitmap_width_in_tiles ) * self._tile_height + local_y % self._tile_height - input_pixel.pixel = ( - self._bitmap._get_pixel( # pylint: disable=protected-access - input_pixel.tile_x, input_pixel.tile_y + output_pixel.pixel = 0 + input_pixel.pixel = 0 + + # We always want to read bitmap pixels by row first and then transpose into + # the destination buffer because most bitmaps are row associated. + if isinstance(self._bitmap, (Bitmap, OnDiskBitmap)): + input_pixel.pixel = ( + self._bitmap._get_pixel( # pylint: disable=protected-access + input_pixel.tile_x, input_pixel.tile_y + ) ) - ) - output_pixel.opaque = True + output_pixel.opaque = True if self._pixel_shader is None: output_pixel.pixel = input_pixel.pixel elif isinstance(self._pixel_shader, Palette): @@ -337,19 +369,19 @@ class TileGrid: if colorspace.depth == 16: struct.pack_into( "H", - buffer, - offset, + buffer.cast("B"), + offset * 2, output_pixel.pixel, ) elif colorspace.depth == 32: struct.pack_into( "I", - buffer, - offset, + buffer.cast("B"), + offset * 4, output_pixel.pixel, ) elif colorspace.depth == 8: - buffer[offset] = output_pixel.pixel & 0xFF + buffer.cast("B")[offset] = output_pixel.pixel & 0xFF elif colorspace.depth < 8: # Reorder the offsets to pack multiple rows into # a byte (meaning they share a column). @@ -361,31 +393,35 @@ class TileGrid: # even if we multiply it back out offset = ( col * pixels_per_byte - + (row // pixels_per_byte) * width + + (row // pixels_per_byte) * pixels_per_byte * width + (row % pixels_per_byte) ) shift = (offset % pixels_per_byte) * colorspace.depth if colorspace.reverse_pixels_in_byte: # Reverse the shift by subtracting it from the leftmost shift shift = (pixels_per_byte - 1) * colorspace.depth - shift - buffer[offset // pixels_per_byte] |= output_pixel.pixel << shift + buffer.cast("B")[offset // pixels_per_byte] |= ( + output_pixel.pixel << shift + ) + return full_coverage def _finish_refresh(self): - first_draw = self._previous_area.x1 == self._previous_area.x2 - hidden = self._hidden_tilegrid or self._hidden_by_parent - if not first_draw and hidden: - self._previous_area.x2 = self._previous_area.x1 - elif self._moved or first_draw: - self._current_area.copy_into(self._previous_area) - - self._moved = False - self._full_change = False - self._partial_change = False - if isinstance(self._pixel_shader, (Palette, ColorConverter)): - self._pixel_shader._finish_refresh() # pylint: disable=protected-access - if isinstance(self._bitmap, (Bitmap, Shape)): - self._bitmap._finish_refresh() # pylint: disable=protected-access + if not self._needs_refresh: + first_draw = self._previous_area.x1 == self._previous_area.x2 + hidden = self._hidden_tilegrid or self._hidden_by_parent + if not first_draw and hidden: + self._previous_area.x2 = self._previous_area.x1 + elif self._moved or first_draw: + self._current_area.copy_into(self._previous_area) + + self._moved = False + self._full_change = False + self._partial_change = False + if isinstance(self._pixel_shader, (Palette, ColorConverter)): + self._pixel_shader._finish_refresh() # pylint: disable=protected-access + if isinstance(self._bitmap, Bitmap): + self._bitmap._finish_refresh() # pylint: disable=protected-access def _get_refresh_areas(self, areas: list[Area]) -> None: # pylint: disable=invalid-name, too-many-branches, too-many-statements @@ -397,14 +433,17 @@ class TileGrid: self._rendered_hidden = True if not first_draw: areas.append(self._previous_area) + self._needs_refresh = False return if self._moved and not first_draw: self._previous_area.union(self._current_area, self._dirty_area) if self._dirty_area.size() < 2 * self._pixel_width * self._pixel_height: areas.append(self._dirty_area) + self._needs_refresh = False return areas.append(self._current_area) areas.append(self._previous_area) + self._needs_refresh = False return tail = areas[-1] if areas else None @@ -412,7 +451,7 @@ class TileGrid: if isinstance(self._bitmap, Bitmap): self._bitmap._get_refresh_areas(areas) # pylint: disable=protected-access refresh_area = areas[-1] if areas else None - if tail != refresh_area: + if refresh_area != tail: # Special case a TileGrid that shows a full bitmap and use its # dirty area. Copy it to ours so we can transform it. if self._tiles_in_bitmap == 1: @@ -420,12 +459,6 @@ class TileGrid: self._partial_change = True else: self._full_change = True - elif isinstance(self._bitmap, Shape): - self._bitmap._get_refresh_areas(areas) # pylint: disable=protected-access - refresh_area = areas[-1] if areas else None - if refresh_area != tail: - refresh_area.copy_into(self._dirty_area) - self._partial_change = True self._full_change = self._full_change or ( isinstance(self._pixel_shader, (Palette, ColorConverter)) @@ -433,6 +466,7 @@ class TileGrid: ) if self._full_change or first_draw: areas.append(self._current_area) + self._needs_refresh = False return if self._partial_change: @@ -476,6 +510,62 @@ class TileGrid: self._dirty_area.x1, ) areas.append(self._dirty_area) + self._needs_refresh = False + + def _set_hidden(self, hidden: bool) -> None: + self._needs_refresh = True + self._hidden_tilegrid = hidden + self._rendered_hidden = False + if not hidden: + self._full_change = True + + def _set_hidden_by_parent(self, hidden: bool) -> None: + self._needs_refresh = True + self._hidden_by_parent = hidden + self._rendered_hidden = False + if not hidden: + self._full_change = True + + def _get_rendered_hidden(self) -> bool: + return self._rendered_hidden + + def _set_all_tiles(self, tile_index: int) -> None: + """Set all tiles to the given tile index""" + if tile_index >= self._tiles_in_bitmap: + raise ValueError("Tile index out of bounds") + self._tiles = bytearray( + (self._width_in_tiles * self._height_in_tiles) * [tile_index] + ) + self._full_change = True + + def _set_tile(self, x: int, y: int, tile_index: int) -> None: + self._needs_refresh = True + self._tiles[y * self._width_in_tiles + x] = tile_index + temp_area = Area() + if not self._partial_change: + tile_area = self._dirty_area + else: + tile_area = temp_area + top_x = (x - self._top_left_x) % self._width_in_tiles + if top_x < 0: + top_x += self._width_in_tiles + tile_area.x1 = top_x * self._tile_width + tile_area.x2 = tile_area.x1 + self._tile_width + top_y = (y - self._top_left_y) % self._height_in_tiles + if top_y < 0: + top_y += self._height_in_tiles + tile_area.y1 = top_y * self._tile_height + tile_area.y2 = tile_area.y1 + self._tile_height + + if self._partial_change: + self._dirty_area.union(temp_area, self._dirty_area) + + self._partial_change = True + + def _set_top_left(self, x: int, y: int) -> None: + self._top_left_x = x + self._top_left_y = y + self._full_change = True @property def hidden(self) -> bool: @@ -487,7 +577,8 @@ class TileGrid: def hidden(self, value: bool): if not isinstance(value, (bool, int)): raise ValueError("Expecting a boolean or integer value") - self._hidden_tilegrid = bool(value) + value = bool(value) + self._set_hidden(value) @property def x(self) -> int: @@ -499,8 +590,10 @@ class TileGrid: if not isinstance(value, int): raise TypeError("X should be a integer type") if self._x != value: + self._moved = True self._x = value - self._update_current_x() + if self._absolute_transform is not None: + self._update_current_x() @property def y(self) -> int: @@ -512,8 +605,10 @@ class TileGrid: if not isinstance(value, int): raise TypeError("Y should be a integer type") if self._y != value: + self._moved = True self._y = value - self._update_current_y() + if self._absolute_transform is not None: + self._update_current_y() @property def flip_x(self) -> bool: @@ -525,7 +620,9 @@ class TileGrid: if not isinstance(value, bool): raise TypeError("Flip X should be a boolean type") if self._flip_x != value: + self._needs_refresh = True self._flip_x = value + self._full_change = True @property def flip_y(self) -> bool: @@ -537,7 +634,9 @@ class TileGrid: if not isinstance(value, bool): raise TypeError("Flip Y should be a boolean type") if self._flip_y != value: + self._needs_refresh = True self._flip_y = value + self._full_change = True @property def transpose_xy(self) -> bool: @@ -547,13 +646,18 @@ class TileGrid: return self._transpose_xy @transpose_xy.setter - def transpose_xy(self, value: bool): + def transpose_xy(self, value: bool) -> None: if not isinstance(value, bool): raise TypeError("Transpose XY should be a boolean type") if self._transpose_xy != value: + self._needs_refresh = True self._transpose_xy = value + if self._pixel_width == self._pixel_height: + self._full_change = True + return self._update_current_x() self._update_current_y() + self._moved = True @property def pixel_shader(self) -> Union[ColorConverter, Palette]: @@ -570,21 +674,21 @@ class TileGrid: ) self._pixel_shader = new_pixel_shader + self._full_change = True + self._needs_refresh = True @property - def bitmap(self) -> Union[Bitmap, OnDiskBitmap, Shape]: - """The Bitmap, OnDiskBitmap, or Shape that is assigned to this TileGrid""" + def bitmap(self) -> Union[Bitmap, OnDiskBitmap]: + """The Bitmap or OnDiskBitmap that is assigned to this TileGrid""" return self._bitmap @bitmap.setter - def bitmap(self, new_bitmap: Union[Bitmap, OnDiskBitmap, Shape]) -> None: - if ( - not isinstance(new_bitmap, Bitmap) - and not isinstance(new_bitmap, OnDiskBitmap) - and not isinstance(new_bitmap, Shape) + def bitmap(self, new_bitmap: Union[Bitmap, OnDiskBitmap]) -> None: + if not isinstance(new_bitmap, Bitmap) and not isinstance( + new_bitmap, OnDiskBitmap ): raise TypeError( - "Unsupported Type: new_bitmap must be Bitmap, OnDiskBitmap, or Shape" + "Unsupported Type: new_bitmap must be Bitmap or OnDiskBitmap" ) if ( @@ -593,7 +697,9 @@ class TileGrid: ): raise ValueError("New bitmap must be same size as old bitmap") + self._needs_refresh = True self._bitmap = new_bitmap + self._full_change = True def _extract_and_check_index(self, index): if isinstance(index, (tuple, list)): @@ -609,23 +715,23 @@ class TileGrid: or index >= len(self._tiles) ): raise ValueError("Tile index out of bounds") - return index + return x, y def __getitem__(self, index: Union[Tuple[int, int], int]) -> int: """Returns the tile index at the given index. The index can either be an x,y tuple or an int equal to ``y * width + x``'. """ - index = self._extract_and_check_index(index) - return self._tiles[index] + x, y = self._extract_and_check_index(index) + return self._tiles[y * self._width_in_tiles + x] def __setitem__(self, index: Union[Tuple[int, int], int], value: int) -> None: """Sets the tile index at the given index. The index can either be an x,y tuple or an int equal to ``y * width + x``. """ - index = self._extract_and_check_index(index) + x, y = self._extract_and_check_index(index) if not 0 <= value <= 255: raise ValueError("Tile value out of bounds") - self._tiles[index] = value + self._set_tile(x, y, value) @property def width(self) -> int: