Texture writing overhaul

.gitignore

@@ -2,3 +2,6 @@ __pycache__/
 .vscode
 *.blend1
 /.venv
+fast64_updater/
+.python-version
+

__init__.py

@@ -20,6 +20,7 @@
 from .fast64_internal.f3d.f3d_writer import f3d_writer_register, f3d_writer_unregister
 from .fast64_internal.f3d.f3d_parser import f3d_parser_register, f3d_parser_unregister
 from .fast64_internal.f3d.flipbook import flipbook_register, flipbook_unregister
+from .fast64_internal.f3d.op_largetexture import op_largetexture_register, op_largetexture_unregister, ui_oplargetexture
 
 from .fast64_internal.f3d_material_converter import (
     MatUpdateConvert,
@@ -225,6 +226,7 @@ def draw(self, context):
         col = self.layout.column()
         col.operator(ArmatureApplyWithMeshOperator.bl_idname)
         # col.operator(CreateMetarig.bl_idname)
+        ui_oplargetexture(col, context)
         addon_updater_ops.update_notice_box_ui(self, context)
 
 
@@ -457,6 +459,7 @@ def register():
     f3d_writer_register()
     flipbook_register()
     f3d_parser_register()
+    op_largetexture_register()
 
     # ROM
 
@@ -485,6 +488,7 @@ def register():
 # called on add-on disabling
 def unregister():
     utility_anim_unregister()
+    op_largetexture_unregister()
     flipbook_unregister()
     f3d_writer_unregister()
     f3d_parser_unregister()

fast64_internal/f3d/f3d_bleed.py

@@ -69,7 +69,7 @@ def bleed_fmesh(self, f3d: F3D, fMesh: FMesh, lastMat: FMaterial, cmd_list: GfxL
             bleed_gfx_lists = BleedGfxLists()
             if triGroup.fMaterial:
                 bleed_gfx_lists.bled_mats = self.bleed_mat(triGroup.fMaterial, lastMat, cmd_list, bleed_state)
-                if not triGroup.fMaterial.useLargeTextures:
+                if not (triGroup.fMaterial.isTexLarge[0] or triGroup.fMaterial.isTexLarge[1]):
                     bleed_gfx_lists.bled_tex = self.bleed_textures(triGroup.fMaterial, lastMat, cmd_list, bleed_state)
             lastMat = triGroup.fMaterial
             # bleed tri group (for large textures) and to remove other unnecessary cmds
@@ -80,42 +80,63 @@ def bleed_fmesh(self, f3d: F3D, fMesh: FMesh, lastMat: FMaterial, cmd_list: GfxL
         self.on_bleed_end(f3d, lastMat, bleed_gfx_lists, cmd_list, default_render_mode)
         return lastMat
 
+    def build_tmem_dict(self, cmd_list: GfxList):
+        im_buffer = None
+        tmem_dict = dict()
+        tile_dict = {i:0 for i in range(8)} # an assumption that hopefully never needs correction
+        for cmd in cmd_list.commands:
+            if type(cmd) == DPSetTextureImage:
+                im_buffer = cmd
+                continue
+            if type(cmd) == DPSetTile:
+                tile_dict[cmd.tile] = cmd.tmem
+            if type(cmd) in (DPLoadTLUTCmd, DPLoadTile, DPLoadBlock):
+                tmem_dict[tile_dict[cmd.tile]] = im_buffer
+                continue
+        return tmem_dict
+
     def bleed_textures(self, curMat: FMaterial, lastMat: FMaterial, cmd_list: GfxList, bleed_state: int):
         if lastMat:
-            bled_tex = []
             # bleed cmds if matching tile has duplicate cmds
-            for j, (LastTex, TexCmds) in enumerate(zip(lastMat.texture_DLs, curMat.texture_DLs)):
-                # deep copy breaks on Image objects so I will only copy the levels needed
-                commands_bled = copy.copy(TexCmds)
-                commands_bled.commands = copy.copy(TexCmds.commands)  # copy the commands also
-                lastList = LastTex.commands
-                # eliminate set tex images
-                set_tex = (c for c in TexCmds.commands if type(c) == DPSetTextureImage)
-                removed_tex = [c for c in set_tex if c in lastList]  # needs to be a list to check "in" multiple times
-                rm_load = None  # flag to elim loads once
-                for j, cmd in enumerate(TexCmds.commands):
-                    # remove set tex explicitly
-                    if cmd in removed_tex:
-                        commands_bled.commands.remove(cmd)
-                        rm_load = True
-                        continue
-                    if rm_load and type(cmd) in (DPLoadTLUTCmd, DPLoadTile, DPLoadBlock):
-                        commands_bled.commands.remove(cmd)
-                        rm_load = None
-                        continue
-                # now eval as normal conditionals
-                iter_cmds = copy.copy(commands_bled.commands)  # need extra list to iterate with
-                for j, cmd in enumerate(iter_cmds):
-                    if self.bleed_individual_cmd(commands_bled, cmd, bleed_state):
-                        if cmd in lastList:
-                            commands_bled.commands[j] = None
-                # remove Nones from list
-                while None in commands_bled.commands:
-                    commands_bled.commands.remove(None)
-                bled_tex.append(commands_bled)
+            # deep copy breaks on Image objects so I will only copy the levels needed
+            commands_bled = copy.copy(curMat.texture_DL)
+            commands_bled.commands = copy.copy(curMat.texture_DL.commands)  # copy the commands also
+            # eliminate set tex images, but only if there is an overlap of the same image at the same tmem location
+            last_im_loads = self.build_tmem_dict(lastMat.texture_DL)
+            new_im_loads = self.build_tmem_dict(commands_bled)
+            removable_images = []
+            for tmem, image in new_im_loads.items():
+                if tmem in last_im_loads and last_im_loads[tmem] == image:
+                    removable_images.append(image)
+            # now go through list and cull out loads for the specific cmds
+            # this will be the set tex image, and the loading cmds
+            rm_load = False
+            for j, cmd in enumerate(curMat.texture_DL.commands):
+                # remove set tex explicitly
+                if cmd in removable_images:
+                    commands_bled.commands[j] = None
+                    rm_load = True
+                    continue
+                if rm_load and type(cmd) == DPSetTile:
+                    commands_bled.commands[j] = None
+                if rm_load and type(cmd) in (DPLoadTLUTCmd, DPLoadTile, DPLoadBlock):
+                    commands_bled.commands[j] = None
+                    rm_load = None
+                    continue
+            # now eval as normal conditionals
+            for j, cmd in enumerate(curMat.texture_DL.commands):
+                if not cmd:
+                    continue # some cmds are None from previous step
+                if self.bleed_individual_cmd(commands_bled, cmd, bleed_state):
+                    if cmd in lastMat.texture_DL.commands:
+                        commands_bled.commands[j] = None
+            # remove Nones from list
+            while None in commands_bled.commands:
+                commands_bled.commands.remove(None)
+            bled_tex = commands_bled
         else:
-            bled_tex = curMat.texture_DLs
-        return bled_tex
+            bled_tex = curMat.texture_DL
+        return bled_tex.commands
 
     def bleed_mat(self, curMat: FMaterial, lastMat: FMaterial, cmd_list: GfxList, bleed_state: int):
         if lastMat:
@@ -136,15 +157,15 @@ def bleed_mat(self, curMat: FMaterial, lastMat: FMaterial, cmd_list: GfxList, bl
         # remove SPEndDisplayList
         while SPEndDisplayList() in commands_bled.commands:
             commands_bled.commands.remove(SPEndDisplayList())
-        return commands_bled
+        return commands_bled.commands
 
     def bleed_tri_group(
         self, f3d: F3D, triGroup: FTriGroup, bleed_gfx_lists: BleedGfxLists, cmd_list: GfxList, bleed_state: int
     ):
         # remove SPEndDisplayList from triGroup
         while SPEndDisplayList() in triGroup.triList.commands:
             triGroup.triList.commands.remove(SPEndDisplayList())
-        if triGroup.fMaterial.useLargeTextures:
+        if (triGroup.fMaterial.isTexLarge[0] or triGroup.fMaterial.isTexLarge[1]):
             triGroup.triList = self.bleed_cmd_list(triGroup.triList, bleed_state)
 
     # this is a little less versatile than comparing by last used material
@@ -167,10 +188,9 @@ def bleed_cmd_list(self, target_cmd_list: GfxList, bleed_state: int):
     # Put triGroup bleed gfx in the FMesh.draw object
     def inline_triGroup(self, f3d: F3D, triGroup: FTriGroup, bleed_gfx_lists: BleedGfxLists, cmd_list: GfxList):
         # add material
-        cmd_list.commands.extend(bleed_gfx_lists.bled_mats.commands)
+        cmd_list.commands.extend(bleed_gfx_lists.bled_mats)
         # add textures
-        for tile, texGfx in enumerate(bleed_gfx_lists.bled_tex):
-            cmd_list.commands.extend(texGfx.commands)
+        cmd_list.commands.extend(bleed_gfx_lists.bled_tex)
         # add in triangles
         cmd_list.commands.extend(triGroup.triList.commands)
         # skinned meshes don't draw tris sometimes, use this opportunity to save a sync
@@ -221,7 +241,9 @@ def bleed_individual_cmd(self, cmd_list: GfxList, cmd: GbiMacro, bleed_state: in
             SPBranchLessZraw,
             SPModifyVertex,
             SPEndDisplayList,
+            DPSetTextureImage,
             DPLoadBlock,
+            DPLoadTile,
             DPLoadTLUTCmd,
             DPFullSync,
         ]:
@@ -278,7 +300,7 @@ def bleed_DPLoadSync(self, cmd_list: GfxList, cmd: GbiMacro, bleed_state: int):
 @dataclass
 class BleedGfxLists:
     bled_mats: GfxList = field(default_factory=list)
-    bled_tex: list[GfxList] = field(default_factory=list)  # list of GfxList
+    bled_tex: GfxList = field(default_factory=list)
     reset_cmds: set[GbiMacro] = field(default_factory=set)  # set of cmds to reset
 
     def __post_init__(self):

fast64_internal/f3d/f3d_enums.py

@@ -335,7 +335,7 @@
     ("TEXEL1", "Texture 1", "Texture 1"),
 ]
 
-texBitSize = {
+texBitSizeInt = {
     "I4": 4,
     "IA4": 4,
     "CI4": 4,
@@ -364,3 +364,8 @@
     ("F3DEX2/LX2", "F3DEX2/LX2", "F3DEX2/LX2"),
     ("F3DEX2.Rej/LX2.Rej", "F3DEX2.Rej/LX2.Rej", "F3DEX2.Rej/LX2.Rej"),
 ]
+
+enumLargeEdges = [
+    ("Clamp", "Clamp", "Clamp outside image bounds"),
+    ("Wrap", "Wrap", "Wrap outside image bounds (more expensive)"),
+]