"""Motion primitives on world-space pose tracks. Every edit is a rigid rotation of a joint subtree or an IK solve with fixed bone lengths, so bone lengths never drift. A Track holds one entity over the whole shot: poses (T, J, 3) world cm weapon (T, 2, 3) grip end, tip end (or None) Primitives take frame ranges [t0, t1) and edit the track in place; they compose left to right. """ import numpy as np from .geometry import rot_axis, rot_z, UP ease = lambda u: u * u * (3 - 2 * u) class Track: def __init__(self, skeleton, frames, root=(0, 0, None), yaw=0.0): self.sk = skeleton; self.T = frames r = np.array(root, dtype=object) z = skeleton.rest[0, 2] if root[2] is None else root[2] base = skeleton.place([float(root[0]), float(root[1]), float(z)], yaw) self.poses = np.repeat(base[None], frames, axis=0) self.yaw = np.full(frames, float(yaw)) self.weapon = None if skeleton.weapon is not None: self.attach_weapon(0, frames) # ------------------------------------------------------------------ helpers def j(self, name): return self.sk.index[name] def forward(self, t): return np.array([np.cos(self.yaw[t]), np.sin(self.yaw[t]), 0.0]) def right(self, t): return np.array([-np.sin(self.yaw[t]), np.cos(self.yaw[t]), 0.0]) # UE: +Y is right of +X def rotate_subtree(self, t, joint, R, pivot=None): """Rotate `joint`'s subtree about pivot (default the joint); a weapon held by a hand in the subtree rotates too.""" idx = self.sk.descendants(joint) p = self.poses[t, self.j(joint)] if pivot is None else np.asarray(pivot, float) self.poses[t, idx] = (self.poses[t, idx] - p) @ R.T + p if self._holds_weapon(idx): self.weapon[t] = (self.weapon[t] - p) @ R.T + p def _holds_weapon(self, idx): return self.weapon is not None and self.sk.weapon is not None and self.j(self.sk.weapon.hand) in idx def attach_weapon(self, t0, t1, direction=None, pitch_deg=35.0): """Weapon rigid in the hand: grip end behind the hand by grip_offset, pointing `direction` (world, per-frame callable or vector) or, by default, forward-up from the forearm (pitch_deg above the facing direction).""" w = self.sk.weapon; assert w is not None if self.weapon is None: self.weapon = np.zeros((self.T, 2, 3)) hand = self.j(w.hand) for t in range(t0, t1): if direction is None: d = self.forward(t) * np.cos(np.radians(pitch_deg)) + UP * np.sin(np.radians(pitch_deg)) else: d = np.asarray(direction(t) if callable(direction) else direction, float) d = d / np.linalg.norm(d) butt = self.poses[t, hand] - d * w.grip_offset self.weapon[t] = [butt, butt + d * w.length] def carry_weapon_rigidly(self, t0, t1, joint=None): """Keep the weapon's pose relative to `joint` (default the hand) as it was at t0 - 1, translating with the joint and rotating with the subtree yaw -- use after primitives that move the hand.""" joint = joint or self.sk.weapon.hand ref = max(t0 - 1, 0); h = self.j(joint) rel = self.weapon[ref] - self.poses[ref, h]; yaw0 = self.yaw[ref] for t in range(t0, t1): self.weapon[t] = self.poses[t, h] + rel @ rot_z(self.yaw[t] - yaw0).T # ---------------------------------------------------------------- whole body def translate(self, t0, t1, offset): off = np.asarray(offset, float) self.poses[t0:t1] += off if self.weapon is not None: self.weapon[t0:t1] += off def freeze(self, t0, t1=None, at=None): """Hold the pose (and weapon) of frame `at` (default t0) for [t0, t1).""" t1 = self.T if t1 is None else t1; at = t0 if at is None else at self.poses[t0:t1] = self.poses[at]; self.yaw[t0:t1] = self.yaw[at] if self.weapon is not None: self.weapon[t0:t1] = self.weapon[at] def turn(self, t0, t1, dyaw, hold=True): """Rotate about the root's vertical axis by dyaw (rad), eased over [t0, t1); frames after t1 keep the new facing if hold.""" end = self.T if hold else t1 for t in range(t0, end): a = dyaw * (ease((t - t0) / max(1, t1 - t0)) if t < t1 else 1.0) R = rot_z(a); p = self.poses[t, 0].copy() self.poses[t] = (self.poses[t] - p) @ R.T + p if self.weapon is not None: self.weapon[t] = (self.weapon[t] - p) @ R.T + p self.yaw[t] += a def move_root_path(self, t0, t1, waypoints, face_motion=True, hold=True): """Carry the whole body along a polyline of world xy waypoints (first = current root xy), eased by arc length. Faces the direction of travel when face_motion. Legs are not animated here -- use gait() afterwards.""" wp = np.asarray(waypoints, float) seglen = np.linalg.norm(np.diff(wp, axis=0), axis=1); cum = np.r_[0, np.cumsum(seglen)]; total = cum[-1] start_xy = self.poses[t0, 0, :2].copy() def at(s): k = min(np.searchsorted(cum, s, side="right") - 1, len(seglen) - 1) return wp[k] + (wp[k + 1] - wp[k]) * ((s - cum[k]) / max(seglen[k], 1e-6)) end = self.T if hold else t1 for t in range(t0, end): u = ease((t - t0) / max(1, t1 - t0)) if t < t1 else 1.0 xy = at(u * total) self.translate(t, t + 1, [xy[0] - self.poses[t, 0, 0], xy[1] - self.poses[t, 0, 1], 0.0]) if face_motion and t < t1: ahead = at(min(total, u * total + 5.0)) - xy if np.linalg.norm(ahead) > 1e-3: target = np.arctan2(ahead[1], ahead[0]) d = (target - self.yaw[t] + np.pi) % (2 * np.pi) - np.pi self.turn(t, t + 1, d, hold=False) if t + 1 < self.T: self.yaw[t + 1:] = self.yaw[t] _ = start_xy def jump(self, t0, t1, height, offset=(0, 0), tuck=0.35): """Parabolic hop over [t0, t1): apex `height` cm, horizontal `offset` (world xy cm, persists after landing). Knees tuck toward the body at the apex by `tuck` of leg length when IK legs are known.""" off = np.asarray(offset, float) for t in range(t0, self.T): u = min(1.0, (t - t0) / max(1, t1 - t0)) lift = 4 * height * u * (1 - u) if t < t1 else 0.0 self.translate(t, t + 1, [off[0] * ease(u), off[1] * ease(u), lift]) # -------------------------------------------------------------------- limbs def two_bone_ik(self, t, upper, lower, end, target, pole): """Place `lower` and `end` so `end` reaches `target` (clamped), bending toward `pole` (world direction).""" a = self.poses[t, self.j(upper)]; L1 = np.linalg.norm(self.sk.rest[self.j(lower)] - self.sk.rest[self.j(upper)]) L2 = np.linalg.norm(self.sk.rest[self.j(end)] - self.sk.rest[self.j(lower)]) d = np.asarray(target, float) - a; dist = np.clip(np.linalg.norm(d), 1e-3, (L1 + L2) * 0.999) dn = d / np.linalg.norm(d) cos_a = np.clip((L1 * L1 + dist * dist - L2 * L2) / (2 * L1 * dist), -1, 1) pole = np.asarray(pole, float); pole = pole - dn * (pole @ dn) pole = pole / np.linalg.norm(pole) if np.linalg.norm(pole) > 1e-6 else np.cross(dn, UP) knee = a + dn * L1 * cos_a + pole * L1 * np.sqrt(1 - cos_a ** 2) tail = self.sk.descendants(end) old_end = self.poses[t, self.j(end)].copy() shift = a + dn * dist - self.poses[t, self.j(end)] self.poses[t, self.j(lower)] = knee self.poses[t, tail] += shift # re-normalise the lower bone exactly e = self.poses[t, self.j(end)]; v = e - knee self.poses[t, tail] += knee + v / np.linalg.norm(v) * L2 - e if self._holds_weapon(tail): # a held weapon follows the hand self.weapon[t] += self.poses[t, self.j(end)] - old_end def legs(self): """(upper, lower, foot) chains of the skeleton, detected by naming.""" sk = self.sk; out = [] for n in sk.joints: if n.startswith("thigh_"): s = n[len("thigh_"):]; out.append((n, f"calf_{s}", f"foot_{s}")) elif n.endswith("_upper") and (n.startswith("front") or n.startswith("hind")): p = n[:-len("_upper")]; out.append((n, f"{p}_lower", f"{p}_foot")) elif n.endswith("_hip") and n.startswith("leg"): p = n[:-len("_hip")]; out.append((n, f"{p}_knee", f"{p}_foot")) return out def gait(self, t0, t1, period=None, duty=0.6, lift=None, phases=None, max_stride=0.7, foot_offsets=None, blend_in=4): """Plant-and-swing feet under the moving root over [t0, t1) with two-bone IK. Rest foot offsets are carried in the body frame; each foot stays fixed on the ground during stance. phases: per-leg cycle offsets (default: alternate left/right, diagonal pairs for four legs, tripod-like for six+). period=None picks the cycle length from the root speed so one stance covers at most max_stride of the leg length (otherwise IK cannot keep the planted foot and it slides).""" chains = self.legs(); assert chains, "skeleton has no recognised legs" if period is None: leg_len = np.mean([self.sk.bone_lengths[self.j(c[1])] + self.sk.bone_lengths[self.j(c[2])] for c in chains]) speed = np.linalg.norm(self.poses[t1 - 1, 0, :2] - self.poses[t0, 0, :2]) / max(1, t1 - t0) peak = 1.5 * speed # eased paths peak at 1.5x the mean speed period = int(np.clip(max_stride * leg_len / max(peak * duty, 1e-3), 8, 48)) self.gait_period = period n = len(chains) if phases is None: phases = [((k % 2) * 0.5 + (k // 2) * 0.25) % 1.0 for k in range(n)] if n > 2 else [0.0, 0.5] lift = lift if lift is not None else 0.12 * self.sk.height # body-frame foot offsets (x forward, y right): the skeleton's rest stance unless given (e.g. a wide lunge) rest_rel = foot_offsets or {c: self.sk.rest[self.j(c[2])] - self.sk.rest[0] for c in chains} def plant(c, cyc, ph): tc = int(round(t0 + (cyc + duty / 2 - ph) * period)); tc = min(max(tc, 0), self.T - 1) off = rest_rel[c] @ rot_z(self.yaw[tc]).T p = self.poses[tc, 0] + off; p[2] = 0.0 return p prev_feet = {c: self.poses[max(t0 - 1, 0), self.j(c[2])].copy() for c in chains} for t in range(t0, t1): for c, ph in zip(chains, phases): x = (t - t0) / period + ph; cyc = int(np.floor(x)); s = x - cyc if s < duty: target = plant(c, cyc, ph) else: u = (s - duty) / (1 - duty) target = plant(c, cyc, ph) * (1 - ease(u)) + plant(c, cyc + 1, ph) * ease(u) target[2] += lift * np.sin(np.pi * u) if blend_in and t0 > 0 and t - t0 < blend_in: # ease in from the feet before the gait k = ease((t - t0 + 1) / (blend_in + 1)) target = prev_feet[c] * (1 - k) + target * k self.two_bone_ik(t, *c, target=target, pole=self.forward(t) + 0.3 * UP) def swing_limb(self, t0, t1, joint, axis, angle, back_by=None): """Rotate `joint`'s subtree about `axis` (world vector or 'right'/'forward'/'up', body-relative) by `angle` rad with ease-in-out, returning to rest over the following `back_by` frames if given.""" for t in range(t0, min(self.T, t1 + (back_by or 0))): if t < t1: a = angle * ease((t - t0) / max(1, t1 - t0)) else: a = angle * (1 - ease((t - t1) / back_by)) ax = {"right": self.right(t), "forward": self.forward(t), "up": UP}.get(axis, axis) if isinstance(axis, str) else axis self.rotate_subtree(t, joint, rot_axis(ax, a)) def reach(self, t0, t1, joint_chain, target, hold=0, pole=None): """Two-bone reach of an (upper, lower, end) chain toward a world target and back.""" pole = pole if pole is not None else UP for t in range(t0, min(self.T, t1 + hold + (t1 - t0))): if t < t1: u = ease((t - t0) / max(1, t1 - t0)) elif t < t1 + hold: u = 1.0 else: u = 1 - ease((t - t1 - hold) / max(1, t1 - t0)) cur = self.poses[t, self.j(joint_chain[2])] self.two_bone_ik(t, *joint_chain, target=cur * (1 - u) + np.asarray(target, float) * u, pole=pole) def lunge(self, t0, t1, distance, head_drop=0.0, recover=None, plant_feet=True): """Body thrust forward `distance` cm (bite / charge) with optional head dip, then back over `recover` frames (or stay if None). plant_feet keeps the feet on their t0 positions via IK while the body moves.""" planted = {c: self.poses[t0, self.j(c[2])].copy() for c in self.legs()} for t in range(t0, self.T): if t < t1: u = ease((t - t0) / max(1, t1 - t0)) elif recover: u = 1 - ease(min(1.0, (t - t1) / recover)) else: u = 1.0 self.translate(t, t + 1, self.forward(t) * distance * u) if head_drop and "neck_01" in self.sk.index: self.rotate_subtree(t, "neck_01", rot_axis(self.right(t), head_drop * u)) if plant_feet and u > 0: for c in self.legs(): # feet stay where they stood at t0 self.two_bone_ik(t, *c, target=planted[c], pole=self.forward(t) + 0.3 * UP) def chain_wave(self, t0, t1, joints, axis, amplitude, cycles=1.0, delay=0.15): """Travelling rotation along a joint chain (tail swipe, serpent slither, wing flap): joint k rotates about `axis` by amplitude * sin(2 pi (cycles * u - k * delay)), applied root-to-tip.""" for t in range(t0, t1): u = (t - t0) / max(1, t1 - t0); env = np.sin(np.pi * u) for k, jn in enumerate(joints): ax = {"right": self.right(t), "forward": self.forward(t), "up": UP}.get(axis, axis) if isinstance(axis, str) else axis a = amplitude * env * np.sin(2 * np.pi * (cycles * u - k * delay)) self.rotate_subtree(t, jn, rot_axis(ax, a / max(1, len(joints)) * 1.5)) def hit_react(self, t0, t1, direction, push=40.0, lean=0.35): """Stagger: pushed `push` cm along world `direction` with the upper body leaning away, recovering by t1.""" d = np.asarray(direction, float); d[2] = 0; d = d / np.linalg.norm(d) spine = "spine_01" if "spine_01" in self.sk.index else self.sk.joints[1] for t in range(t0, self.T): u = (t - t0) / max(1, t1 - t0) k = np.sin(np.pi * min(u, 1.0)) if t < t1 else 0.0 self.translate(t, t + 1, d * push * ease(min(u, 1.0))) if k: self.rotate_subtree(t, spine, rot_axis(np.cross(UP, d), lean * k)) # -------------------------------------------------------------------- weapon def throw_weapon(self, t_release, t_catch, hold_frame, loop_side=250.0, loop_out=0.0, lift=40.0, spins=3, spin_axis=None, camera_forward=None): """Detach the weapon at t_release, fly a boomerang loop and land exactly on the weapon pose of `hold_frame` at t_catch (pose there must already hold the weapon). spin_axis default: toward the camera (pinwheel).""" w0 = self.weapon[t_release].copy(); w1 = self.weapon[hold_frame].copy() L = np.linalg.norm(w0[1] - w0[0]); c0, c1 = w0.mean(0), w1.mean(0) a0, a1 = (w0[1] - w0[0]) / L, (w1[1] - w1[0]) / L fwd = np.asarray(camera_forward, float) if camera_forward is not None else self.forward(t_release) tocam = -fwd.copy(); tocam[2] = 0; tocam /= np.linalg.norm(tocam) side = np.cross(UP, tocam); side /= np.linalg.norm(side) axis = tocam if spin_axis is None else np.asarray(spin_axis, float) def slerp(p, q, u): om = np.arccos(np.clip(p @ q, -1, 1)) return p if om < 1e-6 else (np.sin((1 - u) * om) * p + np.sin(u * om) * q) / np.sin(om) for t in range(t_release + 1, t_catch): u = (t - t_release) / (t_catch - t_release) c = c0 + (c1 - c0) * ease(u) + loop_out * np.sin(np.pi * u) * tocam + loop_side * np.sin(2 * np.pi * u) * side + lift * np.sin(np.pi * u) * UP d = rot_axis(axis, 2 * np.pi * spins * ease(u)) @ slerp(a0, a1, ease(u)) self.weapon[t] = [c - d * L / 2, c + d * L / 2]