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/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()