Fix the "Export Display List" button

Author: Pepe20129

fast64_internal/f3d/f3d_writer.py

@@ -1843,18 +1843,28 @@ def getWriteMethodFromEnum(enumVal):
         return matWriteMethodEnumDict[enumVal]
 
 
-def exportF3DtoXML(dirPath, obj, DLFormat, transformMatrix, texDir, objectPath, savePNG, texSeparate, name, matWriteMethod):
-
+def exportF3DtoXML(dirPath, obj, DLFormat, transformMatrix, texDir, objectPath, savePNG, texSeparate, name, matWriteMethod, logging_func):
+    logging_func({"INFO"}, "exportF3DtoXML 0")
     fModel = FModel(name, DLFormat, matWriteMethod)
+    logging_func({"INFO"}, "exportF3DtoXML 1")
     fMesh = exportF3DCommon(obj, fModel, transformMatrix, True, name, DLFormat, not savePNG)
 
+    logging_func({"INFO"}, "exportF3DtoXML 2")
+    
     modelDirPath = os.path.join(dirPath, objectPath)
-
+    
+    logging_func({"INFO"}, "exportF3DtoXML 3")
+    
     if not os.path.exists(modelDirPath):
         os.makedirs(modelDirPath)
-
+    
+    logging_func({"INFO"}, "exportF3DtoXML 4")
+    
     #gfxFormatter = GfxFormatter(ScrollMethod.Vertex, 64)
-    exportData = fModel.to_soh_xml(modelDirPath, objectPath, None)
+    exportData = fModel.to_soh_xml(modelDirPath, objectPath, logging_func)
+    
+    logging_func({"INFO"}, "exportF3DtoXML 5")
+
     staticData = exportData
     #dynamicData = exportData.dynamicData
     #texC = exportData.textureData
@@ -1879,6 +1889,8 @@ def exportF3DtoXML(dirPath, obj, DLFormat, transformMatrix, texDir, objectPath,
         #texCFile.close()
 
     writeXMLData(staticData, os.path.join(modelDirPath, "model.xml"))
+    
+    logging_func({"INFO"}, "exportF3DtoXML 6")
 
 
 def exportF3DtoC(dirPath, obj, DLFormat, transformMatrix, texDir, savePNG, texSeparate, name, matWriteMethod):
@@ -1956,15 +1968,18 @@ class F3D_ExportDL(bpy.types.Operator):
     # Called on demand (i.e. button press, menu item)
     # Can also be called from operator search menu (Spacebar)
     def execute(self, context):
+        self.report({"INFO"}, "F3D_ExportDL 0")
         if context.mode != "OBJECT":
             bpy.ops.object.mode_set(mode="OBJECT")
         try:
             allObjs = context.selected_objects
             if len(allObjs) == 0:
                 raise PluginError("No objects selected.")
+            self.report({"INFO"}, "F3D_ExportDL 1")
             obj = context.selected_objects[0]
             if obj.type != "MESH":
                 raise PluginError("Object is not a mesh.")
+            self.report({"INFO"}, "F3D_ExportDL 2")
 
             scaleValue = bpy.context.scene.blenderF3DScale
             finalTransform = mathutils.Matrix.Diagonal(mathutils.Vector((scaleValue, scaleValue, scaleValue))).to_4x4()
@@ -1973,9 +1988,12 @@ def execute(self, context):
             raisePluginError(self, e)
             return {"CANCELLED"}
 
+        self.report({"INFO"}, "F3D_ExportDL 3")
+
         try:
             applyRotation([obj], math.radians(90), "X")
 
+            self.report({"INFO"}, "F3D_ExportDL 4")
             exportPath = bpy.path.abspath(context.scene.DLExportPath)
             dlFormat = DLFormat.Static if context.scene.DLExportisStatic else DLFormat.Dynamic
             texDir = bpy.context.scene.DLTexDir
@@ -1984,8 +2002,10 @@ def execute(self, context):
             separateTexDef = bpy.context.scene.DLSeparateTextureDef
             DLName = bpy.context.scene.DLName
             matWriteMethod = getWriteMethodFromEnum(context.scene.matWriteMethod)
+            self.report({"INFO"}, "F3D_ExportDL 5")
 
             if bpy.context.scene.fast64.oot.featureSet == "SoH":
+                self.report({"INFO"}, "F3D_ExportDL 6")
                 exportF3DtoXML(
                     exportPath,
                     obj,
@@ -1997,7 +2017,9 @@ def execute(self, context):
                     separateTexDef,
                     DLName,
                     matWriteMethod,
+                    self.report
                 )
+                self.report({"INFO"}, "F3D_ExportDL 7")
             else:
                 exportF3DtoC(
                     exportPath,

fast64_internal/oot/f3d/operators.py

@@ -92,6 +92,67 @@ def ootConvertMeshToC(
             removeDL(sourcePath, headerPath, name)
 
 
+def ootConvertMeshToXML(
+    originalObj: bpy.types.Object,
+    finalTransform: mathutils.Matrix,
+    DLFormat: DLFormat,
+    saveTextures: bool,
+    settings: OOTDLExportSettings,
+):
+    folderName = settings.folder
+    exportPath = bpy.path.abspath(settings.customPath)
+    isCustomExport = settings.isCustom
+    drawLayer = settings.drawLayer
+    removeVanillaData = settings.removeVanillaData
+    name = toAlnum(settings.name)
+    overlayName = settings.actorOverlayName
+    flipbookUses2DArray = settings.flipbookUses2DArray
+    flipbookArrayIndex2D = settings.flipbookArrayIndex2D if flipbookUses2DArray else None
+
+    try:
+        obj, allObjs = ootDuplicateHierarchy(originalObj, None, False, OOTObjectCategorizer())
+
+        fModel = OOTModel(name, DLFormat, drawLayer)
+        triConverterInfo = TriangleConverterInfo(obj, None, fModel.f3d, finalTransform, getInfoDict(obj))
+        fMeshes = saveStaticModel(
+            triConverterInfo, fModel, obj, finalTransform, fModel.name, not saveTextures, False, "oot"
+        )
+
+        # Since we provide a draw layer override, there should only be one fMesh.
+        for drawLayer, fMesh in fMeshes.items():
+            fMesh.draw.name = name
+
+        ootCleanupScene(originalObj, allObjs)
+
+    except Exception as e:
+        ootCleanupScene(originalObj, allObjs)
+        raise Exception(str(e))
+
+    path = ootGetPath(exportPath, isCustomExport, "assets/objects/", folderName, False, True)
+    includeDir = settings.customAssetIncludeDir if settings.isCustom else f"assets/objects/{folderName}"
+    data = fModel.to_soh_xml(
+        TextureExportSettings(False, saveTextures, includeDir, path), OOTGfxFormatter(ScrollMethod.Vertex)
+    )
+
+    if isCustomExport:
+        textureArrayData = writeTextureArraysNewXML(fModel, flipbookArrayIndex2D)
+        data.append(textureArrayData)
+
+    writeXMLData(data, os.path.join(path, name + ".xml"))
+
+
+def writeTextureArraysNewXML(fModel: OOTModel, arrayIndex: int):
+    textureArrayData = ""
+    #for flipbook in fModel.flipbooks:
+    #    if flipbook.exportMode == "Array":
+    #        if arrayIndex is not None:
+    #            textureArrayData += flipbook_2d_to_xml(flipbook, True, arrayIndex + 1) + "\n"
+    #        else:
+    #            textureArrayData += flipbook_to_xml(flipbook, True) + "\n"
+    return textureArrayData
+
+
+
 class OOT_ImportDL(Operator):
     # set bl_ properties
     bl_idname = "object.oot_import_dl"
@@ -162,15 +223,20 @@ class OOT_ExportDL(Operator):
     # Called on demand (i.e. button press, menu item)
     # Can also be called from operator search menu (Spacebar)
     def execute(self, context):
+        self.report({"INFO"}, "OOT_ExportDL execute 0")
         obj = None
         if context.mode != "OBJECT":
             object.mode_set(mode="OBJECT")
+        self.report({"INFO"}, "OOT_ExportDL execute 1")
         if len(context.selected_objects) == 0:
             raise PluginError("Mesh not selected.")
+        self.report({"INFO"}, "OOT_ExportDL execute 2")
         obj = context.active_object
         if obj.type != "MESH":
             raise PluginError("Mesh not selected.")
 
+        self.report({"INFO"}, "OOT_ExportDL execute 3")
+
         finalTransform = Matrix.Scale(getOOTScale(obj.ootActorScale), 4)
 
         try:
@@ -181,13 +247,24 @@ def execute(self, context):
             saveTextures = context.scene.saveTextures
             exportSettings = context.scene.fast64.oot.DLExportSettings
 
-            ootConvertMeshToC(
-                obj,
-                finalTransform,
-                DLFormat.Static,
-                saveTextures,
-                exportSettings,
-            )
+            self.report({"INFO"}, "OOT_ExportDL execute 4")
+
+            if context.scene.fast64.oot.featureSet == "SoH":
+                ootConvertMeshToXML(
+                    obj,
+                    finalTransform,
+                    DLFormat.Static,
+                    saveTextures,
+                    exportSettings,
+                )
+            else:
+                ootConvertMeshToC(
+                    obj,
+                    finalTransform,
+                    DLFormat.Static,
+                    saveTextures,
+                    exportSettings,
+                )
 
             self.report({"INFO"}, "Success!")
             return {"FINISHED"}