add the possibility to import course from the decomp of mk64

__init__.py

@@ -15,6 +15,8 @@
 from .fast64_internal.oot.props_panel_main import OOT_ObjectProperties
 from .fast64_internal.utility_anim import utility_anim_register, utility_anim_unregister, ArmatureApplyWithMeshOperator
 
+from .fast64_internal.mk64 import MK64_Properties, mk64_register, mk64_unregister
+
 from .fast64_internal.f3d.f3d_material import mat_register, mat_unregister
 from .fast64_internal.f3d.f3d_render_engine import render_engine_register, render_engine_unregister
 from .fast64_internal.f3d.f3d_writer import f3d_writer_register, f3d_writer_unregister
@@ -51,6 +53,7 @@
 gameEditorEnum = (
     ("SM64", "SM64", "Super Mario 64"),
     ("OOT", "OOT", "Ocarina Of Time"),
+    ("MK64", "MK64", "Mario Kart 64"),
 )
 
 
@@ -260,6 +263,7 @@ class Fast64_Properties(bpy.types.PropertyGroup):
 
     sm64: bpy.props.PointerProperty(type=SM64_Properties, name="SM64 Properties")
     oot: bpy.props.PointerProperty(type=OOT_Properties, name="OOT Properties")
+    mk64: bpy.props.PointerProperty(type=MK64_Properties, name="MK64 Properties")
     settings: bpy.props.PointerProperty(type=Fast64Settings_Properties, name="Fast64 Settings")
     renderSettings: bpy.props.PointerProperty(type=Fast64RenderSettings_Properties, name="Fast64 Render Settings")
 
@@ -408,6 +412,8 @@ def gameEditorUpdate(self, context):
         self.f3d_type = "F3D"
     elif self.gameEditorMode == "OOT":
         self.f3d_type = "F3DEX2/LX2"
+    elif self.gameEditorMode == "MK64":
+        self.f3d_type = "F3DEX/LX"
 
 
 # called on add-on enabling
@@ -437,6 +443,7 @@ def register():
     bsdf_conv_register()
     sm64_register(True)
     oot_register(True)
+    mk64_register(True)
 
     for cls in classes:
         register_class(cls)
@@ -483,6 +490,7 @@ def unregister():
     f3d_parser_unregister()
     sm64_unregister(True)
     oot_unregister(True)
+    mk64_unregister(True)
     mat_unregister()
     bsdf_conv_unregister()
     bsdf_conv_panel_unregsiter()

fast64_internal/f3d/f3d_parser.py

@@ -1527,6 +1527,19 @@ def applyTLUT(self, image, tlut):
         if invalidIndicesDetected:
             print("Invalid LUT Indices detected.")
 
+    def getVertexDataStart(self, vertexDataParam: str, f3d: F3D):
+        matchResult = re.search(r"\&?([A-Za-z0-9\_]*)\s*(\[([^\]]*)\])?\s*(\+(.*))?", vertexDataParam)
+        if matchResult is None:
+            raise PluginError("SPVertex param " + vertexDataParam + " is malformed.")
+
+        offset = 0
+        if matchResult.group(3):
+            offset += math_eval(matchResult.group(3), f3d)
+        if matchResult.group(5):
+            offset += math_eval(matchResult.group(5), f3d)
+
+        return matchResult.group(1), offset
+
     def processCommands(self, dlData: str, dlName: str, dlCommands: "list[ParsedMacro]"):
         callStack = [F3DParsedCommands(dlName, dlCommands, 0)]
         while len(callStack) > 0:
@@ -1540,7 +1553,7 @@ def processCommands(self, dlData: str, dlName: str, dlCommands: "list[ParsedMacr
 
             # print(command.name + " " + str(command.params))
             if command.name == "gsSPVertex":
-                vertexDataName, vertexDataOffset = getVertexDataStart(command.params[0], self.f3d)
+                vertexDataName, vertexDataOffset = self.getVertexDataStart(command.params[0], self.f3d)
                 parseVertexData(dlData, vertexDataName, self)
                 self.addVertices(command.params[1], command.params[2], vertexDataName, vertexDataOffset)
             elif command.name == "gsSPMatrix":
@@ -1949,20 +1962,6 @@ def parseDLData(dlData: str, dlName: str):
     return dlCommands
 
 
-def getVertexDataStart(vertexDataParam: str, f3d: F3D):
-    matchResult = re.search(r"\&?([A-Za-z0-9\_]*)\s*(\[([^\]]*)\])?\s*(\+(.*))?", vertexDataParam)
-    if matchResult is None:
-        raise PluginError("SPVertex param " + vertexDataParam + " is malformed.")
-
-    offset = 0
-    if matchResult.group(3):
-        offset += math_eval(matchResult.group(3), f3d)
-    if matchResult.group(5):
-        offset += math_eval(matchResult.group(5), f3d)
-
-    return matchResult.group(1), offset
-
-
 def parseVertexData(dlData: str, vertexDataName: str, f3dContext: F3DContext):
     if vertexDataName in f3dContext.vertexData:
         return f3dContext.vertexData[vertexDataName]

fast64_internal/mk64/README.md

@@ -0,0 +1,9 @@
+# Mario Kart 64
+
+## Importing Course
+It's similar to F3D Importer, you select the file where you have the display list, the name of the display list you want to import and the path to the decomp. (by default course are cut as segment so it's better to use cinematic version who have all, it's in general the last display variable in course_data.inc.c).
+
+Example of configuration:
+- d_course_wario_stadium_dl_CA78
+- path/to/mk64/courses/wario_stadium/course_data.inc.c
+- path/to/mk64

fast64_internal/mk64/__init__.py

@@ -0,0 +1,144 @@
+import bpy
+from bpy_types import PropertyGroup
+from ..f3d.f3d_gbi import get_F3D_GBI
+from ..f3d.f3d_material import createF3DMat
+from ..f3d.f3d_parser import getImportData, importMeshC
+from ..panels import MK64_Panel
+from ..utility import prop_split
+from bpy.utils import register_class, unregister_class
+from ..utility import raisePluginError
+from .f3d_course_parser import MK64F3DContext, parseCourseVtx
+
+
+class MK64_Properties(PropertyGroup):
+    """Global MK64 Scene Properties found under scene.fast64.mk64"""
+
+    version: bpy.props.IntProperty(name="MK64_Properties Version", default=0)
+
+
+class MK64_ImportCourseDL(bpy.types.Operator):
+    # set bl_ properties
+    bl_idname = "object.fast64_mk64_course_import_dl"
+    bl_label = "Import Course DL"
+    bl_options = {"REGISTER", "UNDO", "PRESET"}
+
+    # Called on demand (i.e. button press, menu item)
+    # Can also be called from operator search menu (Spacebar)
+    def execute(self, context):
+        obj = None
+        if context.mode != "OBJECT":
+            bpy.ops.object.mode_set(mode="OBJECT")
+
+        try:
+            name = context.scene.DLImportName
+            importPath = bpy.path.abspath(context.scene.DLImportPath)
+            basePath = bpy.path.abspath(context.scene.DLImportBasePath)
+            scaleValue = context.scene.blenderF3DScale
+
+            removeDoubles = context.scene.DLRemoveDoubles
+            importNormals = context.scene.DLImportNormals
+            drawLayer = context.scene.DLImportDrawLayer
+
+            paths = [importPath]
+
+            if "course_data" in importPath:
+                paths += [importPath.replace("course_data", "course_displaylists")]
+
+            paths += [
+                importPath.replace("course_data.inc", "course_textures.linkonly").replace(
+                    "course_displaylists.inc", "course_textures.linkonly"
+                )
+            ]
+
+            data = getImportData(paths)
+
+            f3d_context = MK64F3DContext(get_F3D_GBI(), basePath, createF3DMat(None))
+            if "course_displaylists" in importPath or "course_data" in importPath:
+                vertexPath = importPath.replace("course_displaylists", "course_vertices").replace(
+                    "course_data", "course_vertices"
+                )
+                print(vertexPath)
+                f3d_context.vertexData["0x4000000"] = parseCourseVtx(vertexPath, f3d_context.f3d)
+
+            importMeshC(
+                data,
+                name,
+                scaleValue,
+                removeDoubles,
+                importNormals,
+                drawLayer,
+                f3d_context,
+            )
+
+            self.report({"INFO"}, "Success!")
+            return {"FINISHED"}
+
+        except Exception as e:
+            if context.mode != "OBJECT":
+                bpy.ops.object.mode_set(mode="OBJECT")
+            raisePluginError(self, e)
+            return {"CANCELLED"}  # must return a set
+
+
+class MK64_ImportCourseDLPanel(MK64_Panel):
+    bl_idname = "MK64_import_course_DL_panel_settings"
+    bl_label = "MK64 Import Course DL Panel Settings"
+    bl_options = set()  # default to open
+    bl_order = 0  # force to front
+
+    @classmethod
+    def poll(cls, context):
+        return True
+
+    # called every frame
+    def draw(self, context):
+        col = self.layout.column()
+        col.scale_y = 1.1  # extra padding
+
+        col.operator(MK64_ImportCourseDL.bl_idname)
+        prop_split(col, context.scene, "DLImportName", "Name")
+        prop_split(col, context.scene, "DLImportPath", "File")
+        prop_split(col, context.scene, "DLImportBasePath", "Base Path")
+        prop_split(col, context.scene, "blenderF3DScale", "Scale")
+        prop_split(col, context.scene, "DLImportDrawLayer", "Draw Layer")
+        col.prop(context.scene, "DLRemoveDoubles")
+        col.prop(context.scene, "DLImportNormals")
+
+        box = col.box().column()
+        box.label(text="All data must be contained within file.")
+        box.label(text="The only exception are pngs converted to inc.c.")
+
+        # col.template_list('F3D_UL_ImportDLPathList', '', context.scene,
+        # 	'DLImportOtherFiles', context.scene, 'DLImportOtherFilesIndex')
+
+
+mk64_classes = (MK64_Properties,)
+
+mk64_panel_classes = (
+    MK64_ImportCourseDL,
+    MK64_ImportCourseDLPanel,
+)
+
+
+def mk64_panel_register():
+    for cls in mk64_panel_classes:
+        register_class(cls)
+
+
+def mk64_panel_unregister():
+    for cls in mk64_panel_classes:
+        unregister_class(cls)
+
+
+def mk64_register(registerPanels):
+    for cls in mk64_classes:
+        register_class(cls)
+    if registerPanels:
+        mk64_panel_register()
+
+
+def mk64_unregister(registerPanel):
+    for cls in reversed(mk64_classes):
+        unregister_class(cls)
+    if registerPanel:
+        mk64_panel_unregister()

fast64_internal/mk64/f3d_course_parser.py

@@ -0,0 +1,58 @@
+import re
+import traceback
+from mathutils import Vector
+from ..f3d.f3d_gbi import F3D
+from ..f3d.f3d_material import RDPSettings
+from ..f3d.f3d_parser import F3DContext, F3DParsedCommands, ParsedMacro, math_eval, parseDLData, parseVertexData
+from ..f3d.f3d_writer import F3DVert
+from ..utility import PluginError, float_from_u16_str, gammaInverseValue, int_from_s16_str, readFile, unpackNormal
+
+
+def courseVertexFormatPatterns():
+    # position, uv, color/normal
+    return (
+        # decomp format
+        r"\{\s*"
+        r"\{+([^,\}]*),([^,\}]*),([^,\}]*)\}\s*,\s*"
+        r"\{([^,\}]*),([^,\}]*)\}\s*,\s*"
+        r"\{MACRO_COLOR_FLAG\(([^,\}]*),([^,\}]*),([^,\}]*),([^,\}])*\),([^,\}]*)\}\s*"
+        r"\}"
+    )
+
+
+def parseCourseVtx(path: str, f3d):
+    data = readFile(path)
+    pattern = courseVertexFormatPatterns()
+    vertexData = []
+    for values in re.findall(pattern, data, re.DOTALL):
+        values = [math_eval(g, f3d) for g in values]
+        vertexData.append(
+            F3DVert(
+                Vector(values[0:3]),
+                Vector(values[3:5]),
+                Vector(values[5:8]),
+                unpackNormal(values[8]),
+                values[9],
+            )
+        )
+    return vertexData
+
+
+class MK64F3DContext(F3DContext):
+    def getVertexDataStart(vertexDataParam: str, f3d: F3D):
+        matchResult = re.search(r"\&?([A-Za-z0-9\_]*)\s*(\[([^\]]*)\])?\s*(\+(.*))?", vertexDataParam)
+        if matchResult is None:
+            raise PluginError("SPVertex param " + vertexDataParam + " is malformed.")
+
+        offset = 0
+        if matchResult.group(3):
+            offset += math_eval(matchResult.group(3), f3d)
+        if matchResult.group(5):
+            offset += math_eval(matchResult.group(5), f3d)
+
+        name = matchResult.group(1)
+
+        if matchResult.group(1).startswith("0x04"):
+            offset = (int(matchResult.group(1), 16) - 0x04000000) // 16
+            name = hex(0x04000000)
+        return name, offset

fast64_internal/panels.py

@@ -46,3 +46,14 @@ class OOT_Panel(bpy.types.Panel):
     @classmethod
     def poll(cls, context):
         return context.scene.gameEditorMode == "OOT"
+
+
+class MK64_Panel(bpy.types.Panel):
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "MK64"
+    bl_options = {"DEFAULT_CLOSED"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.scene.gameEditorMode == "MK64"