[OoT] Various fixes 2 (#612)

* fixed #418

* fixed issue where importing with an invalid path would create a folder

* pack transition actor entry index in parameters

* fixed quick import

* fixed light import with recent decomp

* fixed giant link

* add `BLEND_RATE_AND_FOG_NEAR` macro to the backward compatibility list

* revert door param change

Author: Yanis002

fast64_internal/z64/exporter/scene/__init__.py

@@ -293,6 +293,9 @@ def getNewSceneFile(self, path: str, isSingleFile: bool, textureExportSettings:
             "#undef SCENE_CMD_SPAWN_LIST",
             "#define SCENE_CMD_SPAWN_LIST(spawnList) \\",
             indent + "{ SCENE_CMD_ID_ENTRANCE_LIST, 0, CMD_PTR(spawnList) }",
+            "#endif\n",
+            "#ifndef BLEND_RATE_AND_FOG_NEAR",
+            "#define BLEND_RATE_AND_FOG_NEAR(blendRate, fogNear) (s16)((((blendRate) / 4) << 10) | (fogNear))",
             "#endif\n\n",
         ]
 

fast64_internal/z64/exporter/scene/general.py

@@ -1,3 +1,4 @@
+import bpy
 import re
 
 from dataclasses import dataclass
@@ -37,16 +38,24 @@ def from_data(raw_data: str, not_zapd_assets: bool):
                 for match in re.finditer(r"(\{([0-9\-]*,[0-9\-]*,[0-9\-]*)\})", entry, re.DOTALL):
                     colors_and_dirs.append([hexOrDecInt(value) for value in match.group(2).split(",")])
 
-                blend_and_fogs = entry.split("},")[-1].split(",")
-                blend_split = blend_and_fogs[0].split("|")
-                blend_raw = blend_split[0]
-                fog_near = hexOrDecInt(blend_split[1])
-                z_far = hexOrDecInt(blend_and_fogs[1])
-                blend_rate = getEvalParamsInt(blend_raw)
-                assert blend_rate is not None
-
-                if "/" in blend_raw:
+                if "BLEND_RATE_AND_FOG_NEAR" in entry:
+                    blend_and_fogs = entry.replace(")", "").split("BLEND_RATE_AND_FOG_NEAR(")[-1].strip().split(",")
+                    fog_near = hexOrDecInt(blend_and_fogs[1])
+                    z_far = hexOrDecInt(blend_and_fogs[2])
+                    blend_rate = getEvalParamsInt(blend_and_fogs[0])
+                    assert blend_rate is not None
                     blend_rate *= 4
+                else:
+                    blend_and_fogs = entry.split("},")[-1].split(",")
+                    blend_split = blend_and_fogs[0].split("|")
+                    blend_raw = blend_split[0]
+                    fog_near = hexOrDecInt(blend_split[1])
+                    z_far = hexOrDecInt(blend_and_fogs[1])
+                    blend_rate = getEvalParamsInt(blend_raw)
+                    assert blend_rate is not None
+
+                    if "/" in blend_raw:
+                        blend_rate *= 4
             else:
                 split = entry.split(",")
 
@@ -84,6 +93,9 @@ def from_data(raw_data: str, not_zapd_assets: bool):
     def getBlendFogNear(self):
         """Returns the packed blend rate and fog near values"""
 
+        if bpy.context.scene.fast64.oot.useDecompFeatures:
+            return f"BLEND_RATE_AND_FOG_NEAR({self.blendRate}, {self.fogNear})"
+
         return f"(({self.blendRate} << 10) | {self.fogNear})"
 
     def getColorValues(self, vector: tuple[int, int, int]):

fast64_internal/z64/f3d_writer.py

@@ -352,5 +352,8 @@ def ootReadActorScale(basePath: str, overlayName: str, isLink: bool) -> Optional
             scale = scale[:-1]
         return getOOTScale(1 / float(scale))
 
+    if isLink:
+        return getOOTScale(100.0)
+
     print("WARNING: auto-detection failed, defaulting to this panel's actor scale property value")
     return None

fast64_internal/z64/importer/actor.py

@@ -42,15 +42,23 @@ def parseTransActorList(
 
             sharedSceneData.transDict[actor] = actorObj
 
-            fromRoom = roomObjs[actor.roomFrom]
-            toRoom = roomObjs[actor.roomTo]
-            if actor.roomFrom != actor.roomTo:
-                parentObject(fromRoom, actorObj)
+            # make sure the room is valid
+            fromRoom = roomObjs[actor.roomFrom] if actor.roomFrom >= 0 else None
+            toRoom = roomObjs[actor.roomTo] if actor.roomTo >= 0 else None
+            transActorProp.isRoomTransition = actor.isRoomTransition
+
+            if actor.isRoomTransition:
+                if fromRoom is not None:
+                    parentObject(fromRoom, actorObj)
+                else:
+                    # make it obvious to the user that this transition actor has an issue
+                    actorObj.name = f"Invalid Front Room Index - {actorObj.name}"
+
                 transActorProp.fromRoom = fromRoom
                 transActorProp.toRoom = toRoom
-                transActorProp.isRoomTransition = True
             else:
-                transActorProp.isRoomTransition = False
+                # that side should always be valid
+                assert toRoom is not None
                 parentObject(toRoom, actorObj)
 
             setCustomProperty(transActorProp, "cameraTransitionFront", actor.cameraFront, ootEnumCamTransition)

fast64_internal/z64/importer/scene.py

@@ -105,6 +105,7 @@ def parseScene(
         sceneName,
         False,
         True,
+        True,
     )
 
     file_path = Path(sceneFolderPath).resolve() / f"{sceneName}_scene.c"

fast64_internal/z64/tools/quick_import.py

@@ -71,22 +71,29 @@ def quick_import_exec(context: bpy.types.Context, sym_name: str):
     # this str cast completely useless, it's there to force linting to recognize a Path element
     extracted_dir_p = base_dir_p / str(context.scene.fast64.oot.get_extracted_path())
 
-    assets_paths: list[Path] = [
+    assets_paths: list[tuple[Optional[Path], Path]] = [
         # objects
-        extracted_dir_p / "assets" / "objects",
+        (extracted_dir_p / "assets" / "objects", base_dir_p / "assets" / "objects"),
         # scenes
-        extracted_dir_p / "assets" / "scenes",
+        (extracted_dir_p / "assets" / "scenes", base_dir_p / "assets" / "scenes"),
         # other assets embedded in actors (cutscenes for instance)
-        base_dir_p / "src" / "overlays" / "actors",
+        (None, base_dir_p / "src" / "overlays" / "actors"),
     ]
 
-    for path in assets_paths:
+    for extracted_path, path in assets_paths:
         all_found_defs = get_found_defs(path, sym_name, sym_def_pattern)
 
         if len(all_found_defs) > 0:
             found_dir_p = path
             break
 
+        if extracted_path is not None:
+            all_found_defs = get_found_defs(extracted_path, sym_name, sym_def_pattern)
+
+            if len(all_found_defs) > 0:
+                found_dir_p = extracted_path
+                break
+
     assert found_dir_p is not None
 
     # Ideally if for example sym_name was gLinkAdultHookshotTipDL,

fast64_internal/z64/utility.py

@@ -527,7 +527,9 @@ def ootGetObjectHeaderPath(isCustomExport: bool, exportPath: str, folderName: st
     return filepath
 
 
-def ootGetPath(exportPath, isCustomExport, subPath, folderName, makeIfNotExists, useFolderForCustom):
+def ootGetPath(
+    exportPath, isCustomExport, subPath, folderName, makeIfNotExists, useFolderForCustom, is_import: bool = False
+):
     if isCustomExport:
         path = bpy.path.abspath(os.path.join(exportPath, (folderName if useFolderForCustom else "")))
     else:
@@ -536,7 +538,7 @@ def ootGetPath(exportPath, isCustomExport, subPath, folderName, makeIfNotExists,
         path = bpy.path.abspath(os.path.join(os.path.join(bpy.context.scene.ootDecompPath, subPath), folderName))
 
     if not os.path.exists(path):
-        if isCustomExport or makeIfNotExists:
+        if not is_import and isCustomExport or makeIfNotExists:
             os.makedirs(path)
         else:
             raise PluginError(path + " does not exist.")