Basic node import

__init__.py

@@ -10,21 +10,34 @@
 	"category": "Import-Export"
 }
 
+# Initialize the libraries module.
+from . import lib
+
+# Import all submodules.
 from .menu import topbar_dropdown
+from .menu.import_export import halo1_model
+
+modules = [
+	halo1_model,
+	topbar_dropdown,
+]
 
 def register():
 	'''
 	Registers classes on load by calling the
 	register functions in their respective modules.
 	'''
-	topbar_dropdown.register()
+	for module in modules:
+		module.register()
 
 def unregister():
 	'''
 	Unregisters classes on unload by calling the
 	unregister functions in their respective modules.
 	'''
-	topbar_dropdown.unregister()
+	#Unregister classes in reverse order to avoid any dependency problems.
+	for module in reverse(modules):
+		module.unregister()
 
 if __name__ == "__main__":
 	register()

constants.py

@@ -0,0 +1,13 @@
+
+# These are used to figure out what amount something needs
+# to be scaled when importing or exporting.
+SCALE_MULTIPLIERS = {
+	# 10       : A world unit is 10 feet.
+	# 0.032808 : feet per centimeter
+	# 100.0    : centimeters per meter.
+	'METRIC'   : 10.0/0.032808/100.0,
+	# Halo models in 3dsmax as 100x as big as internally.
+	'MAX'      : 100.0,
+	# Base scale. Used for straight conversions.
+	'HALO'     : 1.0,
+}

halo1/model.py

@@ -0,0 +1,76 @@
+import bpy
+
+from reclaimer.hek.defs.mode import mode_def
+from reclaimer.hek.defs.mod2 import mod2_def
+from reclaimer.model.jms import read_jms
+from reclaimer.model.model_decompilation import extract_model
+
+from ..scene.shapes import create_sphere
+
+def read_halo1model(filepath):
+	'''Takes a halo1 model file and turns it into a jms object.'''
+
+	# TODO: Use a tag handler to see if these files actually are what they
+	# say they are. We can get really nasty parsing problems if they aren't.
+
+	# These two model types can be imported the same way because of their
+	# nearly matching structures when built into a python object.
+	if (filepath.lower().endswith('.gbxmodel')
+	or filepath.lower().endswith('.model')):
+		# Load model
+		tag = None
+		if filepath.lower().endswith('.gbxmodel'):
+			tag = mod2_def.build(filepath=filepath)
+		else:
+			tag = mode_def.build(filepath=filepath)
+		#TODO: Get all lod permutations.
+		#Only getting the superhigh perms for now
+		jms = extract_model(tag.data.tagdata, write_jms=False)[0]
+		return jms
+
+	if filepath.lower().endswith('.jms'):
+		# Read jms file into string.
+		jms_string = ""
+		with open(filepath, 'r') as jms_file:
+			jms_string = jms_file.read()
+		# Read Jms data from string.
+		jms = read_jms(jms_string)
+		# Make sure it's a Halo 1 jms
+		if jms.version != "8200":
+			raise ValueError('Not a Halo 1 jms!')
+
+		return jms
+
+def import_halo1_nodes(jms, scale=1.0, node_size=0.02):
+	'''
+	Import all the nodes from a jms into the scene and returns a list of them.
+	'''
+	# Jms are scaled at x100 halo. Undo that.
+	scale = scale/100
+
+	scene_nodes = dict()
+	for i, node in enumerate(jms.nodes):
+		scene_node = create_sphere(name="@"+node.name, size=node_size)
+
+		# Assign parent if index is valid.
+		if node.parent_index in range(len(scene_nodes)):
+			scene_node.parent = scene_nodes[node.parent_index]
+
+		# Store original rotation mode.
+		rot_mode = scene_node.rotation_mode
+		# Set rotation mode to quaternion and apply the rotation.
+		scene_node.rotation_mode = 'QUATERNION'
+		scene_node.rotation_quaternion = (
+			-node.rot_w, node.rot_i, node.rot_j, node.rot_k
+		)
+		# Set rotation mode back.
+		scene_node.rotation_mode = rot_mode
+
+		# Undo 100x scaling from jms files.
+		scene_node.location = (
+			node.pos_x*scale, node.pos_y*scale, node.pos_z*scale
+		)
+
+		scene_nodes[i] = scene_node
+
+	return scene_nodes

menu/import_export/halo1_model.py

@@ -0,0 +1,124 @@
+import bpy
+from bpy.utils import register_class, unregister_class
+from bpy.props import BoolProperty, FloatProperty, StringProperty, EnumProperty
+from bpy_extras.io_utils import ImportHelper, ExportHelper, orientation_helper, path_reference_mode, axis_conversion
+
+from ...halo1.model import read_halo1model, import_halo1_nodes
+from ...constants import SCALE_MULTIPLIERS
+
+#@orientation_helper(axis_forward='-Z') Find the right value for this.
+class MT_krieg_ImportHalo1Model(bpy.types.Operator, ImportHelper):
+	"""
+	The import operator for gbxmodel/jms models.
+	This stores the properties when inside of the import dialog, and
+	it specifies what to show on the side panel when importing.
+	"""
+	bl_idname = "import_scene.halo1_model"
+	bl_label = "Import Halo 1 Model"
+	bl_options = {'PRESET', 'UNDO'}
+
+	# Import-file-dialog settings:
+
+	filename_ext = ".gbxmodel"
+	filter_glob: StringProperty(
+		default="*.gbxmodel;*.model;*.jms",
+		options={'HIDDEN'},
+	)
+
+	# Node settings:
+
+	use_nodes: BoolProperty(
+		name="Import Nodes",
+		description="Import the nodes/frames.",
+		default=True,
+	)
+	node_size: FloatProperty(
+		name="Node Scene Size",
+		description="Set the size that nodes should have in the Blender scene if at 1.0 scale.",
+		default=0.1,
+		min=0.0,
+	)
+	use_armatures: BoolProperty(
+		name="Import Nodes as Armature",
+		description="Import the nodes as armature.",
+		default=False,
+	)
+
+	# Scaling settings:
+
+	scale_enum: EnumProperty(
+	name="Scale",
+		items=(
+			('METRIC', "Blender",  "Use Blender's metric scaling."),
+			('MAX',    "3ds Max",  "Use 3dsmax's 100xHalo scale."),
+			('HALO',   "Internal", "Use Halo's internal 1.0 scale (small)."),
+			('CUSTOM', "Custom",   "Set your own scaling multiplier."),
+		)
+	)
+	scale_float: FloatProperty(
+		name="Custom Scale",
+		description="Set your own scale.",
+		default=1.0,
+		min=0.0,
+	)
+
+	def execute(self, context):
+		# Set appropriate scaling
+		scale = 1.0
+		if self.scale_enum in SCALE_MULTIPLIERS:
+			scale = SCALE_MULTIPLIERS[self.scale_enum]
+		elif self.scale_enum == 'CUSTOM':
+			scale = self.scale_float
+		else:
+			raise ValueError('Invalid scale_enum state.')
+
+		# Test if jms import function doesn't crash.
+		jms = read_halo1model(self.filepath)
+
+		# Import nodes into the scene.
+		nodes = import_halo1_nodes(jms, scale=scale, node_size=self.node_size)
+
+		return {'FINISHED'}
+
+	def draw(self, context):
+		layout = self.layout
+
+		# Node settings elements:
+
+		box = layout.box()
+		row = box.row()
+		row.label(text="Nodes:")
+		row.prop(self, "use_nodes")
+		if self.use_nodes:
+			box.prop(self, "node_size")
+			box.prop(self, "use_armatures")
+
+		# Scale settings elements:
+
+		box = layout.box()
+		box.label(text="Scale:")
+		row = box.row()
+		row.prop(self, "scale_enum", expand=True)
+
+		if self.scale_enum == 'CUSTOM':
+			row = box.row()
+			row.prop(self, "scale_float")
+
+
+# Enumerate all classes for easy register/unregister.
+classes = (
+	MT_krieg_ImportHalo1Model,
+)
+
+def register():
+	for cls in classes:
+		register_class(cls)
+
+
+def unregister():
+	for cls in reversed(classes): #Reversed because: first in, last out.
+		unregister_class(cls)
+
+
+if __name__ == "__main__":
+	register()

menu/topbar_dropdown.py

@@ -1,6 +1,8 @@
 from bpy.utils import register_class, unregister_class
 from bpy.types import Menu, TOPBAR_MT_editor_menus
 
+from .import_export import halo1_model
+
 class TOPBAR_MT_krieg(Menu):
 	bl_idname = "TOPBAR_MT_krieg_ext"
 	bl_label = "Krieg"
@@ -29,6 +31,11 @@ def draw(self, context):
 
 		# Halo 1:
 
+		layout.operator(
+			halo1_model.MT_krieg_ImportHalo1Model.bl_idname,
+			text="Halo 1 Model (.gbxmodel, .model, .jms)"
+		)
+
 		layout.separator()
 
 		# Whatever else:

scene/shapes.py

@@ -0,0 +1,45 @@
+import bpy
+import bmesh
+
+def create_sphere(name="new_sphere", size=1.0):
+	'''
+	Creates a sphere with the given size.
+	'''
+	scene = bpy.context.collection
+
+	mesh = bpy.data.meshes.new(name)
+	sphere = bpy.data.objects.new(name, mesh)
+
+	scene.objects.link(sphere)
+
+	bm = bmesh.new()
+	bmesh.ops.create_uvsphere(bm,
+		u_segments=16, v_segments=16,
+		diameter=size
+	)
+	bm.to_mesh(mesh)
+	bm.free()
+
+	return sphere
+
+def create_cone(name="new_cone", base_size=1.0, height=3.0):
+	'''
+	Creates a cone with the given sizes.
+	'''
+	scene = bpy.context.collection
+
+	mesh = bpy.data.meshes.new(name)
+	cone = bpy.data.objects.new(name, mesh)
+
+	scene.objects.link(cone)
+
+	bm = bmesh.new()
+	bmesh.ops.create_cone(bm,
+		segments=16,
+		diameter1=base_size, diameter2=base_size,
+		depth=height
+	)
+	bm.to_mesh(mesh)
+	bm.free()
+
+	return cone