Minor envelope progress

addons/io_scene_swbf_msh/msh_model_gather.py

@@ -4,7 +4,7 @@
 import bpy
 import math
 from enum import Enum
-from typing import List, Set, Dict, Tuple
+from typing import List, Set, Dict, Tuple, Set
 from itertools import zip_longest
 from .msh_model import *
 from .msh_model_utilities import *
@@ -22,11 +22,7 @@ def gather_models(apply_modifiers: bool, export_target: str) -> List[Model]:
     parents = create_parents_set()
 
     models_list: List[Model] = []
-    model_indices: Dict[str, int] = {}
-
-    for i, uneval_obj in enumerate(select_objects(export_target)):
-        if not (uneval_obj.type in SKIPPED_OBJECT_TYPES and uneval_obj.name not in parents):
-            model_indices[uneval_obj.name] = i
+    skeleton: bpy.types.Armature = None
 
     for uneval_obj in select_objects(export_target):
         if uneval_obj.type in SKIPPED_OBJECT_TYPES and uneval_obj.name not in parents:
@@ -50,19 +46,23 @@ def gather_models(apply_modifiers: bool, export_target: str) -> List[Model]:
 
         if obj.parent is not None:
             if obj.parent.type == "ARMATURE":
-                model.parent = obj.parent.parent.name
-            else:
-                model.parent = obj.parent.name
+                skeleton = obj.parent
+
+                parent_bone_name = obj.parent_bone
+                if parent_bone_name == "":
+                    model.parent = obj.parent.parent
+                else:
+                    model.parent = parent_bone_name
+
+                if model.model_type == ModelType.SKIN:
+                    model.vgroups_to_modelnames_map = {}
+                    for i, vgroup in enumerate(obj.vertex_groups):
+                        vgroups_to_modelnames_map[i] = vgroup.name
 
 
         if obj.type in MESH_OBJECT_TYPES:
-            mesh = obj.to_mesh()
-
-            vgroups_to_indices = {}
-            for i, vgroup in enumerate(obj.vertex_groups):
-            	vgroups_to_indices[i] = model_indices[vgroup.name]
-
-            model.geometry = create_mesh_geometry(mesh, vgroups_to_indices)
+            mesh = obj.to_mesh()         
+            model.geometry = create_mesh_geometry(mesh, model.model_type == ModelType.SKIN)
             obj.to_mesh_clear()
 
             _, _, world_scale = obj.matrix_world.decompose()
@@ -80,6 +80,30 @@ def gather_models(apply_modifiers: bool, export_target: str) -> List[Model]:
 
         models_list.append(model)
 
+
+    for bone in skeleton.data.bones:
+
+        model = Model()
+        model.name = bone.name
+        model.model_type = ModelType.NULL
+        model.hidden = False
+
+        local_translation, local_rotation, _ = bone.matrix_local.decompose()
+        model.transform.rotation = convert_rotation_space(local_rotation)
+        model.transform.translation = convert_vector_space(local_translation)
+
+        parent_name = bone.parent
+        if parent_name is not None:
+            model.parent = parent_name
+        else:
+            if skeleton.parent is not None:
+                model.parent = skeleton.parent.name
+            else:
+                model.parent = None        
+
+        models_list.append(model)
+
+
     return models_list
 
 def create_parents_set() -> Set[str]:
@@ -94,7 +118,7 @@ def create_parents_set() -> Set[str]:
 
     return parents
 
-def create_mesh_geometry(mesh: bpy.types.Mesh, vgrps_to_indices : Dict[int, int]) -> List[GeometrySegment]:
+def create_mesh_geometry(mesh: bpy.types.Mesh, is_skinned : bool) -> List[GeometrySegment]:
     """ Creates a list of GeometrySegment objects from a Blender mesh.
         Does NOT create triangle strips in the GeometrySegment however. """
 
@@ -115,10 +139,6 @@ def create_mesh_geometry(mesh: bpy.types.Mesh, vgrps_to_indices : Dict[int, int]
         for segment in segments:
             segment.colors = []
 
-    if vgrps_to_indices:
-    	for segment in segments:
-    		segment.weights = []
-
     for segment, material in zip(segments, mesh.materials):
         segment.material_name = material.name
 
@@ -172,13 +192,15 @@ def create_mesh_geometry(mesh: bpy.types.Mesh, vgrps_to_indices : Dict[int, int]
         segment.positions.append(convert_vector_space(mesh.vertices[vertex_index].co))
         segment.normals.append(convert_vector_space(vertex_normal))
 
-        if vgrps_to_indices is not None:
-        	for i,grp_el in mesh.vertices[vertex_index].groups:
-        		segment.weights.append(tuple(vgrps_to_indices[grp_el.group], grp_el.weight))
-        		if i > 3:
-        			break
-        	while (i < 3):
-        		segment.weights.append(tuple(0,0.0))
+        if is_skinned:
+            for i,grp_el in mesh.vertices[vertex_index].groups:
+                segment.weights.append(tuple(grp_el.group, grp_el.weight))
+                print("Adding weight to group {grp_el.group} of value {grp_el.weight}")
+                if i > 3: #will have to look into aramture/skin settings for limiting envolopes to 4 weights...
+                    break
+            while i < 3:
+                segment.weights.append(tuple(0,0.0))
+                i+=1
 
         if mesh.uv_layers.active is None:
             segment.texcoords.append(Vector((0.0, 0.0)))