Speedup anim import & various other fixes

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

@@ -460,6 +460,24 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
 
                     if NifData.data.version >= 0x04020100 and NifOp.props.skin_partition:
                         NifLog.info("Creating skin partition")
+
+                        # warn on bad config settings
+                        if game == 'OBLIVION':
+                            if NifOp.props.pad_bones:
+                                NifLog.warn("Using padbones on Oblivion export. Disable the pad bones option to get higher quality skin partitions.")
+                        if game in ('OBLIVION', 'FALLOUT_3'):
+                            if NifOp.props.max_bones_per_partition < 18:
+                                NifLog.warn("Using less than 18 bones per partition on Oblivion/Fallout 3 export."
+                                            "Set it to 18 to get higher quality skin partitions.")
+                            elif NifOp.props.max_bones_per_partition > 18:
+                                NifLog.warn("Using more than 18 bones per partition on Oblivion/Fallout 3 export."
+                                            "This may cause issues in-game.")
+                        if game == 'SKYRIM':
+                            if NifOp.props.max_bones_per_partition < 24:
+                                NifLog.warn("Using less than 24 bones per partition on Skyrim export."
+                                            "Set it to 24 to get higher quality skin partitions.")
+                        # Skyrim Special Edition has a limit of 80 bones per partition, but export is not yet supported
+
                         part_order = [getattr(NifFormat.BSDismemberBodyPartType, face_map.name, None) for face_map in b_obj.face_maps]
                         part_order = [body_part for body_part in part_order if body_part is not None]
                         # override pyffi trishape.update_skin_partition with custom one (that allows ordering)
@@ -475,18 +493,6 @@ def export_tri_shapes(self, b_obj, n_parent, n_root, trishape_name=None):
                             maximize_bone_sharing=(game in ('FALLOUT_3', 'SKYRIM')),
                             part_sort_order=part_order)
 
-                        # warn on bad config settings
-                        if game == 'OBLIVION':
-                            if NifOp.props.pad_bones:
-                                NifLog.warn("Using padbones on Oblivion export. Disable the pad bones option to get higher quality skin partitions.")
-                        if game in ('OBLIVION', 'FALLOUT_3'):
-                            if NifOp.props.max_bones_per_partition < 18:
-                                NifLog.warn("Using less than 18 bones per partition on Oblivion/Fallout 3 export."
-                                            "Set it to 18 to get higher quality skin partitions.")
-                        if game == 'SKYRIM':
-                            if NifOp.props.max_bones_per_partition < 24:
-                                NifLog.warn("Using less than 24 bones per partition on Skyrim export."
-                                            "Set it to 24 to get higher quality skin partitions.")
                         if lostweight > NifOp.props.epsilon:
                             NifLog.warn(f"Lost {lostweight:f} in vertex weights while creating a skin partition for Blender object '{b_obj.name}' (nif block '{trishape.name}')")
 

io_scene_niftools/modules/nif_import/animation/__init__.py

@@ -141,6 +141,25 @@ def set_extrapolation(extend_type, fcurves):
             for fcurve in fcurves:
                 fcurve.extrapolation = 'CONSTANT'
 
+    def add_keys(self, fcurves, times, keys, interp):
+        """
+        Add a key (len=n) to a set of fcurves (len=n) at the given frame. Set the key's interpolation to interp.
+        """
+        samples = [round(t * self.fps) for t in times]
+        assert len(samples) == len(keys)
+        # get interpolation enum representation
+        ipo = bpy.types.Keyframe.bl_rna.properties['interpolation'].enum_items[interp].value
+        interpolations = [ipo for _ in range(len(samples))]
+        # import the keys
+        for fcurve, fcu_keys in zip(fcurves, zip(*keys)):
+            # add new points
+            fcurve.keyframe_points.add(count=len(fcu_keys))
+            # populate points with keys for this curve
+            fcurve.keyframe_points.foreach_set("co", [x for co in zip(samples, fcu_keys) for x in co])
+            fcurve.keyframe_points.foreach_set("interpolation", interpolations)
+            # update
+            fcurve.update()
+
     def add_key(self, fcurves, t, key, interp):
         """
         Add a key (len=n) to a set of fcurves (len=n) at the given frame. Set the key's interpolation to interp.

io_scene_niftools/modules/nif_import/animation/transform.py

@@ -39,6 +39,7 @@
 
 import bpy
 import mathutils
+import time
 
 from functools import singledispatch
 from bisect import bisect_left
@@ -187,18 +188,30 @@ def import_keyframe_controller(self, n_kfc, b_armature, b_target, b_action_name)
             return
         NifLog.debug(f'Importing keyframe controller for {b_target.name}')
 
-        translations = []
-        scales = []
-        rotations = []
-        eulers = []
         n_kfd = None
+        # fallout, Loki - we set extrapolation according to the root NiControllerSequence.cycle_type
+        flags = None
+
+        # create or get the action
+        if b_armature and isinstance(b_target, bpy.types.PoseBone):
+            # action on armature, one per armature
+            b_action = self.create_action(b_armature, b_action_name)
+            if b_target.name in self.bind_data:
+                n_bind_rot_inv, n_bind_trans = self.bind_data[b_target.name]
+            bone_name = b_target.name
+        else:
+            # one action per object
+            b_action = self.create_action(b_target, f"{b_action_name}_{b_target.name}")
+            bone_name = None
 
         # transform controllers (dartgun.nif)
         if isinstance(n_kfc, NifFormat.NiTransformController):
             if n_kfc.interpolator:
                 n_kfd = n_kfc.interpolator.data
         # B-spline curve import
         elif isinstance(n_kfc, NifFormat.NiBSplineInterpolator):
+            # Bsplines are Bezier curves
+            interp_rot = interp_loc = interp_scale = "BEZIER"
             # used by WLP2 (tiger.kf), but only for non-LocRotScale data
             # eg. bone stretching - see controlledblock.get_variable_1()
             # do not support this for now, no good representation in Blender
@@ -207,24 +220,21 @@ def import_keyframe_controller(self, n_kfc, b_armature, b_target, b_action_name)
                 # keys = list(kfc._getCompKeys(kfc.offset, 1, kfc.bias, kfc.multiplier))
                 return
             times = list(n_kfc.get_times())
-            # just do these temp steps to avoid generating empty fcurves down the line
-            trans_temp = [mathutils.Vector(tup) for tup in n_kfc.get_translations()]
-            if trans_temp:
-                translations = zip(times, trans_temp)
-            rot_temp = [mathutils.Quaternion(tup) for tup in n_kfc.get_rotations()]
-            if rot_temp:
-                rotations = zip(times, rot_temp)
-            scale_temp = list(n_kfc.get_scales())
-            if scale_temp:
-                scales = zip(times, scale_temp)
-            # Bsplines are Bezier curves
-            interp_rot = interp_loc = interp_scale = "BEZIER"
+            keys = list(n_kfc.get_translations())
+            self.import_translations(b_action, bone_name, times, keys, flags, interp_loc, n_bind_rot_inv, n_bind_trans)
+            keys = list(n_kfc.get_rotations())
+            self.import_quats(b_action, bone_name, times, keys, flags, interp_rot, n_bind_rot_inv)
+            keys = list(n_kfc.get_scales())
+            self.import_scales(b_action, bone_name, times, keys, flags, interp_scale)
         elif isinstance(n_kfc, NifFormat.NiMultiTargetTransformController):
             # not sure what this is used for
             return
         else:
             # ZT2 & Fallout
             n_kfd = n_kfc.data
+        # ZT2 - get extrapolation for every kfc
+        if isinstance(n_kfc, NifFormat.NiKeyframeController):
+            flags = n_kfc.flags
         if isinstance(n_kfd, NifFormat.NiKeyframeData):
             interp_rot = self.get_b_interp_from_n_interp(n_kfd.rotation_type)
             interp_loc = self.get_b_interp_from_n_interp(n_kfd.translations.interpolation)
@@ -247,67 +257,62 @@ def import_keyframe_controller(self, n_kfc, b_armature, b_target, b_action_name)
                     x_r = interpolate(times_all, times_x, [key.value for key in n_kfd.xyz_rotations[0].keys])
                     y_r = interpolate(times_all, times_y, [key.value for key in n_kfd.xyz_rotations[1].keys])
                     z_r = interpolate(times_all, times_z, [key.value for key in n_kfd.xyz_rotations[2].keys])
-                eulers = zip(times_all, zip(x_r, y_r, z_r))
+                    self.import_eulers(b_action, bone_name, times_all, zip(x_r, y_r, z_r), flags, interp_rot, n_bind_rot_inv)
             else:
                 b_target.rotation_mode = "QUATERNION"
-                rotations = [(key.time, key.value) for key in n_kfd.quaternion_keys]
+                times = [key.time for key in n_kfd.quaternion_keys]
+                keys = [key.value for key in n_kfd.quaternion_keys]
+                self.import_quats(b_action, bone_name, times, keys, flags, interp_rot, n_bind_rot_inv)
 
-            if n_kfd.scales.keys:
-                scales = [(key.time, key.value) for key in n_kfd.scales.keys]
+            times = [key.time for key in n_kfd.scales.keys]
+            keys = [key.value for key in n_kfd.scales.keys]
+            self.import_scales(b_action, bone_name, times, keys, flags, interp_scale)
+            times = [key.time for key in n_kfd.translations.keys]
+            keys = [key.value for key in n_kfd.translations.keys]
+            self.import_translations(b_action, bone_name, times, keys, flags, interp_loc, n_bind_rot_inv, n_bind_trans)
 
-            if n_kfd.translations.keys:
-                translations = [(key.time, key.value) for key in n_kfd.translations.keys]
+        return b_action
 
-        # ZT2 - get extrapolation for every kfc
-        if isinstance(n_kfc, NifFormat.NiKeyframeController):
-            flags = n_kfc.flags
-        # fallout, Loki - we set extrapolation according to the root NiControllerSequence.cycle_type
-        else:
-            flags = None
+    def import_scales(self, b_action, bone_name, times, keys, flags, interp_scale):
+        if not keys:
+            return
+        NifLog.debug('Scale keys...')
+        # make 3D
+        keys = [(val, val, val) for t, val in keys]
+        fcurves = self.create_fcurves(b_action, "scale", range(3), flags, bone_name)
+        self.add_keys(fcurves, times, keys, interp_scale)
 
-        # create or get the action
-        if b_armature and isinstance(b_target, bpy.types.PoseBone):
-            # action on armature, one per armature
-            b_action = self.create_action(b_armature, b_action_name)
-            if b_target.name in self.bind_data:
-                n_bind_rot_inv, n_bind_trans = self.bind_data[b_target.name]
-            bone_name = b_target.name
-        else:
-            # one action per object
-            b_action = self.create_action(b_target, f"{b_action_name}_{b_target.name}")
-            bone_name = None
+    def import_translations(self, b_action, bone_name, times, keys, flags, interp_loc, n_bind_rot_inv, n_bind_trans):
+        if not keys:
+            return
+        NifLog.debug('Translation keys...')
+        keys = [mathutils.Vector([val.x, val.y, val.z]) for val in keys]
+        if bone_name:
+            keys = [
+                math.import_keymat(n_bind_rot_inv, mathutils.Matrix.Translation(key - n_bind_trans)).to_translation()
+                for key in keys]
+        fcurves = self.create_fcurves(b_action, "location", range(3), flags, bone_name)
+        self.add_keys(fcurves, times, keys, interp_loc)
 
-        if eulers:
-            NifLog.debug('Rotation keys..(euler)')
-            fcurves = self.create_fcurves(b_action, "rotation_euler", range(3), flags, bone_name)
-            for t, val in eulers:
-                key = mathutils.Euler(val)
-                if bone_name:
-                    key = math.import_keymat(n_bind_rot_inv, key.to_matrix().to_4x4()).to_euler()
-                self.add_key(fcurves, t, key, interp_rot)
-        elif rotations:
-            NifLog.debug('Rotation keys...(quaternions)')
-            fcurves = self.create_fcurves(b_action, "rotation_quaternion", range(4), flags, bone_name)
-            for t, val in rotations:
-                key = mathutils.Quaternion([val.w, val.x, val.y, val.z])
-                if bone_name:
-                    key = math.import_keymat(n_bind_rot_inv, key.to_matrix().to_4x4()).to_quaternion()
-                self.add_key(fcurves, t, key, interp_rot)
-        if translations:
-            NifLog.debug('Translation keys...')
-            fcurves = self.create_fcurves(b_action, "location", range(3), flags, bone_name)
-            for t, val in translations:
-                key = mathutils.Vector([val.x, val.y, val.z])
-                if bone_name:
-                    key = math.import_keymat(n_bind_rot_inv, mathutils.Matrix.Translation(key - n_bind_trans)).to_translation()
-                self.add_key(fcurves, t, key, interp_loc)
-        if scales:
-            NifLog.debug('Scale keys...')
-            fcurves = self.create_fcurves(b_action, "scale", range(3), flags, bone_name)
-            for t, val in scales:
-                key = (val, val, val)
-                self.add_key(fcurves, t, key, interp_scale)
-        return b_action
+    def import_quats(self, b_action, bone_name, times, keys, flags, interp_rot, n_bind_rot_inv):
+        if not keys:
+            return
+        NifLog.debug('Rotation keys...(quaternions)')
+        keys = [mathutils.Quaternion([val.w, val.x, val.y, val.z]) for val in keys]
+        if bone_name:
+            keys = [math.import_keymat(n_bind_rot_inv, key.to_matrix().to_4x4()).to_quaternion() for key in keys]
+        fcurves = self.create_fcurves(b_action, "rotation_quaternion", range(4), flags, bone_name)
+        self.add_keys(fcurves, times, keys, interp_rot)
+
+    def import_eulers(self, b_action, bone_name, times, keys, flags, interp_rot, n_bind_rot_inv):
+        if not keys:
+            return
+        NifLog.debug('Rotation keys..(euler)')
+        keys = [mathutils.Euler(val) for val in keys]
+        if bone_name:
+            keys = [math.import_keymat(n_bind_rot_inv, key.to_matrix().to_4x4()).to_euler() for key in keys]
+        fcurves = self.create_fcurves(b_action, "rotation_euler", range(3), flags, bone_name)
+        self.add_keys(fcurves, times, keys, interp_rot)
 
     def import_transforms(self, n_block, b_obj, bone_name=None):
         """Loads an animation attached to a nif block."""

io_scene_niftools/modules/nif_import/geometry/vertex/groups.py

@@ -164,8 +164,14 @@ def import_skin(ni_block, b_obj):
                                 v_group.add([vert], w, 'REPLACE')
 
         # import body parts as face maps
-        # get faces (triangles) as map of tuples to index
-        tri_map = {frozenset(polygon.vertices): polygon.index for polygon in b_obj.data.polygons}
+        # get faces (triangles) as map of unordered vertices to list of indices
+        tri_map = {}
+        for polygon in b_obj.data.polygons:
+            vertices = frozenset(polygon.vertices)
+            if vertices in tri_map:
+                tri_map[vertices].append(polygon.index)
+            else:
+                tri_map[vertices] = [polygon.index]
         if isinstance(skininst, NifFormat.BSDismemberSkinInstance):
             skinpart = ni_block.get_skin_partition()
             for bodypart, skinpartblock in zip(skininst.partitions, skinpart.skin_partition_blocks):
@@ -178,4 +184,5 @@ def import_skin(ni_block, b_obj):
                     f_group = b_obj.face_maps.new(name=group_name)
 
                 # add the triangles to the face map
-                f_group.add([tri_map[frozenset(vertices)] for vertices in skinpartblock.get_mapped_triangles()])
+                for vertices in skinpartblock.get_mapped_triangles():
+                    f_group.add(tri_map[frozenset(vertices)])

io_scene_niftools/operators/nif_import_op.py

@@ -65,7 +65,7 @@ class NifImportOperator(Operator, ImportHelper, CommonScale, CommonDevOperator,
     animation: bpy.props.BoolProperty(
         name="Animation",
         description="Import animation",
-        default=False)
+        default=True)
 
     # Merge skeleton roots.
     merge_skeleton_roots: bpy.props.BoolProperty(