from __future__ import annotations

from typing import TYPE_CHECKING, Any, Dict, Iterable, Union, cast

from PIL import Image, ImageDraw

from PIL.Image import Transform, Transpose

from ..classes import SpriteAtlasData

from ..enums import (

ClassIDType,

SpriteMeshType,

SpritePackingMode,

SpritePackingRotation,

)

from ..helpers.MeshHelper import MeshHandler

from .Texture2DConverter import get_image_from_texture2d

if TYPE_CHECKING:

from typing import List, Optional, Tuple

from ..classes import PPtr, Sprite, Texture2D

try:

import numpy as np

except ImportError:

np = None

class SpriteSettings:

packed: bool

packingMode: SpritePackingMode

packingRotation: SpritePackingRotation

meshType: SpriteMeshType

def __init__(self, settings_raw):

self.settingsRaw = settings_raw

self.packed = bool(self.settingsRaw & 1) # 1

self.packingMode = SpritePackingMode((self.settingsRaw >> 1) & 1) # 1

self.packingRotation = SpritePackingRotation((self.settingsRaw >> 2) & 0xF) # 4

self.meshType = SpriteMeshType((self.settingsRaw >> 6) & 1) # 1

# rest of the bits are reserved

def get_image(sprite: Sprite, texture: PPtr[Texture2D], alpha_texture: Optional[PPtr[Texture2D]]) -> Image.Image:

assert sprite.assets_file, "Sprite assets file is not set!"

cache = cast(Dict[Any, Any], sprite.assets_file._cache) # TODO: edit in SerializibleFile

if alpha_texture:

cache_id = (texture.path_id, alpha_texture.path_id)

if cache_id not in cache:

original_image = get_image_from_texture2d(texture.read(), False)

alpha_image = get_image_from_texture2d(alpha_texture.read(), False)

original_image = Image.merge("RGBA", (*original_image.split()[:3], alpha_image.split()[0]))

cache[cache_id] = original_image

else:

cache_id = texture.path_id

if cache_id not in cache:

original_image = get_image_from_texture2d(texture.read(), False)

cache[cache_id] = original_image

return cache[cache_id]

def get_image_from_sprite(m_Sprite: Sprite) -> Image.Image:

atlas = None

if m_Sprite.m_SpriteAtlas:

atlas = m_Sprite.m_SpriteAtlas.read()

elif m_Sprite.m_AtlasTags:

# looks like the direct pointer is empty, let's try to find the Atlas via its name

assert m_Sprite.assets_file, "Sprite assets file is not set!"

for obj in m_Sprite.assets_file.objects.values():

if obj.type == ClassIDType.SpriteAtlas:

atlas = obj.read()

if atlas.m_Name == m_Sprite.m_AtlasTags[0]:

break

atlas = None

if atlas:

sprite_atlas_data = next(value for key, value in atlas.m_RenderDataMap if key == m_Sprite.m_RenderDataKey)

assert isinstance(sprite_atlas_data, SpriteAtlasData), "SpriteAtlasData not found!"

else:

sprite_atlas_data = m_Sprite.m_RD

m_Texture2D = sprite_atlas_data.texture

alpha_texture = sprite_atlas_data.alphaTexture

texture_rect = sprite_atlas_data.textureRect

settings_raw = sprite_atlas_data.settingsRaw

original_image = get_image(m_Sprite, m_Texture2D, alpha_texture)

sprite_image = original_image.crop(

(

texture_rect.x,

texture_rect.y,

texture_rect.x + texture_rect.width,

texture_rect.y + texture_rect.height,

)

)

settings_raw = SpriteSettings(settings_raw)

if settings_raw.packed == 1:

rotation = settings_raw.packingRotation

if rotation == SpritePackingRotation.kSPRFlipHorizontal:

sprite_image = sprite_image.transpose(Transpose.FLIP_LEFT_RIGHT)

# spriteImage = RotateFlip(RotateFlipType.RotateNoneFlipX)

elif rotation == SpritePackingRotation.kSPRFlipVertical:

sprite_image = sprite_image.transpose(Transpose.FLIP_TOP_BOTTOM)

# spriteImage.RotateFlip(RotateFlipType.RotateNoneFlipY)

elif rotation == SpritePackingRotation.kSPRRotate180:

sprite_image = sprite_image.transpose(Transpose.ROTATE_180)

# spriteImage.RotateFlip(RotateFlipType.Rotate180FlipNone)

elif rotation == SpritePackingRotation.kSPRRotate90:

sprite_image = sprite_image.transpose(Transpose.ROTATE_270)

# spriteImage.RotateFlip(RotateFlipType.Rotate270FlipNone)

if settings_raw.packingMode == SpritePackingMode.kSPMTight:

assert m_Sprite.object_reader, "Sprite object reader is not set!"

mesh = MeshHandler(m_Sprite.m_RD, m_Sprite.object_reader.version)

mesh.process()

if mesh.m_UV0 and any(u or v for u, v in mesh.m_UV0):

# copy triangles from mesh

sprite_image = render_sprite_mesh(m_Sprite, mesh, original_image)

else:

# create mask to keep only the polygon

sprite_image = mask_sprite(m_Sprite, mesh, sprite_image)

return sprite_image.transpose(Transpose.FLIP_TOP_BOTTOM)

def mask_sprite(m_Sprite: Sprite, mesh: MeshHandler, sprite_image: Image.Image) -> Image.Image:

mask_img = Image.new("1", sprite_image.size, color=0)

draw = ImageDraw.ImageDraw(mask_img)

# normalize the points

# shift the whole point matrix into the positive space

# multiply them with a factor to scale them to the image

positions = mesh.m_Vertices

assert positions, "No vertices found in sprite mesh!"

# find the axis that has only one value - can be removed

# usually the z axis

min_x = min(x for x, _y, _z in positions)

min_y = min(y for _x, y, _z in positions)

factor = m_Sprite.m_PixelsToUnits

positions_2d = [((x - min_x) * factor, (y - min_y) * factor) for x, y, _z in positions]

# generate triangles from the given points

triangles = [

(

positions_2d[a],

positions_2d[b],

positions_2d[c],

)

for submesh in mesh.get_triangles()

for a, b, c in submesh

]

for triangle in triangles:

draw.polygon(triangle, fill=1)

# apply the mask

if sprite_image.mode == "RGBA":

# the image already has an alpha channel,

# so we have to use composite to keep it

empty_img = Image.new(sprite_image.mode, sprite_image.size, color=0)

sprite_image = Image.composite(sprite_image, empty_img, mask_img)

else:

# add mask as alpha-channel to keep the polygon clean

sprite_image.putalpha(mask_img)

return sprite_image

def render_sprite_mesh(m_Sprite: Sprite, mesh: MeshHandler, texture: Image.Image) -> Image.Image:

for triangles in mesh.get_triangles():

positions = mesh.m_Vertices

if not positions:

continue

uv = mesh.m_UV0

if not uv:

raise ValueError("No UV coordinates found in sprite mesh!")

# 2. patch position data

# 2.1 make positions 2d

# find the axis that has only one value - can be removed

# usually the z axis

axis_values = [[pos[i] for pos in positions] for i in range(3)]

for i in range(2, -1, -1):

if len(set(axis_values[i])) == 1:

break

else:

raise ValueError("Can't process 3d sprites!")

axis_values = axis_values[:i] + axis_values[i + 1 :]

x_min = min(axis_values[0])

y_min = min(axis_values[1])

x_max = max(axis_values[0])

y_max = max(axis_values[1])

# 2.2 map positions from middle to top left

# 2.3 convert relative positions to absolute

pixels_to_units = m_Sprite.m_PixelsToUnits

positions_abs = [

(round((x - x_min) * pixels_to_units), round((y - y_min) * pixels_to_units)) for x, y in zip(*axis_values)

]

width, height = texture.size

uv_abs = [(round(u * width), round(v * height)) for u, v in uv]

# 2.4 generate final image size

size = (

round((x_max - x_min) * pixels_to_units),

round((y_max - y_min) * pixels_to_units),

)

sprite = Image.new(texture.mode, size)

for tri in triangles:

copy_triangle(

texture,

tuple(uv_abs[i] for i in tri), # type: ignore

sprite,

tuple(positions_abs[i] for i in tri), # type: ignore

)

return sprite

else:

raise ValueError("No triangles found in mesh!")

def copy_triangle(

src_img: Image.Image,

src_tri: Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]],

dst_img: Image.Image,

dst_tri: Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]],

) -> None:

src_off = (

(src_tri[1][0] - src_tri[0][0], src_tri[1][1] - src_tri[0][1]),

(src_tri[2][0] - src_tri[0][0], src_tri[2][1] - src_tri[0][1]),

)

dst_off = (

(dst_tri[1][0] - dst_tri[0][0], dst_tri[1][1] - dst_tri[0][1]),

(dst_tri[2][0] - dst_tri[0][0], dst_tri[2][1] - dst_tri[0][1]),

)

# check if transform is necessary by comparing the triangle sizes

if src_off[0] == dst_off[0] and src_off[1] == dst_off[1]:

# no transform necessary, just copy the triangle

# make rectangle that contains the triangle

# upper_left, _, lower_right = sorted(src_tri)

upper_left = (

min(src_tri[0][0], src_tri[1][0], src_tri[2][0]),

min(src_tri[0][1], src_tri[1][1], src_tri[2][1]),

)

lower_right = (

max(src_tri[0][0], src_tri[1][0], src_tri[2][0]),

max(src_tri[0][1], src_tri[1][1], src_tri[2][1]),

)

src_part = src_img.crop((*upper_left, *lower_right))

# create mask for triangle

mask_box = [(x - upper_left[0], y - upper_left[1]) for x, y in src_tri]

mask = Image.new("1", src_part.size)

maskdraw = ImageDraw.Draw(mask)

maskdraw.polygon(mask_box, fill=255)

# paste triangle into destination image

dst = (

int(min(dst_tri[0][0], dst_tri[1][0], dst_tri[2][0])),

int(min(dst_tri[0][1], dst_tri[1][1], dst_tri[2][1])),

)

dst_img.paste(src_part, dst, mask=mask)

else:

# transform is necessary, use affine transformation

# https://stackoverflow.com/a/6959111

((x11, x12), (x21, x22), (x31, x32)) = src_tri

((y11, y12), (y21, y22), (y31, y32)) = dst_tri

# Construct matrix M manually

M = [

[y11, y12, 1, 0, 0, 0],

[y21, y22, 1, 0, 0, 0],

[y31, y32, 1, 0, 0, 0],

[0, 0, 0, y11, y12, 1],

[0, 0, 0, y21, y22, 1],

[0, 0, 0, y31, y32, 1],

]

# Vector y corresponds to the x coordinates in the source triangle

y = [x11, x21, x31, x12, x22, x32]

if np:

A = np.linalg.solve(M, y)

else:

# np.lingal.solve - obviously way faster, but numpy will only come with 2.0

A = linalg_solve(M, y) # type: ignore

transformed = src_img.transform(dst_img.size, Transform.AFFINE, A)

mask = Image.new("1", dst_img.size)

maskdraw = ImageDraw.Draw(mask)

maskdraw.polygon(dst_tri, fill=255)

dst_img.paste(transformed, mask=mask)

def linalg_solve(M: List[List[Union[float, int]]], y: List[Union[float, int]]) -> List[float]:

# M^-1 * y

M_i = get_matrix_inverse(M)

return [sum(M_i[i][j] * y[j] for j in range(len(y))) for i in range(len(M_i))]

def transpose_matrix(m: List[List[float]]) -> Iterable[List[float]]:

# https://stackoverflow.com/a/39881366

return map(list, zip(*m))

def get_matrix_minor(m: List[List[float]], i: int, j: int) -> List[List[float]]:

# https://stackoverflow.com/a/39881366

return [row[:j] + row[j + 1 :] for row in (m[:i] + m[i + 1 :])]

def get_matrix_determinant(m: List[List[float]]) -> float:

# https://stackoverflow.com/a/39881366

# base case for 2x2 matrix

if len(m) == 2:

return m[0][0] * m[1][1] - m[0][1] * m[1][0]

return sum(((-1) ** c) * m[0][c] * get_matrix_determinant(get_matrix_minor(m, 0, c)) for c in range(len(m)))

def get_matrix_inverse(m: List[List[float]]) -> List[List[float]]:

# https://stackoverflow.com/a/39881366

determinant = get_matrix_determinant(m)

# special case for 2x2 matrix:

if len(m) == 2:

return [

[m[1][1] / determinant, -1 * m[0][1] / determinant],

[-1 * m[1][0] / determinant, m[0][0] / determinant],

]

# find matrix of cofactors

cofactors = [

[((-1) ** (r + c)) * get_matrix_determinant(get_matrix_minor(m, r, c)) for c in range(len(m))]

for r in range(len(m))

]

cofactors = list(transpose_matrix(cofactors))

return [[c / determinant for c in row] for row in cofactors]

__all__ = ["get_image_from_sprite"]