[OoT] New Exporter

fast64_internal/oot/__init__.py

@@ -76,6 +76,19 @@ class OOT_Properties(bpy.types.PropertyGroup):
     animImportSettings: bpy.props.PointerProperty(type=OOTAnimImportSettingsProperty)
     collisionExportSettings: bpy.props.PointerProperty(type=OOTCollisionExportSettings)
 
+    useDecompFeatures: bpy.props.BoolProperty(
+        name="Use decomp for export", description="Use names and macros from decomp when exporting", default=True
+    )
+
+    exportMotionOnly: bpy.props.BoolProperty(
+        name="Export CS Motion Data Only",
+        description=(
+            "Export everything or only the camera and actor motion data.\n"
+            + "This will insert the data into the cutscene."
+        ),
+        default=False,
+    )
+
 
 oot_classes = (OOT_Properties,)
 

fast64_internal/oot/collision/exporter/to_c/collision.py

@@ -5,7 +5,7 @@
 from ...exporter import OOTCollision, OOTCameraData
 from ...properties import OOTCollisionExportSettings
 from ..classes import OOTCameraData, OOTCameraPosData, OOTCrawlspaceData
-from ..functions import exportCollisionCommon
+from ....exporter.collision import CollisionHeader
 
 from .....utility import (
     PluginError,
@@ -270,7 +270,6 @@ def ootCollisionToC(collision):
 def exportCollisionToC(
     originalObj: bpy.types.Object, transformMatrix: mathutils.Matrix, exportSettings: OOTCollisionExportSettings
 ):
-    includeChildren = exportSettings.includeChildren
     name = toAlnum(originalObj.name)
     isCustomExport = exportSettings.customExport
     folderName = exportSettings.folder
@@ -289,26 +288,34 @@ def exportCollisionToC(
         restoreHiddenState(hiddenState)
 
     try:
-        exportCollisionCommon(collision, obj, transformMatrix, includeChildren, name)
-        ootCleanupScene(originalObj, allObjs)
+        if not obj.ignore_collision:
+            # get C data
+            colData = CData()
+            colData.source = '#include "ultra64.h"\n#include "z64.h"\n#include "macros.h"\n'
+            if not isCustomExport:
+                colData.source += f'#include "{folderName}.h"\n\n'
+            else:
+                colData.source += "\n"
+            colData.append(
+                CollisionHeader.new(
+                    f"{name}_collisionHeader",
+                    name,
+                    obj,
+                    transformMatrix,
+                    bpy.context.scene.fast64.oot.useDecompFeatures,
+                    exportSettings.includeChildren,
+                ).getC()
+            )
+
+            # write file
+            path = ootGetPath(exportPath, isCustomExport, "assets/objects/", folderName, False, True)
+            filename = exportSettings.filename if exportSettings.isCustomFilename else f"{name}_collision"
+            writeCData(colData, os.path.join(path, f"{filename}.h"), os.path.join(path, f"{filename}.c"))
+            if not isCustomExport:
+                addIncludeFiles(folderName, path, name)
+        else:
+            raise PluginError("ERROR: The selected mesh object ignores collision!")
     except Exception as e:
-        ootCleanupScene(originalObj, allObjs)
         raise Exception(str(e))
-
-    collisionC = ootCollisionToC(collision)
-
-    data = CData()
-    data.source += '#include "ultra64.h"\n#include "z64.h"\n#include "macros.h"\n'
-    if not isCustomExport:
-        data.source += '#include "' + folderName + '.h"\n\n'
-    else:
-        data.source += "\n"
-
-    data.append(collisionC)
-
-    path = ootGetPath(exportPath, isCustomExport, "assets/objects/", folderName, False, True)
-    filename = exportSettings.filename if exportSettings.isCustomFilename else f"{name}_collision"
-    writeCData(data, os.path.join(path, f"{filename}.h"), os.path.join(path, f"{filename}.c"))
-
-    if not isCustomExport:
-        addIncludeFiles(folderName, path, name)
+    finally:
+        ootCleanupScene(originalObj, allObjs)

fast64_internal/oot/collision/operators.py

@@ -1,4 +1,4 @@
-from bpy.types import Operator, Mesh
+from bpy.types import Operator
 from bpy.utils import register_class, unregister_class
 from bpy.ops import object
 from mathutils import Matrix

fast64_internal/oot/cutscene/exporter/functions.py

@@ -44,6 +44,6 @@ def getNewCutsceneExport(csName: str, motionOnly: bool):
     # this allows us to change the exporter's variables to get what we need
     return CutsceneExport(
         getCutsceneObjects(csName),
-        bpy.context.scene.fast64.oot.hackerFeaturesEnabled or bpy.context.scene.useDecompFeatures,
+        bpy.context.scene.fast64.oot.hackerFeaturesEnabled or bpy.context.scene.fast64.oot.useDecompFeatures,
         motionOnly,
     )

fast64_internal/oot/cutscene/operators.py

@@ -8,12 +8,12 @@
 from bpy.types import Scene, Operator, Context
 from bpy.utils import register_class, unregister_class
 from ...utility import CData, PluginError, writeCData, raisePluginError
-from ..oot_utility import getCollection, getCutsceneName
+from ..oot_utility import getCollection
 from ..oot_constants import ootData
-from ..scene.exporter.to_c import getCutsceneC
 from .constants import ootEnumCSTextboxType, ootEnumCSListType
 from .importer import importCutsceneData
 from .exporter import getNewCutsceneExport
+from ..exporter.cutscene import Cutscene
 
 
 def checkGetFilePaths(context: Context):
@@ -180,10 +180,11 @@ def execute(self, context):
             cpath, hpath, headerfilename = checkGetFilePaths(context)
             csdata = ootCutsceneIncludes(headerfilename)
 
-            if context.scene.exportMotionOnly:
+            if context.scene.fast64.oot.exportMotionOnly:
+                # TODO: improve this
                 csdata.append(insertCutsceneData(cpath, activeObj.name.removeprefix("Cutscene.")))
             else:
-                csdata.append(getCutsceneC(getCutsceneName(activeObj)))
+                csdata.append(Cutscene(activeObj, context.scene.fast64.oot.useDecompFeatures).getC())
             writeCData(csdata, hpath, cpath)
 
             self.report({"INFO"}, "Successfully exported cutscene")
@@ -213,10 +214,10 @@ def execute(self, context):
                         print(f"Parent: {obj.parent.name}, Object: {obj.name}")
                         raise PluginError("Cutscene object must not be parented to anything")
 
-                    if context.scene.exportMotionOnly:
+                    if context.scene.fast64.oot.exportMotionOnly:
                         raise PluginError("ERROR: Not implemented yet.")
                     else:
-                        csdata.append(getCutsceneC(getCutsceneName(obj)))
+                        csdata.append(Cutscene(obj, context.scene.fast64.oot.useDecompFeatures).getC())
                     count += 1
 
             if count == 0:

fast64_internal/oot/cutscene/panels.py

@@ -27,11 +27,6 @@ def draw(self, context):
         exportBox = layout.box()
         exportBox.label(text="Cutscene Exporter")
 
-        col = exportBox.column()
-        if not context.scene.fast64.oot.hackerFeaturesEnabled:
-            col.prop(context.scene, "useDecompFeatures")
-        col.prop(context.scene, "exportMotionOnly")
-
         prop_split(exportBox, context.scene, "ootCutsceneExportPath", "Export To")
 
         activeObj = context.view_layer.objects.active
@@ -66,25 +61,10 @@ def draw(self, context):
 
 
 def cutscene_panels_register():
-    Scene.useDecompFeatures = BoolProperty(
-        name="Use Decomp for Export", description="Use names and macros from decomp when exporting", default=True
-    )
-
-    Scene.exportMotionOnly = BoolProperty(
-        name="Export Motion Data Only",
-        description=(
-            "Export everything or only the camera and actor motion data.\n"
-            + "This will insert the data into the cutscene."
-        ),
-    )
-
     for cls in oot_cutscene_panel_classes:
         register_class(cls)
 
 
 def cutscene_panels_unregister():
-    del Scene.exportMotionOnly
-    del Scene.useDecompFeatures
-
     for cls in oot_cutscene_panel_classes:
         unregister_class(cls)

fast64_internal/oot/exporter/__init__.py

@@ -0,0 +1,137 @@
+import bpy
+import os
+
+from mathutils import Matrix
+from bpy.types import Object
+from ...f3d.f3d_gbi import DLFormat, TextureExportSettings
+from ..oot_model_classes import OOTModel
+from ..oot_f3d_writer import writeTextureArraysNew, writeTextureArraysExisting1D
+from .scene import Scene
+from .decomp_edit import Files
+
+from ...utility import (
+    PluginError,
+    checkObjectReference,
+    unhideAllAndGetHiddenState,
+    restoreHiddenState,
+    toAlnum,
+    readFile,
+    writeFile,
+)
+
+from ..oot_utility import (
+    ExportInfo,
+    OOTObjectCategorizer,
+    ootDuplicateHierarchy,
+    ootCleanupScene,
+    getSceneDirFromLevelName,
+    ootGetPath,
+)
+
+
+def writeTextureArraysExistingScene(fModel: OOTModel, exportPath: str, sceneInclude: str):
+    drawConfigPath = os.path.join(exportPath, "src/code/z_scene_table.c")
+    drawConfigData = readFile(drawConfigPath)
+    newData = drawConfigData
+
+    if f'#include "{sceneInclude}"' not in newData:
+        additionalIncludes = f'#include "{sceneInclude}"\n'
+    else:
+        additionalIncludes = ""
+
+    for flipbook in fModel.flipbooks:
+        if flipbook.exportMode == "Array":
+            newData = writeTextureArraysExisting1D(newData, flipbook, additionalIncludes)
+        else:
+            raise PluginError("Scenes can only use array flipbooks.")
+
+    if newData != drawConfigData:
+        writeFile(drawConfigPath, newData)
+
+
+class SceneExport:
+    """This class is the main exporter class, it handles generating the C data and writing the files"""
+
+    @staticmethod
+    def create_scene(originalSceneObj: Object, transform: Matrix, exportInfo: ExportInfo) -> Scene:
+        """Returns and creates scene data"""
+        # init
+        if originalSceneObj.type != "EMPTY" or originalSceneObj.ootEmptyType != "Scene":
+            raise PluginError(f'{originalSceneObj.name} is not an empty with the "Scene" empty type.')
+
+        if bpy.context.scene.exportHiddenGeometry:
+            hiddenState = unhideAllAndGetHiddenState(bpy.context.scene)
+
+        # Don't remove ignore_render, as we want to reuse this for collision
+        sceneObj, allObjs = ootDuplicateHierarchy(originalSceneObj, None, True, OOTObjectCategorizer())
+
+        if bpy.context.scene.exportHiddenGeometry:
+            restoreHiddenState(hiddenState)
+
+        try:
+            sceneName = f"{toAlnum(exportInfo.name)}_scene"
+            newScene = Scene.new(
+                sceneName,
+                sceneObj,
+                transform,
+                exportInfo.useMacros,
+                exportInfo.saveTexturesAsPNG,
+                OOTModel(f"{sceneName}_dl", DLFormat.Static, False),
+            )
+            newScene.validateScene()
+
+        except Exception as e:
+            raise Exception(str(e))
+        finally:
+            ootCleanupScene(originalSceneObj, allObjs)
+
+        return newScene
+
+    @staticmethod
+    def export(originalSceneObj: Object, transform: Matrix, exportInfo: ExportInfo):
+        """Main function"""
+        # circular import fixes
+        from .decomp_edit.config import Config
+
+        checkObjectReference(originalSceneObj, "Scene object")
+        scene = SceneExport.create_scene(originalSceneObj, transform, exportInfo)
+
+        isCustomExport = exportInfo.isCustomExportPath
+        exportPath = exportInfo.exportPath
+        sceneName = exportInfo.name
+
+        exportSubdir = ""
+        if exportInfo.customSubPath is not None:
+            exportSubdir = exportInfo.customSubPath
+        if not isCustomExport and exportInfo.customSubPath is None:
+            exportSubdir = os.path.dirname(getSceneDirFromLevelName(sceneName))
+
+        sceneInclude = exportSubdir + "/" + sceneName + "/"
+        path = ootGetPath(exportPath, isCustomExport, exportSubdir, sceneName, True, True)
+        textureExportSettings = TextureExportSettings(False, exportInfo.saveTexturesAsPNG, sceneInclude, path)
+
+        sceneFile = scene.getNewSceneFile(path, exportInfo.isSingleFile, textureExportSettings)
+
+        if not isCustomExport:
+            writeTextureArraysExistingScene(scene.model, exportPath, sceneInclude + sceneName + "_scene.h")
+        else:
+            textureArrayData = writeTextureArraysNew(scene.model, None)
+            sceneFile.sceneTextures += textureArrayData.source
+            sceneFile.header += textureArrayData.header
+
+        sceneFile.write()
+        for room in scene.rooms.entries:
+            room.roomShape.copy_bg_images(path)
+
+        if not isCustomExport:
+            Files.add_scene_edits(exportInfo, scene, sceneFile)
+
+        hackerootBootOption = exportInfo.hackerootBootOption
+        if hackerootBootOption is not None and hackerootBootOption.bootToScene:
+            Config.setBootupScene(
+                os.path.join(exportPath, "include/config/config_debug.h")
+                if not isCustomExport
+                else os.path.join(path, "config_bootup.h"),
+                f"ENTR_{sceneName.upper()}_{hackerootBootOption.spawnIndex}",
+                hackerootBootOption,
+            )

fast64_internal/oot/exporter/actor.py

@@ -0,0 +1,31 @@
+from ...utility import indent
+
+# this file is not inside the room folder since the scene data can have actors too
+
+
+class Actor:
+    """Defines an Actor"""
+
+    def __init__(self):
+        self.name = str()
+        self.id = str()
+        self.pos: list[int] = []
+        self.rot = str()
+        self.params = str()
+
+    def getActorEntry(self):
+        """Returns a single actor entry"""
+
+        posData = "{ " + ", ".join(f"{round(p)}" for p in self.pos) + " }"
+        rotData = "{ " + self.rot + " }"
+
+        actorInfos = [self.id, posData, rotData, self.params]
+        infoDescs = ["Actor ID", "Position", "Rotation", "Parameters"]
+
+        return (
+            indent
+            + (f"// {self.name}\n" + indent if self.name != "" else "")
+            + "{\n"
+            + ",\n".join((indent * 2) + f"/* {desc:10} */ {info}" for desc, info in zip(infoDescs, actorInfos))
+            + ("\n" + indent + "},\n")
+        )