soh_xml_exporter.py

"""SOH XML export extensions for F3D GBI classes.
Monkey-patches to_soh_xml() and related methods onto F3D classes at registration time.
All methods are removed at unregistration time.
"""

import os
import bpy
from html import escape
from pathlib import Path
from struct import pack
import xml.etree.ElementTree as ET

from ...f3d.f3d_gbi import (
    DPFullSync,
    DPLoadBlock,
    DPLoadSync,
    DPLoadTLUTCmd,
    DPLoadTile,
    DPPipeSync,
    DPSetCombineMode,
    DPSetEnvColor,
    DPSetPrimColor,
    DPSetTextureImage,
    DPSetTextureLUT,
    DPSetTile,
    DPSetTileSize,
    DPTileSync,
    FImageKey,
    FLODGroup,
    FMaterial,
    FMesh,
    FModel,
    FPaletteKey,
    FScrollData,
    FSetTileSizeScrollField,
    FTriGroup,
    GfxList,
    SP1Triangle,
    SP2Triangles,
    SPBranchList,
    SPClearGeometryMode,
    SPCullDisplayList,
    SPDisplayList,
    SPEndDisplayList,
    SPLoadGeometryMode,
    SPMatrix,
    SPSetGeometryMode,
    SPSetLights,
    SPSetOtherMode,
    SPTexture,
    SPVertex,
    Vtx,
    VtxList,
    FTexRect,
    FLODGroup,
    Light,
    Ambient,
    Hilite,
    Lights,
    LookAt,
    SPMatrix,
    SPViewport,
    SPDisplayList,
    SPLine3D,
    SPLineW3D,
    SPSegment,
    SPClipRatio,
    SPAlphaCompareCull,
    SPModifyVertex,
    SPBranchLessZraw,
    SPNumLights,
    SPLight,
    SPLightColor,
    SPSetLights,
    SPLookAt,
    DPSetHilite1Tile,
    DPSetHilite2Tile,
    SPFogFactor,
    SPFogPosition,
    SPPerspNormalize,
    SPGeometryMode,
    DPPipelineMode,
    DPSetCycleType,
    DPSetTexturePersp,
    DPSetTextureDetail,
    DPSetTextureLOD,
    DPSetTextureFilter,
    DPSetTextureConvert,
    DPSetCombineKey,
    DPSetColorDither,
    DPSetAlphaDither,
    DPSetAlphaCompare,
    DPSetDepthSource,
    DPSetRenderMode,
    DPSetCombineMode,
    DPSetBlendColor,
    DPSetFogColor,
    DPSetFillColor,
    DPSetPrimDepth,
    DPSetOtherMode,
    DPSetTileSize,
    DPSetTile,
    DPLoadTextureBlock,
    DPLoadTextureBlockYuv,
    _DPLoadTextureBlock,
    DPLoadTextureBlock_4b,
    DPLoadTextureTile,
    DPLoadTextureTile_4b,
    DPLoadTLUT_pal16,
    DPLoadTLUT_pal256,
    DPLoadTLUT,
    DPSetConvert,
    DPSetKeyR,
    DPSetKeyGB,
    SPTextureRectangle,
    SPScisTextureRectangle,
    format_asset_path,
    get_image_from_image_key,
)
from ...utility import (
    PluginError,
    writeXMLData,
    resolve_internal_export_path,
)
from ...z64.exporter.skeleton.classes import OOTSkeleton, OOTLimb

# --- Helper functions ---


def getDynamicCosmeticXmlAttrs(cosmeticEntry: str, cosmeticCategory: str):
    entry = escape(cosmeticEntry.strip(), quote=True) if cosmeticEntry else ""
    if not entry:
        return ""

    attrs = f' CosmeticEntry="{entry}"'
    category = escape(cosmeticCategory.strip(), quote=True) if cosmeticCategory else ""
    if category:
        attrs += f' CosmeticCategory="{category}"'
    return attrs


def _get_cosmetic_manifest_path(modelDirPath: str, objectPath: str) -> str:
    model_path = Path(modelDirPath)
    object_parts = [part for part in (objectPath or "").replace("\\", "/").split("/") if part]
    if not object_parts:
        manifest_root = model_path.parent if model_path.name.lower() == "alt" else model_path
        return str(manifest_root / "CosmeticEntries")

    model_parts = list(model_path.parts)
    if len(model_parts) >= len(object_parts):
        tail = model_parts[-len(object_parts) :]
        if [part.lower() for part in tail] == [part.lower() for part in object_parts]:
            manifest_root = Path(*model_parts[: len(model_parts) - len(object_parts)])
            if manifest_root.name.lower() == "alt":
                manifest_root = manifest_root.parent
            return str(manifest_root / "CosmeticEntries")

    manifest_root = model_path.parent if model_path.name.lower() == "alt" else model_path
    return str(manifest_root / "CosmeticEntries")


def _read_existing_cosmetic_manifest_entries(manifestPath: str) -> list[dict[str, str]]:
    if not os.path.exists(manifestPath):
        return []

    try:
        root = ET.parse(manifestPath).getroot()
    except ET.ParseError as exc:
        raise PluginError(f"Unable to parse existing cosmetic manifest at {manifestPath}: {exc}") from exc

    if root.tag != "CustomCosmetics":
        raise PluginError(f'Unexpected cosmetic manifest root "{root.tag}" in {manifestPath}.')

    entries: list[dict[str, str]] = []
    for entry in root.findall("Entry"):
        entries.append(
            {
                "CosmeticCategory": entry.get("CosmeticCategory", ""),
                "CosmeticEntry": entry.get("CosmeticEntry", ""),
                "MaterialPath": entry.get("MaterialPath", ""),
                "CosmeticType": entry.get("CosmeticType", ""),
            }
        )
    return entries


def _serialize_cosmetic_manifest(entries: list[dict[str, str]]) -> str:
    lines = ["<CustomCosmetics>"]
    for entry in entries:
        attrs = " ".join(
            [
                f'CosmeticCategory="{escape(entry["CosmeticCategory"], quote=True)}"',
                f'CosmeticEntry="{escape(entry["CosmeticEntry"], quote=True)}"',
                f'MaterialPath="{escape(entry["MaterialPath"], quote=True)}"',
                f'CosmeticType="{escape(entry["CosmeticType"], quote=True)}"',
            ]
        )
        lines.append(f"	<Entry {attrs} />")
    lines.append("</CustomCosmetics>")
    return "\n".join(lines)


def _collect_material_cosmetic_manifest_entries(fMaterial, objectPath: str) -> list[dict[str, str]]:
    materialPath = format_asset_path(objectPath, fMaterial.material.name)
    entries: list[dict[str, str]] = []

    for command in fMaterial.material.commands:
        cosmeticType = None
        if isinstance(command, DPSetPrimColor):
            cosmeticType = "Prim"
        elif isinstance(command, DPSetEnvColor):
            cosmeticType = "Env"

        if cosmeticType is None:
            continue

        cosmeticEntry = (getattr(command, "cosmeticEntry", "") or "").strip()
        if not cosmeticEntry:
            continue

        entries.append(
            {
                "CosmeticCategory": (getattr(command, "cosmeticCategory", "") or "").strip(),
                "CosmeticEntry": cosmeticEntry,
                "MaterialPath": materialPath,
                "CosmeticType": cosmeticType,
            }
        )

    return entries


def _write_custom_cosmetics_manifest(modelDirPath: str, objectPath: str, manifestEntries: list[dict[str, str]]):
    if not manifestEntries:
        return

    manifestPath = _get_cosmetic_manifest_path(modelDirPath, objectPath)
    existingEntries = _read_existing_cosmetic_manifest_entries(manifestPath)
    mergedEntries = list(existingEntries)
    existingKeys = {
        (
            entry["CosmeticCategory"],
            entry["CosmeticEntry"],
            entry["MaterialPath"],
            entry["CosmeticType"],
        )
        for entry in existingEntries
    }

    for entry in manifestEntries:
        key = (
            entry["CosmeticCategory"],
            entry["CosmeticEntry"],
            entry["MaterialPath"],
            entry["CosmeticType"],
        )
        if key in existingKeys:
            continue
        existingKeys.add(key)
        mergedEntries.append(entry)

    writeXMLData(_serialize_cosmetic_manifest(mergedEntries), manifestPath)


# --- Extracted methods ---


# FSetTileSizeScrollField.to_soh_xml
def _FSetTileSizeScrollField_to_soh_xml(self, tex_index, dimensions):
    """Export scroll data for a single texture as XML for SOH.

    Args:
        tex_index: Texture index (0 for TEXEL0, 1 for TEXEL1)
        dimensions: Tuple of (width, height) in texels

    Returns:
        XML string with TexScroll element, or empty string if no scrolling
    """
    width, height = dimensions
    if self.s == 0 and self.t == 0:
        return ""  # No scrolling, don't export

    return f'<TexScroll TexIndex="{tex_index}" S="{self.s}" T="{self.t}" Width="{width}" Height="{height}" Interval="{self.interval}"/>\n'


# Vtx.to_soh_xml
def _Vtx_to_soh_xml(self):
    baseStr = '<Vtx X="{pX}" Y="{pY}" Z="{pZ}" S="{s}" T="{t}" R="{r}" G="{g}" B="{b}" A="{a}"/>'
    return baseStr.format(
        pX=self.position[0],
        pY=self.position[1],
        pZ=self.position[2],
        s=self.uv[0],
        t=self.uv[1],
        r=self.colorOrNormal[0],
        g=self.colorOrNormal[1],
        b=self.colorOrNormal[2],
        a=self.colorOrNormal[3],
    )


# VtxList.to_soh_xml
def _VtxList_to_soh_xml(self):
    data = '<Vertex Version="0">\n'
    for vert in self.vertices:
        data += "\t" + vert.to_soh_xml() + "\n"
    data += "</Vertex>\n"
    return data


# GfxList.to_soh_xml
def _GfxList_to_soh_xml(self, modelDirPath, objectPath):
    data = '<DisplayList Version="0">\n'
    for command in self.commands:
        if isinstance(command, (SPDisplayList, SPBranchList, SPVertex, DPSetTextureImage)):
            data += "\t" + command.to_soh_xml(objectPath) + "\n"
        else:
            data += "\t" + command.to_soh_xml() + "\n"

    data += "</DisplayList>\n\n"

    return data


# FModel.to_soh_xml
def _FModel_to_soh_xml(self, modelDirPath, objectPath, include_cull_vertices=True, combine_root_meshes=False):
    data = ""

    if combine_root_meshes:
        combined_call_lines = []
        combined_other_lines = []
        for mesh in self.meshes.values():
            data += mesh.to_soh_xml(modelDirPath, objectPath, include_cull_vertices, write_root_draw=False)
            call_lines, other_lines = mesh.get_soh_root_draw_lines(objectPath)
            combined_call_lines.extend(call_lines)
            if call_lines or other_lines:
                combined_other_lines = other_lines

        if combined_call_lines or combined_other_lines:
            data += (
                '<DisplayList Version="0">\n'
                + "".join(combined_call_lines + combined_other_lines)
                + "</DisplayList>\n\n"
            )
    else:
        for mesh in self.meshes.values():
            data += mesh.to_soh_xml(modelDirPath, objectPath, include_cull_vertices)

    for lod in self.LODGroups.values():
        data += lod.to_soh_xml(modelDirPath)

    for fMaterial, _ in self.materials.values():
        data += fMaterial.to_soh_xml(modelDirPath, objectPath)

    self.texturesSavedLastExport = self.save_soh_textures(modelDirPath)
    self.save_soh_palettes(modelDirPath)
    self.freePalettes()

    return data


# FModel.save_soh_textures
def _FModel_save_soh_textures(self, exportPath):
    texturesSaved = 0

    for key, texture in self.textures.items():
        if isinstance(key, FPaletteKey):
            continue
        if not isinstance(key, FImageKey):
            continue

        if getattr(texture, "skip_export", False):
            continue

        image = get_image_from_image_key(key)
        imageFileName = texture.name
        fmt_code = -1

        if texture.fmt == "G_IM_FMT_RGBA":
            if texture.bitSize == "G_IM_SIZ_16b":
                fmt_code = 2
            elif texture.bitSize == "G_IM_SIZ_32b":
                fmt_code = 1
        elif texture.fmt == "G_IM_FMT_CI":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 3
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 4
        elif texture.fmt == "G_IM_FMT_I":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 5
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 6
        elif texture.fmt == "G_IM_FMT_IA":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 7
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 8
            elif texture.bitSize == "G_IM_SIZ_16b":
                fmt_code = 9

        if fmt_code == -1:
            raise PluginError(
                f"Unsupported texture format {texture.fmt}/{texture.bitSize} when exporting SOH XML textures."
            )

        bpy.path.abspath(image.filepath)
        internal_path = getattr(texture, "internal_path", "")
        targetPath = bpy.path.abspath(resolve_internal_export_path(exportPath, internal_path, imageFileName))
        targetDir = os.path.dirname(targetPath)
        if targetDir and not os.path.exists(targetDir):
            os.makedirs(targetDir, exist_ok=True)

        isPacked = image.packed_file is not None
        if not isPacked:
            image.pack()
        oldpath = image.filepath
        try:
            image.filepath = targetPath
            with open(targetPath, "wb") as file:
                file.write(
                    pack(
                        "<IIIQIQIQQQIIIIIffI",
                        0,
                        0x4F544558,
                        1,
                        0xDEADBEEFDEADBEEF,
                        0,
                        0,
                        0,
                        0,
                        0,
                        0,
                        0,
                        fmt_code,
                        texture.width,
                        texture.height,
                        0,
                        1.0,
                        1.0,
                        len(texture.data),
                    )
                    + texture.data
                )
            texturesSaved += 1
            if not isPacked:
                old_dir = ""
                unpack_path = oldpath or targetPath
                if oldpath:
                    old_dir = os.path.dirname(bpy.path.abspath(oldpath))
                else:
                    old_dir = os.path.dirname(bpy.path.abspath(targetPath))
                if old_dir and not os.path.exists(old_dir):
                    os.makedirs(old_dir, exist_ok=True)
                image.filepath = unpack_path
                try:
                    image.unpack()
                except RuntimeError:
                    pass
        except Exception as exc:
            image.filepath = oldpath
            raise Exception(str(exc))
        image.filepath = oldpath
    return texturesSaved


# FModel.save_soh_palettes
def _FModel_save_soh_palettes(self, exportPath):
    palettesSaved = 0
    for key, texture in self.textures.items():
        if not isinstance(key, FPaletteKey):
            continue
        if getattr(texture, "skip_export", False):
            continue

        palette_name = texture.filename or texture.name
        if not palette_name:
            continue
        if palette_name.endswith(".inc.c"):
            palette_filename = palette_name[:-6]
        else:
            palette_filename = os.path.splitext(palette_name)[0]

        fmt_code = -1
        if texture.fmt == "G_IM_FMT_RGBA":
            if texture.bitSize == "G_IM_SIZ_16b":
                fmt_code = 2
            elif texture.bitSize == "G_IM_SIZ_32b":
                fmt_code = 1
        elif texture.fmt == "G_IM_FMT_CI":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 3
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 4
        elif texture.fmt == "G_IM_FMT_I":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 5
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 6
        elif texture.fmt == "G_IM_FMT_IA":
            if texture.bitSize == "G_IM_SIZ_4b":
                fmt_code = 7
            elif texture.bitSize == "G_IM_SIZ_8b":
                fmt_code = 8
            elif texture.bitSize == "G_IM_SIZ_16b":
                fmt_code = 9

        if fmt_code == -1:
            raise PluginError(
                f"Unsupported palette format {texture.fmt}/{texture.bitSize} when exporting SOH XML textures."
            )

        internal_path = getattr(texture, "internal_path", "")
        targetPath = bpy.path.abspath(resolve_internal_export_path(exportPath, internal_path, palette_filename))
        targetDir = os.path.dirname(targetPath)
        if targetDir and not os.path.exists(targetDir):
            os.makedirs(targetDir, exist_ok=True)

        try:
            with open(targetPath, "wb") as file:
                file.write(
                    pack(
                        "<IIIQIQIQQQIIIIIffI",
                        0,
                        0x4F544558,
                        1,
                        0xDEADBEEFDEADBEEF,
                        0,
                        0,
                        0,
                        0,
                        0,
                        0,
                        0,
                        fmt_code,
                        texture.width,
                        texture.height,
                        0,
                        1.0,
                        1.0,
                        len(texture.data),
                    )
                    + texture.data
                )
            palettesSaved += 1
        except Exception as exc:
            raise Exception(str(exc))

    return palettesSaved


# FMesh.get_soh_root_draw_lines
def _FMesh_get_soh_root_draw_lines(self, objectPath):
    def command_xml(command):
        if isinstance(command, (SPDisplayList, SPBranchList, DPSetTextureImage)):
            return "\t" + command.to_soh_xml(objectPath) + "\n"
        return "\t" + command.to_soh_xml() + "\n"

    call_lines = []
    other_lines = []
    for command in self.draw.commands:
        if isinstance(command, (SPVertex, SPCullDisplayList)):
            continue
        line = command_xml(command)
        if isinstance(command, (SPDisplayList, SPBranchList)):
            call_lines.append(line)
        else:
            other_lines.append(line)

    return call_lines, other_lines


# FMesh.to_soh_xml
def _FMesh_to_soh_xml(self, modelDirPath, objectPath, include_cull_vertices=True, write_root_draw=True):
    if include_cull_vertices and self.cullVertexList is not None:
        cullData = self.cullVertexList.to_soh_xml()
        writeXMLData(cullData, os.path.join(modelDirPath, self.cullVertexList.name))

    for triGroup in self.triangleGroups:
        triGroup.to_soh_xml(modelDirPath, objectPath)

    for drawOverride in self.draw_overrides:
        overrideData = drawOverride.to_soh_xml(modelDirPath)
        writeXMLData(overrideData, os.path.join(modelDirPath, drawOverride.name))

    if not write_root_draw:
        return ""

    call_lines, other_lines = self.get_soh_root_draw_lines(objectPath)
    drawData = '<DisplayList Version="0">\n' + "".join(call_lines + other_lines) + "</DisplayList>\n\n"
    writeXMLData(drawData, os.path.join(modelDirPath, self.draw.name))
    return drawData


# FTriGroup.to_soh_xml
def _FTriGroup_to_soh_xml(self, modelDirPath, objectPath):
    vtxData = self.vertexList.to_soh_xml()
    writeXMLData(vtxData, os.path.join(modelDirPath, self.vertexList.name))

    triListData = self.triList.to_soh_xml(modelDirPath, objectPath)
    writeXMLData(triListData, os.path.join(modelDirPath, self.triList.name))
    return ""


# FScrollData.to_soh_xml
def _FScrollData_to_soh_xml(self):
    """Export all tile scroll data as XML for SOH.

    Returns:
        XML string with TexScroll elements for each texture that has scrolling,
        or empty string if no scrolling is present
    """
    data = ""

    # Export tex0 scroll if present
    if self.tile_scroll_tex0.s != 0 or self.tile_scroll_tex0.t != 0:
        data += "\t\t" + self.tile_scroll_tex0.to_soh_xml(0, self.dimensions)

    # Export tex1 scroll if present
    if self.tile_scroll_tex1.s != 0 or self.tile_scroll_tex1.t != 0:
        data += "\t\t" + self.tile_scroll_tex1.to_soh_xml(1, self.dimensions)

    return data


# FMaterial.to_soh_xml
def _FMaterial_to_soh_xml(self, modelDirPath, objectPath):
    data = ""

    if self.material.tag.Export:
        matData = self.material.to_soh_xml(modelDirPath, objectPath)
        # Insert scroll data before closing DisplayList tag if present
        if self.scrollData.has_scroll_data():
            scrollData = self.scrollData.to_soh_xml()
            matData = matData.replace("</DisplayList>", scrollData + "</DisplayList>")
        writeXMLData(matData, os.path.join(modelDirPath, self.material.name))
        _write_custom_cosmetics_manifest(
            modelDirPath,
            objectPath,
            _collect_material_cosmetic_manifest_entries(self, objectPath),
        )

    if self.revert is not None and self.revert.tag.Export:
        revData = self.revert.to_soh_xml(modelDirPath, objectPath)
        writeXMLData(revData, os.path.join(modelDirPath, self.revert.name))

    return data


# SPMatrix.to_soh_xml
def _SPMatrix_to_soh_xml(self, objectPath=""):
    name = self.matrix
    path = f"{objectPath}/{name}" if objectPath else f">{name}"
    return f'<Matrix Path="{path}" Param="{self.param}"/>'


# SPVertex.to_soh_xml
def _SPVertex_to_soh_xml(self, objectPath=""):
    baseStr = '<LoadVertices Path="{parent}/{vertexPath}" VertexBufferIndex="{bufferIndex}" VertexOffset="{vertexOffset}" Count="{count}"/>'
    return baseStr.format(
        parent=objectPath,
        vertexPath=self.vertList.name,
        bufferIndex=self.index,
        vertexOffset=self.offset,
        count=self.count,
    )


# SPDisplayList.to_soh_xml
def _SPDisplayList_to_soh_xml(self, objectPath=""):
    name = self.displayList.name
    path = format_asset_path(objectPath, name)
    return f'<CallDisplayList Path="{path}"/>'


# SPEndDisplayList.to_soh_xml
def _SPEndDisplayList_to_soh_xml(self):
    return "<EndDisplayList/>"


# SP1Triangle.to_soh_xml
def _SP1Triangle_to_soh_xml(self, objectPath=""):
    return f'<Triangle1 V00="{self.v0}" V01="{self.v1}" V02="{self.v2}"/>'


# SP2Triangles.to_soh_xml
def _SP2Triangles_to_soh_xml(self, objectPath=""):
    first = f'<Triangle1 V00="{self.v00}" V01="{self.v01}" V02="{self.v02}"/>'
    second = f'<Triangle1 V00="{self.v10}" V01="{self.v11}" V02="{self.v12}"/>'
    return first + "\n\t" + second


# SPCullDisplayList.to_soh_xml
def _SPCullDisplayList_to_soh_xml(self, objectPath=""):
    return f'<CullDisplayList Start="{self.vstart}" End="{self.vend}"/>'


# SPSetLights.to_soh_xml
def _SPSetLights_to_soh_xml(self, objectPath=""):
    return ""


# SPTexture.to_soh_xml
def _SPTexture_to_soh_xml(self, objectPath=""):
    return f'<Texture S="{self.s}" T="{self.t}" Level="{self.level}" Tile="{self.tile}" On="{self.on}"/>'


# SPSetGeometryMode.to_soh_xml
def _SPSetGeometryMode_to_soh_xml(self, objectPath=""):
    if not self.flagList:
        return "<SetGeometryMode/>"
    flags = " ".join(f'{flag}="1"' for flag in sorted(self.flagList, key=str))
    return f"<SetGeometryMode {flags}/>"


# SPClearGeometryMode.to_soh_xml
def _SPClearGeometryMode_to_soh_xml(self, objectPath=""):
    if not self.flagList:
        return "<ClearGeometryMode/>"
    flags = " ".join(f'{flag}="1"' for flag in sorted(self.flagList, key=str))
    return f"<ClearGeometryMode {flags}/>"


# SPLoadGeometryMode.to_soh_xml
def _SPLoadGeometryMode_to_soh_xml(self, objectPath=""):
    flags = ",".join(sorted(self.flagList))
    return f'<GeometryFlags Mode="Load" Flags="{flags}"/>'


# SPSetOtherMode.to_soh_xml
def _SPSetOtherMode_to_soh_xml(self, objectPath=""):
    if not self.flagList:
        return f'<SetOtherMode Cmd="{self.cmd}" Sft="{self.sft}" Length="{self.length}"/>'
    flags = " ".join(f'{flag}="1"' for flag in sorted(self.flagList, key=str))
    return f'<SetOtherMode Cmd="{self.cmd}" Sft="{self.sft}" Length="{self.length}" {flags}/>'


# DPSetTextureLUT.to_soh_xml
def _DPSetTextureLUT_to_soh_xml(self, objectPath=""):
    return f'<SetTextureLUT Mode="{self.mode}"/>'


# DPSetTextureImage.to_soh_xml
def _DPSetTextureImage_to_soh_xml(self, objectPath=""):
    prefix = (
        self.image.internal_path
        if self.image.internal_path
        else (objectPath if self.image.filename is not None else "")
    )
    imagePath = format_asset_path(prefix, self.image.name if self.image.name else "")
    return f'<SetTextureImage Path="{imagePath}" Format="{self.fmt}" Size="{self.siz}" Width="{self.width}"/>'


# DPSetCombineMode.to_soh_xml
def _DPSetCombineMode_to_soh_xml(self, objectPath=""):
    def _cc(name: str) -> str:
        return name if name.startswith("G_CCMUX_") else f"G_CCMUX_{name}"

    def _ac(name: str) -> str:
        return name if name.startswith("G_ACMUX_") else f"G_ACMUX_{name}"

    return (
        "<SetCombineLERP "
        f'A0="{_cc(self.a0)}" B0="{_cc(self.b0)}" C0="{_cc(self.c0)}" D0="{_cc(self.d0)}" '
        f'Aa0="{_ac(self.Aa0)}" Ab0="{_ac(self.Ab0)}" Ac0="{_ac(self.Ac0)}" Ad0="{_ac(self.Ad0)}" '
        f'A1="{_cc(self.a1)}" B1="{_cc(self.b1)}" C1="{_cc(self.c1)}" D1="{_cc(self.d1)}" '
        f'Aa1="{_ac(self.Aa1)}" Ab1="{_ac(self.Ab1)}" Ac1="{_ac(self.Ac1)}" Ad1="{_ac(self.Ad1)}"/>'
    )


# DPSetEnvColor.to_soh_xml
def _DPSetEnvColor_to_soh_xml(self, objectPath=""):
    return (
        f'<SetEnvColor R="{self.r}" G="{self.g}" B="{self.b}" A="{self.a}"'
        f"{getDynamicCosmeticXmlAttrs(self.cosmeticEntry, self.cosmeticCategory)}/>"
    )


# DPSetPrimColor.to_soh_xml
def _DPSetPrimColor_to_soh_xml(self, objectPath=""):
    return (
        f'<SetPrimColor M="{self.m}" L="{self.l}" R="{self.r}" G="{self.g}" B="{self.b}" A="{self.a}"'
        f"{getDynamicCosmeticXmlAttrs(self.cosmeticEntry, self.cosmeticCategory)}/>"
    )


# DPSetTileSize.to_soh_xml
def _DPSetTileSize_to_soh_xml(self, objectPath=""):
    return f'<SetTileSize T="{self.tile}" Uls="{self.uls}" Ult="{self.ult}" ' f'Lrs="{self.lrs}" Lrt="{self.lrt}"/>'


# DPLoadTile.to_soh_xml
def _DPLoadTile_to_soh_xml(self, objectPath=""):
    return f'<LoadTile Tile="{self.tile}" Uls="{self.uls}" Ult="{self.ult}" ' f'Lrs="{self.lrs}" Lrt="{self.lrt}"/>'


# DPSetTile.to_soh_xml
def _DPSetTile_to_soh_xml(self, objectPath=""):
    return (
        f'<SetTile Format="{self.fmt}" Size="{self.siz}" Line="{self.line}" TMem="{self.tmem}" '
        f'Tile="{self.tile}" Palette="{self.palette}" Cms0="{self.cms[0]}" Cms1="{self.cms[1]}" '
        f'Cmt0="{self.cmt[0]}" Cmt1="{self.cmt[1]}" MaskS="{self.masks}" ShiftS="{self.shifts}" '
        f'MaskT="{self.maskt}" ShiftT="{self.shiftt}"/>'
    )


# DPLoadBlock.to_soh_xml
def _DPLoadBlock_to_soh_xml(self, objectPath=""):
    return f'<LoadBlock Tile="{self.tile}" Uls="{self.uls}" Ult="{self.ult}" ' f'Lrs="{self.lrs}" Dxt="{self.dxt}" />'


# DPLoadTLUTCmd.to_soh_xml
def _DPLoadTLUTCmd_to_soh_xml(self, objectPath=""):
    return f'<LoadTLUTCmd Tile="{self.tile}" Count="{self.count}"/>'


# DPFullSync.to_soh_xml
def _DPFullSync_to_soh_xml(self):
    return "<FullSync/>"


# DPTileSync.to_soh_xml
def _DPTileSync_to_soh_xml(self):
    return "<TileSync/>"


# DPPipeSync.to_soh_xml
def _DPPipeSync_to_soh_xml(self):
    return "<PipeSync/>"


# DPLoadSync.to_soh_xml
def _DPLoadSync_to_soh_xml(self):
    return "<LoadSync/>"


# OOTSkeleton.toSohXML
def _OOTSkeleton_toSohXML(self, modelDirPath, objectPath):
    limbData = ""
    data = ""

    if self.limbRoot is None:
        return data

    limbList = self.createLimbList()
    isFlex = self.isFlexSkeleton()

    limbData += '<Skeleton Version="0" Type="'

    if isFlex:
        limbData += 'Flex" LimbCount="{lc}" DisplayListCount="{dlC}">\n'.format(
            lc=self.getNumLimbs(), dlC=self.getNumDLs()
        )
    else:
        limbData += 'Normal" LimbCount="{lc}">\n'.format(lc=self.getNumLimbs())

    for limb in limbList:
        indLimbData = limb.toSohXML(self.hasLOD, objectPath)

        writeXMLData(indLimbData, os.path.join(modelDirPath, limb.name()))

        limbData += '\t<SkeletonLimb Path="{path}/{name}"/>\n'.format(
            path=objectPath if len(objectPath) > 0 else ">", name=limb.name()
        )

    limbData += "</Skeleton>"
    return limbData


# OOTLimb.toSohXML
def _OOTLimb_toSohXML(self, isLOD, objectPath):
    data = '<SkeletonLimb Version="0" Type="'

    if not isLOD:
        data += 'Standard" '
    else:
        data += 'Lod" '

    DLName = self.DL.name if self.DL is not None else "gEmptyDL"

    if DLName != "gEmptyDL":
        DLName = (objectPath + "/" if len(objectPath) > 0 else ">") + DLName

    data += (
        'LegTransX="{legTransX}" LegTransY="{legTransY}" LegTransZ="{legTransZ}" '
        'ChildIndex="{firstChildIndex}" SiblingIndex="{siblingIndex}" DisplayList1="{displayList1}"/>\n'
    ).format(
        legTransX=int(round(self.translation[0])),
        legTransY=int(round(self.translation[1])),
        legTransZ=int(round(self.translation[2])),
        firstChildIndex=self.firstChildIndex,
        siblingIndex=self.nextSiblingIndex,
        displayList1=DLName,
    )

    return data


# FTexRectdef.to_soh_xml
def _FTexRect_to_soh_xml(self, savePNG, texDir):
    data = ""
    for info, texture in self.textures.items():
        if savePNG:
            data += texture.to_xml(texDir)
        else:
            data += texture.to_xml(texDir)

    dynamicData = self.draw.to_xml(texDir)

    writeXMLData(dynamicData, os.path.join(texDir, self.draw.name))
    return data


# FLODGroup.to_soh_xml
def _FLODGroup_to_soh_xml(self, f3d):
    self.create_data()

    dynamicData = ""
    staticData = self.vertexList.to_xml()
    for displayList in self.subdraws:
        if displayList is not None:
            dynamicData += displayList.to_xml(f3d)
    dynamicData += self.draw.to_xml(f3d)
    return staticData, dynamicData


# Light.to_soh_xml
def _Light_to_soh_xml(self):
    return f'<Light Color0="{self.color[0]}" Color1="{self.color[1]}" Color2="{self.color[2]}" Normal0="{self.normal[0]}" Normal1="{self.normal[1]}" Normal2="{self.normal[2]}"/>'


# Ambient.to_soh_xml
def _Ambient_to_soh_xml(self):
    return f'<Ambient Color0="{self.color[0]}" Color1="{self.color[1]}" Color2="{self.color[2]}"/>'


# Hilite.to_soh_xml
def _Hilite_to_soh_xml(self):
    return f'<Hilite X1="{self.x1}" Y1="{self.y1}" X2="{self.x2}" Y2="{self.y2}"/>'


# Lights.to_soh_xml
def _Lights_to_soh_xml(self):
    data = "<Lights Size={l}>".format(len(self.l))
    for light in self.l:
        data += "\t" + light.to_xml() + "\n"
    data += "</Lights>"
    return data


# LookAt.to_soh_xml
def _LookAt_to_soh_xml(self):
    data = "<LookAt>"
    for light in self.l:
        data += "\t" + light.to_xml() + "\n"
    data += "</LookAt>"
    return data


# SPMatrix.to_soh_xml
def _SPMatrix_to_soh_xml(self):
    return f'<Matrix Path=">{str(self.matrix)}" Param="{self.param}"/>'


# SPViewport.to_soh_xml
def _SPViewport_to_soh_xml(self):
    return f'<Viewport Path="{self.viewport.name}"/>'


# SPDisplayList.to_soh_xml
def _SPDisplayList_to_soh_xml(self, objectPath):
    name = self.displayList.name
    baseStr = '<CallDisplayList Path="{path}"/>'
    data = baseStr.format(path=">" + name if "0x" in name else (objectPath + "/" + name))
    return data


# SPLine3D.to_soh_xml
def _SPLine3D_to_soh_xml(self):
    return f'<Line3D V0="{self.v0}" V1="{self.v1}" Flag="{self.flag}"/>'


# SPLineW3D.to_soh_xml
def _SPLineW3D_to_soh_xml(self):
    return f'<Line3D V0="{self.v0}" V1="{self.v1}" WD="{self.wd}" Flag="{self.flag}"/>'


# SPSegment.to_soh_xml
def _SPSegment_to_soh_xml(self):
    return f'<Segment Seg="{self.segment}" Base="{self.base}"/>'


# SPClipRatio.to_soh_xml
def _SPClipRatio_to_soh_xml(self):
    return f'<ClipRatio Ratio="{self.ratio}"/>'


# SPAlphaCompareCull.to_soh_xml
def _SPAlphaCompareCull_to_soh_xml(self):
    return "<!-- SPAlphaCompareCull is not implemented -->"


# SPModifyVertex.to_soh_xml
def _SPModifyVertex_to_soh_xml(self):
    return f'<ModifyVertex Vtx="{self.vtx}" Where="{self.where}" Val="{self.val}"/>'


# SPBranchLessZraw.to_soh_xml
def _SPBranchLessZraw_to_soh_xml(self):
    return f'<ModifyVertex BranchDL="{self.dl.name}" Vtx="{self.vtx}" ZVal="{self.zval}"/>'


# SPNumLights.to_soh_xml
def _SPNumLights_to_soh_xml(self):
    return f'<NumLights Lites="{self.n}"/>'


# SPLight.to_soh_xml
def _SPLight_to_soh_xml(self):
    return f'<Light L="{self.light.name}" N="{self.n}"/>'


# SPLightColor.to_soh_xml
def _SPLightColor_to_soh_xml(self):
    return f'<LightColor N="{self.n}" Col="{self.col}"/>'


# SPSetLights.to_soh_xml
def _SPSetLights_to_soh_xml(self):
    data = "<!-- SetLights Not Implemented -->"
    return data


# SPLookAt.to_soh_xml
def _SPLookAt_to_soh_xml(self):
    return f'<LookAt L="{self.la.name}"/>'


# DPSetHilite1Tile.to_soh_xml
def _DPSetHilite1Tile_to_soh_xml(self):
    return f'<Hilite1Tile Tile="{self.tile}" Hilite="{self.hilite.name}" Width="{self.width}" Height="{self.height}"/>'


# DPSetHilite2Tile.to_soh_xml
def _DPSetHilite2Tile_to_soh_xml(self):
    return f'<Hilite2Tile Tile="{self.tile}" Hilite="{self.hilite.name}" Width="{self.width}" Height="{self.height}"/>'


# SPFogFactor.to_soh_xml
def _SPFogFactor_to_soh_xml(self):
    return f'<FogFactor FM="{self.fm}" FO="{self.fo}"/>'


# SPFogPosition.to_soh_xml
def _SPFogPosition_to_soh_xml(self):
    return f'<FogPosition Min="{self.minVal}" Max="{self.maxVal}"/>'


# SPPerspNormalize.to_soh_xml
def _SPPerspNormalize_to_soh_xml(self):
    return f'<PerpsNormalize S="{self.s}"/>'


# SPGeometryMode.to_soh_xml
def _SPGeometryMode_to_soh_xml(self):
    data = "<SetGeometryMode "

    for flag in self.setFlagList:
        if flag != "0":
            data += f'{flag}="1" '

    data += " />\n"

    data += "\t<ClearGeometryMode "

    for flag in self.clearFlagList:
        if flag != "0":
            data += f'{flag}="1" '

    data += " />"

    return data


# DPPipelineMode.to_soh_xml
def _DPPipelineMode_to_soh_xml(self):
    return f'<PipelineMode {self.mode}="1"/>'


# DPSetCycleType.to_soh_xml
def _DPSetCycleType_to_soh_xml(self):
    return f'<SetCycleType {self.mode}="1"/>'


# DPSetTexturePersp.to_soh_xml
def _DPSetTexturePersp_to_soh_xml(self):
    return f'<SetTexturePersp Enable="{self.mode}"/>'


# DPSetTextureDetail.to_soh_xml
def _DPSetTextureDetail_to_soh_xml(self):
    return f'<SetTextureDetail Type="{self.mode}"/>'


# DPSetTextureLOD.to_soh_xml
def _DPSetTextureLOD_to_soh_xml(self):
    return f'<SetTextureLOD Mode="{self.mode}"/>'


# DPSetTextureFilter.to_soh_xml
def _DPSetTextureFilter_to_soh_xml(self):
    return f'<SetTextureFilter Mode="{self.mode}"/>'


# DPSetTextureConvert.to_soh_xml
def _DPSetTextureConvert_to_soh_xml(self):
    return f'<SetTextureFilter Type="{self.mode}"/>'


# DPSetCombineKey.to_soh_xml
def _DPSetCombineKey_to_soh_xml(self):
    return f'<SetCombineKey Type="{self.mode}"/>'


# DPSetColorDither.to_soh_xml
def _DPSetColorDither_to_soh_xml(self):
    return f'<SetColorDither Type="{self.mode}"/>'


# DPSetAlphaDither.to_soh_xml
def _DPSetAlphaDither_to_soh_xml(self):
    return f'<SetAlphaDither Type="{self.mode}"/>'


# DPSetAlphaCompare.to_soh_xml
def _DPSetAlphaCompare_to_soh_xml(self):
    return f'<SetAlphaCompare Mode="{self.mask}"/>'


# DPSetDepthSource.to_soh_xml
def _DPSetDepthSource_to_soh_xml(self):
    return f'<SetDepthSource Source="{self.src}"/>'


# DPSetRenderMode.to_soh_xml
def _DPSetRenderMode_to_soh_xml(self):
    data = "<SetRenderMode "

    if len(self.flagList) != 2:
        raise PluginError("For a rendermode preset, only two fields should be used.")

    for idx, name in enumerate(self.flagList):
        data += f'Mode{(idx + 1)}="{name}" '

    data += "/>"

    return data


# DPSetCombineMode.to_soh_xml
def _DPSetCombineMode_to_soh_xml(self):
    baseStr = '<SetCombineLERP A0="G_CCMUX_{a0}" B0="G_CCMUX_{b0}" C0="G_CCMUX_{c0}" D0="G_CCMUX_{d0}" Aa0="G_ACMUX_{aa0}" Ab0="G_ACMUX_{ab0}" Ac0="G_ACMUX_{ac0}" Ad0="G_ACMUX_{ad0}" A1="G_CCMUX_{a1}" B1="G_CCMUX_{b1}" C1="G_CCMUX_{c1}" D1="G_CCMUX_{d1}" Aa1="G_ACMUX_{aa1}" Ab1="G_ACMUX_{ab1}" Ac1="G_ACMUX_{ac1}" Ad1="G_ACMUX_{ad1}"/>'
    data = baseStr.format(
        a0=self.a0,
        b0=self.b0,
        c0=self.c0,
        d0=self.d0,
        aa0=self.Aa0,
        ab0=self.Ab0,
        ac0=self.Ac0,
        ad0=self.Ad0,
        a1=self.a1,
        b1=self.b1,
        c1=self.c1,
        d1=self.d1,
        aa1=self.Aa1,
        ab1=self.Ab1,
        ac1=self.Ac1,
        ad1=self.Ad1,
    )

    return data


# DPSetBlendColor.to_soh_xml
def _DPSetBlendColor_to_soh_xml(self):
    return f'<SetBlendColor R="{self.r}" G="{self.g}" B="{self.b}" A="{self.a}"/>'


# DPSetFogColor.to_soh_xml
def _DPSetFogColor_to_soh_xml(self):
    return '<SetFogColor R="{self.r}" G="{self.g}" B="{self.b}" A="{self.a}"/>'


# DPSetFillColor.to_soh_xml
def _DPSetFillColor_to_soh_xml(self):
    return f'<SetFillColor C="{self.d}"/>'


# DPSetPrimDepth.to_soh_xml
def _DPSetPrimDepth_to_soh_xml(self):
    return f'<SetPrimDepth Z="{self.z}" DZ="{self.dz}"/>'


# DPSetOtherMode.to_soh_xml
def _DPSetOtherMode_to_soh_xml(self):
    data = "<!-- SetOtherMode Not Implemented -->"
    return data


# DPSetTileSize.to_soh_xml
def _DPSetTileSize_to_soh_xml(self):
    return f'<SetTileSize T="{self.tile}" Uls="{self.uls}" Ult="{self.ult}" Lrs="{self.lrs}" Lrt="{self.lrt}"/>'


# DPSetTile.to_soh_xml
def _DPSetTile_to_soh_xml(self):
    baseStr = '<SetTile Format="{fmt}" Size="{siz}" Line="{line}" TMem="{tmem}" Tile="{tile}" Palette="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt1}" MaskS="{maskS}" ShiftS="{shiftS}" MaskT="{maskT}" ShiftT="{shiftT}"/>'
    data = baseStr.format(
        fmt=self.fmt,
        siz=self.siz,
        line=self.line,
        tmem=self.tmem,
        tile=self.tile,
        pal=self.palette,
        cms0=self.cms[0],
        cms1=self.cms[1],
        cmt0=self.cmt[0],
        cmt1=self.cmt[1],
        maskS=self.masks,
        shiftS=self.shifts,
        maskT=self.maskt,
        shiftT=self.shiftt,
    )

    return data


# DPLoadTextureBlock.to_soh_xml
def _DPLoadTextureBlock_to_soh_xml(self):
    data = '<LoadTextureBlock TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# DPLoadTextureBlockYuv.to_soh_xml
def _DPLoadTextureBlockYuv_to_soh_xml(self):
    data = '<LoadTextureBlockYuv TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# _DPLoadTextureBlock.to_soh_xml
def __DPLoadTextureBlock_to_soh_xml(self):
    data = '<TLoadTextureBlock TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# DPLoadTextureBlock_4b.to_soh_xml
def _DPLoadTextureBlock_4b_to_soh_xml(self):
    data = '<LoadTextureBlock4b TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# DPLoadTextureTile.to_soh_xml
def _DPLoadTextureTile_to_soh_xml(self):
    data = '<LoadTextureTile TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Uls="{uls}" Ult="{ult}" Lrs="{lrs}" Lrt="{lrt}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.uls,
        self.ult,
        self.lrs,
        self.lrt,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# DPLoadTextureTile_4b.to_soh_xml
def _DPLoadTextureTile_4b_to_soh_xml(self):
    data = '<LoadTextureTile4b TImg="{timg}" Fmt="{fmt}" Siz="{siz}" Width="{width}" Height="{height}" Pal="{pal}" Cms0="{cms0}" Cms1="{cms1}" Cmt0="{cmt0}" Cmt1="{cmt0}" Masks="{masks}" Maskt="{maskt}" Shifts="{shifts}" Shiftt="{shift}" />'.format(
        self.timg.name,
        self.fmt,
        self.width,
        self.height,
        self.pal,
        self.cms[0],
        self.cms[1],
        self.cmt[0],
        self.cmt[1],
        self.masks,
        self.maskt,
        self.shifts,
        self.shiftt,
    )
    return data


# DPLoadTLUT_pal16.to_soh_xml
def _DPLoadTLUT_pal16_to_soh_xml(self):
    return f'<LoadTLUTPal16 Pal="{self.pal}" Dram="{self.dram.name}"/>'


# DPLoadTLUT_pal256.to_soh_xml
def _DPLoadTLUT_pal256_to_soh_xml(self):
    return f'<LoadTLUTPal256 Dram="{self.dram.name}"/>'


# DPLoadTLUT.to_soh_xml
def _DPLoadTLUT_to_soh_xml(self):
    return f'<LoadTlut Count="{self.count}" TMemAddr="{self.tmemaddr}" Dram="{self.dram.name}"/>'


# DPSetConvert.to_soh_xml
def _DPSetConvert_to_soh_xml(self):
    return f'<SetConvert K0="{self.k0}" K1="{self.k1}" K2="{self.k2}" K3="{self.k3}" K4="{self.k4}" K5="{self.k5}"/>'


# DPSetKeyR.to_soh_xml
def _DPSetKeyR_to_soh_xml(self):
    return f'<SetKeyA WR="{self.wr}" CR="{self.cr}" SR="{self.sr}"/>'


# DPSetKeyGB.to_soh_xml
def _DPSetKeyGB_to_soh_xml(self):
    return f'<SetKeyGB CG="{self.cg}" SG="{self.sg}" WG="{self.wg}" CB="{self.cb}" SB="{self.sb}" WB="{self.wb}"/>'


# SPTextureRectangle.to_soh_xml
def _SPTextureRectangle_to_soh_xml(self):
    return f'<TextureRectangle Ulx="{self.xl}" Uly="{self.yl}" Lrx="{self.xh}" Lry="{self.yh}" Tile="{self.tile}" S="{self.s}" T="{self.t}" Dsdx="{self.dsdx}" Dsdy="{self.dtdy}"/>'


# SPScisTextureRectangle.to_soh_xml
def _SPScisTextureRectangle_to_soh_xml(self):
    return f'<ScisTextureRectangle Ulx="{self.xl}" Uly="{self.yl}" Lrx="{self.xh}" Lry="{self.yh}" Tile="{self.tile}" S="{self.s}" T="{self.t}" Dsdx="{self.dsdx}" Dsdy="{self.dtdy}"/>'


# --- Patch registry ---


_PATCHES = {
    FSetTileSizeScrollField: {
        "to_soh_xml": _FSetTileSizeScrollField_to_soh_xml,
    },
    Vtx: {
        "to_soh_xml": _Vtx_to_soh_xml,
    },
    VtxList: {
        "to_soh_xml": _VtxList_to_soh_xml,
    },
    GfxList: {
        "to_soh_xml": _GfxList_to_soh_xml,
    },
    FModel: {
        "to_soh_xml": _FModel_to_soh_xml,
        "save_soh_textures": _FModel_save_soh_textures,
        "save_soh_palettes": _FModel_save_soh_palettes,
    },
    FMesh: {
        "get_soh_root_draw_lines": _FMesh_get_soh_root_draw_lines,
        "to_soh_xml": _FMesh_to_soh_xml,
    },
    FTriGroup: {
        "to_soh_xml": _FTriGroup_to_soh_xml,
    },
    FScrollData: {
        "to_soh_xml": _FScrollData_to_soh_xml,
    },
    FMaterial: {
        "to_soh_xml": _FMaterial_to_soh_xml,
    },
    SPMatrix: {
        "to_soh_xml": _SPMatrix_to_soh_xml,
    },
    SPVertex: {
        "to_soh_xml": _SPVertex_to_soh_xml,
    },
    SPDisplayList: {
        "to_soh_xml": _SPDisplayList_to_soh_xml,
    },
    SPEndDisplayList: {
        "to_soh_xml": _SPEndDisplayList_to_soh_xml,
    },
    SP1Triangle: {
        "to_soh_xml": _SP1Triangle_to_soh_xml,
    },
    SP2Triangles: {
        "to_soh_xml": _SP2Triangles_to_soh_xml,
    },
    SPCullDisplayList: {
        "to_soh_xml": _SPCullDisplayList_to_soh_xml,
    },
    SPSetLights: {
        "to_soh_xml": _SPSetLights_to_soh_xml,
    },
    SPTexture: {
        "to_soh_xml": _SPTexture_to_soh_xml,
    },
    SPSetGeometryMode: {
        "to_soh_xml": _SPSetGeometryMode_to_soh_xml,
    },
    SPClearGeometryMode: {
        "to_soh_xml": _SPClearGeometryMode_to_soh_xml,
    },
    SPLoadGeometryMode: {
        "to_soh_xml": _SPLoadGeometryMode_to_soh_xml,
    },
    SPSetOtherMode: {
        "to_soh_xml": _SPSetOtherMode_to_soh_xml,
    },
    DPSetTextureLUT: {
        "to_soh_xml": _DPSetTextureLUT_to_soh_xml,
    },
    DPSetTextureImage: {
        "to_soh_xml": _DPSetTextureImage_to_soh_xml,
    },
    DPSetCombineMode: {
        "to_soh_xml": _DPSetCombineMode_to_soh_xml,
    },
    DPSetEnvColor: {
        "to_soh_xml": _DPSetEnvColor_to_soh_xml,
    },
    DPSetPrimColor: {
        "to_soh_xml": _DPSetPrimColor_to_soh_xml,
    },
    DPSetTileSize: {
        "to_soh_xml": _DPSetTileSize_to_soh_xml,
    },
    DPLoadTile: {
        "to_soh_xml": _DPLoadTile_to_soh_xml,
    },
    DPSetTile: {
        "to_soh_xml": _DPSetTile_to_soh_xml,
    },
    DPLoadBlock: {
        "to_soh_xml": _DPLoadBlock_to_soh_xml,
    },
    DPLoadTLUTCmd: {
        "to_soh_xml": _DPLoadTLUTCmd_to_soh_xml,
    },
    DPFullSync: {
        "to_soh_xml": _DPFullSync_to_soh_xml,
    },
    DPTileSync: {
        "to_soh_xml": _DPTileSync_to_soh_xml,
    },
    DPPipeSync: {
        "to_soh_xml": _DPPipeSync_to_soh_xml,
    },
    DPLoadSync: {
        "to_soh_xml": _DPLoadSync_to_soh_xml,
    },
    OOTSkeleton: {
        "toSohXML": _OOTSkeleton_toSohXML,
    },
    OOTLimb: {
        "toSohXML": _OOTLimb_toSohXML,
    },
    FTexRect: {
        "to_soh_xml": _FTexRect_to_soh_xml,
    },
    FLODGroup: {
        "to_soh_xml": _FLODGroup_to_soh_xml,
    },
    Light: {
        "to_soh_xml": _Light_to_soh_xml,
    },
    Ambient: {
        "to_soh_xml": _Ambient_to_soh_xml,
    },
    Hilite: {
        "to_soh_xml": _Hilite_to_soh_xml,
    },
    Lights: {
        "to_soh_xml": _Lights_to_soh_xml,
    },
    LookAt: {
        "to_soh_xml": _LookAt_to_soh_xml,
    },
    SPMatrix: {
        "to_soh_xml": _SPMatrix_to_soh_xml,
    },
    SPViewport: {
        "to_soh_xml": _SPViewport_to_soh_xml,
    },
    SPDisplayList: {
        "to_soh_xml": _SPDisplayList_to_soh_xml,
    },
    SPLine3D: {
        "to_soh_xml": _SPLine3D_to_soh_xml,
    },
    SPLineW3D: {
        "to_soh_xml": _SPLineW3D_to_soh_xml,
    },
    SPSegment: {
        "to_soh_xml": _SPSegment_to_soh_xml,
    },
    SPClipRatio: {
        "to_soh_xml": _SPClipRatio_to_soh_xml,
    },
    SPAlphaCompareCull: {
        "to_soh_xml": _SPAlphaCompareCull_to_soh_xml,
    },
    SPModifyVertex: {
        "to_soh_xml": _SPModifyVertex_to_soh_xml,
    },
    SPBranchLessZraw: {
        "to_soh_xml": _SPBranchLessZraw_to_soh_xml,
    },
    SPNumLights: {
        "to_soh_xml": _SPNumLights_to_soh_xml,
    },
    SPLight: {
        "to_soh_xml": _SPLight_to_soh_xml,
    },
    SPLightColor: {
        "to_soh_xml": _SPLightColor_to_soh_xml,
    },
    SPSetLights: {
        "to_soh_xml": _SPSetLights_to_soh_xml,
    },
    SPLookAt: {
        "to_soh_xml": _SPLookAt_to_soh_xml,
    },
    DPSetHilite1Tile: {
        "to_soh_xml": _DPSetHilite1Tile_to_soh_xml,
    },
    DPSetHilite2Tile: {
        "to_soh_xml": _DPSetHilite2Tile_to_soh_xml,
    },
    SPFogFactor: {
        "to_soh_xml": _SPFogFactor_to_soh_xml,
    },
    SPFogPosition: {
        "to_soh_xml": _SPFogPosition_to_soh_xml,
    },
    SPPerspNormalize: {
        "to_soh_xml": _SPPerspNormalize_to_soh_xml,
    },
    SPGeometryMode: {
        "to_soh_xml": _SPGeometryMode_to_soh_xml,
    },
    DPPipelineMode: {
        "to_soh_xml": _DPPipelineMode_to_soh_xml,
    },
    DPSetCycleType: {
        "to_soh_xml": _DPSetCycleType_to_soh_xml,
    },
    DPSetTexturePersp: {
        "to_soh_xml": _DPSetTexturePersp_to_soh_xml,
    },
    DPSetTextureDetail: {
        "to_soh_xml": _DPSetTextureDetail_to_soh_xml,
    },
    DPSetTextureLOD: {
        "to_soh_xml": _DPSetTextureLOD_to_soh_xml,
    },
    DPSetTextureFilter: {
        "to_soh_xml": _DPSetTextureFilter_to_soh_xml,
    },
    DPSetTextureConvert: {
        "to_soh_xml": _DPSetTextureConvert_to_soh_xml,
    },
    DPSetCombineKey: {
        "to_soh_xml": _DPSetCombineKey_to_soh_xml,
    },
    DPSetColorDither: {
        "to_soh_xml": _DPSetColorDither_to_soh_xml,
    },
    DPSetAlphaDither: {
        "to_soh_xml": _DPSetAlphaDither_to_soh_xml,
    },
    DPSetAlphaCompare: {
        "to_soh_xml": _DPSetAlphaCompare_to_soh_xml,
    },
    DPSetDepthSource: {
        "to_soh_xml": _DPSetDepthSource_to_soh_xml,
    },
    DPSetRenderMode: {
        "to_soh_xml": _DPSetRenderMode_to_soh_xml,
    },
    DPSetCombineMode: {
        "to_soh_xml": _DPSetCombineMode_to_soh_xml,
    },
    DPSetBlendColor: {
        "to_soh_xml": _DPSetBlendColor_to_soh_xml,
    },
    DPSetFogColor: {
        "to_soh_xml": _DPSetFogColor_to_soh_xml,
    },
    DPSetFillColor: {
        "to_soh_xml": _DPSetFillColor_to_soh_xml,
    },
    DPSetPrimDepth: {
        "to_soh_xml": _DPSetPrimDepth_to_soh_xml,
    },
    DPSetOtherMode: {
        "to_soh_xml": _DPSetOtherMode_to_soh_xml,
    },
    DPSetTileSize: {
        "to_soh_xml": _DPSetTileSize_to_soh_xml,
    },
    DPSetTile: {
        "to_soh_xml": _DPSetTile_to_soh_xml,
    },
    DPLoadTextureBlock: {
        "to_soh_xml": _DPLoadTextureBlock_to_soh_xml,
    },
    DPLoadTextureBlockYuv: {
        "to_soh_xml": _DPLoadTextureBlockYuv_to_soh_xml,
    },
    _DPLoadTextureBlock: {
        "to_soh_xml": __DPLoadTextureBlock_to_soh_xml,
    },
    DPLoadTextureBlock_4b: {
        "to_soh_xml": _DPLoadTextureBlock_4b_to_soh_xml,
    },
    DPLoadTextureTile: {
        "to_soh_xml": _DPLoadTextureTile_to_soh_xml,
    },
    DPLoadTextureTile_4b: {
        "to_soh_xml": _DPLoadTextureTile_4b_to_soh_xml,
    },
    DPLoadTLUT_pal16: {
        "to_soh_xml": _DPLoadTLUT_pal16_to_soh_xml,
    },
    DPLoadTLUT_pal256: {
        "to_soh_xml": _DPLoadTLUT_pal256_to_soh_xml,
    },
    DPLoadTLUT: {
        "to_soh_xml": _DPLoadTLUT_to_soh_xml,
    },
    DPSetConvert: {
        "to_soh_xml": _DPSetConvert_to_soh_xml,
    },
    DPSetKeyR: {
        "to_soh_xml": _DPSetKeyR_to_soh_xml,
    },
    DPSetKeyGB: {
        "to_soh_xml": _DPSetKeyGB_to_soh_xml,
    },
    SPTextureRectangle: {
        "to_soh_xml": _SPTextureRectangle_to_soh_xml,
    },
    SPScisTextureRectangle: {
        "to_soh_xml": _SPScisTextureRectangle_to_soh_xml,
    },
}


def register():
    for cls, methods in _PATCHES.items():
        for name, func in methods.items():
            setattr(cls, name, func)


def unregister():
    for cls, methods in _PATCHES.items():
        for name in methods:
            if hasattr(cls, name):
                delattr(cls, name)