Pyffi overhaul

install/makezip.bat

@@ -32,5 +32,14 @@ xcopy "%ROOT%"\LICENSE.rst io_scene_niftools
 xcopy "%ROOT%"\README.rst io_scene_niftools
 popd
 
-powershell -executionpolicy bypass -Command "%DIR%\zip.ps1" -source "%DIR%\temp\io_scene_niftools" -destination "%DIR%\%ZIP_NAME%.zip"
-rmdir /s /q %DIR%\temp
+set "COMMAND_FILE=%DIR%\zip.ps1"
+set "COMMAND_FILE=%COMMAND_FILE: =` %"
+
+set "SOURCE_DIR=%DIR%\temp\io_scene_niftools"
+set "SOURCE_DIR=%SOURCE_DIR: =` %"
+
+set "DESTINATION_DIR=%DIR%\%ZIP_NAME%.zip"
+set "DESTINATION_DIR=%DESTINATION_DIR: =` %"
+
+powershell -executionpolicy bypass -Command "%COMMAND_FILE%" -source "%SOURCE_DIR%" -destination "%DESTINATION_DIR%"
+rmdir /s /q "%DIR%\temp"

io_scene_niftools/__init__.py

@@ -72,8 +72,8 @@ def locate_dependencies():
 
     with open(os.path.join(current_dir, "VERSION.txt")) as version:
         NifLog.info(f"Loading: Blender Niftools Addon: {version.read()}")
-        import pyffi
-        NifLog.info(f"Loading: PyFFi: {pyffi.__version__}")
+        import generated.formats.nif as NifFormat
+        NifLog.info(f"Loading: NifFormat: {NifFormat.__xml_version__}") # todo [generated] update this and library to have actual versioning
 
 
 locate_dependencies()

io_scene_niftools/file_io/nif.py

@@ -37,8 +37,9 @@
 #
 # ***** END LICENSE BLOCK *****
 
+import os.path as path
 
-from pyffi.formats.nif import NifFormat
+import generated.formats.nif as NifFormat
 
 from io_scene_niftools.utils.logging import NifLog, NifError
 
@@ -51,18 +52,18 @@ def load_nif(file_path):
         """Loads a nif from the given file path"""
         NifLog.info(f"Importing {file_path}")
 
-        data = NifFormat.Data()
+        file_ext = path.splitext(file_path)[1]
 
         # open file for binary reading
         with open(file_path, "rb") as nif_stream:
             # check if nif file is valid
-            data.inspect_version_only(nif_stream)
-            if data.version >= 0:
+            modification, (version, user_version, bs_version) = NifFormat.NifFile.inspect_version_only(nif_stream)
+            if version >= 0:
                 # it is valid, so read the file
-                NifLog.info(f"NIF file version: {data.version:x}")
-                NifLog.info("Reading file")
-                data.read(nif_stream)
-            elif data.version == -1:
+                NifLog.info(f"NIF file version: {version:x}")
+                NifLog.info(f"Reading {file_ext} file")
+                data = NifFormat.NifFile.from_stream(nif_stream)
+            elif version == -1:
                 raise NifError("Unsupported NIF version.")
             else:
                 raise NifError("Not a NIF file.")

io_scene_niftools/kf_export.py

@@ -40,10 +40,6 @@
 import os
 import bpy
 
-import pyffi.spells.nif.fix
-
-from io_scene_niftools.file_io.kf import KFFile
-from io_scene_niftools.modules.nif_export import armature
 from io_scene_niftools.modules.nif_export.animation.transform import TransformAnimation
 from io_scene_niftools.nif_common import NifCommon
 from io_scene_niftools.utils import math
@@ -95,6 +91,8 @@ def execute(self):
         # scale correction for the skeleton
         self.apply_scale(data, round(1 / NifOp.props.scale_correction))
 
+        data.validate()
+
         kffile = os.path.join(directory, prefix + filebase + ext)
         with open(kffile, "wb") as stream:
             data.write(stream)

io_scene_niftools/kf_import.py

@@ -39,10 +39,7 @@
 
 import os
 
-import pyffi.spells.nif.fix
-
-from io_scene_niftools.file_io.kf import KFFile
-from io_scene_niftools.modules.nif_export import armature
+from io_scene_niftools.file_io.nif import NifFile as KFFile
 from io_scene_niftools.modules.nif_import.animation.transform import TransformAnimation
 from io_scene_niftools.nif_common import NifCommon
 from io_scene_niftools.utils import math
@@ -72,7 +69,7 @@ def execute(self):
                 # get nif space bind pose of armature here for all anims
                 self.transform_anim.get_bind_data(b_armature)
             for kf_file in kf_files:
-                kfdata = KFFile.load_kf(kf_file)
+                kfdata = KFFile.load_nif(kf_file)
 
                 self.apply_scale(kfdata, NifOp.props.scale_correction)
 

io_scene_niftools/modules/nif_export/animation/__init__.py

@@ -39,7 +39,7 @@
 from abc import ABC
 
 import bpy
-from pyffi.formats.nif import NifFormat
+from generated.formats.nif import classes as NifClasses
 
 from io_scene_niftools.modules.nif_export.block_registry import block_store
 from io_scene_niftools.utils.singleton import NifOp, NifData
@@ -93,14 +93,14 @@ def get_controllers(nodes):
         """find all nodes and relevant controllers"""
         node_kfctrls = {}
         for node in nodes:
-            if not isinstance(node, NifFormat.NiAVObject):
+            if not isinstance(node, NifClasses.NiAVObject):
                 continue
             # get list of all controllers for this node
             ctrls = node.get_controllers()
             for ctrl in ctrls:
                 if bpy.context.scene.niftools_scene.game == 'MORROWIND':
                     # morrowind: only keyframe controllers
-                    if not isinstance(ctrl, NifFormat.NiKeyframeController):
+                    if not isinstance(ctrl, NifClasses.NiKeyframeController):
                         continue
                 if node not in node_kfctrls:
                     node_kfctrls[node] = []
@@ -132,14 +132,14 @@ def create_controller(self, parent_block, target_name, priority=0):
             # link interpolator from the controller
             n_kfc.interpolator = n_kfi
         # if parent is a node, attach controller to that node
-        if isinstance(parent_block, NifFormat.NiNode):
+        if isinstance(parent_block, NifClasses.NiNode):
             parent_block.add_controller(n_kfc)
             if n_kfi:
                 # set interpolator default data
                 n_kfi.scale, n_kfi.rotation, n_kfi.translation = parent_block.get_transform().get_scale_quat_translation()
 
         # else ControllerSequence, so create a link
-        elif isinstance(parent_block, NifFormat.NiControllerSequence):
+        elif isinstance(parent_block, NifClasses.NiControllerSequence):
             controlled_block = parent_block.add_controlled_block()
             controlled_block.priority = priority
             # todo - pyffi adds the names to the NiStringPalette, but it creates one per controller link...
@@ -159,15 +159,15 @@ def create_controller(self, parent_block, target_name, priority=0):
                 controlled_block.controller_type = "NiTransformController"
                 # get the parent's string palette
                 if not parent_block.string_palette:
-                    parent_block.string_palette = NifFormat.NiStringPalette()
+                    parent_block.string_palette = NifClasses.NiStringPalette(NifData.data)
                 # assign string palette to controller
                 controlled_block.string_palette = parent_block.string_palette
                 # add the strings and store their offsets
                 palette = controlled_block.string_palette.palette
                 controlled_block.node_name_offset = palette.add_string(controlled_block.node_name)
                 controlled_block.controller_type_offset = palette.add_string(controlled_block.controller_type)
         # morrowind style
-        elif isinstance(parent_block, NifFormat.NiSequenceStreamHelper):
+        elif isinstance(parent_block, NifClasses.NiSequenceStreamHelper):
             # create node reference by name
             nodename_extra = block_store.create_block("NiStringExtraData")
             nodename_extra.bytes_remaining = len(target_name) + 4
@@ -184,14 +184,14 @@ def create_controller(self, parent_block, target_name, priority=0):
     @staticmethod
     def get_n_interp_from_b_interp(b_ipol):
         if b_ipol == "LINEAR":
-            return NifFormat.KeyType.LINEAR_KEY
+            return NifClasses.KeyType.LINEAR_KEY
         elif b_ipol == "BEZIER":
-            return NifFormat.KeyType.QUADRATIC_KEY
+            return NifClasses.KeyType.QUADRATIC_KEY
         elif b_ipol == "CONSTANT":
-            return NifFormat.KeyType.CONST_KEY
+            return NifClasses.KeyType.CONST_KEY
 
         NifLog.warn(f"Unsupported interpolation mode ({b_ipol}) in blend, using quadratic/bezier.")
-        return NifFormat.KeyType.QUADRATIC_KEY
+        return NifClasses.KeyType.QUADRATIC_KEY
 
     def add_dummy_markers(self, b_action):
         # if we exported animations, but no animation groups are defined,

io_scene_niftools/modules/nif_export/animation/material.py

@@ -37,11 +37,11 @@
 #
 # ***** END LICENSE BLOCK *****
 
-from pyffi.formats.nif import NifFormat
+from generated.formats.nif import classes as NifClasses
 
 from io_scene_niftools.modules.nif_export.animation import Animation
 from io_scene_niftools.modules.nif_export.block_registry import block_store
-from io_scene_niftools.utils.singleton import NifOp
+from io_scene_niftools.utils.singleton import NifOp, NifData
 from io_scene_niftools.utils.logging import NifLog
 
 
@@ -71,9 +71,9 @@ def export_material_controllers(self, b_material, n_mat_prop):
         if not n_mat_prop:
             raise ValueError("Bug!! must add material property before exporting alpha controller")
         colors = (("alpha", None),
-                  ("niftools.ambient_color", NifFormat.TargetColor.TC_AMBIENT),
-                  ("diffuse_color", NifFormat.TargetColor.TC_DIFFUSE),
-                  ("specular_color", NifFormat.TargetColor.TC_SPECULAR))
+                  ("niftools.ambient_color", NifClasses.MaterialColor.TC_AMBIENT),
+                  ("diffuse_color", NifClasses.MaterialColor.TC_DIFFUSE),
+                  ("specular_color", NifClasses.MaterialColor.TC_SPECULAR))
         # the actual export
         for b_dtype, n_dtype in colors:
             self.export_material_alpha_color_controller(b_material, n_mat_prop, b_dtype, n_dtype)
@@ -99,8 +99,8 @@ def export_material_alpha_color_controller(self, b_material, n_mat_prop, b_dtype
         # create the key data
         n_key_data = block_store.create_block(keydata, fcurves)
         n_key_data.data.num_keys = len(fcurves[0].keyframe_points)
-        n_key_data.data.interpolation = NifFormat.KeyType.LINEAR_KEY
-        n_key_data.data.keys.update_size()
+        n_key_data.data.interpolation = NifClasses.KeyType.LINEAR_KEY
+        n_key_data.data.reset_field("keys")
 
         # assumption: all curves have same amount of keys and are sampled at the same time
         for i, n_key in enumerate(n_key_data.data.keys):
@@ -148,13 +148,13 @@ def export_uv_controller(self, b_material, n_geom):
             return
 
         # get the uv curves and translate them into nif data
-        n_uv_data = NifFormat.NiUVData()
+        n_uv_data = NifClasses.NiUVData(NifData.data)
         for fcu, n_uv_group in zip(fcurves, n_uv_data.uv_groups):
             if fcu:
                 NifLog.debug(f"Exporting {fcu} as NiUVData")
                 n_uv_group.num_keys = len(fcu.keyframe_points)
-                n_uv_group.interpolation = NifFormat.KeyType.LINEAR_KEY
-                n_uv_group.keys.update_size()
+                n_uv_group.interpolation = NifClasses.KeyType.LINEAR_KEY
+                n_uv_group.reset_field("keys")
                 for b_point, n_key in zip(fcu.keyframe_points, n_uv_group.keys):
                     # add each point of the curve
                     b_frame, b_value = b_point.co
@@ -167,7 +167,7 @@ def export_uv_controller(self, b_material, n_geom):
 
         # if uv data is present then add the controller so it is exported
         if fcurves[0].keyframe_points:
-            n_uv_ctrl = NifFormat.NiUVController()
+            n_uv_ctrl = NifClasses.NiUVController(NifData.data)
             self.set_flags_and_timing(n_uv_ctrl, fcurves)
             n_uv_ctrl.data = n_uv_data
             # attach block to geometry

io_scene_niftools/modules/nif_export/animation/morph.py

@@ -37,7 +37,7 @@
 #
 # ***** END LICENSE BLOCK *****
 
-from pyffi.formats.nif import NifFormat
+from generated.formats.nif import classes as NifClasses
 from pyffi.formats.egm import EgmFormat
 
 from io_scene_niftools.modules.nif_export.animation import Animation
@@ -101,25 +101,25 @@ def export_morph_animation(self, b_mesh, b_key, n_trishape, vertmap):
         morph_ctrl.data = morph_data
         morph_data.num_morphs = len(b_key.key_blocks)
         morph_data.num_vertices = n_trishape.data.num_vertices
-        morph_data.morphs.update_size()
+        morph_data.reset_field("morphs")
 
         # create interpolators (for newer nif versions)
         morph_ctrl.num_interpolators = len(b_key.key_blocks)
-        morph_ctrl.interpolators.update_size()
+        morph_ctrl.reset_field("interpolators")
 
         # interpolator weights (for Fallout 3)
-        morph_ctrl.interpolator_weights.update_size()
+        morph_ctrl.reset_field("interpolator_weights")
         # TODO [morph] some unknowns, bethesda only
         # TODO [morph] just guessing here, data seems to be zero always
         morph_ctrl.num_unknown_ints = len(b_key.key_blocks)
-        morph_ctrl.unknown_ints.update_size()
+        morph_ctrl.reset_field("unknown_ints")
         for key_block_num, key_block in enumerate(b_key.key_blocks):
             # export morphed vertices
             n_morph = morph_data.morphs[key_block_num]
             n_morph.frame_name = key_block.name
             NifLog.info(f"Exporting n_morph {key_block.name}: vertices")
             n_morph.arg = morph_data.num_vertices
-            n_morph.vectors.update_size()
+            n_morph.reset_field("vectors")
             for b_v_index, (n_v_indices, b_vert) in enumerate(list(zip(vertmap, key_block.data))):
                 # see if this b_vert is used in the nif
                 if not n_v_indices:
@@ -161,9 +161,9 @@ def export_morph_animation(self, b_mesh, b_key, n_trishape, vertmap):
             # note: we set data on n_morph for older nifs and on floatdata for newer nifs
             # of course only one of these will be actually written to the file
             for n_data in (n_morph, n_floatdata):
-                n_data.interpolation = NifFormat.KeyType.LINEAR_KEY
+                n_data.interpolation = NifClasses.KeyType.LINEAR_KEY
                 n_data.num_keys = len(fcurves[0].keyframe_points)
-                n_data.keys.update_size()
+                n_data.reset_field("keys")
 
             for i, b_keyframe in enumerate(fcurves[0].keyframe_points):
                 frame, value = b_keyframe.co

io_scene_niftools/modules/nif_export/animation/object.py

@@ -38,7 +38,7 @@
 # ***** END LICENSE BLOCK *****
 
 import bpy
-from pyffi.formats.nif import NifFormat
+from generated.formats.nif import classes as NifClasses
 
 from io_scene_niftools.modules.nif_export.animation import Animation
 from io_scene_niftools.modules.nif_export.block_registry import block_store
@@ -66,13 +66,13 @@ def export_visibility(self, n_node, b_action):
         # NiVisData = old style, NiBoolData = new style
         n_vis_data = block_store.create_block("NiVisData", fcurves)
         n_vis_data.num_keys = len(fcurves[0].keyframe_points)
-        n_vis_data.keys.update_size()
+        n_vis_data.reset_field("keys")
 
         # we just leave interpolation at constant
         n_bool_data = block_store.create_block("NiBoolData", fcurves)
-        n_bool_data.data.interpolation = NifFormat.KeyType.CONST_KEY
+        n_bool_data.data.interpolation = NifClasses.KeyType.CONST_KEY
         n_bool_data.data.num_keys = len(fcurves[0].keyframe_points)
-        n_bool_data.data.keys.update_size()
+        n_bool_data.data.reset_field("keys")
         for b_point, n_vis_key, n_bool_key in zip(fcurves[0].keyframe_points, n_vis_data.keys, n_bool_data.data.keys):
             # add each point of the curve
             b_frame, b_value = b_point.co