azurpaint 1.0.0__py3-none-any.whl

azurpaint/__init__.py

@@ -0,0 +1,6 @@
+__version__ = '1.0.0'
+
+from .main import Azurpaint
+from .exception import *
+from .types import *
+from .lib import Inspector, Tree, Node

azurpaint/classes/AABB.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .Vector2 import Vector2
+
+
+class AABB:
+  center: Vector2
+  extend: Vector2
+
+  def __init__(self, center: Vector2, extend: Vector2) -> None:
+    self.center = center
+    self.extend = extend
+
+
+  def __repr__(self) -> str:
+    return f"<{self.__class__.__name__} center={self.center.values()} extend={self.extend.values()}>"
+
+
+  @property
+  def padding(self) -> Vector2:
+    return self.center - self.extend
+
+
+  @property
+  def size(self) -> Vector2:
+    return self.center + self.extend

azurpaint/classes/AssetReader.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union, cast
+from pathlib import Path
+from UnityPy import Environment, classes
+from UnityPy.enums import ClassIDType
+from UnityPy.files import ObjectReader
+
+from ..types import PathLike
+from ..exception import PrefabNotFound
+
+
+class AssetReader:
+  """
+    Read UnityAsset using UnityPy.
+  """
+  path: Path
+  prefab: Path
+  environment: Environment
+  files: List[str] = []
+  face: Dict[str, int]
+
+  def __init__(self, path: PathLike, prefab: PathLike) -> None:
+    self.face = {}
+    self.path = Path(path)
+    self.prefab = Path(prefab)
+
+    if not self.filepath.exists():
+      raise FileNotFoundError(f"File {self.filepath.as_posix()!r} not exists.")
+
+    self.environment = Environment(self.filepath.as_posix())
+    self.files.append(self.prefab.as_posix())
+
+    if not self.has_prefab:
+      raise PrefabNotFound(f"Prefab {self.prefab.as_posix()!r} not exists.")
+
+
+  def __repr__(self) -> str:
+    return f"<{self.__class__.__name__} prefab={self.prefab.as_posix()}>"
+
+
+  @property
+  def root(self) -> classes.GameObject:
+    return self.get_object_by_path_id(next(iter(self.environment.container.values())).path_id)
+
+
+  @property
+  def filepath(self) -> Path:
+    return Path(self.path, self.prefab)
+
+
+  @property
+  def has_prefab(self) -> bool:
+    try:
+      return any(key.endswith('.prefab') for key in self.environment.container.keys())
+    except:
+      return False
+
+
+  @property
+  def cabs(self) -> List[str]:
+    return list(k for k in self.environment.cabs.keys() if not k.endswith('.ress'))
+
+
+  @property
+  def dependencies(self) -> List[str]:
+    assets: classes.AssetBundle = self.get_object_by_path_id(1)
+    
+    if not hasattr(assets, 'm_Dependencies'):
+      raise ValueError(f"Prefab {self.prefab.as_posix()} is missing 'AssetBundle.m_Dependencies'.")
+
+    return cast(List[str], assets.m_Dependencies)
+
+
+  def get_cabs(self, name: PathLike) -> List[str]:
+    environment = Environment(Path(name).as_posix())
+    return list(k for k in environment.cabs.keys() if not k.endswith('.ress'))
+
+
+  def load(self, path: PathLike, is_face: bool = False) -> Path:
+    path = Path(path)
+
+    if not path.is_relative_to(self.path):
+      path = Path(self.path, path)
+
+    # is_dependencies is not used, it's a bit complicated with azurlane assets
+    # since some asset like paintingface is not an direct dependency for a lot ship
+    self.environment.load_file(path.as_posix())
+    self.files.append(path.relative_to(self.path).as_posix())
+
+    if is_face or path.is_relative_to(Path(self.path, 'paintingface')):
+      self.face = self._get_face(path)
+
+    return path
+
+
+  def loads(self, path: Union[PathLike, Iterable[PathLike]]) -> List[Path]:
+    if not isinstance(path, Iterable) or isinstance(path, str):
+      path = [path]
+
+    _loaded = []
+
+    for link in path:
+      _loaded.append(self.load(link))
+
+    return _loaded
+
+
+  def _gather_files(self, folders: List[str] = ['painting', 'paintings', 'paintingface']) -> List[str]:
+    """
+      Get all files list that have same name as prefab in painting, paintings and paintingface
+    """
+    files: List[str] = []
+
+    for folder in folders:
+      glob = Path(self.path, folder).glob(f"{self.prefab.name.split('_')[0]}*")
+      files.extend([file.relative_to(self.path).as_posix() for file in glob])
+
+    return files
+
+
+  def _get_face(self, path: Path) -> Dict[str, int]:
+    face = {}
+
+    for obj in cast(List[ObjectReader], self.environment.files[path.as_posix()].get_objects()):
+      if obj.type != ClassIDType.Sprite:
+        continue
+
+      obj = cast(classes.Sprite, obj.read())
+      face[obj.name] = obj.path_id
+
+    return {key: face[key] for key in sorted(face.keys())}
+
+
+
+  def _load_face(self, force: bool = True) -> None:
+    if len(self.face):
+      return
+
+    files = self._gather_files(['paintingface'])
+    prefab_face = Path('paintingface', self.prefab.name).as_posix()
+
+    if prefab_face in files:
+      self.load(prefab_face, is_face=True)
+      return
+
+    if not force:
+      return
+
+    # face not found or not same as prefab name
+    # sometimes face have different name with underscore extension 
+    # but still have same basename eg like _hx extension
+    # this is not perfect it may load wrong face
+    possible_name: List[str] = [prefab_face]
+
+    while '_' in prefab_face:
+      prefab_face = prefab_face.rsplit('_', 1)[0]
+      possible_name.append(prefab_face)
+
+    matches: List[str] = [file for file in files if file in possible_name]
+
+    if len(matches) == 0:
+      return
+
+    # when matches is more than one. probably the longest is more desired one
+    # since it splitted with underscore so we're prefer longer string
+    self.load(max(matches, key=len), is_face=True)
+
+
+  def find_dependencies(self) -> Tuple[Set[str], Set[str]]:
+    """
+      Find all dependencies in loaded path
+
+      :returns: tuple[`result`, `missing_dependencies`]
+    """
+    result: Set[str] = set()
+    dependencies: Set[str] = set(self.dependencies)
+
+    if not len(dependencies):
+      return result, dependencies
+
+    files: List[str] = self._gather_files()
+
+    # blank image used by asset to create canvas
+    files.append('painting/touming_tex')
+
+    for file in files:
+      if not len(dependencies):
+        break
+
+      for cab in self.get_cabs(Path(self.path, file)):
+        if cab in dependencies:
+          result.add(file)
+          dependencies.remove(cab)
+
+    return result, dependencies
+
+
+  def load_dependencies(self, force_face_load: bool = False) -> None:
+    """
+      Automatically search for dependencies by name.
+
+      :params force_face_load: force load face with matching name
+
+      Warning
+      -------
+      This is still in experimental state, undefined behaviour may occurs.
+    """
+    dependencies, _ = self.find_dependencies()
+
+    if not len(self.face):
+      self._load_face(force=force_face_load)
+
+    self.loads(dependencies)
+
+
+  def get_object_by_path_id(self, path_id: int) -> Any:
+    for obj in self.environment.objects:
+      if obj.path_id == path_id:
+        return cast(Any, obj.read(return_typetree_on_error=False))
+
+
+  def get_object_by_name(self, name: str, type: ClassIDType) -> Any:
+    for obj in self.environment.objects:
+      try:
+        if not hasattr(obj, 'name') or (obj.type != type):
+          continue
+
+        obj = cast(Any, obj.read(return_typetree_on_error=False))
+
+        if hasattr(obj, 'name') and (str(obj.name) == str(name)):
+          return obj
+
+      except:
+        continue
+
+
+  def get_component_from_object(
+    self,
+    gameobject: classes.GameObject,
+    types: Optional[Iterable[ClassIDType]] = None,
+    names: Optional[Set[str]] = None,
+    attributes: Optional[Set[str]] = None
+  ) -> Any:
+    for component_pptr in cast(List[classes.PPtr], gameobject.m_Components):
+      if types and (not component_pptr.type in types):
+        continue
+
+      component = self.get_object_by_path_id(component_pptr.path_id)
+
+      if names and (not component.name in names):
+        continue
+
+      if attributes:
+        for attribute in attributes:
+          if hasattr(component, attribute):
+            return component
+
+      return component

azurpaint/classes/GameObject.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from PIL import Image
+from typing import Generator, List, Optional, Union, cast
+from UnityPy import classes
+from UnityPy.enums import ClassIDType
+
+from ..exception import \
+  MeshImageNotFound, MonoBehaviourNotFound, RectTransformNotFound, TransformNotFound
+
+from .AssetReader import AssetReader
+from .MeshImage import MeshImage
+from .RectTransform import RectTransform
+from .Vector2 import Vector2
+
+
+
+class GameObject:
+  reader: AssetReader
+
+  name: str
+  path_id: int
+  active: bool
+  parent: Optional[GameObject]
+  children: List[GameObject]
+
+  # Unity component
+  Transform: Union[classes.Transform, classes.RectTransform]
+  RectTransform: Optional[RectTransform]
+  MonoBehaviour: Optional[MeshImage]
+
+  # variable
+  scale: Vector2
+  size: Vector2
+  local_offset: Vector2
+  global_offset: Vector2
+  image: Optional[Image.Image]
+
+
+  def __init__(
+    self,
+    reader: AssetReader,
+    gameobject: classes.GameObject,
+    parent: Optional[GameObject] = None
+  ) -> None:
+    self.reader = reader
+
+    self.name = gameobject.name
+    self.path_id = gameobject.path_id
+    self.active = bool(gameobject.m_IsActive)
+    self.parent = parent
+    self.children = []
+
+    # default value to prevent attr not found
+    self.RectTransform = None
+    self.MonoBehaviour = None
+    self.image         = None
+    self.scale         = Vector2.one()
+    self.size          = Vector2.zero()
+    self.local_offset  = Vector2.zero()
+    self.global_offset = Vector2.zero()
+
+
+    # this can be improved but im too lazy to change this
+    self.Transform = cast(Union[classes.RectTransform, classes.Transform],
+      self.reader.get_component_from_object(
+        gameobject=gameobject,
+        types=[ClassIDType.RectTransform, ClassIDType.Transform]
+      )
+    )
+
+    if not self.Transform:
+      # unexpected behaviour, since every component in unity
+      # should have an Transform or RectTransform by default
+      raise TransformNotFound(f"Transform not found in {self}.")
+
+    if self.Transform.type == ClassIDType.RectTransform:
+      self.RectTransform = RectTransform(cast(classes.RectTransform, self.Transform))
+
+    # Transform have scale too
+    self.scale = Vector2.from_value(self.Transform.m_LocalScale)
+
+    if self.parent and not self.parent.is_root:
+      self.scale *= self.parent.scale
+
+    if not (self.is_root or self.active):
+      return
+
+    try:
+      self.MonoBehaviour = MeshImage(self.reader, gameobject=gameobject)
+
+      if self.is_root or self.active:
+        self.image = self.MonoBehaviour.image
+
+      if self.image:
+        self.size = Vector2.from_value(self.image.size)
+
+    except (MeshImageNotFound, MonoBehaviourNotFound):
+      pass
+
+    if not self.image:
+      return
+
+    if not self.RectTransform:
+      raise RectTransformNotFound(f"RectTransform not found in {self}.")
+
+    size_delta = self.RectTransform.size_delta
+
+    # root always use size_delta when active
+    # some root doesn't active like qiye_4 or kelifulan_4 it's gonna stretch the image
+    # resize only smaller image than size delta
+    # we handle image that larger in size delta in offset
+    if (self.is_root and self.active) or size_delta.is_bigger(self.size):
+      self.image = self.image.resize(size_delta.as_size(), Image.Resampling.LANCZOS)
+      self.size = Vector2.from_value(self.image.size)
+      return
+
+
+  def __repr__(self) -> str:
+    return f"<{self.__class__.__name__} name={self.name}>"
+
+
+  @property
+  def root(self) -> GameObject:
+    root = self
+
+    while self.parent:
+      root = self.parent
+
+    return root
+
+
+  @property
+  def is_root(self) -> bool:
+    return bool(self.parent == None)
+
+
+  def change_face(self, path_id: int) -> bool:
+    if self.name != 'face':
+      gameobject = self.root.find_child('face')
+
+      # face should be available in all ship, even ship without face asset still have face gameobject
+      if not gameobject:
+        raise Exception(f"ERROR: {self.reader.prefab.as_posix()!r} <GameObject name=face> not found.")
+
+      return gameobject.change_face(path_id=path_id)
+
+    sprite: Optional[classes.Sprite] = self.reader.get_object_by_path_id(path_id=path_id)
+
+    if not sprite:
+      return False
+
+    texture2d: classes.Texture2D = self.reader.get_object_by_path_id(
+      path_id=sprite.m_RD.texture.path_id)
+
+    self.active = True
+    self.image = texture2d.image
+    self.size = Vector2.from_value(self.image.size)
+
+    if not self.RectTransform:
+      raise RectTransformNotFound(f"RectTransform not found in {self}.")
+
+    size_delta = self.RectTransform.size_delta
+
+    if size_delta.is_bigger(self.size):
+      self.image = self.image.resize(size_delta.as_size(), Image.Resampling.LANCZOS)
+      self.size = Vector2.from_value(self.image.size)
+
+    return True
+
+
+  def find_child(self, name: str) -> Optional[GameObject]:
+    for child in self.children:
+      if child.name == name:
+        return child
+
+      from_child = child.find_child(name)
+
+      if from_child:
+        return from_child
+
+
+  def retrieve_children(self, recursive: bool = True) -> bool:
+    if not self.Transform:
+      return False
+
+    for child in self.Transform.m_Children:
+      child_transform = self.reader.get_object_by_path_id(child.path_id)
+      child_object = self.reader.get_object_by_path_id(child_transform.m_GameObject.path_id)
+      object_layer = GameObject(reader=self.reader, gameobject=child_object, parent=self)
+
+      if recursive:
+        object_layer.retrieve_children(recursive=recursive)
+        self.children.append(object_layer)
+
+    return True
+
+
+  # todo: well move this method into RectTransform?
+  def calculate_local_offset(self, recursive: bool = True) -> Vector2:
+    if self.RectTransform:
+      anchor_min = self.RectTransform.anchor_min
+      anchor_max = self.RectTransform.anchor_max
+      anchor_pos = self.RectTransform.anchor_pos
+      size_delta = self.RectTransform.size_delta
+      pivot = self.RectTransform.pivot
+
+      if anchor_min == anchor_max:
+        if self.parent:
+          pivot = Vector2(x=pivot.x, y=1 - pivot.y)
+
+          pivot_offset = (pivot * size_delta) + (0, self.size.y - size_delta.y)
+          pivot_anchor = self.scale * pivot_offset
+
+          anchor_offset = Vector2(x=anchor_pos.x - pivot_anchor.x, y=anchor_pos.y + pivot_anchor.y)
+          self.local_offset = (self.parent.size * anchor_min) + (anchor_offset.x, -anchor_offset.y)
+
+          # resize when local_offset already calculated to prevent miss calculation
+          # self.size is the truesize, so size not updated here to make debug easier
+          if self.image:
+            self.image = self.image.resize(
+              (self.size * self.scale).as_size(), Image.Resampling.LANCZOS)
+
+      else:
+        if self.parent:
+          self.size = self.parent.size * (anchor_min - anchor_max).apply(abs)
+
+        self.local_offset = Vector2(x=-anchor_pos.x, y=anchor_pos.y)
+
+
+    if recursive:
+      for child in self.children:
+        child.calculate_local_offset(recursive=recursive)
+
+    return self.local_offset
+
+
+  def get_smallest_offset(self) -> Vector2:
+    min_offset = Vector2.zero()
+
+    if self.image:
+      min_offset = self.local_offset
+
+    for child in self.children:
+      child_offset = child.get_smallest_offset()
+      min_offset = Vector2.min(min_offset, child_offset)
+
+    return min_offset
+
+
+  def calculate_global_offset(self, offset: Optional[Vector2] = None) -> Vector2:
+    offset = offset or self.get_smallest_offset()
+
+    self.global_offset = self.local_offset - offset
+
+    for child in self.children:
+      child.calculate_global_offset(offset=self.global_offset)
+
+    return self.global_offset
+
+
+  def get_biggset_size(self) -> Vector2:
+    size_offset = Vector2.zero()
+
+    if self.image:
+      # we doesn't want to calculate root scale
+      # dev sometimes put root scale into unreasonable value like 90x
+      scale = Vector2.one() if self.is_root else self.scale
+      size_offset = self.global_offset + (self.size * scale)
+
+    for child in self.children:
+      child_offset = child.get_biggset_size()
+      size_offset = Vector2.max(size_offset, child_offset)
+
+    return size_offset
+
+
+  def yield_layers(self) -> Generator[GameObject, None, None]:
+    if self.image:
+      yield self
+
+    for child in self.children:
+      for layer in child.yield_layers():
+        yield layer