refactor(rendering): movie clips rendering feature almost done (buggy for now)

Author: danila-schelkov

system/lib/features/cut_sprites.py

@@ -2,6 +2,10 @@
 from pathlib import Path
 
 from system.lib.console import Console
+from system.lib.matrices import Matrix2x3
+from system.lib.objects.renderable.renderable_factory import (
+    create_renderable_from_plain,
+)
 from system.lib.swf import SupercellSWF
 from system.localization import locale
 
@@ -12,26 +16,28 @@ def render_objects(swf: SupercellSWF, output_folder: Path):
     os.makedirs(output_folder / "movie_clips", exist_ok=True)
 
     # TODO: Too slow, fix it
-    # movie_clips_skipped = 0
-    # movie_clip_count = len(swf.movie_clips)
-    # for movie_clip_index in range(movie_clip_count):
-    #     movie_clip = swf.movie_clips[movie_clip_index]
-    #
-    #     rendered_movie_clip = movie_clip.render(swf)
-    #     if sum(rendered_movie_clip.size) >= 2:
-    #         clip_name = movie_clip.export_name or movie_clip.id
-    #         rendered_movie_clip.save(f"{output_folder}/movie_clips/{clip_name}.png")
-    #     else:
-    #         # For debug:
-    #         # logger.warning(f'MovieClip {movie_clip.id} cannot be rendered.')
-    #         movie_clips_skipped += 1
-    #
-    #     Console.progress_bar(
-    #         "Rendering movie clips (%d/%d). Skipped count: %d"
-    #         % (movie_clip_index + 1, movie_clip_count, movie_clips_skipped),
-    #         movie_clip_index,
-    #         movie_clip_count,
-    #     )
+    movie_clips_skipped = 0
+    movie_clip_count = len(swf.movie_clips)
+    for movie_clip_index in range(movie_clip_count):
+        movie_clip = swf.movie_clips[movie_clip_index]
+
+        rendered_movie_clip = create_renderable_from_plain(swf, movie_clip).render(
+            Matrix2x3()
+        )
+        if sum(rendered_movie_clip.size) >= 2:
+            clip_name = movie_clip.export_name or movie_clip.id
+            rendered_movie_clip.save(f"{output_folder}/movie_clips/{clip_name}.png")
+        else:
+            # For debug:
+            # logger.warning(f'MovieClip {movie_clip.id} cannot be rendered.')
+            movie_clips_skipped += 1
+
+        Console.progress_bar(
+            "Rendering movie clips (%d/%d). Skipped count: %d"
+            % (movie_clip_index + 1, movie_clip_count, movie_clips_skipped),
+            movie_clip_index,
+            movie_clip_count,
+        )
 
     print()
 
@@ -47,7 +53,7 @@ def render_objects(swf: SupercellSWF, output_folder: Path):
             shapes_count,
         )
 
-        rendered_shape = shape.render()
+        rendered_shape = create_renderable_from_plain(swf, shape).render(Matrix2x3())
         rendered_shape.save(f"{output_folder}/shapes/{shape.id}.png")
 
         regions_count = len(shape.regions)

system/lib/matrices/matrix2x3.py

@@ -1,3 +1,5 @@
+from typing import Self
+
 from system.bytestream import Reader
 
 DEFAULT_MULTIPLIER = 1024
@@ -6,19 +8,27 @@
 
 class Matrix2x3:
     """
-    This matrix looks like:
+    self matrix looks like:
     [a c x]
     [b d y]
     """
 
-    def __init__(self):
+    def __init__(self, matrix: Self | None = None):
         self.a: float = 1
         self.b: float = 0
         self.c: float = 0
         self.d: float = 1
         self.x: float = 0
         self.y: float = 0
 
+        if matrix is not None:
+            self.a = matrix.a
+            self.b = matrix.b
+            self.c = matrix.c
+            self.d = matrix.d
+            self.x = matrix.x
+            self.y = matrix.y
+
     def load(self, reader: Reader, tag: int):
         divider: int
         if tag == 8:
@@ -40,3 +50,20 @@ def apply_x(self, x: float, y: float):
 
     def apply_y(self, x: float, y: float):
         return y * self.d + x * self.b + self.y
+
+    def multiply(self, matrix: Self) -> Self:
+        a = (self.a * matrix.a) + (self.b * matrix.c)
+        b = (self.a * matrix.b) + (self.b * matrix.d)
+        c = (self.d * matrix.d) + (self.c * matrix.b)
+        d = (self.d * matrix.c) + (self.c * matrix.a)
+        x = matrix.apply_x(self.x, self.y)
+        y = matrix.apply_y(self.x, self.y)
+
+        self.a = a
+        self.b = b
+        self.d = c
+        self.c = d
+        self.x = x
+        self.y = y
+
+        return self

system/lib/matrices/matrix_bank.py

@@ -4,20 +4,20 @@
 
 class MatrixBank:
     def __init__(self):
-        self.matrices: list[Matrix2x3] = []
-        self.color_transforms: list[ColorTransform] = []
+        self._matrices: list[Matrix2x3] = []
+        self._color_transforms: list[ColorTransform] = []
 
     def init(self, matrix_count: int, color_transform_count: int):
-        self.matrices = []
+        self._matrices = []
         for i in range(matrix_count):
-            self.matrices.append(Matrix2x3())
+            self._matrices.append(Matrix2x3())
 
-        self.color_transforms = []
+        self._color_transforms = []
         for i in range(color_transform_count):
-            self.color_transforms.append(ColorTransform())
+            self._color_transforms.append(ColorTransform())
 
     def get_matrix(self, index: int) -> Matrix2x3:
-        return self.matrices[index]
+        return self._matrices[index]
 
     def get_color_transform(self, index: int) -> ColorTransform:
-        return self.color_transforms[index]
+        return self._color_transforms[index]

system/lib/objects/movie_clip/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["MovieClip", "MovieClipFrame"]
+
+from system.lib.objects.movie_clip.movie_clip import MovieClip
+from system.lib.objects.movie_clip.movie_clip_frame import MovieClipFrame

system/lib/objects/movie_clip.py renamed to system/lib/objects/movie_clip/movie_clip.py

@@ -2,10 +2,8 @@
 
 from typing import TYPE_CHECKING
 
-from PIL import Image
-
-from system.bytestream import Reader
-from system.lib.matrices import Matrix2x3
+from ..plain_object import PlainObject
+from .movie_clip_frame import MovieClipFrame
 
 if TYPE_CHECKING:
     from system.lib.swf import SupercellSWF
@@ -14,38 +12,14 @@
 CACHE = {}
 
 
-class MovieClipFrame:
-    def __init__(self):
-        self._elements_count: int = 0
-        self._label: str | None = None
-
-        self._elements: list[tuple[int, int, int]] = []
-
-    def load(self, reader: Reader) -> None:
-        self._elements_count = reader.read_short()
-        self._label = reader.read_string()
-
-    def get_elements_count(self) -> int:
-        return self._elements_count
-
-    def set_elements(self, elements: list[tuple[int, int, int]]) -> None:
-        self._elements = elements
-
-    def get_elements(self) -> list[tuple[int, int, int]]:
-        return self._elements
-
-    def get_element(self, index: int) -> tuple[int, int, int]:
-        return self._elements[index]
-
-
-class MovieClip:
+class MovieClip(PlainObject):
     def __init__(self):
         super().__init__()
 
         self.id = -1
         self.export_name: str | None = None
         self.fps: int = 30
-        self.frames_count: int = 0
+        self.frame_count: int = 0
         self.frames: list[MovieClipFrame] = []
         self.frame_elements: list[tuple[int, int, int]] = []
         self.blends: list[int] = []
@@ -56,7 +30,7 @@ def load(self, swf: SupercellSWF, tag: int):
         self.id = swf.reader.read_ushort()
 
         self.fps = swf.reader.read_char()
-        self.frames_count = swf.reader.read_ushort()
+        self.frame_count = swf.reader.read_ushort()
 
         if tag in (3, 14):
             pass
@@ -113,6 +87,3 @@ def load(self, swf: SupercellSWF, tag: int):
                 self.matrix_bank_index = swf.reader.read_uchar()
             else:
                 swf.reader.read(frame_length)
-
-    def render(self, swf: SupercellSWF, matrix: Matrix2x3 | None = None) -> Image.Image:
-        raise Exception("Not implemented yet")

system/lib/objects/movie_clip/movie_clip_frame.py

@@ -0,0 +1,25 @@
+from system.bytestream import Reader
+
+
+class MovieClipFrame:
+    def __init__(self):
+        self._elements_count: int = 0
+        self._label: str | None = None
+
+        self._elements: list[tuple[int, int, int]] = []
+
+    def load(self, reader: Reader) -> None:
+        self._elements_count = reader.read_short()
+        self._label = reader.read_string()
+
+    def get_elements_count(self) -> int:
+        return self._elements_count
+
+    def set_elements(self, elements: list[tuple[int, int, int]]) -> None:
+        self._elements = elements
+
+    def get_elements(self) -> list[tuple[int, int, int]]:
+        return self._elements
+
+    def get_element(self, index: int) -> tuple[int, int, int]:
+        return self._elements[index]

system/lib/objects/plain_object.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from system.lib.swf import SupercellSWF
+
+
+class PlainObject(ABC):
+    @abstractmethod
+    def load(self, swf: SupercellSWF, tag: int):
+        ...

system/lib/objects/renderable/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from PIL import Image
+
+from system.lib.math.rect import Rect
+from system.lib.matrices import ColorTransform, Matrix2x3
+
+
+class DisplayObject(ABC):
+    def __init__(self):
+        self._matrix = Matrix2x3()
+        self._color_transform = ColorTransform()
+
+    @abstractmethod
+    def calculate_bounds(self, matrix: Matrix2x3 | None = None) -> Rect:
+        ...
+
+    @abstractmethod
+    def render(self, matrix: Matrix2x3) -> Image.Image:
+        ...
+
+    def set_matrix(self, matrix: Matrix2x3):
+        self._matrix = matrix
+
+    def set_color_transform(self, color_transform: ColorTransform):
+        self._color_transform = color_transform

system/lib/objects/renderable/display_object.py

@@ -0,0 +1,29 @@
+from system.lib.objects import Shape
+from system.lib.objects.movie_clip.movie_clip import MovieClip
+from system.lib.objects.plain_object import PlainObject
+from system.lib.objects.renderable.display_object import DisplayObject
+from system.lib.objects.renderable.renderable_movie_clip import RenderableMovieClip
+from system.lib.objects.renderable.renderable_shape import RenderableShape
+from system.lib.swf import SupercellSWF
+
+
+def create_renderable_from_plain(
+    swf: SupercellSWF, plain_object: PlainObject
+) -> DisplayObject:
+    if isinstance(plain_object, Shape):
+        return RenderableShape(plain_object)
+    if isinstance(plain_object, MovieClip):
+        children = []
+
+        for bind_id in plain_object.binds:
+            bind_object = swf.get_display_object(bind_id)
+
+            display_object = None
+            if bind_object is not None:
+                display_object = create_renderable_from_plain(swf, bind_object)
+
+            children.append(display_object)
+
+        return RenderableMovieClip.create_from_plain(swf, plain_object, children)
+
+    raise Exception(f"Unsupported object type: {plain_object}")