@volter/blender-engine 0.1.134 → 0.1.135

package/browser/rna.ts

@@ -528,22 +528,29 @@ export interface BlenderUvLayout {
 }
 
 /**
- * ONE TRACK of {@link BlenderActionClip}: a bone's LOCAL `position`,
- * `quaternion` or `scale` sampled at every integer frame.
- *
- * `constant` says the door found every sample equal to the first and shipped
- * two keys instead of N — which is most of a rig, most of the time.
+ * ONE F-CURVE of {@link BlenderActionClip}, whole: one component (`index`) of one of a bone's
+ * channels (`location`, `rotation_quaternion` as w,x,y,z, `rotation_euler`, `rotation_axis_angle`
+ * as angle,x,y,z, `scale`), with everything `fcurve_eval_keyframes` reads to evaluate it.
  */
-export interface BlenderClipTrack {
+export interface BlenderClipTrack extends BlenderClipCurve {
   readonly bone: string;
-  readonly property: 'position' | 'quaternion' | 'scale';
-  readonly stride: number;
-  readonly count: number;
-  readonly constant: boolean;
-  /** Float32 seconds, `count` of them, zero at `clipStart`. */
-  readonly timeBase64: string;
-  /** Float32, `count * stride`. */
-  readonly valueBase64: string;
+  readonly property: 'location' | 'rotation_quaternion' | 'rotation_euler' | 'rotation_axis_angle' | 'scale';
+  readonly index: number;
+}
+
+/** An F-Curve's body: everything Blender evaluates it from, wherever it lives. */
+export interface BlenderClipCurve {
+  /** `FCurve.extrapolation`: `CONSTANT` or `LINEAR`. */
+  readonly extrapolation: string;
+  /** Per key, how the segment after it interpolates: 0 constant, 1 linear, 2 Bezier. */
+  readonly interpolation: readonly number[];
+  /** Float32, six per key: `co`, `handle_left`, `handle_right` (frame, value each). */
+  readonly keysBase64: string;
+  /** A Cycles modifier: [mode before, cycles before, mode after, cycles after]; mode 0 none,
+   *  1 repeat, 2 repeat with offset, 3 mirror. */
+  readonly cycles?: readonly [number, number, number, number];
+  /** What this curve does in Blender that is not played (an easing type, another modifier). */
+  readonly unsupported?: readonly string[];
 }
 
 /** One column of the Timeline's summary row: a frame at which SOMETHING is
@@ -616,9 +623,18 @@ export interface BlenderActionClip {
   readonly tracks: readonly BlenderClipTrack[];
   readonly clipStart?: number;
   readonly clipEnd?: number;
+  /** The range Blender places the action over NLA strips in: its keys, null on a side a Cycles
+   *  modifier repeats into. */
+  readonly keysStart?: number | null;
+  readonly keysEnd?: number | null;
+  /** Blender repeats it past its range (Cycles modifiers on its curves, or `use_cyclic`). */
+  readonly cyclic?: boolean;
   readonly duration?: number;
   readonly sampled?: number;
   /** Bones the action names that the armature does not have. */
   readonly unplayedBones?: readonly string[];
+  /** What the action keys besides bone channels (the object's own transform, a property),
+   *  which plays only in Blender. */
+  readonly unsupported?: readonly string[];
   readonly reason?: string;
 }

package/browser/session.py

@@ -1332,10 +1332,116 @@ def _armature_bones(obj, locked_groups):
             # (`overlay_armature.cc:2059-2084`); it shades both the solid and
             # the wire toward `bone_locked_weight`.
             "lockedWeight": bone.name in locked_groups,
+            # WHAT THE PRESENTER EVALUATES THE POSE FROM, the same inputs `BKE_pose_where_is` takes:
+            # the rest matrix (`Bone.matrix_local`, armature space), the channels' own values (what
+            # a channel no action animates keeps), and the bone's constraints.
+            "rest": _matrix_rows(bone.matrix_local),
+            "channels": _bone_channels(pchan),
+            **_bone_inherit(bone),
+            **_bone_constraints(pchan),
         })
     return bones
 
 
+def _bone_channels(pchan):
+    """A pose bone's channel VALUES as Blender stores them (`PoseBone.location`,
+    `rotation_*`, `scale`), every rotation property and the mode that chooses among them, so the
+    presenter blends them exactly as the NLA does, per channel, before building the matrix."""
+    return {
+        "mode": pchan.rotation_mode,
+        "location": [float(v) for v in pchan.location],
+        "rotation_quaternion": [float(v) for v in pchan.rotation_quaternion],
+        "rotation_euler": [float(v) for v in pchan.rotation_euler],
+        "rotation_axis_angle": [float(v) for v in pchan.rotation_axis_angle],
+        "scale": [float(v) for v in pchan.scale],
+    }
+
+
+def _bone_inherit(bone):
+    """The parenting flags, only when one is not Blender's default (the presenter composes the
+    default chain `parent @ rest @ basis`, and names a bone that asks for another)."""
+    flags = []
+    if not bone.use_inherit_rotation:
+        flags.append("use_inherit_rotation=False")
+    if bone.inherit_scale != "FULL":
+        flags.append("inherit_scale=%s" % bone.inherit_scale)
+    if not bone.use_local_location:
+        flags.append("use_local_location=False")
+    if getattr(bone, "use_relative_parent", False):
+        flags.append("use_relative_parent=True")
+    return {"inherit": flags} if flags else {}
+
+
+def _bone_constraints(pchan):
+    """A pose bone's constraint stack, in order. Every constraint is named with its type; the ones
+    the presenter evaluates (Damped Track) carry what it needs."""
+    stack = []
+    for con in pchan.constraints:
+        entry = {"name": con.name, "type": con.type, "enabled": bool(con.enabled),
+                 "influence": float(con.influence)}
+        target = getattr(con, "target", None)
+        if target is not None:
+            entry["target"] = target.name
+            subtarget = getattr(con, "subtarget", "")
+            if subtarget:
+                entry["subtarget"] = subtarget
+        if con.type == "DAMPED_TRACK":
+            entry["trackAxis"] = con.track_axis
+            entry["headTail"] = float(con.head_tail)
+        stack.append(entry)
+    return {"constraints": stack} if stack else {}
+
+
+def _strip_influence_curve(strip):
+    """A strip's keyed influence (`NlaStrip.fcurves`, data path `influence`), whole, so the
+    presenter evaluates it at every frame as `nlastrip_evaluate_controls` does."""
+    if not strip.use_animated_influence:
+        return {}
+    for fcurve in strip.fcurves:
+        if fcurve.data_path == "influence":
+            return {"influenceCurve": _curve_body(fcurve)}
+    return {}
+
+
+def _armature_animation(obj):
+    """THE ARMATURE'S ANIMATION STACK as Blender evaluates it (`BKE_animsys_evaluate_animdata`):
+    its NLA tracks bottom to top, then the active action over them, each with its influence and
+    blend type. Strip timing is Blender's own (`nlastrip_get_frame`), so it is sent whole."""
+    adt = obj.animation_data
+    if adt is None:
+        return {}
+    tracks = []
+    for track in adt.nla_tracks:
+        strips = []
+        for strip in track.strips:
+            strips.append({
+                "name": strip.name, "type": strip.type,
+                "action": strip.action.name if strip.action is not None else None,
+                "start": float(strip.frame_start), "end": float(strip.frame_end),
+                "actionStart": float(strip.action_frame_start), "actionEnd": float(strip.action_frame_end),
+                "scale": float(strip.scale), "repeat": float(strip.repeat),
+                "influence": float(strip.influence), "animatedInfluence": bool(strip.use_animated_influence),
+                **_strip_influence_curve(strip),
+                "animatedTime": bool(strip.use_animated_time),
+                "blendIn": float(strip.blend_in), "blendOut": float(strip.blend_out),
+                "blendType": strip.blend_type, "extrapolation": strip.extrapolation,
+                "reversed": bool(strip.use_reverse), "mute": bool(strip.mute),
+            })
+        tracks.append({"name": track.name, "mute": bool(track.mute), "solo": bool(track.is_solo),
+                       "strips": strips})
+    drivers = sorted({match.group(1) for match in (_BONE_PATH.match(fc.data_path) for fc in adt.drivers)
+                      if match is not None})
+    return {"animation": {
+        "useNla": bool(adt.use_nla),
+        "influence": float(adt.action_influence),
+        "blendType": adt.action_blend_type,
+        "extrapolation": adt.action_extrapolation,
+        "tweak": bool(adt.use_tweak_mode),
+        "tracks": tracks,
+        **({"drivers": drivers} if drivers else {}),
+    }}
+
+
 def _locked_weight_groups(view_layer):
     """The vertex groups `BONE_DRAW_LOCKED_WEIGHT` is read from.
 
@@ -1378,6 +1484,7 @@ def _armatures(view_layer):
             "action": (obj.animation_data.action.name
                        if obj.animation_data is not None and obj.animation_data.action is not None
                        else None),
+            **_armature_animation(obj),
         }
     return armatures
 
@@ -1651,6 +1758,9 @@ class Session:
         # THE SCENE'S CLOCK beside the frame number: what a Timeline draws and a mixer maps time by.
         frame["clock"] = {"start": int(scene.frame_start), "end": int(scene.frame_end),
                           "fps": float(scene.render.fps) / float(scene.render.fps_base or 1.0)}
+        # ACTIONS NOTHING KEEPS: no user and no fake user, so the next save drops them (Blender's own
+        # rule). A game that plays one is told before it vanishes.
+        frame["unkeptActions"] = sorted(a.name for a in bpy.data.actions if a.users == 0 and not a.use_fake_user)
         frame["weights"] = _weights(scene, view_layer, frame, self._known)
         warnings = list(frame.get("warnings", ()))
         warnings.extend(_WARNINGS)
@@ -3853,6 +3963,13 @@ def rna_context(object_name=None, collection_path=None):
 # list longer than _OUTLINER_PAGE answers its first page and says how many more
 # there are, so a scene of 20,000 objects cannot turn one read into a
 # 20,000-row payload.
+#
+# AND THE READ COSTS WHAT IT SHOWS, not what the scene holds: an object's row
+# and its expansion are built only once the page has kept its place
+# (`rna_outliner`). The ids do not move for it. An id's ordinal is the number of
+# rows that claimed the same address before it in the WHOLE tree's order, kept
+# rows or not, and `_OutlinerScope` answers that count for a kept object's rows
+# from what every earlier object would have claimed.
 
 _OUTLINER_PAGE = 64
 
@@ -4191,6 +4308,60 @@ def _outliner_object(obj, view_layer, seen, chosen, active):
     return row
 
 
+def _outliner_preorder(row, out):
+    """A built row and everything under it, IN THE ORDER THEY CLAIMED THEIR IDS:
+    every builder above makes a row before its children, and its children in
+    list order, so the claim order is the tree's pre-order."""
+    out.append(row)
+    for child in row["children"]:
+        _outliner_preorder(child, out)
+    return out
+
+
+class _OutlinerScope:
+    """THE COUNTS ONE KEPT OBJECT'S ROWS CLAIM AGAINST, in `_outliner_unique`'s
+    own `seen` shape (`get`, item assignment).
+
+    Every address an object's expansion claims is one of three kinds, and two
+    of them never need the rows that came before to be built:
+
+      - under the OBJECT's own address (`.animation_data`, `.pose`, its pose
+        bones, `.constraints`, `.modifiers`, `.particle_systems`,
+        `.vertex_groups`): only that object's expansions claim it, so the
+        count before is how many times the object was expanded before;
+      - under its DATA's or the data's shape keys' address (the data row,
+        key blocks, bones, bone collections): only expansions of that data
+        claim it -- bones only outside Pose Mode -- so the count before is
+        how many times the data was expanded before;
+      - anything else (the object row itself, materials, a modifier's linked
+        object or node group, an instanced collection) is shared with any
+        row in the tree, and its count is the tree's own, in `seen`."""
+
+    def __init__(self, seen, scopes):
+        self.seen = seen
+        # (prefix, exact address, count before), most specific first.
+        self.scopes = scopes
+        self.local = {}
+
+    def _before(self, path):
+        if path is not None:
+            for prefix, address, before in self.scopes:
+                if path == address or path.startswith(prefix):
+                    return before
+        return None
+
+    def get(self, path, default=0):
+        if path in self.local:
+            return self.local[path]
+        before = self._before(path)
+        return self.seen.get(path, default) if before is None else before
+
+    def __setitem__(self, path, count):
+        self.local[path] = count
+        if self._before(path) is None:
+            self.seen[path] = count
+
+
 # ---- the node editor's tree ------------------------------------------------
 #
 # THE ONE READ A NODE VIEW NEEDS. The generic `rna_view` door answers every one
@@ -4897,8 +5068,12 @@ def rna_action_clip(object_name=None, bake=True, action_name=None):
     adt = arm_obj.animation_data if arm_obj is not None else None
     assigned = adt.action if adt is not None else None
     if arm_obj is None or (assigned is None and not action_name):
-        header["reason"] = ("Nothing here carries an action: the Timeline draws the scene range "
-                            "and an empty summary row, which is Blender's own empty state.")
+        # NLA STRIPS PLAY WITHOUT AN ACTIVE ACTION, and the Timeline's summary row draws only the
+        # active action's keys, as Blender's does; so the empty state is said only when nothing plays.
+        strips = adt is not None and any(len(track.strips) for track in adt.nla_tracks)
+        if not strips:
+            header["reason"] = ("Nothing here carries an action: the Timeline draws the scene range "
+                                "and an empty summary row, which is Blender's own empty state.")
         return header
     action = assigned
     slot = getattr(adt, "action_slot", None) if adt is not None else None
@@ -4937,16 +5112,28 @@ def rna_action_clip(object_name=None, bake=True, action_name=None):
     if not bake:
         return header
     frames = sorted(columns)
-    first = int(math.floor(frames[0]))
-    last = int(math.ceil(frames[-1]))
+    # THE ACTION'S OWN RANGE (`Action.frame_range`: its keys, or its manual range) with its keys:
+    # what a strip or the action line plays, sampled through `FCurve.evaluate`, which applies the
+    # curves' extrapolation and modifiers (a Cycles modifier repeats them) as Blender does.
+    span = getattr(action, "frame_range", None)
+    first = int(math.floor(min(frames[0], span[0] if span is not None else frames[0])))
+    last = int(math.ceil(max(frames[-1], span[1] if span is not None else frames[-1])))
     if last <= first:
         last = first + 1
     header["clipStart"] = first
     header["clipEnd"] = last
+    # THE RANGE BLENDER PLACES THE ACTIVE ACTION OVER over NLA strips (`calc_action_range` with
+    # modifiers): its keys, opened to either side a Cycles modifier repeats into (null: unbounded).
+    # A manual frame range does not enter it. Measured: a cycling action is not held at its end.
+    header["keysStart"], header["keysEnd"] = _action_key_range(action, first, last)
     channels = {}
+    others = set()
     for fcurve in curves:
         match = _BONE_PATH.match(fcurve.data_path)
         if match is None:
+            # NOT A BONE'S CHANNEL: the armature object's own transform (root motion), a custom
+            # property, a bone channel this door does not read. Named, so it is never dropped quietly.
+            others.add(fcurve.data_path)
             continue
         bone, prop = match.group(1), match.group(2)
         channels.setdefault((bone, prop), {})[int(fcurve.array_index)] = fcurve
@@ -4955,61 +5142,19 @@ def rna_action_clip(object_name=None, bake=True, action_name=None):
                             "door does not play (object transform, shape keys, a material). The "
                             "Timeline still draws its keys." % (action.name,))
         return header
-    rest_relative = {}
-    for pchan in _pose_bones_parents_first(arm_obj):
-        local = pchan.bone.matrix_local
-        parent = pchan.parent
-        rest_relative[pchan.name] = (parent.bone.matrix_local.inverted_safe() @ local
-                                     if parent is not None else local.copy())
-    times = [(frame - first) / fps for frame in range(first, last + 1)]
     tracks = []
     unplayed = []
-    for bone in sorted({name for name, _ in channels}):
-        pchan = arm_obj.pose.bones.get(bone)
-        if pchan is None:
+    for (bone, prop) in sorted(channels):
+        if arm_obj.pose.bones.get(bone) is None:
             unplayed.append(bone)
             continue
-        rest = rest_relative[bone]
-        rotation_mode = pchan.rotation_mode
-        positions, quaternions, scales = [], [], []
-        previous = None
-        for frame in range(first, last + 1):
-            location = _sample(channels.get((bone, "location")), pchan.location, frame)
-            scale = _sample(channels.get((bone, "scale")), pchan.scale, frame, default=1.0)
-            if rotation_mode == "QUATERNION":
-                quat = mathutils.Quaternion(
-                    _sample(channels.get((bone, "rotation_quaternion")),
-                            pchan.rotation_quaternion, frame, size=4, default=None,
-                            identity=(1.0, 0.0, 0.0, 0.0)))
-            elif rotation_mode == "AXIS_ANGLE":
-                raw = _sample(channels.get((bone, "rotation_axis_angle")),
-                              pchan.rotation_axis_angle, frame, size=4, default=None,
-                              identity=(0.0, 0.0, 1.0, 0.0))
-                quat = mathutils.Quaternion(raw[1:4], raw[0])
-            else:
-                quat = mathutils.Euler(
-                    _sample(channels.get((bone, "rotation_euler")), pchan.rotation_euler, frame),
-                    rotation_mode).to_quaternion()
-            basis = mathutils.Matrix.LocRotScale(mathutils.Vector(location), quat,
-                                                 mathutils.Vector(scale))
-            position, rotation, scaling = (rest @ basis).decompose()
-            # QUATERNION CONTINUITY, and it is not cosmetic: three's
-            # `QuaternionLinearInterpolant` takes the shorter arc between
-            # NEIGHBOURING samples, so one sign flip in the middle of a bake
-            # spins the bone the long way round for a frame.
-            if previous is not None and rotation.dot(previous) < 0.0:
-                rotation.negate()
-            previous = rotation.copy()
-            positions.extend((position.x, position.y, position.z))
-            quaternions.extend((rotation.x, rotation.y, rotation.z, rotation.w))
-            scales.extend((scaling.x, scaling.y, scaling.z))
-        tracks.extend(_track(bone, "position", times, positions, 3))
-        tracks.extend(_track(bone, "quaternion", times, quaternions, 4))
-        tracks.extend(_track(bone, "scale", times, scales, 3))
+        for index, fcurve in sorted(channels[(bone, prop)].items()):
+            tracks.append(_curve(bone, prop, index, fcurve))
+    if others:
+        header["unsupported"] = ["curves on %s" % ", ".join(sorted(others))]
     header.update({
         "tracks": tracks,
         "duration": (last - first) / fps,
-        "sampled": len(times),
         "unplayedBones": unplayed,
     })
     return header
@@ -5022,52 +5167,94 @@ _KEY_TYPE_RANK = {"JITTER": 1, "GENERATED": 2, "MOVING_HOLD": 3, "BREAKDOWN": 4,
                   "KEYFRAME": 5, "EXTREME": 6}
 
 
-def _sample(group, current, frame, size=3, default=0.0, identity=None):
-    """One channel's value at `frame`: each component's own F-Curve where there
-    is one, and the pose channel's CURRENT value where there is not -- which is
-    what Blender does too (an unkeyed component simply keeps its value)."""
-    fallback = list(identity) if identity is not None else [
-        (current[i] if current is not None and i < len(current) else default) for i in range(size)]
-    if identity is not None and current is not None and group is not None:
-        fallback = [float(v) for v in current]
-    if group is None:
-        return fallback
-    out = list(fallback)
-    for index, fcurve in group.items():
-        if 0 <= index < len(out):
-            out[index] = float(fcurve.evaluate(frame))
-    return out
-
+_INTERPOLATION = {"CONSTANT": 0, "LINEAR": 1, "BEZIER": 2}
+_CYCLE_MODE = {"NONE": 0, "REPEAT": 1, "REPEAT_OFFSET": 2, "MIRROR": 3}
 
-def _track(bone, prop, times, values, stride):
-    """One three.js keyframe track, or two keys when nothing moves.
-
-    The arrays cross as base64 Float32 (`timeBase64`, `valueBase64`), the shape
-    every large payload in this file takes."""
-    count = len(times)
-    constant = True
-    for i in range(1, count):
-        for c in range(stride):
-            if abs(values[i * stride + c] - values[c]) > 1e-6:
-                constant = False
-                break
-        if not constant:
-            break
-    if constant:
-        if count == 0:
-            return []
-        times = [times[0], times[-1]]
-        values = values[0:stride] * 2
-    return [{
-        "bone": bone,
-        "property": prop,
-        "stride": stride,
-        "count": len(times),
-        "constant": constant,
-        "timeBase64": base64.b64encode(array.array("f", times).tobytes()).decode("ascii"),
-        "valueBase64": base64.b64encode(array.array("f", values).tobytes()).decode("ascii"),
-    }]
 
+def _action_key_range(action, first, last):
+    """`Action::get_frame_range_of_keys(true)` (`action.cc`, `get_frame_range_of_fcurves`): every
+    F-Curve of the WHOLE action (every layer, strip and slot) widens the range by its keys, and only
+    its LAST modifier counts: Limits widens it by its set X limits, Cycles opens each side its mode
+    repeats into, any other type opens both sides. Mute is not read. None is an open side."""
+    low, high = None, None
+    opened_low = opened_high = False
+    curves = list(getattr(action, "fcurves", None) or ())
+    for layer in getattr(action, "layers", ()):
+        for strip in getattr(layer, "strips", ()):
+            for bag in (getattr(strip, "channelbags", None) or ()):
+                curves.extend(bag.fcurves)
+    # A curve's keys and its last modifier count independently: a keyless curve carrying a
+    # Generator or Noise still opens the range, as in Blender.
+    limits = []
+    for fcurve in curves:
+        points = fcurve.keyframe_points
+        if len(points):
+            frames = [float(key.co[0]) for key in points]
+            low = min(frames) if low is None else min(low, min(frames))
+            high = max(frames) if high is None else max(high, max(frames))
+        if not len(fcurve.modifiers):
+            continue
+        modifier = fcurve.modifiers[-1]
+        if modifier.type == "LIMITS":
+            limits.append(modifier)
+        elif modifier.type == "CYCLES":
+            opened_low = opened_low or modifier.mode_before != "NONE"
+            opened_high = opened_high or modifier.mode_after != "NONE"
+        else:
+            opened_low = opened_high = True
+    if low is None:
+        low, high = first, last
+    for modifier in limits:
+        if modifier.use_min_x:
+            low = min(low, float(modifier.min_x))
+        if modifier.use_max_x:
+            high = max(high, float(modifier.max_x))
+    return (None if opened_low else low), (None if opened_high else high)
+
+
+def _curve(bone, prop, index, fcurve):
+    """One bone channel's F-Curve: its address and its body (`_curve_body`)."""
+    return {"bone": bone, "property": prop, "index": index, **_curve_body(fcurve)}
+
+
+def _curve_body(fcurve):
+    """ONE F-CURVE, whole: its keys and handles, how each segment interpolates, its extrapolation
+    and its Cycles modifier, which is everything `fcurve_eval_keyframes` and `fcm_cycles_time` read
+    to evaluate it. The presenter evaluates it as they do, at any frame, fractional or not.
+
+    The keys cross as base64 Float32, six per key: `co`, `handle_left`, `handle_right`
+    (frame, value each). A segment whose interpolation is one of the easing types (Back, Bounce,
+    Elastic, Sine, ...) and any modifier other than Cycles are named rather than played."""
+    keys = array.array("f")
+    interpolation = []
+    unsupported = []
+    for key in fcurve.keyframe_points:
+        keys.extend((key.co[0], key.co[1], key.handle_left[0], key.handle_left[1],
+                     key.handle_right[0], key.handle_right[1]))
+        code = _INTERPOLATION.get(key.interpolation)
+        if code is None:
+            unsupported.append("%s interpolation" % key.interpolation.lower())
+            code = 1
+        interpolation.append(code)
+    cycles = None
+    for modifier in fcurve.modifiers:
+        if modifier.mute:
+            continue
+        if modifier.type == "CYCLES" and not modifier.use_restricted_range and not modifier.use_influence:
+            cycles = [_CYCLE_MODE.get(modifier.mode_before, 0), int(modifier.cycles_before),
+                      _CYCLE_MODE.get(modifier.mode_after, 0), int(modifier.cycles_after)]
+        else:
+            unsupported.append("%s modifier" % modifier.type.lower())
+    out = {
+        "extrapolation": fcurve.extrapolation,
+        "interpolation": interpolation,
+        "keysBase64": base64.b64encode(keys.tobytes()).decode("ascii"),
+    }
+    if cycles is not None:
+        out["cycles"] = cycles
+    if unsupported:
+        out["unsupported"] = sorted(set(unsupported))
+    return out
 
 def rna_outliner(selected=None):
     """BLENDER'S VIEW LAYER TREE for the session's scene.
@@ -5092,10 +5279,16 @@ def rna_outliner(selected=None):
     engine_active = view_layer.objects.active
     active = engine_active.name if engine_active is not None else None
     seen = {}
-    # Every object row, with the row it sits under and the COLLECTION row it
+    # Every object's PLACE, with the row it sits under and the COLLECTION row it
     # belongs to -- what `ObjectsChildrenBuilder`'s map holds, and what the
-    # parent walk below moves.
+    # parent walk below moves. A place is not a row yet: `{"place": obj,
+    # "name", "children"}`, where `children` are the child objects the fold
+    # hangs under it. The page decides which places become rows.
     placements = {}
+    # Every place, in the order the whole tree's rows claim their ids: each
+    # collection's row, its child collections, then its objects, depth first.
+    occurrences = []
+    collections = []
 
     def place(obj, row, collection_row):
         placements.setdefault(obj.name, []).append([row, collection_row, collection_row])
@@ -5122,10 +5315,12 @@ def rna_outliner(selected=None):
             # Fold parenting before paging: a parent may follow its children in
             # collection order, and must not disappear behind the flat cap.
             for obj in collection.objects:
-                object_row = _outliner_object(obj, view_layer, seen, chosen, active)
-                place(obj, object_row, row)
-                children.append(object_row)
+                spot = {"place": obj, "name": obj.name, "children": []}
+                occurrences.append(spot)
+                place(obj, spot, row)
+                children.append(spot)
         row["children"] = children
+        collections.append(row)
         return row
 
     scene_collection = _outliner_row(
@@ -5138,10 +5333,12 @@ def rna_outliner(selected=None):
                                              child.collection.name))
                 for child in root.children]
     for obj in root.collection.objects:
-        object_row = _outliner_object(obj, view_layer, seen, chosen, active)
-        place(obj, object_row, scene_collection)
-        children.append(object_row)
+        spot = {"place": obj, "name": obj.name, "children": []}
+        occurrences.append(spot)
+        place(obj, spot, scene_collection)
+        children.append(spot)
     scene_collection["children"] = children
+    collections.append(scene_collection)
 
     # `ObjectsChildrenBuilder::make_object_parent_hierarchy_collections`, parents
     # before children: a child object is MOVED out of its collection's row and
@@ -5159,8 +5356,15 @@ def rna_outliner(selected=None):
             placed.add(obj.name)
             ordered.append(obj)
 
-    for name in list(placements):
-        order(bpy.data.objects[name])
+    # The placed object itself, not `bpy.data.objects[name]`: a lookup by name is
+    # a walk of the whole ID list, and one per object made this loop quadratic
+    # (43 ms of a 1,490-object read).
+    for entries in list(placements.values()):
+        order(entries[0][0]["place"])
+    # A move takes the place out of its collection's list; the lists are
+    # filtered once below rather than searched once per move (`list.remove`).
+    moved = set()
+    duplicates = []
     for obj in ordered:
         if obj.parent is None:
             continue
@@ -5169,24 +5373,25 @@ def rna_outliner(selected=None):
         if not parents or not mine:
             continue
         for parent_row, _parent_owner, parent_collection in parents:
-            moved = False
+            moved_here = False
             for entry in mine:
                 row, owner, _collection = entry
                 if owner is not parent_collection:
                     continue
-                owner["children"].remove(row)
+                moved.add(id(row))
                 parent_row["children"].append(row)
                 entry[1] = parent_row
-                moved = True
+                moved_here = True
                 break
-            if moved:
+            if moved_here:
                 continue
-            duplicate = _outliner_row(
-                _rna_address(obj), obj.name, "TSE_SOME_ID", _outliner_object_icon(obj), seen,
-                struct="Object", objectType=obj.type, object=obj.name,
-                selected=obj.name in chosen, active=obj.name == active, notInCollection=True)
+            duplicate = {"place": obj, "name": obj.name, "children": [], "duplicate": True}
+            duplicates.append(duplicate)
             parent_row["children"].append(duplicate)
             mine.append([duplicate, parent_row, parent_collection])
+    if moved:
+        for row in collections:
+            row["children"] = [child for child in row["children"] if id(child) not in moved]
 
     # THE SELECTION KEEPS ITS ROWS PAST THE PAGE. A row is how the editor
     # addresses an object -- the viewport's outline and gizmo, the Properties
@@ -5196,18 +5401,20 @@ def rna_outliner(selected=None):
     # page of the selection, so selecting everything cannot turn one read back
     # into the whole tree the page exists to keep out (Canyon Comet, 1,493
     # objects selected: 1.77 MB a read uncapped, 142 KB capped).
+    # The caller's choice comes before the rest of the engine's selection: a click
+    # onto a selection already larger than a page keeps the object just clicked.
     wanted = [active] if active is not None else []
-    wanted += [o.name for o in view_layer.objects if o.select_get(view_layer=view_layer)]
     wanted += sorted(chosen)
+    wanted += [o.name for o in view_layer.objects if o.select_get(view_layer=view_layer)]
     kept = set()
     for name in wanted:
-        if len(kept) > _OUTLINER_PAGE:
+        if len(kept) >= _OUTLINER_PAGE:
             break
         kept.add(name)
     holding = set()
 
     def hold(row):
-        inside = row.get("struct") == "Object" and row.get("object") in kept
+        inside = "place" in row and row["name"] in kept
         for child in row.get("children", []):
             inside = hold(child) or inside
         if inside:
@@ -5216,13 +5423,36 @@ def rna_outliner(selected=None):
 
     hold(scene_collection)
 
+    # A PLACE THE PAGE KEEPS BECOMES ITS ROW: the object's own row and the
+    # expansion `TreeElementIDObject::expand` hangs under it, then the child
+    # objects the fold put there, in that order. Its ids are claimed below, in
+    # the whole tree's order; `claims` is the expansion's own claim order.
+    scratch = {}
+
+    def kept_row(spot):
+        if "place" not in spot:
+            return spot
+        obj = spot["place"]
+        if spot.get("duplicate"):
+            row = _outliner_row(
+                _rna_address(obj), obj.name, "TSE_SOME_ID", _outliner_object_icon(obj), scratch,
+                struct="Object", objectType=obj.type, object=obj.name,
+                selected=obj.name in chosen, active=obj.name == active, notInCollection=True)
+            spot["claims"] = [row]
+        else:
+            row = _outliner_object(obj, view_layer, scratch, chosen, active)
+            spot["claims"] = _outliner_preorder(row, [])
+        row["children"] = row["children"] + spot["children"]
+        spot["row"] = row
+        return row
+
     # Cap the hierarchy's visible child lists, not the collection's flat input.
     # Every parent participates in folding even when its child list needs a page.
     def page_tree(row):
         members = row.get("children", [])
         children, more = _outliner_page(members)
         beyond = [child for child in members[len(children):] if id(child) in holding]
-        children = children + beyond
+        children = [kept_row(child) for child in children + beyond]
         row["children"] = children
         if more - len(beyond):
             row["more"] = more - len(beyond)
@@ -5231,6 +5461,90 @@ def rna_outliner(selected=None):
 
     page_tree(scene_collection)
 
+    # THE IDS, CLAIMED IN THE WHOLE TREE'S ORDER as if every object had been
+    # built: a kept object's rows claim through `_OutlinerScope`; an object the
+    # page left behind adds only what it would have claimed that a later row
+    # can share -- its own address, its materials, its modifiers' linked
+    # datablocks, its instanced collection -- and one more expansion of itself
+    # and of its data. Data with no address of its own claims its rows the
+    # long way, every one in the shared count.
+    addresses = {}
+
+    def address(datablock):
+        key = datablock.as_pointer()
+        if key not in addresses:
+            addresses[key] = _rna_address(datablock)
+        return addresses[key]
+
+    def bump(path):
+        seen[path] = seen.get(path, 0) + 1
+
+    expanded = {}
+    data_expanded = {}
+    bones_expanded = {}
+    for spot in occurrences:
+        obj = spot["place"]
+        object_key = obj.as_pointer()
+        object_path = address(obj)
+        data = obj.data
+        exact = object_path is None
+        scopes = [] if exact else [(object_path + ".", None, expanded.get(object_key, 0))]
+        data_key = bones = None
+        if data is not None:
+            data_key = data.as_pointer()
+            data_path = address(data)
+            keys = getattr(data, "shape_keys", None)
+            keys_path = address(keys) if keys is not None else None
+            exact = exact or data_path is None or (keys is not None and keys_path is None)
+            bones = isinstance(data, bpy.types.Armature) and obj.mode != "POSE"
+            if not exact:
+                before = data_expanded.get(data_key, 0)
+                scopes += [(data_path + ".bones[", None, bones_expanded.get(data_key, 0)),
+                           (data_path + ".", data_path, before)]
+                if keys_path is not None:
+                    scopes.append((keys_path + ".", keys_path, before))
+        if exact:
+            scopes = []
+        row = spot.get("row")
+        if row is not None or exact:
+            # Built rows, or the long way for data the scopes cannot name.
+            scope = _OutlinerScope(seen, scopes)
+            if row is None:
+                _outliner_object(obj, view_layer, scope, chosen, active)
+            else:
+                for claimed in spot["claims"]:
+                    claimed["id"] = _outliner_unique(claimed["path"], scope)
+        else:
+            bump(object_path)
+            if data is not None:
+                for material in getattr(data, "materials", ()) or ():
+                    if material is not None:
+                        bump(address(material))
+            for slot in obj.material_slots:
+                if slot.material is not None:
+                    bump(address(slot.material))
+            for md in obj.modifiers:
+                for member in ("object", "node_group"):
+                    linked = getattr(md, member, None)
+                    if linked is None:
+                        continue
+                    linked_path = address(linked)
+                    if linked_path:
+                        bump(linked_path)
+                    break
+            if obj.instance_collection is not None and obj.instance_type == "COLLECTION":
+                bump(address(obj.instance_collection))
+        expanded[object_key] = expanded.get(object_key, 0) + 1
+        if data_key is not None:
+            data_expanded[data_key] = data_expanded.get(data_key, 0) + 1
+            if bones:
+                bones_expanded[data_key] = bones_expanded.get(data_key, 0) + 1
+    # The fold's duplicates claim after every collection's objects, as they are made.
+    for spot in duplicates:
+        claimed = _outliner_unique(address(spot["place"]), seen)
+        if "row" in spot:
+            spot["row"]["id"] = claimed
+
     return {
         "scene": scene_path,
         "viewLayer": view_layer_path,

package/browser/three/blender-runtime-armature.ts

@@ -33,6 +33,7 @@ import { LineSegmentsGeometry } from 'three/addons/lines/LineSegmentsGeometry.js
 import { z } from 'zod';
 
 const scalar = z.number().finite();
+const matrixSchema = z.array(z.tuple([scalar, scalar, scalar, scalar])).length(4);
 
 /** ONE BONE, as `session.py`'s `_armature_bones` answers it. */
 export const boneSchema = z
@@ -49,9 +50,76 @@ export const boneSchema = z
     select: z.boolean(),
     active: z.boolean(),
     lockedWeight: z.boolean(),
+    /** `Bone.matrix_local`, the rest matrix in the armature's space. */
+    rest: matrixSchema.optional(),
+    /** The channels' own values: what a channel no action animates keeps. */
+    channels: z.object({
+      mode: z.string(),
+      location: z.array(scalar).length(3),
+      rotation_quaternion: z.array(scalar).length(4),
+      rotation_euler: z.array(scalar).length(3),
+      rotation_axis_angle: z.array(scalar).length(4),
+      scale: z.array(scalar).length(3),
+    }).strict().optional(),
+    /** Parenting flags that are not Blender's default, by name. */
+    inherit: z.array(z.string()).optional(),
+    /** The bone's constraint stack, in order. */
+    constraints: z.array(z.object({
+      name: z.string(),
+      type: z.string(),
+      enabled: z.boolean(),
+      influence: scalar,
+      target: z.string().optional(),
+      subtarget: z.string().optional(),
+      trackAxis: z.string().optional(),
+      headTail: scalar.optional(),
+    }).strict()).optional(),
   })
   .strict();
 
+/** One NLA strip, as `session.py`'s `_armature_animation` answers it. */
+export const nlaStripSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  action: z.string().nullable(),
+  start: scalar,
+  end: scalar,
+  actionStart: scalar,
+  actionEnd: scalar,
+  scale: scalar,
+  repeat: scalar,
+  influence: scalar,
+  animatedInfluence: z.boolean(),
+  /** The keyed influence's F-Curve, when `animatedInfluence`. */
+  influenceCurve: z.object({
+    extrapolation: z.string(),
+    interpolation: z.array(z.number()),
+    keysBase64: z.string(),
+    cycles: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+    unsupported: z.array(z.string()).optional(),
+  }).strict().optional(),
+  animatedTime: z.boolean(),
+  blendIn: scalar,
+  blendOut: scalar,
+  blendType: z.string(),
+  extrapolation: z.string(),
+  reversed: z.boolean(),
+  mute: z.boolean(),
+}).strict();
+
+/** An armature's animation stack: NLA tracks bottom to top, then the active action over them. */
+export const armatureAnimationSchema = z.object({
+  useNla: z.boolean(),
+  influence: scalar,
+  blendType: z.string(),
+  extrapolation: z.string(),
+  /** The NLA is in tweak mode (`use_tweak_mode`), which the presenter does not play. */
+  tweak: z.boolean().optional(),
+  tracks: z.array(z.object({ name: z.string(), mute: z.boolean(), solo: z.boolean(), strips: z.array(nlaStripSchema) }).strict()),
+  /** Bones whose channels a driver sets. */
+  drivers: z.array(z.string()).optional(),
+}).strict();
+
 export const armatureSchema = z
   .object({
     object: z.string(),
@@ -63,10 +131,14 @@ export const armatureSchema = z
     bones: z.array(boneSchema),
     /** `animation_data.action`, the action it plays (`session.py` `_armatures`). */
     action: z.string().nullable().optional(),
+    animation: armatureAnimationSchema.optional(),
   })
   .strict();
 
 export type BlenderArmature = z.infer<typeof armatureSchema>;
+export type BlenderArmatureBone = z.infer<typeof boneSchema>;
+export type BlenderArmatureAnimation = z.infer<typeof armatureAnimationSchema>;
+export type BlenderNlaStrip = z.infer<typeof nlaStripSchema>;
 type Bone = z.infer<typeof boneSchema>;
 
 /**

package/browser/three/blender-runtime-skeleton.ts

@@ -193,6 +193,8 @@ export class RuntimeSkeletons {
       return world.invert();
     });
     mesh.updateWorldMatrix(true, false);
+    // A re-export rebinds the same mesh: its old skeleton's bone texture goes with it.
+    (skinned.skeleton as THREE.Skeleton | undefined)?.dispose();
     skinned.bind(new THREE.Skeleton(bones, inverses), mesh.matrixWorld.clone());
     return skinned;
   }

package/browser/three/blender-runtime-view.ts

@@ -7,7 +7,7 @@ import * as THREE from 'three';
 import { z } from 'zod';
 import { onPresenterChange, presenterChanged } from './blender-presenter-change';
 import { bytesFromBase64 } from './blender-base64';
-import { ArmatureOverlay, armatureSchema } from './blender-runtime-armature';
+import { ArmatureOverlay, armatureSchema, type BlenderArmature } from './blender-runtime-armature';
 import { type FrameSkin, RuntimeSkeletons, skinGeometry } from './blender-runtime-skeleton';
 import { UNKNOWN_GEOMETRY, UNKNOWN_IMAGE } from './blender-runtime-frame';
 import {
@@ -607,6 +607,8 @@ export const frameSchema = z
     actions: z.record(z.string(), z.number().int().nonnegative()).default({}),
     /** The scene's frame range and rate (`session.py`), beside `frame`. */
     clock: z.object({ start: z.number().int(), end: z.number().int(), fps: z.number().finite().positive() }).strict().optional(),
+    /** Actions with no user and no fake user, which the next save drops. */
+    unkeptActions: z.array(z.string()).default([]),
     /** The active object's active vertex group, per vertex
      *  (`blender-runtime-weights.ts`); null when nothing is painted. */
     weights: weightsSchema.nullable().default(null),
@@ -1126,18 +1128,23 @@ export class BlenderRuntimeView {
   animationFacts(): {
     frame: number;
     clock: { start: number; end: number; fps: number } | null;
+    /** Actions the next save drops: no user and no fake user. */
+    unkept: readonly string[];
     active: string | null;
     actions: Readonly<Record<string, number>>;
-    armatures: Readonly<Record<string, { action: string | null }>>;
+    /** Each armature as the frame describes it: bones (rest, channels, constraints, Blender's own
+     *  pose), its action and its NLA stack. */
+    armatures: Readonly<Record<string, BlenderArmature>>;
     skinArmature(object: string): string | null;
   } {
     const frame = this.frame;
     return {
       frame: frame?.frame ?? 0,
       clock: frame?.clock ?? null,
+      unkept: frame?.unkeptActions ?? [],
       active: frame?.active ?? null,
       actions: frame?.actions ?? {},
-      armatures: Object.fromEntries(Object.entries(frame?.armatures ?? {}).map(([name, armature]) => [name, { action: armature.action ?? null }])),
+      armatures: frame?.armatures ?? {},
       skinArmature: (name) => {
         const object = this.objectForBlenderName(name) as THREE.Mesh | null;
         const skin = object?.geometry?.userData['blenderSkin'] as { armature: string } | undefined;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.134",
+  "version": "0.1.135",
   "publishConfig": {
     "access": "public"
   },

package/wasm/BUNDLE.json

@@ -45,6 +45,6 @@
   "note": "Emscripten 6.0.5, Release -O3 objects and -O2 link, retained public build recipe and dependency licenses. Scoped render-evaluated export preserves render-only geometry and render-specific modifier results without replacing the viewport export state. Prior geometry identity and memory fixes remain. Full-scene Three versus Cycles rendering parity remains incomplete.",
   "callTrampoline": "CPython 3.13.13 is compiled with PY_CALL_TRAMPOLINE for Blender CPython slot arity casts. This applies to CPython dispatch, not arbitrary indirect calls.",
   "engineIds": "The session preserves the compiled native CYCLES engine. VOLTER_THREE selects the explicit raster presenter; BLENDER_EEVEE and BLENDER_WORKBENCH remain presentation engines.",
-  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. Scoped begin_render_export/end_render_export reads the render engine depsgraph and isolates viewport revision, undo, deferred resource and image watcher state. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. A frame ships each armature-deformed mesh's skin with its geometry (write_skin: four joints and weights per drawn vertex by the armature's deform bones, keyed by skin_digest so it is re-sent only when the binding changes) and each armature's assigned action (actions).",
+  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. Scoped begin_render_export/end_render_export reads the render engine depsgraph and isolates viewport revision, undo, deferred resource and image watcher state. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. A frame ships each armature-deformed mesh's skin with its geometry (write_skin: four joints and weights per drawn vertex by the armature's deform bones, keyed by skin_digest so it is re-sent only when the binding changes), every action in the file with its revision (actions), and each armature's assigned action.",
   "preloadedPayload": "releasePreloadedFileData releases the JS preload buffer after session ready. The measured working payload exclusions are retained."
 }