AGIDMGen 0.1.0__py3-none-any.whl

AGIDMGen/IDModGenService.py

@@ -0,0 +1,300 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+import os
+from typing import Any, List, Optional, Union
+from FixRaidenBoss2 import BaseLogger, Model
+##### EndExtImports
+
+
+##### LocalImports
+from .constants.ModLoaders import ModLoaders
+from .exceptions.Error import Error
+from .model.IDModGenStats import IDModGenStats
+from .tools.ModDownloader import ModDownloader
+from .tools.gimi.GIMIIdentityModGenerator import GIMIIdentityModGenerator
+from .tools.wwmi.WWMIIdentityModGenerator import WWMIIdentityModGenerator
+##### EndLocalImports
+
+
+##### Script
+class IDModGenService(Model):
+    """
+    The library's entry point: generates the identity mods of several characters at once, from their asset
+    folders or from their download folders, and reports what it did
+
+    It is the model half, with no user interface of its own: progress and the summary go to the
+    :attr:`logger` (nothing is reported without one), and the results are in :attr:`stats`. A character that
+    cannot be generated does not stop the others: its exception is recorded in :attr:`IDModGenStats.skipped`.
+
+    .. note::
+        Like Anime Game Remap's ``RemapService``, :meth:`generate` returns nothing; read :attr:`stats` after it.
+        For one character, a generator (:class:`GIMIIdentityModGenerator` or :class:`WWMIIdentityModGenerator`)
+        can be used directly instead, and raises when it fails.
+
+    Examples
+    --------
+    .. code-block:: python
+        :linenos:
+
+        import AGIDMGen as IDMG
+        import FixRaidenBoss2 as FRB          # Anime Game Remap's API: its logger serves both libraries
+
+        # every character's newest download folder, printed as it goes
+        service = IDMG.IDModGenService(IDMG.ModLoaders.GIMI, names = ["Yelan", "Ayaka"], outputFolder = "Mods", logger = FRB.Logger())
+        service.generate()
+        print(sorted(service.stats.generated), service.stats.skipped)
+
+        # from asset folders, collecting the output instead of printing it (eg. in a server)
+        logger = FRB.Logger(logTxt = True, verbose = False)
+        service = IDMG.IDModGenService(IDMG.ModLoaders.WWMI, assetsFolders = ["WWMI-Assets/PlayerCharacterData/Sanhua"], logger = logger)
+        service.generate()
+        print(logger.loggedTxt)
+
+    Parameters
+    ----------
+    loader: :class:`ModLoaders`
+        The mod loader the mods are for
+
+    assetsFolders: Optional[List[:class:`str`]]
+        The characters' asset folders to generate from. If this value is ``None``, no asset folder is used :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    names: Optional[List[:class:`str`]]
+        The characters to generate from their download folders (see :meth:`ModDownloader.getName`). If this value is ``None``, no download folder is used :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    outputFolder: Optional[:class:`str`]
+        The folder each mod is written into, as ``<outputFolder>/<name>``. If this value is ``None``, the current folder is used :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    version: Optional[:class:`str`]
+        The game version wanted for the download folders (see :meth:`ModDownloader.find`). If this value is ``None``, the newest :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    downloader: Optional[:class:`ModDownloader`]
+        What downloads the download folders. If this value is ``None``, one that downloads every file :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    downloadFolder: Optional[:class:`str`]
+        The folder to keep the downloaded files in, as ``<downloadFolder>/<name>``. If this value is ``None``, temporary folders are used :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    generator: Optional[Union[:class:`GIMIIdentityModGenerator`, :class:`WWMIIdentityModGenerator`]]
+        The generator, with its options. If this value is ``None``, one for ``loader`` with its default options :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    modName: Optional[:class:`str`]
+        The name of the character in the mod, when there is only one character. If this value is ``None``, the generator's default :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    assetPrefix: Optional[:class:`str`]
+        What a GIMI asset folder's files start with, when there is only one asset folder (see :meth:`GIMIIdentityModGenerator.generate`) :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    handleExceptions: :class:`bool`
+        Whether a failure of the whole run (eg. options that contradict each other) is reported to the logger and :meth:`generate` returns, rather than raised :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``False``
+
+    logger: Optional[:class:`BaseLogger`]
+        Where the run reports progress. If this value is ``None``, nothing is reported :raw-html:`<br />` :raw-html:`<br />`
+
+        **Default**: ``None``
+
+    Attributes
+    ----------
+    loader: :class:`ModLoaders`
+        The mod loader the mods are for
+
+    assetsFolders: List[:class:`str`]
+        The characters' asset folders to generate from
+
+    names: List[:class:`str`]
+        The characters to generate from their download folders
+
+    outputFolder: :class:`str`
+        The folder each mod is written into
+
+    version: Optional[:class:`str`]
+        The game version wanted for the download folders
+
+    downloader: :class:`ModDownloader`
+        What downloads the download folders
+
+    downloadFolder: Optional[:class:`str`]
+        The folder to keep the downloaded files in
+
+    generator: Union[:class:`GIMIIdentityModGenerator`, :class:`WWMIIdentityModGenerator`]
+        The generator
+
+    modName: Optional[:class:`str`]
+        The name of the character in the mod, when there is only one character
+
+    assetPrefix: Optional[:class:`str`]
+        What a GIMI asset folder's files start with, when there is only one asset folder
+
+    handleExceptions: :class:`bool`
+        Whether a failure of the whole run is reported rather than raised
+    """
+
+    def __init__(self, loader: ModLoaders, assetsFolders: Optional[List[str]] = None, names: Optional[List[str]] = None, outputFolder: Optional[str] = None,
+                 version: Optional[str] = None, downloader: Optional[ModDownloader] = None, downloadFolder: Optional[str] = None,
+                 generator: Optional[Union[GIMIIdentityModGenerator, WWMIIdentityModGenerator]] = None, modName: Optional[str] = None,
+                 assetPrefix: Optional[str] = None, handleExceptions: bool = False, logger: Optional[BaseLogger] = None):
+        super().__init__(logger = logger)
+        self.loader = loader
+        self.assetsFolders = [] if (assetsFolders is None) else list(assetsFolders)
+        self.names = [] if (names is None) else list(names)
+        self.outputFolder = os.getcwd() if (outputFolder is None) else outputFolder
+        self.version = version
+        self.downloader = ModDownloader(logger = logger) if (downloader is None) else downloader
+        self.downloadFolder = downloadFolder
+        self.generator = generator
+        self.modName = modName
+        self.assetPrefix = assetPrefix
+        self.handleExceptions = handleExceptions
+        self._stats = IDModGenStats()
+
+    @property
+    def stats(self) -> IDModGenStats:
+        """
+        What the last :meth:`generate` did
+
+        :getter: Retrieves the stats
+        :type: :class:`IDModGenStats`
+        """
+
+        return self._stats
+
+    def _getGenerator(self) -> Union[GIMIIdentityModGenerator, WWMIIdentityModGenerator]:
+        expected = GIMIIdentityModGenerator if (self.loader == ModLoaders.GIMI) else WWMIIdentityModGenerator
+        if (self.generator is None):
+            return expected(logger = self.logger)
+        if (not isinstance(self.generator, expected)):
+            raise Error(f"a {type(self.generator).__name__} cannot generate {self.loader.value} mods")
+        if (self.generator.logger is None):
+            self.generator.logger = self.logger
+        return self.generator
+
+    def _checkOptions(self):
+        sourceCount = len(self.assetsFolders) + len(self.names)
+        if (sourceCount == 0):
+            raise Error("there is nothing to generate: give asset folders or character names")
+        if (self.modName is not None and sourceCount > 1):
+            raise Error("a mod name can only be given for one character")
+        if (self.assetPrefix is not None and (len(self.assetsFolders) != 1 or self.names)):
+            raise Error("an asset prefix can only be given for one asset folder")
+        if (self.assetPrefix is not None and self.loader != ModLoaders.GIMI):
+            raise Error("an asset prefix is only for GIMI asset folders")
+
+    def _reportException(self, error: BaseException):
+        # the library's own errors explain themselves; anything else is a bug, and gets its traceback
+        if (isinstance(error, Error)):
+            self.print("error", str(error))
+        else:
+            self.print("handleException", error)
+
+    def _generateOne(self, generator, label: str, generate) -> Optional[Any]:
+        self.print("openHeading", label, sideLen = 5)
+        try:
+            mod = generate()
+        except Exception as e:
+            self._stats.addSkipped(label, e)
+            self._reportException(e)
+            self.print("closeHeading")
+            return None
+
+        self._stats.addGenerated(label, mod)
+        for line in mod.getSummary():
+            self.print("log", line)
+        self.print("closeHeading")
+        self.print("space")
+        return mod
+
+    def generate(self):
+        """
+        Generates the identity mods, then reports what was done
+
+        Raises
+        ------
+        :class:`Error`
+            If the options contradict each other, and :attr:`handleExceptions` is ``False``
+        """
+
+        self._stats.clear()
+        try:
+            self._checkOptions()
+            generator = self._getGenerator()
+        except Exception as e:
+            if (not self.handleExceptions):
+                raise
+            self._reportException(e)
+            return
+
+        prevPrefix = None if (self.logger is None) else self.logger.prefix
+        for assetsFolder in self.assetsFolders:
+            label = os.path.basename(os.path.normpath(assetsFolder))
+            if (self.logger is not None):
+                self.logger.prefix = label
+
+            kwargs = {"name": self.modName}
+            if (self.loader == ModLoaders.GIMI):
+                kwargs["assetPrefix"] = self.assetPrefix
+            modFolder = os.path.join(self.outputFolder, self.modName if (self.modName is not None) else label)
+            self._generateOne(generator, label, lambda: generator.generate(assetsFolder, modFolder, **kwargs))
+
+        for name in self.names:
+            if (self.logger is not None):
+                self.logger.prefix = name
+
+            modFolder = os.path.join(self.outputFolder, self.modName if (self.modName is not None) else name)
+            downloadFolder = None if (self.downloadFolder is None) else os.path.join(self.downloadFolder, name)
+            self._generateOne(generator, name, lambda: generator.generateFromRepo(name, modFolder, version = self.version, downloader = self.downloader,
+                                                                                  downloadFolder = downloadFolder, modName = self.modName))
+
+        if (self.logger is not None):
+            self.logger.prefix = prevPrefix
+        self.report()
+
+    def report(self):
+        """
+        Reports the summary of the last :meth:`generate` to the logger
+        """
+
+        if (self.logger is None):
+            return
+
+        includePrefix = self.logger.includePrefix
+        self.logger.includePrefix = False
+        self.print("openHeading", "Summary", sideLen = 10)
+        self.print("log", f"Generated {len(self._stats.generated)} identity mod(s) into {self.outputFolder}")
+        if (self._stats.skipped):
+            self.print("log", f"Could not generate {len(self._stats.skipped)}:")
+            for name, error in self._stats.skipped.items():
+                self.print("bulletPoint", f"{name}: {error}")
+        self.print("closeHeading")
+
+        if (self._stats.noErrors):
+            self.print("space")
+            self.print("log", "ENJOY")
+        self.logger.includePrefix = includePrefix
+##### EndScript

AGIDMGen/__init__.py

@@ -0,0 +1,78 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+##### LocalImports
+
+# --- Constants --------
+from .constants.DumpDataKinds import DumpDataKinds
+from .constants.DXGIFormats import DXGIFormats, DXGIFormatPrefix
+from .constants.FileEncodings import FileEncodings, IniFileEncoding, ReadEncodings
+from .constants.GIMIBuffers import GIMIBuffers, GIMISemanticBuffers, GIMIFixedStrides, GIMIHashFileSuffix
+from .constants.GIMITextureLayouts import GIMITextureLayouts
+from .constants.ModDownloadRepos import ModDownloadRepos, ModDownloadGameFolders
+from .constants.ModLoaders import ModLoaders
+
+# --- Data --------
+from .data.ModDownloadData import ModDownloadData, ModDownloadAliases
+from .constants.WWMIBuffers import WWMIBuffers, WWMIBlendRemapBuffers, WWMIShapeKeySlots, WWMIBlendRemapSize, WWMIBlendIndexLimit, WWMIDownloadNames, WWMIDownloadTextureSuffix
+
+# --- Exceptions --------
+from .exceptions.Error import Error
+from .exceptions.BadAssetData import BadAssetData
+from .exceptions.DownloadFailed import DownloadFailed
+from .exceptions.UnknownDXGIFormat import UnknownDXGIFormat
+
+# --- Model --------
+from .model.IDModGenStats import IDModGenStats
+from .model.ModDownload import ModDownload
+from .model.files.DumpDataType import DumpDataType
+from .model.files.DumpElement import DumpElement
+from .model.files.FmtFile import FmtFile
+from .model.files.IbDumpFile import IbDumpFile
+from .model.files.VbDumpFile import VbDumpFile
+from .model.gimi.GIMIComponent import GIMIComponent
+from .model.gimi.GIMIIdentityMod import GIMIIdentityMod
+from .model.gimi.GIMITextureSource import GIMITextureSource
+from .model.wwmi.WWMIBlendRemap import WWMIBlendRemap
+from .model.wwmi.WWMIComponent import WWMIComponent
+from .model.wwmi.WWMIDrawRange import WWMIDrawRange
+from .model.wwmi.WWMIMesh import WWMIMesh
+from .model.wwmi.WWMIIdentityMod import WWMIIdentityMod
+from .model.wwmi.WWMIShapeKeys import WWMIShapeKeys
+
+# --- Tools --------
+from .tools.DumpValueTools import DumpValueTools
+from .tools.FormatTools import FormatTools
+from .tools.ModDownloader import ModDownloader
+from .tools.VersionTools import VersionTools
+from .tools.gimi.GIMIDownloadFolderBuilder import GIMIDownloadFolderBuilder
+from .tools.gimi.GIMIIniBuilder import GIMIIniBuilder
+from .tools.gimi.GIMIIdentityModGenerator import GIMIIdentityModGenerator
+from .tools.wwmi.WWMIDownloadFolderBuilder import WWMIDownloadFolderBuilder
+from .tools.wwmi.WWMIIniBuilder import WWMIIniBuilder
+from .tools.wwmi.WWMIIdentityModGenerator import WWMIIdentityModGenerator, WWMITexturePattern
+
+# --- Service --------
+from .IDModGenService import IDModGenService
+
+##### EndLocalImports
+
+
+__all__ = ["IDModGenService", "IDModGenStats",
+           "DumpDataKinds", "GIMIBuffers", "GIMISemanticBuffers", "GIMIFixedStrides", "GIMITextureLayouts",
+           "DumpDataType", "DumpElement", "IbDumpFile", "VbDumpFile", "GIMIComponent", "GIMIIdentityMod", "GIMITextureSource",
+           "DumpValueTools", "GIMIIniBuilder", "GIMIIdentityModGenerator", "GIMIDownloadFolderBuilder", "WWMIDownloadFolderBuilder",
+           "ModDownloadRepos", "ModDownloadGameFolders", "ModDownloadData", "ModDownloadAliases", "DownloadFailed", "ModDownload", "ModDownloader", "VersionTools",
+           "GIMIHashFileSuffix", "WWMIDownloadNames", "WWMIDownloadTextureSuffix", "WWMIDrawRange", "WWMIMesh",
+           "DXGIFormats", "DXGIFormatPrefix", "FileEncodings", "IniFileEncoding", "ReadEncodings", "ModLoaders",
+           "WWMIBuffers", "WWMIBlendRemapBuffers", "WWMIShapeKeySlots", "WWMIBlendRemapSize", "WWMIBlendIndexLimit",
+           "Error", "BadAssetData", "UnknownDXGIFormat",
+           "FmtFile", "WWMIBlendRemap", "WWMIComponent", "WWMIIdentityMod", "WWMIShapeKeys",
+           "FormatTools", "WWMIIniBuilder", "WWMIIdentityModGenerator", "WWMITexturePattern"]

AGIDMGen/__main__.py

@@ -0,0 +1,24 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+import sys
+##### EndExtImports
+
+
+##### LocalImports
+from .main import main
+##### EndLocalImports
+
+
+##### Script
+sys.exit(main())
+##### EndScript

AGIDMGen/constants/DXGIFormats.py

@@ -0,0 +1,35 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from typing import Dict, Tuple
+##### EndExtImports
+
+
+##### Script
+#: The prefix of the full name of a DXGI format
+DXGIFormatPrefix = "DXGI_FORMAT_"
+
+# The DXGI formats a buffer element may be declared with, and how each one is decoded: the numpy dtype
+#   of one channel and the number of channels.
+#
+# note: this is a dict and not an Enum on purpose -- several formats decode the same way
+#   (R8G8B8A8_UINT and R8G8B8A8_UNORM), and an Enum would make those aliases of one member
+
+#: The DXGI formats a buffer element can be decoded from (without the ``DXGI_FORMAT_`` prefix), each with the numpy dtype of one channel and the number of channels
+DXGIFormats: Dict[str, Tuple[str, int]] = {
+    "R32G32B32A32_FLOAT": ("<f4", 4), "R32G32B32_FLOAT": ("<f4", 3), "R32G32_FLOAT": ("<f4", 2), "R32_FLOAT": ("<f4", 1),
+    "R16G16B16A16_FLOAT": ("<f2", 4), "R16G16B16_FLOAT": ("<f2", 3), "R16G16_FLOAT": ("<f2", 2), "R16_FLOAT": ("<f2", 1),
+    "R8G8B8A8_UINT": ("u1", 4), "R8G8B8A8_UNORM": ("u1", 4), "R8G8B8A8_SNORM": ("i1", 4), "R8G8B8_SNORM": ("i1", 3), "R8_SNORM": ("i1", 1), "R8_UINT": ("u1", 1), "R8_UNORM": ("u1", 1),
+    "R16G16B16A16_UINT": ("<u2", 4), "R16G16B16A16_UNORM": ("<u2", 4), "R16G16_UNORM": ("<u2", 2), "R16_UINT": ("<u2", 1),
+    "R32G32B32A32_UINT": ("<u4", 4), "R32_UINT": ("<u4", 1),
+}
+##### EndScript

AGIDMGen/constants/DumpDataKinds.py

@@ -0,0 +1,41 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from enum import Enum
+##### EndExtImports
+
+
+##### Script
+class DumpDataKinds(Enum):
+    """
+    The kinds of value one channel of a buffer element can hold, as named by the suffix of its DXGI format
+
+    Attributes
+    ----------
+    Float: :class:`str`
+        A floating point number (``FLOAT``)
+
+    SignedInt: :class:`str`
+        A signed integer (``SINT``)
+
+    UnsignedInt: :class:`str`
+        An unsigned integer (``UINT``)
+
+    Unorm: :class:`str`
+        An unsigned number from 0 to 1, stored as an unsigned integer scaled to its largest value (``UNORM``)
+    """
+
+    Float = "FLOAT"
+    SignedInt = "SINT"
+    UnsignedInt = "UINT"
+    Unorm = "UNORM"
+##### EndScript

AGIDMGen/constants/FileEncodings.py

@@ -0,0 +1,39 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from enum import Enum
+##### EndExtImports
+
+
+##### Script
+class FileEncodings(Enum):
+    """
+    The text encodings used when reading and writing the files of a mod
+
+    Attributes
+    ----------
+    UTF8: :class:`str`
+        The `utf-8` encoding
+
+    Latin1: :class:`str`
+        The `latin1` encoding
+    """
+
+    UTF8 = "utf-8"
+    Latin1 = "latin1"
+
+
+#: The encoding a ``.ini`` file is written in
+IniFileEncoding = FileEncodings.UTF8.value
+#: The encodings tried, in order, when reading a text file
+ReadEncodings = [IniFileEncoding, FileEncodings.Latin1.value]
+##### EndScript

AGIDMGen/constants/GIMIBuffers.py

@@ -0,0 +1,53 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from enum import Enum
+from typing import Dict
+##### EndExtImports
+
+
+##### Script
+class GIMIBuffers(Enum):
+    """
+    The vertex buffers of one component of a GIMI mod, in the order GIMI lays a vertex out. Each one is
+    written to ``<name><component><buffer>.buf``
+
+    Attributes
+    ----------
+    Position: :class:`str`
+        The ``POSITION``, ``NORMAL`` and ``TANGENT`` of the vertices
+
+    Blend: :class:`str`
+        The ``BLENDWEIGHT(S)`` and ``BLENDINDICES`` of the vertices
+
+    Texcoord: :class:`str`
+        The ``COLOR`` and ``TEXCOORD`` (``TEXCOORD1``, ...) of the vertices
+    """
+
+    Position = "Position"
+    Blend = "Blend"
+    Texcoord = "Texcoord"
+
+
+#: The buffer each element of a dumped vertex belongs to, by its semantic name
+GIMISemanticBuffers: Dict[str, GIMIBuffers] = {
+    "POSITION": GIMIBuffers.Position, "NORMAL": GIMIBuffers.Position, "TANGENT": GIMIBuffers.Position,
+    "BLENDWEIGHT": GIMIBuffers.Blend, "BLENDWEIGHTS": GIMIBuffers.Blend, "BLENDINDICES": GIMIBuffers.Blend,
+    "COLOR": GIMIBuffers.Texcoord, "TEXCOORD": GIMIBuffers.Texcoord
+}
+
+#: The number of bytes per vertex GIMI fixes for a buffer. The Texcoord buffer's is not fixed: it is 20 with a second UV set and 12 without, and can differ between the components of one character
+GIMIFixedStrides: Dict[GIMIBuffers, int] = {GIMIBuffers.Position: 40, GIMIBuffers.Blend: 32}
+
+#: What the name of a download folder's copy of the asset folder's ``hash.json`` ends with: ``<prefix>Hash.json``
+GIMIHashFileSuffix = "Hash.json"
+##### EndScript

AGIDMGen/constants/GIMITextureLayouts.py

@@ -0,0 +1,58 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from enum import Enum
+from typing import Tuple
+##### EndExtImports
+
+
+##### Script
+class GIMITextureLayouts(Enum):
+    """
+    The two layouts a GIMI mod binds an object's textures in, chosen by whether the object's shader reads a
+    normal map. Each value is the (register, texture kind) pairs of the layout, and the command list of
+    ``ORFix`` that moves the textures to the registers the shader actually reads
+
+    Attributes
+    ----------
+    NormalMap: Tuple[Tuple[Tuple[:class:`str`, :class:`str`], ...], :class:`str`]
+        ``ps-t0`` normal map, ``ps-t1`` diffuse and ``ps-t2`` light map, fixed by ``ORFix``
+
+    Plain: Tuple[Tuple[Tuple[:class:`str`, :class:`str`], ...], :class:`str`]
+        ``ps-t0`` diffuse and ``ps-t1`` light map, fixed by ``NNFix``
+    """
+
+    NormalMap = ((("ps-t0", "NormalMap"), ("ps-t1", "Diffuse"), ("ps-t2", "LightMap")), "CommandList\\global\\ORFix\\ORFix")
+    Plain = ((("ps-t0", "Diffuse"), ("ps-t1", "LightMap")), "CommandList\\global\\ORFix\\NNFix")
+
+    @property
+    def registers(self) -> Tuple[Tuple[str, str], ...]:
+        """
+        The (register, texture kind) pairs of the layout
+
+        :getter: Retrieves the registers
+        :type: Tuple[Tuple[:class:`str`, :class:`str`], ...]
+        """
+
+        return self.value[0]
+
+    @property
+    def fixCommand(self) -> str:
+        """
+        The command list that moves the layout's textures to the registers the shader reads
+
+        :getter: Retrieves the command list
+        :type: :class:`str`
+        """
+
+        return self.value[1]
+##### EndScript

AGIDMGen/constants/ModDownloadRepos.py

@@ -0,0 +1,45 @@
+##### Credits
+
+# ===== Anime Game Identity Mod Generator (AGIDMGen) =====
+# Authors: Albert Gold#2696
+#
+# A sub-project of Anime Game Remap (AG Remap)
+# if you used it to make your mods pls give credit for "Albert Gold#2696"
+
+##### EndCredits
+
+
+##### ExtImports
+from enum import Enum
+from typing import Dict
+##### EndExtImports
+
+
+##### LocalImports
+from .ModLoaders import ModLoaders
+##### EndLocalImports
+
+
+##### Script
+class ModDownloadRepos(Enum):
+    """
+    The repositories that hold characters' download folders, in the order they are searched: a file Anime
+    Game Remap has is taken from Anime Game Remap, so it is never kept twice. Each value is the address of
+    the repository's ``Data/Mod Downloads`` folder
+
+    Attributes
+    ----------
+    AGRemap: :class:`str`
+        `Anime Game Remap <https://github.com/nhok0169/Anime-Game-Remap>`_'s download folders
+
+    AGIDMGen: :class:`str`
+        This library's own download folders, for what Anime Game Remap does not have
+    """
+
+    AGRemap = "https://github.com/nhok0169/Anime-Game-Remap/raw/master/Data/Mod%20Downloads"
+    AGIDMGen = "https://github.com/Alex-Au1/Anime-Game-Identity-Mod-Generator/raw/main/Data/Mod%20Downloads"
+
+
+#: The folder of each mod loader's game in ``Data/Mod Downloads``
+ModDownloadGameFolders: Dict[ModLoaders, str] = {ModLoaders.GIMI: "GI", ModLoaders.WWMI: "WuWa"}
+##### EndScript