Speedup anim import & various other fixes

docs/user/features/geometry/geometry.rst

@@ -94,3 +94,15 @@ Vertex Color & Alpha
 * `This image should clarify per-face vertex colouring
   <http://i211.photobucket.com/albums/bb189/NifTools/Blender/documentation/per_face_vertex_color.jpg>`_
 * On export, the scripts will create extra vertices for different vertex colors per face.
+
+
+.. _geometry-shapekeys:
+
+Shape Key Animations
+--------------------
+
+**Example:**
+
+#. :ref:`Create a mesh-object <geometry-mesh>`.
+#. Add relative shape keys to your mesh.
+#. Keyframe each shape key's value so that the key influences the shape of the mesh at the desired time.

io_scene_niftools/modules/nif_export/animation/morph.py

@@ -55,10 +55,11 @@ def __init__(self):
         EGMData.data = None
 
     def export_morph(self, b_mesh, n_trishape, vertmap):
-        # shape b_key morphing
+        NifLog.debug(f"Checking {b_mesh.name} for shape keys")
+        # shape keys are only present on non-evaluated meshes!
         b_key = b_mesh.shape_keys
         if b_key and len(b_key.key_blocks) > 1:
-
+            NifLog.debug(f"{b_mesh.name} has shape keys")
             # yes, there is a b_key object attached
             # export as egm, or as morph_data?
             if b_key.key_blocks[1].name.startswith("EGM"):

io_scene_niftools/modules/nif_export/collision/havok.py

@@ -173,8 +173,7 @@ def export_bhk_rigid_body(self, b_obj, n_col_obj):
         n_r_body.restitution = b_r_body.restitution
         n_r_body.max_linear_velocity = b_obj.nifcollision.max_linear_velocity
         n_r_body.max_angular_velocity = b_obj.nifcollision.max_angular_velocity
-        # todo - no longer available in blender 3.1, add to nifcollision
-        # n_r_body.penetration_depth = b_obj.collision.permeability
+        n_r_body.penetration_depth = b_obj.nifcollision.penetration_depth
         n_r_body.motion_system = b_obj.nifcollision.motion_system
         n_r_body.deactivator_type = b_obj.nifcollision.deactivator_type
         n_r_body.solver_deactivation = b_obj.nifcollision.solver_deactivation

io_scene_niftools/modules/nif_export/geometry/mesh/__init__.py

@@ -78,21 +78,22 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
 
         assert (b_obj.type == 'MESH')
 
-        # get mesh from b_obj
-        b_mesh = self.get_triangulated_mesh(b_obj)
-        b_mesh.calc_normals_split()
+        # get mesh from b_obj, and evaluate the mesh with modifiers applied, too
+        b_mesh = b_obj.data
+        eval_mesh = self.get_triangulated_mesh(b_obj)
+        eval_mesh.calc_normals_split()
 
         # getVertsFromGroup fails if the mesh has no vertices
         # (this happens when checking for fallout 3 body parts)
         # so quickly catch this (rare!) case
-        if not b_mesh.vertices:
+        if not eval_mesh.vertices:
             # do not export anything
             NifLog.warn(f"{b_obj} has no vertices, skipped.")
             return
 
         # get the mesh's materials, this updates the mesh material list
         if not isinstance(n_parent, NifFormat.RootCollisionNode):
-            mesh_materials = b_mesh.materials
+            mesh_materials = eval_mesh.materials
         else:
             # ignore materials on collision trishapes
             mesh_materials = []
@@ -102,9 +103,9 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
             mesh_materials = [None]
 
         # vertex color check
-        mesh_hasvcol = b_mesh.vertex_colors
+        mesh_hasvcol = eval_mesh.vertex_colors
         # list of body part (name, index, vertices) in this mesh
-        polygon_parts = self.get_polygon_parts(b_obj, b_mesh)
+        polygon_parts = self.get_polygon_parts(b_obj, eval_mesh)
         game = bpy.context.scene.niftools_scene.game
 
         # Non-textured materials, vertex colors are used to color the mesh
@@ -188,9 +189,9 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
             # The following algorithm extracts all unique quads(vert, uv-vert, normal, vcol),
             # produce lists of vertices, uv-vertices, normals, vertex colors, and face indices.
 
-            mesh_uv_layers = b_mesh.uv_layers
+            mesh_uv_layers = eval_mesh.uv_layers
             vertquad_list = []  # (vertex, uv coordinate, normal, vertex color) list
-            vertex_map = [None for _ in range(len(b_mesh.vertices))]  # blender vertex -> nif vertices
+            vertex_map = [None for _ in range(len(eval_mesh.vertices))]  # blender vertex -> nif vertices
             vertex_positions = []
             normals = []
             vertex_colors = []
@@ -200,21 +201,21 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
             bodypartfacemap = []
             polygons_without_bodypart = []
 
-            if b_mesh.polygons:
+            if eval_mesh.polygons:
                 if mesh_uv_layers:
                     # if we have uv coordinates double check that we have uv data
-                    if not b_mesh.uv_layer_stencil:
-                        NifLog.warn(f"No UV map for texture associated with selected mesh '{b_mesh.name}'.")
+                    if not eval_mesh.uv_layer_stencil:
+                        NifLog.warn(f"No UV map for texture associated with selected mesh '{eval_mesh.name}'.")
 
             use_tangents = False
             if mesh_uv_layers and mesh_hasnormals:
                 if game in ('OBLIVION', 'FALLOUT_3', 'SKYRIM') or (game in self.texture_helper.USED_EXTRA_SHADER_TEXTURES):
                     use_tangents = True
-                    b_mesh.calc_tangents(uvmap=mesh_uv_layers[0].name)
+                    eval_mesh.calc_tangents(uvmap=mesh_uv_layers[0].name)
                     tangents = []
                     bitangent_signs = []
 
-            for poly in b_mesh.polygons:
+            for poly in eval_mesh.polygons:
 
                 # does the face belong to this trishape?
                 if b_mat is not None and poly.material_index != materialIndex:
@@ -230,25 +231,25 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
                 f_index = [-1] * f_numverts
                 for i, loop_index in enumerate(poly.loop_indices):
 
-                    fv_index = b_mesh.loops[loop_index].vertex_index
-                    vertex = b_mesh.vertices[fv_index]
+                    fv_index = eval_mesh.loops[loop_index].vertex_index
+                    vertex = eval_mesh.vertices[fv_index]
                     vertex_index = vertex.index
                     fv = vertex.co
 
                     # smooth = vertex normal, non-smooth = face normal)
                     if mesh_hasnormals:
                         if poly.use_smooth:
-                            fn = b_mesh.loops[loop_index].normal
+                            fn = eval_mesh.loops[loop_index].normal
                         else:
                             fn = poly.normal
                     else:
                         fn = None
 
-                    fuv = [uv_layer.data[loop_index].uv for uv_layer in b_mesh.uv_layers]
+                    fuv = [uv_layer.data[loop_index].uv for uv_layer in eval_mesh.uv_layers]
 
                     # TODO [geomotry][mesh] Need to map b_verts -> n_verts
                     if mesh_hasvcol:
-                        f_col = list(b_mesh.vertex_colors[0].data[loop_index].color)
+                        f_col = list(eval_mesh.vertex_colors[0].data[loop_index].color)
                     else:
                         f_col = None
 
@@ -282,8 +283,8 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
                         if mesh_hasnormals:
                             normals.append(vertquad[2])
                         if use_tangents:
-                            tangents.append(b_mesh.loops[loop_index].tangent)
-                            bitangent_signs.append([b_mesh.loops[loop_index].bitangent_sign])
+                            tangents.append(eval_mesh.loops[loop_index].tangent)
+                            bitangent_signs.append([eval_mesh.loops[loop_index].bitangent_sign])
                         if mesh_hasvcol:
                             vertex_colors.append(vertquad[3])
                         if mesh_uv_layers:
@@ -312,7 +313,7 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
 
             # check that there are no missing body part polygons
             if polygons_without_bodypart:
-                self.select_unassigned_polygons(b_mesh, b_obj, polygons_without_bodypart)
+                self.select_unassigned_polygons(eval_mesh, b_obj, polygons_without_bodypart)
 
             if len(triangles) > 65535:
                 raise NifError("Too many polygons. Decimate your mesh and try again.")
@@ -402,7 +403,7 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
                         b_list_weight = []
                         b_vert_group = b_obj.vertex_groups[bone_group]
 
-                        for b_vert in b_mesh.vertices:
+                        for b_vert in eval_mesh.vertices:
                             if len(b_vert.groups) == 0:  # check vert has weight_groups
                                 unweighted_vertices.append(b_vert.index)
                                 continue
@@ -504,6 +505,7 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
             tridata.consistency_flags = b_obj.niftools.consistency_flags
 
             # export EGM or NiGeomMorpherController animation
+            # shape keys are only present on the raw, unevaluated mesh
             self.morph_anim.export_morph(b_mesh, trishape, vertex_map)
         return trishape
 

io_scene_niftools/modules/nif_export/object/__init__.py

@@ -97,35 +97,27 @@ def get_export_objects(self, only_selected=True):
     def export_root_node(self, root_objects, filebase):
         """ Exports a nif's root node; use blender root if there is only one, else create a meta root """
         # TODO [collsion] detect root collision -> root collision node (can be mesh or empty)
-        #     self.nif_export.collisionhelper.export_collision(b_obj, n_parent)
+        #     self.export_collision(b_obj, n_parent)
         #     return None  # done; stop here
         self.n_root = None
+        node_type = bpy.context.scene.niftools_scene.rootnode
         # there is only one root object so that will be our final root
         if len(root_objects) == 1:
             b_obj = root_objects[0]
-            self.export_node(b_obj, None)
+            self.export_node(b_obj, None, n_node_type=node_type)
 
         # there is more than one root object so we create a meta root
         else:
-            NifLog.info("Created meta root because blender scene had multiple root objects")
-            self.n_root = types.create_ninode()
+            NifLog.info(f"Created meta root because blender scene had {len(root_objects)} root objects")
+            self.n_root = types.create_ninode(n_node_type=node_type)
             self.n_root.name = "Scene Root"
             for b_obj in root_objects:
                 self.export_node(b_obj, self.n_root)
 
-        # TODO [object] How dow we know we are selecting the right node in the case of multi-root?
-        # making root block a fade node
-        root_type = b_obj.niftools.rootnode
-        if bpy.context.scene.niftools_scene.game in ('FALLOUT_3', 'SKYRIM') and root_type == 'BSFadeNode':
-            NifLog.info("Making root block a BSFadeNode")
-            fade_root_block = NifFormat.BSFadeNode().deepcopy(self.n_root)
-            fade_root_block.replace_global_node(self.n_root, fade_root_block)
-            self.n_root = fade_root_block
-
         # various extra datas
         object_property = ObjectDataProperty()
         object_property.export_bsxflags_upb(self.n_root, root_objects)
-        object_property.export_inventory_marker(self.n_root, root_objects)
+        object_property.export_inventory_marker(self.n_root)
         object_property.export_weapon_location(self.n_root, b_obj)
         types.export_furniture_marker(self.n_root, filebase)
         return self.n_root
@@ -147,7 +139,7 @@ def set_node_flags(self, b_obj, n_node):
             else:
                 n_node.flags = 0x000C  # morrowind
 
-    def export_node(self, b_obj, n_parent):
+    def export_node(self, b_obj, n_parent, n_node_type=None):
         """Export a mesh/armature/empty object b_obj as child of n_parent.
         Export also all children of b_obj.
 
@@ -190,7 +182,7 @@ def export_node(self, b_obj, n_parent):
                     b_action = False
 
         # -> everything else (empty/armature) is a (more or less regular) node
-        node = types.create_ninode(b_obj)
+        node = types.create_ninode(b_obj, n_node_type=n_node_type)
         # set parenting here so that it can be accessed
         if not self.n_root:
             self.n_root = node
@@ -213,26 +205,22 @@ def export_node(self, b_obj, n_parent):
         # if it is an armature, export the bones as ninode children of this ninode
         elif b_obj.type == 'ARMATURE':
             self.armaturehelper.export_bones(b_obj, node)
-
-        # export all children of this b_obj as children of this NiNode
-        self.export_children(b_obj, node)
+            # special case: objects parented to armature bones
+            for b_child in b_obj.children:
+                # find and attach to the right bone
+                if b_child.parent_bone:
+                    b_obj_bone = b_obj.data.bones[b_child.parent_bone]
+                    self.export_node(b_child, block_store.block_to_obj[b_obj_bone])
+                # just child of the armature itself, so attach to armature root
+                else:
+                    self.export_node(b_child, node)
+        else:
+            # export all children of this empty object as children of this node
+            for b_child in b_obj.children:
+                self.export_node(b_child, node)
 
         return node
 
-    def export_children(self, b_parent, n_parent):
-        """Export all children of blender object b_parent as children of n_parent."""
-        # loop over all obj's children
-        for b_child in b_parent.children:
-            temp_parent = n_parent
-            # special case: objects parented to armature bones - find the nif parent bone
-            if b_parent.type == 'ARMATURE' and b_child.parent_bone != "":
-                parent_bone = b_parent.data.bones[b_child.parent_bone]
-                assert (parent_bone in block_store.block_to_obj.values())
-                for temp_parent, obj in block_store.block_to_obj.items():
-                    if obj == parent_bone:
-                        break
-            self.export_node(b_child, temp_parent)
-
     def export_collision(self, b_obj, n_parent):
         """Main function for adding collision object b_obj to a node.
         Returns True if this object is exported as a collision"""
@@ -259,7 +247,7 @@ def export_collision(self, b_obj, n_parent):
             else:
                 # all nodes failed so add new one
                 node = types.create_ninode(b_obj)
-                node.name = 'collisiondummy{:d}'.format(n_parent.num_children)
+                node.name = f'collisiondummy{n_parent.num_children}'
                 if b_obj.niftools.flags != 0:
                     node_flag_hex = hex(b_obj.niftools.flags)
                 else:
@@ -273,4 +261,4 @@ def export_collision(self, b_obj, n_parent):
         else:
             NifLog.warn(f"Collisions not supported for game '{bpy.context.scene.niftools_scene.game}', skipped collision object '{b_obj.name}'")
 
-        return True
+        return True

io_scene_niftools/modules/nif_export/property/object/__init__.py

@@ -220,21 +220,18 @@ def has_collision():
 
     # TODO [object][property] Move to object property
     @staticmethod
-    def export_inventory_marker(n_root, root_objects):
-        if bpy.context.scene.niftools_scene.game in ('SKYRIM',):
-            for root_object in root_objects:
-                if root_object.niftools_bs_invmarker:
-                    for extra_item in n_root.extra_data_list:
-                        if isinstance(extra_item, NifFormat.BSInvMarker):
-                            raise NifError("Multiple Items have Inventory marker data only one item may contain this data")
-                    else:
-                        n_extra_list = NifFormat.BSInvMarker()
-                        n_extra_list.name = root_object.niftools_bs_invmarker[0].name.encode()
-                        n_extra_list.rotation_x = (-root_object.niftools_bs_invmarker[0].bs_inv_x % (2 * pi)) * 1000
-                        n_extra_list.rotation_y = (-root_object.niftools_bs_invmarker[0].bs_inv_y % (2 * pi)) * 1000
-                        n_extra_list.rotation_z = (-root_object.niftools_bs_invmarker[0].bs_inv_z % (2 * pi)) * 1000
-                        n_extra_list.zoom = root_object.niftools_bs_invmarker[0].bs_inv_zoom
-                        n_root.add_extra_data(n_extra_list)
+    def export_inventory_marker(n_root):
+        """Attaches a BSInvMarker to n_root if desired and fill in its values"""
+        niftools_scene = bpy.context.scene.niftools_scene
+        if niftools_scene.game in ('SKYRIM',) and niftools_scene.bs_inv:
+            bs_inv = niftools_scene.bs_inv[0]
+            n_bs_inv_marker = NifFormat.BSInvMarker()
+            n_bs_inv_marker.name = bs_inv.name.encode()
+            n_bs_inv_marker.rotation_x = (-bs_inv.x % (2 * pi)) * 1000
+            n_bs_inv_marker.rotation_y = (-bs_inv.y % (2 * pi)) * 1000
+            n_bs_inv_marker.rotation_z = (-bs_inv.z % (2 * pi)) * 1000
+            n_bs_inv_marker.zoom = bs_inv.zoom
+            n_root.add_extra_data(n_bs_inv_marker)
 
     # TODO [object][property] Move to new object type
     def export_weapon_location(self, n_root, root_obj):

io_scene_niftools/modules/nif_export/types.py

@@ -45,21 +45,22 @@
 from io_scene_niftools.utils.singleton import NifOp
 
 
-def create_ninode(b_obj=None):
+def create_ninode(b_obj=None, n_node_type=None):
     """Essentially a wrapper around create_block() that creates nodes of the right type"""
-    # when no b_obj is passed, it means we create a root node
+    # when no b_obj is passed, use the passed n_node_type
     if not b_obj:
-        return block_store.create_block("NiNode")
-
+        if n_node_type is None:
+            n_node_type = "NiNode"
     # get node type - some are stored as custom property of the b_obj
-    try:
-        n_node_type = b_obj["type"]
-    except KeyError:
-        n_node_type = "NiNode"
-
-    # ...others by presence of constraints
-    if has_track(b_obj):
-        n_node_type = "NiBillboardNode"
+    else:
+        try:
+            n_node_type = b_obj["type"]
+        except KeyError:
+            n_node_type = "NiNode"
+
+        # ...others by presence of constraints
+        if has_track(b_obj):
+            n_node_type = "NiBillboardNode"
 
     # now create the node
     n_node = block_store.create_block(n_node_type, b_obj)