Code to import and test keyframe loop related code. Also code to split location and rotation into two seperate variables and a fit other bits.

Author: tngreene

io_xplane2blender/importer/xplane_imp_cmd_builder.py

@@ -174,12 +174,12 @@ def scan_float(s_itr:iter)
             name_hint = ""
 
         elif directive == "ANIM_begin":
-            builder.build_cmd("ANIM_begin")
+            builder.build_cmd("ANIM_begin", name_hint=name_hint)
         elif directive == "ANIM_end":
             builder.build_cmd("ANIM_end")
         elif directive == "ANIM_trans_begin":
             dataref_path = components[0]
-            builder.build_cmd("ANIM_trans_begin", dataref_path)
+            builder.build_cmd("ANIM_trans_begin", dataref_path, name_hint=name_hint)
         elif directive == "ANIM_trans_key":
             value = float(components[0])
             location = vec_x_to_b(list(map(float, components[1:4])))
@@ -193,7 +193,7 @@ def scan_float(s_itr:iter)
         elif directive == "ANIM_rotate_begin":
             axis = vec_x_to_b(list(map(float, components[0:3])))
             dataref_path = components[3]
-            builder.build_cmd(directive, axis, dataref_path)
+            builder.build_cmd(directive, axis, dataref_path, name_hint=name_hint)
         elif directive == "ANIM_rotate_key":
             value = float(components[0])
             degrees = float(components[1])
@@ -215,7 +215,7 @@ def scan_float(s_itr:iter)
                 path = components[8]
             except IndexError as e:
                 pass
-            builder.build_cmd(directive, xyz1, xyz2, v1, v2, path)
+            builder.build_cmd(directive, xyz1, xyz2, v1, v2, path, name_hint=name_hint)
         elif directive == "ANIM_rotate":
             dxyz = vec_x_to_b(list(map(float, components[:3])))
             r1, r2 = map(float, components[3:5])
@@ -228,7 +228,7 @@ def scan_float(s_itr:iter)
                 path = components[7]
             except IndexError:
                 pass
-            builder.build_cmd(directive, dxyz, r1, r2, v1, v2, path)
+            builder.build_cmd(directive, dxyz, r1, r2, v1, v2, path, name_hint=name_hint)
         else:
             # print(f"{directive} is not implemted yet")
             pass

io_xplane2blender/importer/xplane_imp_parser.py

@@ -24,6 +24,8 @@
     ANIM_TYPE_HIDE,
     ANIM_TYPE_SHOW,
     ANIM_TYPE_TRANSFORM,
+    PRECISION_KEYFRAME,
+    PRECISION_OBJ_FLOAT,
 )
 from io_xplane2blender.xplane_helpers import XPlaneLogger, logger
 from io_xplane2blender.xplane_types import (
@@ -130,42 +132,50 @@ def useLogger(self):
         logger.clear()
         logger.addTransport(XPlaneLogger.ConsoleTransport(), logLevels)
 
-    def assertAction(
+
+    def assertTransformAction(
         self,
         bl_object: bpy.types.Object,
-        expected_action_struct: xplane_imp_cmd_builder.IntermediateAnimation,
+        expected_inter_anim: xplane_imp_cmd_builder.IntermediateAnimation,
     ):
         """
         Asserts that an object's action datablock matches the animation specified by the ImportedAnimation struct.
-        The action datablock must have 0 or 3 location/rotation_euler channels as is relavent.
-        There should be an even number of Blender and X-Plane keyframes.
-
-        Every keyframe
-        #TODO: Stupid? Does the importer need to be very specific? Would we have to test that spec?
-        assertAnimation expects the imported and fixture Action information to test will be fixture and counts on the action have 0 or 3 channels exactly for testing location and rotation.
-        Those channels must have the same number of keyframes. Our importer will always create 3 channels with
-        an equal number of keyframes (even if some are just 0,0,0) for simplicity
+
+        Assumes
+            - bl_object has an action with `location` or `rotation` (in XYZ Eulers), **exclusively**
+            - Tests 1 dataref path at a time
         """
         try:
             action = bl_object.animation_data.action
         except AttributeError:  # animation_data is None
-            pass
+            assert False
         else:
 
-            def action_as_intermediate_animation(bl_object: bpy.types.Object):
-                real_action_struct = xplane_imp_cmd_builder.IntermediateAnimation(
-                    [], collections.defaultdict(list), []
+            def action_as_intermediate_animation(
+                bl_object: bpy.types.Object,
+            ) -> xplane_imp_cmd_builder.IntermediateAnimation:
+                """
+                Convert a bl_object's action into an IntermediateAnimation
+                """
+
+                action_as_intermediate_animation = (
+                    xplane_imp_cmd_builder.IntermediateAnimation()
                 )
 
                 def recombine_fcurves(
                     action: bpy.types.Action, data_path: str
-                ) -> Union[List[Vector], Dict[Vector, float]]:
+                ) -> Union[List[Vector], Euler]:
+                    """
+                    Turns an FCurve's Location and Rotation into lists of Vectors or Eulers
+
+                    TODO: Cannot handle missing channels or an object with location and rotation
+                    """
                     try:
-                        x_comp, y_comp, z_comp = [
+                        x_comp, y_comp, z_comp = (
                             [k.co[1] for k in f.keyframe_points]
                             for f in action.fcurves
                             if f.data_path == data_path
-                        ]
+                        )
                     except ValueError:  # no matching fcurves found
                         if data_path == "location":
                             return []
@@ -178,101 +188,93 @@ def recombine_fcurves(
                                 for x, y, z in zip(x_comp, y_comp, z_comp)
                             ]
                         elif data_path == "rotation_euler":
-                            return {
-                                Vector((1, 0, 0)).freeze(): list(
-                                    map(math.degrees, x_comp)
-                                ),
-                                Vector((0, 1, 0)).freeze(): list(
-                                    map(math.degrees, y_comp)
-                                ),
-                                Vector((0, 0, 1)).freeze(): list(
-                                    map(math.degrees, z_comp)
-                                ),
-                            }
-
-                if action:
-                    real_action_struct.locations = recombine_fcurves(action, "location")
-                    real_action_struct.rotations = recombine_fcurves(
-                        action, "rotation_euler"
-                    )
+                            return Euler((x_comp, y_comp, z_comp))
+
+                action_as_intermediate_animation.locations = recombine_fcurves(
+                    bl_object.animation_data.action, "location"
+                )
+                action_as_intermediate_animation.rotations = recombine_fcurves(
+                    bl_object.animation_data.action, "rotation_euler"
+                )
+                # ---end recombine_fcurves-------------------------------------
 
                 def get_dataref_prop_from_data_path(
-                    bl_object: bpy.types.Object, data_path: str
-                ) -> xplane_props.XPlaneDataref:
-                    try:
-                        return bl_object.xplane.datarefs[
-                            int(
+                    bl_object: bpy.types.Object, expected_path: str
+                ) -> Tuple[bpy.types.FCurve, xplane_props.XPlaneDataref]:
+                    for fcurve in (
+                        fcurve
+                        for fcurve in bl_object.animation_data.action.fcurves
+                        if fcurve.data_path.startswith("xplane.datarefs[")
+                    ):
+                        try:
+                            data_path_idx = int(
                                 re.match(
-                                    "xplane\.datarefs\[(\d+)\]\.value", data_path
+                                    "xplane\.datarefs\[(\d+)\]\.value", fcurve.data_path
                                 ).group(1)
                             )
-                        ]
-                    except AttributeError:  # No match, None has no 'group'
-                        pass  # TODO: fail here? It is, after all, wrong to end up with the wrong number of datarefs
-                    # Impossible do something, this is an error?
-                    except IndexError:
-                        pass  # TODO: Do something
-
-                data_paths_to_xp_values = {
-                    f.data_path: [k.co[1] for k in f.keyframe_points]
-                    for f in action.fcurves
-                    if f.data_path.startswith("xplane.datarefs")
-                }
-
-                for dataref_prop, xp_values in [
-                    (get_dataref_prop_from_data_path(bl_object, data_path), xp_values)
-                    for data_path, xp_values in data_paths_to_xp_values.items()
-                ]:
-                    real_action_struct.xp_dataref = (
-                        xplane_imp_cmd_builder.IntermediateDataref(
-                            values=xp_values,
-                        )
-                    )
+                        except AttributeError:
+                            # We expect tests to be so simple that they only have 1 dataref,
+                            # but in case they have multiple...
+                            pass
+                        except IndexError:  # Is this actually impossible?
+                            assert (
+                                False
+                            ), f"{bl_object.name} has data_path as out of index: {expected_path}"
+                        else:
+                            # Unit tests are so carefuly authored
+                            # we don't need error handling here.
+                            # fcurves and datarefs will be 1:1
+                            dataref_prop = bl_object.xplane.datarefs[data_path_idx]
+                            if dataref_prop.path == expected_path:
+                                return (fcurve, dataref_prop)
+                    else:  # no early return
+                        assert (
+                            False
+                        ), f"{expected_path} was not found in {bl_object.name}"
+
+                # ----end get_dataref_prop_from_data_path----------------------
+
+                expected_path = expected_inter_anim.xp_dataref.path
+                xp_fcurve, dataref_prop = get_dataref_prop_from_data_path(
+                    bl_object, expected_path
+                )
+                xp_values: List[float] = [k.co[1] for k in xp_fcurve.keyframe_points]
+                action_as_intermediate_animation.xp_dataref = xplane_imp_cmd_builder.IntermediateDataref(
+                    anim_type=dataref_prop.anim_type,
+                    loop=dataref_prop.loop,
+                    path=dataref_prop.path,
+                    # Why? The importer tracks these seperately to make optimzations
+                    # XPlane2Blender will have the data on one "time line" only
+                    location_values=xp_values,
+                    rotation_values=xp_values,
+                )
 
-                return real_action_struct
+                return action_as_intermediate_animation
 
+            # fmt: off
             real_action_struct = action_as_intermediate_animation(bl_object)
-
-            def copy_rest_of_dref_prop(bl_object, real_action_struct):
-                # In case there was no action and we'll only have show hides
-                if not real_action_struct.xp_dataref:
-                    real_action_struct.xp_dataref = (
-                        xplane_imp_parser.IntermediateDataref()
-                    )
-
-                for bl_dref, real_xp_dataref in zip(
-                    bl_object.xplane.datarefs, real_action_struct.xp_dataref
-                ):
-                    real_xp_dataref.anim_type = bl_dref.anim_type
-                    real_xp_dataref.loop = bl_dref.loop
-                    real_xp_dataref.path = bl_dref.path
-
-                    real_xp_dataref.show_hide_v1 = bl_dref.show_hide_v1
-                    real_xp_dataref.show_hide_v2 = bl_dref.show_hide_v2
-
-            copy_rest_of_dref_prop(bl_object, real_action_struct)
+            self.assertEqual(real_action_struct.xp_dataref.anim_type,    expected_inter_anim.xp_dataref.anim_type)
+            self.assertAlmostEqual(real_action_struct.xp_dataref.loop,   expected_inter_anim.xp_dataref.loop, places=1)
+            self.assertEqual(real_action_struct.xp_dataref.path,         expected_inter_anim.xp_dataref.path)
+            self.assertAlmostEqual(real_action_struct.xp_dataref.show_hide_v1, expected_inter_anim.xp_dataref.show_hide_v1, places=PRECISION_OBJ_FLOAT)
+            self.assertAlmostEqual(real_action_struct.xp_dataref.show_hide_v2, expected_inter_anim.xp_dataref.show_hide_v2, places=PRECISION_OBJ_FLOAT)
+            # fmt: on
 
             for real_loc, expected_loc in zip(
-                real_action_struct.locations, expected_action_struct.locations
+                real_action_struct.locations, expected_inter_anim.locations
             ):
                 self.assertVectorAlmostEqual(real_loc, expected_loc, 1)
 
             for real_rot_degrees, expected_rot_degrees in [
                 (
                     real_action_struct.rotations[axis],
-                    expected_action_struct.rotations[axis],
+                    expected_inter_anim.rotations[axis],
                 )
                 for axis in real_action_struct.rotations
             ]:
                 for real_deg, exp_deg in zip(real_rot_degrees, expected_rot_degrees):
                     self.assertAlmostEqual(real_deg, exp_deg, places=1)
 
-            for (real_dataref_prop, expected_dataref_prop) in zip(
-                sorted(real_action_struct.xp_dataref, key=lambda d: d.path),
-                sorted(expected_action_struct.xp_datarefs, key=lambda d: d.path),
-            ):
-                self.assertEqual(real_dataref_prop, expected_dataref_prop)
-
     def assertImportSucceeds(self, filepath: Union[str, pathlib.Path], msg: str = None):
         """
         Tests import succeeds without syntatic or semantic errors.
@@ -292,9 +294,7 @@ def assertImportSucceeds(self, filepath: Union[str, pathlib.Path], msg: str = No
         try:
             result = xplane_imp_parser.import_obj(filepath)
         except xplane_imp_parser.UnrecoverableParserError:
-            self.fail(
-                msg=msg if msg else f"Import of {filepath} did not succeed",
-            )
+            self.fail(msg=msg if msg else f"Import of {filepath} did not succeed",)
         else:
             self.assertEqual(
                 result,

io_xplane2blender/tests/__init__.py

@@ -183,6 +183,7 @@ def __init__(
         dataref_value: Optional[float] = None,
         dataref_show_hide_v1: Optional[float] = None,
         dataref_show_hide_v2: Optional[float] = None,
+        dataref_loop: Optional[float] = None,
         dataref_anim_type: str = xplane_constants.ANIM_TYPE_TRANSFORM,  # Must be xplane_constants.ANIM_TYPE_*
         location: Optional[Vector] = None,
         rotation_mode: str = "XYZ",
@@ -199,6 +200,7 @@ def __init__(
         self.dataref_value = dataref_value
         self.dataref_show_hide_v1 = dataref_show_hide_v1
         self.dataref_show_hide_v2 = dataref_show_hide_v2
+        self.dataref_loop = dataref_loop
         self.dataref_anim_type = dataref_anim_type
         self.location = location
         self.rotation_mode = rotation_mode
@@ -911,6 +913,8 @@ def set_animation_data(
             dataref_prop.show_hide_v2 = kf_info.dataref_show_hide_v2
         else:
             dataref_prop.value = kf_info.dataref_value
+            # Multiple assignment isn't harmful
+            dataref_prop.loop = kf_info.dataref_loop
 
         if not kf_info.location and not kf_info.rotation:
             continue

io_xplane2blender/tests/test_creation_helpers.py

@@ -0,0 +1,47 @@
+I
+800
+OBJ
+
+GLOBAL_cockpit_lit
+POINT_COUNTS	3	0	0	3
+
+VT	1	0	1	-0	-1	-0	0.625	1	# 0
+VT	1	0	-1	-0	-1	-0	0.625	0.75	# 1
+VT	-1	0	1	-0	-1	-0	0.375	1	# 2
+
+IDX	0
+IDX	1
+IDX	2
+
+# Unit Test Overview
+#
+# This tests that keyframe_loop is properly imported,
+# and incidentally that empty_2 is optimized out and
+# it is given to mesh_2.5.
+#
+# THe object names are the loop values
+
+# 0 ROOT
+	# 1 Mesh: Cube
+	ANIM_begin
+	# static rotation
+	# translation keyframes
+    # name_hint: empty_1.1
+	ANIM_trans_begin	dref_1
+	ANIM_trans_key	0	0	0	-0
+	ANIM_trans_key	1	2	0	-0
+		ANIM_keyframe_loop	1.1
+	ANIM_trans_end
+	# translation keyframes
+    # name_hint: empty_2
+	ANIM_trans_begin	dref_2
+	ANIM_trans_key	0	0	0	-0
+	ANIM_trans_key	1	2	0	-0
+		ANIM_keyframe_loop	2.5
+	ANIM_trans_end
+    # name_hint: mesh_2.5
+	ATTR_shiny_rat	0.5
+	TRIS	0 3
+	ANIM_end
+
+# Build with Blender 2.80 (sub 75) (build b'f6cb5f54494e'). Exported with XPlane2Blender 4.1.0-beta.1+101.NO_BUILD_NUMBR