fix(swf texture): saving texture more properly, get rid of ktx tags

Author: danila-schelkov

src/xcoder/bytestream.py

@@ -56,28 +56,33 @@ def __init__(self, endian: Literal["little", "big"] = "little"):
         super().__init__()
         self._endian: Literal["little", "big"] = endian
 
-    def write_int(self, integer: int, length: int = 1, signed: bool = False):
+    def write_tagged(self, tag: int, data: bytes) -> None:
+        self.write_ubyte(tag)
+        self.write_uint32(len(data))
+        self.write(data)
+
+    def write_int(self, integer: int, length: int = 1, signed: bool = False) -> None:
         self.write(integer.to_bytes(length, self._endian, signed=signed))
 
-    def write_ubyte(self, integer: int):
+    def write_ubyte(self, integer: int) -> None:
         self.write_int(integer)
 
-    def write_byte(self, integer: int):
+    def write_byte(self, integer: int) -> None:
         self.write_int(integer, signed=True)
 
-    def write_uint16(self, integer: int):
+    def write_uint16(self, integer: int) -> None:
         self.write_int(integer, 2)
 
-    def write_int16(self, integer: int):
+    def write_int16(self, integer: int) -> None:
         self.write_int(integer, 2, True)
 
-    def write_uint32(self, integer: int):
+    def write_uint32(self, integer: int) -> None:
         self.write_int(integer, 4)
 
-    def write_int32(self, integer: int):
+    def write_int32(self, integer: int) -> None:
         self.write_int(integer, 4, True)
 
-    def write_string(self, string: str | None = None):
+    def write_string(self, string: str | None) -> None:
         if string is None:
             self.write_byte(0xFF)
             return

src/xcoder/console.py

@@ -1,19 +1,22 @@
+from typing import ClassVar
+
+
 class Console:
-    previous_percentage: int = -1
+    _previous_percentage: ClassVar[int] = -1
 
     @classmethod
     def progress_bar(cls, message: str, current: int, total: int) -> None:
         percentage = (current + 1) * 100 // total
-        if percentage == cls.previous_percentage:
+        if percentage == cls._previous_percentage:
             return
 
         print(f"\r[{percentage}%] {message}", end="")
 
         if percentage == 100:
             print()
-            cls.previous_percentage = -1
+            cls._previous_percentage = -1
         else:
-            cls.previous_percentage = percentage
+            cls._previous_percentage = percentage
 
     @staticmethod
     def ask_integer(message: str):

src/xcoder/features/place_sprites.py

@@ -16,14 +16,11 @@ def place_sprites(
     file_info: FileInfo, folder: Path, overwrite: bool = False
 ) -> list[Image.Image]:
     files_to_overwrite = os.listdir(folder / ("overwrite" if overwrite else ""))
-    texture_files = os.listdir(folder / "textures")
-
-    sheets = []
-    for i in range(len(file_info.sheets)):
-        sheet_info = file_info.sheets[i]
 
+    sheets: list[Image.Image] = []
+    for i, sheet_info in enumerate(file_info.sheets):
         sheets.append(
-            Image.open(f"{folder}/textures/{texture_files[i]}")
+            Image.open(f"{folder}/textures/{folder.name}_{i}.png")
             if overwrite
             else Image.new(
                 get_format_by_pixel_type(sheet_info.pixel_type), sheet_info.size

src/xcoder/features/sc/__init__.py

@@ -1,70 +1,68 @@
+from collections.abc import Sequence
 from pathlib import Path
-import struct
 
 from PIL import Image
 from loguru import logger
 
 from xcoder.bytestream import Writer
 from xcoder.console import Console
 from xcoder.features.files import write_sc
-from xcoder.images import get_byte_count_by_pixel_type, save_texture, split_image
 from xcoder.localization import locale
+from xcoder.objects import SWFTexture
 from xcoder.xcod import FileInfo
 
 
 def compile_sc(
     output_folder: Path,
     file_info: FileInfo,
-    sheets: list[Image.Image],
+    sheets: Sequence[Image.Image],
 ):
-    sc = Writer()
+    writer = Writer()
 
-    for picture_index in range(len(sheets)):
-        sheet_info = file_info.sheets[picture_index]
-        sheet = sheets[picture_index]
+    for i, image in enumerate(sheets):
+        sheet_info = file_info.sheets[i]
 
-        file_type = sheet_info.file_type
+        tag = sheet_info.file_type
         pixel_type = sheet_info.pixel_type
 
-        if sheet.size != sheet_info.size:
+        if image.size != sheet_info.size:
             logger.info(
                 locale.illegal_size
-                % (sheet_info.width, sheet_info.height, sheet.width, sheet.height)
+                % (sheet_info.width, sheet_info.height, image.width, image.height)
             )
 
             if Console.question(locale.resize_qu):
                 logger.info(locale.resizing)
-                sheet = sheet.resize(sheet_info.size, Image.Resampling.LANCZOS)
+                image = image.resize(sheet_info.size, Image.Resampling.LANCZOS)
 
-        width, height = sheet.size
-        pixel_size = get_byte_count_by_pixel_type(pixel_type)
-
-        file_size = width * height * pixel_size + 5
+        width, height = image.size
 
         logger.info(
             locale.about_sc.format(
                 filename=file_info.name,
-                index=picture_index,
+                index=i,
                 pixel_type=pixel_type,
                 width=width,
                 height=height,
             )
         )
 
-        sc.write(struct.pack("<BIBHH", file_type, file_size, pixel_type, width, height))
+        swf_texture = SWFTexture(width=width, height=height, pixel_type=pixel_type)
+        swf_texture.image = image
+
+        texture_writer = Writer()
+        swf_texture.save(writer, tag, True)
 
-        if file_type in (27, 28):
-            sheet = split_image(sheet)
+        writer.write_tagged(tag, texture_writer.getvalue())
 
-        save_texture(sc, sheet, pixel_type)
         print()
 
-    sc.write(bytes(5))
+    writer.write_tagged(0, b"")  # EOF tag
 
     logger.info(locale.compressing_with % file_info.signature.name.upper())
     write_sc(
         output_folder / f"{file_info.name}.sc",
-        sc.getvalue(),
+        writer.getvalue(),
         file_info.signature,
         file_info.signature_version,
     )

src/xcoder/images.py

@@ -6,12 +6,12 @@
 if TYPE_CHECKING:
     from PIL._imaging import PixelAccess
 
-from xcoder.bytestream import Reader, Writer
+from xcoder.bytestream import Reader
 from xcoder.console import Console
 from xcoder.localization import locale
 from xcoder.math.point import Point
 from xcoder.matrices import Matrix2x3
-from xcoder.pixel_utils import get_pixel_encode_function, get_raw_mode
+from xcoder.pixel_utils import get_raw_mode
 
 CHUNK_SIZE = 32
 
@@ -128,31 +128,6 @@ def get_format_by_pixel_type(pixel_type: int) -> str:
     raise Exception(locale.unknown_pixel_type % pixel_type)
 
 
-def save_texture(writer: Writer, image: Image.Image, pixel_type: int) -> None:
-    raw_mode = get_raw_mode(pixel_type)
-    encode_pixel = get_pixel_encode_function(pixel_type)
-
-    width, height = image.size
-
-    pixels = image.getdata()
-
-    # Some packers for raw_encoder are absent
-    # https://github.com/python-pillow/Pillow/blob/58e48745cc7b6c6f7dd26a50fe68d1a82ea51562/src/encode.c#L337
-    # https://github.com/python-pillow/Pillow/blob/main/src/libImaging/Pack.c#L668
-    if raw_mode != image.mode and encode_pixel is not None:
-        for y in range(height):
-            for x in range(width):
-                # noinspection PyTypeChecker
-                writer.write(encode_pixel(pixels[y * width + x]))
-
-            Console.progress_bar(locale.writing_pic, y, height)
-
-        return
-
-    writer.write(image.tobytes("raw", raw_mode, 0, 1))
-    Console.progress_bar(locale.writing_pic, height - 1, height)
-
-
 def transform_image(
     image: Image.Image, scale_x: float, scale_y: float, angle: float, x: float, y: float
 ) -> Image.Image:

src/xcoder/matrices/matrix2x3.py

@@ -46,10 +46,10 @@ def load(self, reader: Reader, tag: int):
         self.x = reader.read_twip()
         self.y = reader.read_twip()
 
-    def apply_x(self, x: float, y: float):
+    def apply_x(self, x: float, y: float) -> float:
         return x * self.a + y * self.c + self.x
 
-    def apply_y(self, x: float, y: float):
+    def apply_y(self, x: float, y: float) -> float:
         return y * self.d + x * self.b + self.y
 
     def multiply(self, matrix: Self) -> Self:
@@ -86,5 +86,5 @@ def get_scale(self) -> tuple[float, float]:
 
         return scale_x, scale_y
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"Matrix2x3{self.a, self.b, self.c, self.d, self.x, self.y}"

src/xcoder/objects/texture.py

@@ -1,28 +1,38 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeAlias
 
 from PIL import Image
 import zstandard
 
 from ktx import get_image_from_ktx_data
-from xcoder.bytestream import Reader
-from xcoder.images import join_image, load_image_from_buffer
+from xcoder.bytestream import Reader, Writer
+from xcoder.console import Console
+from xcoder.images import join_image, load_image_from_buffer, split_image
+from xcoder.localization import locale
+from xcoder.pixel_utils import get_pixel_encode_function, get_raw_mode
 
 if TYPE_CHECKING:
     from xcoder.swf import SupercellSWF
 
 
+PixelType: TypeAlias = int
+
+_interleaved_tags = (27, 28, 29)
+
+
 class SWFTexture:
-    def __init__(self):
-        self.width = 0
-        self.height = 0
+    def __init__(
+        self, *, width: int = 0, height: int = 0, pixel_type: PixelType = -1
+    ) -> None:
+        self.width: int = width
+        self.height: int = height
 
-        self.pixel_type = -1
+        self.pixel_type: PixelType = pixel_type
 
         self.image: Image.Image | None = None
 
-    def load(self, swf: SupercellSWF, tag: int, has_texture: bool):
+    def load(self, swf: SupercellSWF, tag: int, has_texture: bool) -> None:
         assert swf.reader is not None
 
         khronos_texture_length = 0
@@ -56,8 +66,44 @@ def load(self, swf: SupercellSWF, tag: int, has_texture: bool):
 
         self.image = self._load_texture(swf.reader, tag)
 
+    def save(self, writer: Writer, tag: int, has_texture: bool) -> None:
+        writer.write_ubyte(self.pixel_type)
+        writer.write_uint16(self.width)
+        writer.write_uint16(self.height)
+
+        if not has_texture:
+            return
+
+        assert self.image is not None
+        image = self.image
+
+        if tag in _interleaved_tags:
+            image = split_image(self.image)
+
+        raw_mode = get_raw_mode(self.pixel_type)
+        encode_pixel = get_pixel_encode_function(self.pixel_type)
+
+        width, height = image.size
+
+        pixels = image.getdata()
+
+        # Note: Some packers for raw_encoder are absent
+        # https://github.com/python-pillow/Pillow/blob/58e48745cc7b6c6f7dd26a50fe68d1a82ea51562/src/encode.c#L337
+        # https://github.com/python-pillow/Pillow/blob/main/src/libImaging/Pack.c#L668
+        if raw_mode != image.mode and encode_pixel is not None:
+            for y in range(height):
+                for x in range(width):
+                    writer.write(encode_pixel(pixels[y * width + x]))  # type: ignore
+
+                Console.progress_bar(locale.writing_pic, y, height)
+
+            return
+
+        writer.write(image.tobytes("raw", raw_mode, 0, 1))
+        Console.progress_bar(locale.writing_pic, height - 1, height)
+
     def _load_texture(self, reader: Reader, tag: int) -> Image.Image:
-        if tag in (27, 28, 29):
+        if tag in _interleaved_tags:
             return join_image(self.pixel_type, self.width, self.height, reader)
 
         return load_image_from_buffer(self.pixel_type, self.width, self.height, reader)

src/xcoder/swf.py

@@ -172,6 +172,10 @@ def _load_tags(self, is_texture_file: bool) -> bool:
                         )
                     )
 
+                    # Note: get rid of ktx texture tags
+                    if tag in (45, 47):
+                        tag = 34
+
                     self.xcod_writer.write_ubyte(tag)
                     self.xcod_writer.write_ubyte(texture.pixel_type)
                     self.xcod_writer.write_uint16(texture.width)

src/xcoder/xcod.py

@@ -73,7 +73,7 @@ def parse_base_info(file_info: FileInfo, reader: Reader) -> None:
     file_info.signature_version = 1 if reader.read_string() == "LZMA" else 3
 
     sheets_count = reader.read_uchar()
-    for i in range(sheets_count):
+    for _i in range(sheets_count):
         file_type = reader.read_uchar()
         pixel_type = reader.read_uchar()
         width = reader.read_ushort()
@@ -84,13 +84,13 @@ def parse_base_info(file_info: FileInfo, reader: Reader) -> None:
 
 def parse_detailed_info(file_info: FileInfo, reader: Reader) -> None:
     shapes_count = reader.read_ushort()
-    for shape_index in range(shapes_count):
+    for _shape_index in range(shapes_count):
         shape_id = reader.read_ushort()
 
         regions = []
 
         regions_count = reader.read_ushort()
-        for region_index in range(regions_count):
+        for _region_index in range(regions_count):
             texture_id, points_count = reader.read_uchar(), reader.read_uchar()
 
             points = [