@volter/blender-engine 0.1.133 → 0.1.135

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.
 
@@ -1372,6 +1478,13 @@ def _armatures(view_layer):
             # `ARM_DRAW_MODE_*` switch, `:906-936`).
             "mode": obj.mode,
             "bones": _armature_bones(obj, locked),
+            # THE ACTION IT PLAYS (`animation_data.action`): what the presenter's mixer plays on
+            # this armature's skeleton, baked through the clip door at the revision the frame's
+            # `actions` names for it.
+            "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
 
@@ -1642,6 +1755,12 @@ class Session:
             "scale_length": float(scene.unit_settings.scale_length),
         }
         frame["armatures"] = _armatures(view_layer)
+        # 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)
@@ -3844,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
 
@@ -4182,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
@@ -4617,31 +4797,6 @@ def _matrix_rows(matrix):
     return [[float(v) for v in row] for row in matrix]
 
 
-def rna_rig(object_name=None):
-    """EVERY SKIN BINDING THE SCENE NEEDS -- or one named mesh's.
-
-    A LIST, not a singleton, and that is what the PRESENTER's question is: a
-    presented frame carries every object at once, and the presenter has to know
-    which of its meshes are `THREE.SkinnedMesh`es before it builds them. Asking
-    per object would be one round trip per mesh; asking by NAME stays available
-    for a `cyclotron eval` that wants to read one.
-    """
-    scene_frame = int(bpy.context.scene.frame_current)
-    if object_name:
-        obj = bpy.data.objects.get(object_name)
-        if obj is None:
-            raise ValueError("The engine holds no object named %r" % (object_name,))
-        subjects = [obj]
-    else:
-        subjects = [obj for obj in bpy.context.view_layer.objects
-                    if obj.type == "MESH" and obj.data is not None
-                    and obj.find_armature() is not None]
-    rigs = []
-    for obj in subjects:
-        _asked({"checkpoint": "rig-object"})
-        rigs.append(_rig_of(obj))
-    return {"frame": scene_frame, "named": object_name, "rigs": rigs}
-
 
 def _rig_of(obj):
     """ONE MESH'S SKIN BINDING: the armature's bones, and up to four weighted
@@ -4841,50 +4996,6 @@ def _summary_objects():
     return out
 
 
-def rna_armature_actions():
-    """EVERY ARMATURE AND THE ACTIONS THAT CAN PLAY ON IT -- what a game picks its clips from.
-
-    An action can play on an armature when it animates at least one of that armature's pose bones
-    (`pose.bones["<name>"]...` on a bone the armature has). Read off each action's F-Curves through
-    `_action_channelbag`, every channelbag, so an action assigned to nothing (a clip library: Idle,
-    Run, Attack beside each other in the file) is offered as well as the one each armature plays now.
-    READ ONLY."""
-    out = []
-    for arm in bpy.data.objects:
-        if arm.type != "ARMATURE" or arm.pose is None:
-            continue
-        bones = {pchan.name for pchan in arm.pose.bones}
-        current = arm.animation_data.action.name if (arm.animation_data and arm.animation_data.action) else None
-        names = []
-        keys, total = 0, 0.0
-        for action in bpy.data.actions:
-            curves = []
-            legacy = getattr(action, "fcurves", None)
-            if legacy is not None:
-                curves = list(legacy)
-            else:
-                for layer in getattr(action, "layers", ()):
-                    for strip in getattr(layer, "strips", ()):
-                        for bag in (getattr(strip, "channelbags", None) or ()):
-                            curves.extend(bag.fcurves)
-            if any((m := _BONE_PATH.match(fc.data_path)) is not None and m.group(1) in bones for fc in curves):
-                names.append(action.name)
-                # A CHEAP SIGNATURE of the keys, so a reader can tell a key edit from no change
-                # without baking: the count and the sum of every key's frame and value.
-                for fc in curves:
-                    for key in fc.keyframe_points:
-                        keys += 1
-                        total += float(key.co[0]) * 7.0 + float(key.co[1])
-        out.append({"armature": arm.name, "current": current, "actions": sorted(names),
-                    "keys": "%d:%.6f" % (keys, total)})
-    scene = bpy.context.scene
-    # THE SCENE'S CLOCK TOO: a reader that skips a re-bind on an unchanged listing must still see
-    # the playhead and range move when an agent sets them.
-    return {"armatures": out, "scene": {"frameCurrent": int(scene.frame_current),
-                                        "frameStart": int(scene.frame_start), "frameEnd": int(scene.frame_end),
-                                        "fps": float(scene.render.fps) / float(scene.render.fps_base or 1.0)}}
-
-
 def rna_action_clip(object_name=None, bake=True, action_name=None):
     """ONE ACTION AS A THREE.JS CLIP: per bone, the LOCAL transform it has at
     every integer frame of the action's own range.
@@ -4957,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
@@ -4997,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
@@ -5015,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
@@ -5082,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
-
-
-def _track(bone, prop, times, values, stride):
-    """One three.js keyframe track, or two keys when nothing moves.
+_INTERPOLATION = {"CONSTANT": 0, "LINEAR": 1, "BEZIER": 2}
+_CYCLE_MODE = {"NONE": 0, "REPEAT": 1, "REPEAT_OFFSET": 2, "MIRROR": 3}
 
-    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.
@@ -5152,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])
@@ -5182,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(
@@ -5198,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
@@ -5219,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
@@ -5229,37 +5373,178 @@ 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
+    # rail -- so a selected or active object, the caller's or the engine's, keeps
+    # its row and every row above it however far down a long list it sits.
+    # BOUNDED LIKE THE PAGE ITSELF: the active object always, then at most one
+    # 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 += 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:
+            break
+        kept.add(name)
+    holding = set()
+
+    def hold(row):
+        inside = "place" in row and row["name"] in kept
+        for child in row.get("children", []):
+            inside = hold(child) or inside
+        if inside:
+            holding.add(id(row))
+        return inside
+
+    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):
-        children, more = _outliner_page(row.get("children", []))
+        members = row.get("children", [])
+        children, more = _outliner_page(members)
+        beyond = [child for child in members[len(children):] if id(child) in holding]
+        children = [kept_row(child) for child in children + beyond]
         row["children"] = children
-        if more:
-            row["more"] = more
+        if more - len(beyond):
+            row["more"] = more - len(beyond)
         for child in children:
             page_tree(child)
 
     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,
@@ -5511,12 +5796,8 @@ def _dispatch(request):
     # THE RIG AND CLIP DOORS (the Timeline): both READS, so neither presents
     # and neither owes a derivation. There is deliberately no writer beside
     # them -- keying, moving a key and setting a range are edits.
-    if op == "rig":
-        return rna_rig(request.get("object"))
     if op == "action-clip":
         return rna_action_clip(request.get("object"), request.get("bake", True), request.get("action"))
-    if op == "armature-actions":
-        return rna_armature_actions()
     if op == "outliner":
         return rna_outliner(request.get("selected"))
     if op == "outliner-set":