ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/proxykit36/proxykit/motion.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 16.9 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/motion.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/proxykit36/proxykit/motion.py
-
curl -L -o motion.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/motion.py
16.9 kB
| """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] | |