Version 11.2.0 - Added interpolation mode options to animation properties and updated documentation to reflect new features. Enhanced animation export functionality to support forced interpolation modes.

Author: Nusiq

docs/animations/essential_concepts.md

@@ -30,6 +30,10 @@ Let's say that in the image above, `bone_2` uses constant interpolation on frame
 
 This behavior can cause unexpected results when using stepped or smooth interpolation. To ensure predictable animations, it's generally best to use linear interpolation unless a different mode is necessary.
 
+```{note}
+If you want to force all keyframes to use a specific interpolation mode, you can use the `Interpolation mode` field in [Mcblend: Animation](mcblend-object-properties-animations).
+```
+
 ```{warning}
 Bézier interpolation in Blender does not exactly match smooth frames in Minecraft, which use a Catmull-Rom spline. For a similar effect in Blender's preview, use Bézier interpolation with "automatic" handle types.
 

docs/gui/object_properties.md

@@ -47,6 +47,7 @@ The Materials panel allows you to quickly create materials that are similar to t
 
 Once you've set up your render controller, you can use the `Apply materials` button to automatically create the materials for preview in Blender. This will help you get a better sense of how your model will look in Minecraft.
 
+(mcblend-object-properties-animations)=
 ### Mcblend: Animations
 
 ![](/img/gui/object_properties_armature_animations.png)
@@ -62,6 +63,7 @@ The `Mcblend: Animations panel` allows you to easily switch between animations i
 - The `Override previous animation` field directly translates to the override_previous_animation property of the Minecraft animation. It doesn't affect how the animation is rendered in Blender.
 - The `Loop` field directly translates to the loop property of the Minecraft animation file. There are three options: `true`, `false`, and `hold_on_last_frame`.
 - The `Anim Time Update` field directly translates to the anim_time_update property of the Minecraft animation file. You should either leave it empty (if you don't want to have anim_time_update in your animation) or put a Molang expression in it. It doesn't affect the animation in Mcblend because Mcblend doesn't support Molang.
+- The `Interpolation mode` field directly translates to the interpolation mode of the Minecraft animation file. There are four options: `linear`, `smooth`, `step`, and `auto`.
 - The `Frame start` field indicates the first frame of the animation. It tells Mcblend where the animation starts.
 - The `Frame end` field indicates the last frame of the animation. It tells Mcblend where the animation ends.
 

docs/img/gui/object_properties_armature_animations.png

@@ -116,7 +116,7 @@
     "author": "Artur",
     "description": "An addon that allows to design and animate Minecraft Bedrock Edition models",
     "blender": (4, 2, 0),
-    "version": (11, 1, 0),  # Remember to update the version in the "docs/conf.py"
+    "version": (11, 2, 0),  # Remember to update the version in the "docs/conf.py"
     "location": "",
     "warning": "",
     "category": "Object"

mcblend/__init__.py

@@ -199,6 +199,17 @@ class MCBLEND_AnimationProperties(PropertyGroup):
         default="",
         maxlen=1024
     )
+    interpolation_mode: EnumProperty(
+        items=(
+            ('AUTO', 'Auto', 'Use the interpolation mode detected from Blender keyframes'),
+            ('LINEAR', 'Linear', 'Force all keyframes to use linear interpolation'),
+            ('SMOOTH', 'Smooth', 'Force all keyframes to use smooth interpolation'),
+            ('STEP', 'Step', 'Force all keyframes to use step interpolation')
+        ),
+        name='Interpolation Mode',
+        description='Control how keyframes are interpolated',
+        default='AUTO'
+    )
     loop: EnumProperty(
         items=(
             (

mcblend/object_data.py

@@ -48,6 +48,7 @@ class MCBLEND_AnimationProperties(PropertyGroup):
     skip_rest_poses: bool
     override_previous_animation: bool
     anim_time_update: str
+    interpolation_mode: str
     loop: str
     frame_start: int
     frame_current: int

mcblend/object_data.pyi

@@ -21,7 +21,7 @@
 
 from .sqlite_bedrock_packs.better_json_tools import load_jsonc
 
-from .animation import AnimationExport
+from .animation import AnimationExport, InterpolationMode
 from .common import (
     MINECRAFT_SCALE_FACTOR, CubePolygon, McblendObject, McblendObjectGroup, MeshType,
     apply_obj_transform_keep_origin, fix_cube_rotation, star_pattern_match,
@@ -84,21 +84,29 @@ def export_animation(
     if armature is None or armature.type != 'ARMATURE':
         # Should never happen (checked in the operator)
         raise ValueError("Selected object is not an armature")
-    anim_data = get_mcblend(armature).animations[
-        get_mcblend(armature).active_animation]
+    model_properties = get_mcblend(armature)
+    anim_id = model_properties.active_animation
+    anim_data = model_properties.animations[anim_id]
 
-    # TODO - write this code nicer, passing world_origin as a string isn't
-    # a perfect solution
     world_origin = None
-    use_armature_origin: bool = get_mcblend(
-        armature).model_origin == ModelOriginType.ARMATURE.value
+    use_armature_origin: bool = model_properties.model_origin == (
+        ModelOriginType.ARMATURE.value)
     if use_armature_origin:
         world_origin = armature
 
     # Check and create object properties
     object_properties = McblendObjectGroup(armature, world_origin)
 
     effective_fps = context.scene.render.fps/context.scene.render.fps_base
+    # Create forced interpolation mode from string
+    forced_interpolation = InterpolationMode.AUTO
+    if anim_data.interpolation_mode == 'LINEAR':
+        forced_interpolation = InterpolationMode.LINEAR
+    elif anim_data.interpolation_mode == 'SMOOTH':
+        forced_interpolation = InterpolationMode.SMOOTH
+    elif anim_data.interpolation_mode == 'STEP':
+        forced_interpolation = InterpolationMode.STEP
+
     animation = AnimationExport(
         name=anim_data.name,
         length=(context.scene.frame_end-1)/effective_fps,
@@ -110,7 +118,8 @@ def export_animation(
         effect_events={
             event.name: event.get_effects_dict()
             for event in get_mcblend_events(context.scene)
-        }
+        },
+        forced_interpolation=forced_interpolation
     )
     animation.load_poses_and_bone_states(object_properties, context)
     return animation.json(

mcblend/operator_func/__init__.py

@@ -30,6 +30,7 @@ class InterpolationMode(Enum):
     STEP = 0
     LINEAR = 1
     SMOOTH = 2
+    AUTO = 3  # Use the interpolation mode detected from Blender keyframes
 
     # Must be comparable for bisect
     def __lt__(self, other: InterpolationMode) -> bool:
@@ -165,9 +166,12 @@ def frame_to_t(frame: float, fps: float) -> str:
     float, None | Tuple[str, TransformationType, InterpolationMode]]
 
 class ObjectKeyframesInfo:
-    def __init__(self, obj: Object | None):
+    def __init__(
+            self, obj: Object | None, 
+            forced_interpolation: InterpolationMode = InterpolationMode.AUTO):
         self.keyframes: set[float] = set()
         self.timelines: Dict[tuple[str, TransformationType], Timeline] = {}
+        self.forced_interpolation = forced_interpolation
         if obj is None:
             return
         self._init_keyframes_and_timelines(obj)
@@ -183,6 +187,10 @@ def get_bone_state(
         :param timestamp: the timestamp of the keyframe.
         :returns: the interpolation mode of the bone state.
         '''
+        # Return forced interpolation if not AUTO
+        if self.forced_interpolation != InterpolationMode.AUTO:
+            return self.forced_interpolation
+            
         timelines_key = (bone_name, transformation_type)
         if timelines_key not in self.timelines:
             return InterpolationMode.LINEAR
@@ -399,6 +407,9 @@ class AnimationExport:
     :param poses: Optional - poses of the animation (keyframes) keyed by the
         number of the frame. This dictionary is empty by default after the
         creation and it gets populated on loading the poses.
+    :param forced_interpolation: Optional - force all keyframes to use a specific
+        interpolation mode: InterpolationMode.LINEAR, InterpolationMode.SMOOTH,
+        InterpolationMode.STEP, or InterpolationMode.AUTO (default).
     '''
     name: str
     length: float
@@ -412,6 +423,8 @@ class AnimationExport:
     poses: Dict[float, Pose] = field(default_factory=dict)
     sound_effects: Dict[int, List[Dict[Any, Any]]] = field(default_factory=dict)
     particle_effects: Dict[int, List[Dict[Any, Any]]] = field(default_factory=dict)
+    forced_interpolation: InterpolationMode = field(
+        default=InterpolationMode.AUTO)
 
     def load_poses_and_bone_states(
             self, object_properties: McblendObjectGroup,
@@ -437,7 +450,9 @@ def load_poses_and_bone_states(
                 # The frame value in the dictionary key doesn't really matter
                 self.poses[keyframe] = pose
             else:
-                bone_states = ObjectKeyframesInfo(context.object)
+                bone_states = ObjectKeyframesInfo(
+                    context.object, forced_interpolation=self.forced_interpolation
+                )
                 for keyframe in sorted(bone_states.keyframes):
                     if (
                         keyframe < context.scene.frame_start or

mcblend/operator_func/animation.py

@@ -734,6 +734,10 @@ def draw(self, context: Context):
                     active_anim,  # type: ignore
                     "anim_time_update",
                     text="Anim Time Update")
+                col.prop(
+                    active_anim,  # type: ignore
+                    "interpolation_mode",
+                    text="Interpolation Mode")
                 col.prop(
                     bpy.context.scene,  # type: ignore
                     "frame_start", text="Frame start")