@rydr/game-sdk 8.11.0 → 8.13.0

package/dist/three/rider/cyclist-pose.js

@@ -0,0 +1,173 @@
+/**
+ * POSE A HUMANOID AS A CYCLIST — the bridge from the flat rig's solved joints to a skeleton's
+ * rotations.
+ *
+ * `mountRiderRig` already solves every joint the pose needs: hip, shoulder, head, elbow, both knees
+ * and both pedals, as points in the flat 200×200 drawing space. So there is no cycling *animation*
+ * to author here and no clip to bake — the gait already exists, and this file only re-expresses it.
+ * That is why the rider can be a real character without anyone producing a `Cycling` clip.
+ *
+ * ## Why this is rotations and not positions
+ *
+ * The skeleton is a parented chain (`hips → chest → shoulder → elbow → hand`, `hips → hipL → kneeL`)
+ * whose limbs hang along **−Y** at rest. You cannot place a knee: you rotate the hip until the knee
+ * lands there. And because each joint inherits its parent's rotation, a joint's own angle is the
+ * WORLD angle it needs MINUS the world angle its parent already has — which is the whole of
+ * {@link segmentAngle} and the subtractions below.
+ *
+ * The bike is drawn side-on, in a plane, so every rotation is about Z alone. Rotating the rest
+ * direction `(0, −1)` by θ gives `(sin θ, −cos θ)`, so the angle that points a segment along `d` is
+ * `atan2(dx, −dy)`. All of the trigonometry in this file is that one identity.
+ *
+ * ## The lengths have to agree
+ *
+ * A rotation can aim a limb but cannot stretch it, so if the skeleton's thigh is not the thigh the IK
+ * solved with, the knee lands in the right *direction* at the wrong *distance* and the foot leaves the
+ * pedal. {@link cyclistProportions} builds the character to the drawing's own dimensions instead of
+ * re-solving the IK against the character's — one conversion, and the feet stay on the pedals.
+ */
+import * as THREE from "three";
+import { RIG_GEOMETRY as G } from "../../ui/rider-rig.js";
+/**
+ * The swing angle that points a HANGING limb from `a` to `b`, in the character's sagittal plane.
+ *
+ * Two conventions have to be honoured at once, and getting either wrong lays the rider flat on the
+ * floor — which is exactly what the first attempt did.
+ *
+ * 1. **The rig faces +Z and swings about X.** The platform's own note is the authority: "`rotation.x`
+ *    = t puts its far end at `z = −L·sin(t)`: NEGATIVE swings the limb FORWARD (+Z)". So rest is
+ *    `(0, −1, 0)` and rotating by φ gives `(0, −cos φ, −sin φ)`. Rotating about Z instead — the
+ *    obvious guess for a side-on drawing — swings the limbs sideways out of the bike's plane.
+ * 2. **The flat drawing has y pointing DOWN**, the scene has it UP.
+ *
+ * Put the character under a group turned +90° about Y (see {@link mountCyclist}) and its local +Z
+ * becomes world +X, the way the bike faces. Working the two frames through leaves φ = −θ, where θ is
+ * the angle in the flat drawing.
+ */
+function swingDown(a, b) {
+    const dx = b.x - a.x;
+    const dyUp = -(b.y - a.y);
+    return -Math.atan2(dx, dyUp === 0 ? 1e-6 : -dyUp);
+}
+/**
+ * The same, for a segment that RISES from its joint rather than hangs from it.
+ *
+ * The torso and the neck are the two: `chest` sits on the hips and its geometry runs up to `neck`,
+ * which runs up to the head. Their rest direction is `(0, +1, 0)`, not `(0, −1, 0)`, so rotating by φ
+ * gives `(0, cos φ, sin φ)` and the angle is `atan2(dx, dyUp)` with no negation.
+ *
+ * Using the hanging formula on the torso was a real bug and a quiet one: the rider sat up straight,
+ * pedalled correctly, held the bars — and faced backwards down the bike, because a sign error of this
+ * shape reflects the segment rather than breaking it.
+ */
+function swingUp(a, b) {
+    const dx = b.x - a.x;
+    const dyUp = -(b.y - a.y);
+    return Math.atan2(dx, dyUp === 0 ? 1e-6 : dyUp);
+}
+/**
+ * The dimensions the character must be built to, in metres — everything else is the variant's own.
+ *
+ * `scale` is the flat-units-to-metres factor the renderer already uses, so every length here is the
+ * same length the IK solved with. Only the lengths the pose depends on are forced; `spine` and `neck`
+ * stay the variant's, because those are its silhouette rather than its reach.
+ *
+ * Worth knowing: this rider's legs are long for the wheel — the flat drawing is a stylised stick
+ * figure whose limbs were tuned to read at a glance, not to anatomy, and that only becomes visible
+ * once a correctly-proportioned character stands next to it. Forcing the drawing's lengths keeps the
+ * two renderers showing the same rider; deriving them from anatomy instead would put the feet through
+ * the cranks.
+ */
+export function cyclistOverrides(scale) {
+    const dist = (a, b) => Math.hypot(b.x - a.x, b.y - a.y) * scale;
+    return {
+        /**
+         * The spine is REACH, not silhouette — which is what I got wrong first.
+         *
+         * It is what places the shoulder, and the shoulder is where the arm starts. Left at the variant's
+         * own ~0.5 m against the drawing's 0.74 m, the shoulder sat too low and the hands could not get to
+         * the bars however correct the arm angles were: the rider pedalled properly with both arms hanging
+         * at their sides.
+         */
+        spine: dist(G.HIP0, G.SHOULDER0),
+        // Floor → hip, straight off the saddle's own height in the drawing.
+        hipHeight: (G.GROUND - G.SADDLE.y) * scale,
+        thigh: 42 * scale,
+        shin: 44 * scale,
+        upperArm: 25 * scale,
+        forearm: 25 * scale,
+        hipWidth: 0.085,
+        shoulderWidth: 0.16,
+    };
+}
+/**
+ * The group to add to the scene: it carries the quarter-turn that makes the character face the way the
+ * bike does, and it parks the rig at the saddle so every joint below it works in local space.
+ */
+export function mountCyclist(riderRoot, scale) {
+    const mount = new THREE.Group();
+    // Face +X. `root.rotation.y = facing` is the rig's own convention, with 0 facing +Z.
+    mount.rotation.y = Math.PI / 2;
+    mount.position.x = (G.SADDLE.x - G.VB_W / 2) * scale;
+    mount.add(riderRoot);
+    return mount;
+}
+/**
+ * Drive one frame. Every joint the flat pose solved gets its rotation; nothing is re-derived.
+ *
+ * The rise out of the saddle goes on `body`, which is the joint the rig documents as owning bob and
+ * lean — so it lifts the whole rider without disturbing the skeleton's own hip height. `chest` carries
+ * the fold onto the bars, and the arms and head inherit it, which is why a folded rider's head tucks
+ * without a second calculation.
+ */
+export function poseCyclist(joints, pose, scale) {
+    const j = joints;
+    // Fore-aft and rise, both relative to the saddle the mount is parked on. Local +Z is world +X.
+    j.body.position.z = (pose.hip.x - G.SADDLE.x) * scale;
+    j.body.position.y = (G.SADDLE.y - pose.hip.y) * scale;
+    /**
+     * The fold goes on `hips`, NOT on `chest` — and this is the whole reason the hands could not reach
+     * the bars.
+     *
+     * `chest` is chained at `hips + (0, spine, 0)` and the shoulders sit AT the chest's origin, so
+     * rotating the chest pivots the upper body about a point directly above the hips: the shoulders
+     * never move forward, however far the rider is leaning. They stayed 45 drawing-units behind where
+     * the flat IK had solved them, so the arms were reaching for bars that were out of range.
+     *
+     * Rotating `hips` moves the chest — and with it the shoulders — around the hip joint, which is where
+     * a cyclist actually folds. The cost is that the legs are chained off `hips` too and would swing
+     * with the torso, so each leg subtracts the lean back out below. That is the same additive-rotation
+     * bookkeeping as everywhere else here.
+     */
+    const torso = swingUp(pose.hip, pose.shoulder);
+    j.hips.rotation.x = torso;
+    j.chest.rotation.x = 0;
+    // The neck brings the head back toward level, so a folded rider still looks where they are going
+    // rather than at the front hub.
+    j.neck.rotation.x = swingUp(pose.shoulder, pose.head) - torso;
+    // Arms: both hands on the bars. They hang off the chest, which now inherits the fold.
+    const upper = swingDown(pose.shoulder, pose.elbow);
+    const fore = swingDown(pose.elbow, G.BAR);
+    for (const [shoulder, elbow] of [
+        [j.shoulderL, j.elbowL],
+        [j.shoulderR, j.elbowR],
+    ]) {
+        shoulder.rotation.x = upper - torso;
+        elbow.rotation.x = fore - upper;
+    }
+    // Legs: one per side, each on its own crank throw — which is what the flat view could only suggest
+    // by drawing the far one darker. Minus the fold, which they inherit from `hips` and must not follow.
+    for (const leg of [
+        { hip: j.hipL, knee: j.kneeL, kneePt: pose.kneeNear, pedal: pose.pedalNear },
+        { hip: j.hipR, knee: j.kneeR, kneePt: pose.kneeFar, pedal: pose.pedalFar },
+    ]) {
+        const thigh = swingDown(pose.hip, leg.kneePt);
+        leg.hip.rotation.x = thigh - torso;
+        leg.knee.rotation.x = swingDown(leg.kneePt, leg.pedal) - thigh;
+    }
+}
+/** What a variant's own flourishes read. The crank angle is the gait phase for a cyclist. */
+export function tickPose(pose, time) {
+    return { effort: pose.effort, time, phase: pose.crankAngle * (Math.PI / 180) };
+}
+//# sourceMappingURL=cyclist-pose.js.map

package/dist/three/rider/cyclist-pose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclist-pose.js","sourceRoot":"","sources":["../../../src/three/rider/cyclist-pose.ts"],"names":[],"mappings":"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"}

package/dist/three/rider/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The 3D rider rig — a second renderer for `mountRiderRig` from `@rydr/game-sdk/ui`.
+ *
+ * See `three-rider-rig.ts` for what is shared with the flat renderer (everything but the drawing) and
+ * for when a 3D rig is worth a WebGL context.
+ */
+export * from "./three-rider-rig.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/three/rider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/three/rider/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,sBAAsB,CAAC"}

package/dist/three/rider/index.js

@@ -0,0 +1,8 @@
+/**
+ * The 3D rider rig — a second renderer for `mountRiderRig` from `@rydr/game-sdk/ui`.
+ *
+ * See `three-rider-rig.ts` for what is shared with the flat renderer (everything but the drawing) and
+ * for when a 3D rig is worth a WebGL context.
+ */
+export * from "./three-rider-rig.js";
+//# sourceMappingURL=index.js.map

package/dist/three/rider/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/three/rider/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,sBAAsB,CAAC"}

package/dist/three/rider/three-rider-rig.d.ts

@@ -0,0 +1,80 @@
+/**
+ * THREE RIDER RIG — the rider-on-a-trainer drawing, in 3D.
+ *
+ * A second {@link RigRenderer} for `mountRiderRig`, exactly as `createThreePadRenderer` is a second
+ * renderer for the controller views. The component is unchanged: it still owns the two EMAs, the
+ * crank, the effort, the %FTP zone and the glass tooltip, and it still hands over one
+ * {@link RigPose} per frame. All this file does is draw that pose with meshes instead of paths.
+ *
+ * ```ts
+ * import { createThreeRiderRig } from "@rydr/game-sdk/three";
+ * import { mountRiderRig } from "@rydr/game-sdk/ui";
+ *
+ * mountRiderRig(panel, { design: "solid", ftp: 240, renderer: createThreeRiderRig });
+ * ```
+ *
+ * ## What is shared, and what that buys
+ *
+ * **The joints arrive already solved.** `RigPose` carries the hip, shoulder, head, elbow, both knees
+ * and both pedals as points in the flat 200×200 drawing space — so the two-bone IK, the crank
+ * kinematics, the out-of-the-saddle rise and the posture fold all stay in `rider-rig.ts` and run
+ * once. This file re-derives nothing, which is the whole point of the seam: two renderers cannot
+ * drift into two different gaits, and a fix to the pedalling fixes both.
+ *
+ * So the mapping is the only geometry here: {@link toWorld} takes a flat point to metres. The drawing
+ * space is scaled off the ONE wheel that is left — a 700c wheel is 0.68 m and 52 units across, giving
+ * ~1.05 m of wheelbase and a rider whose head sits at ~1.7 m. Those are a real bike's numbers, which
+ * matters because in 3D a wrong scale reads as a toy the moment perspective is applied.
+ *
+ * **The tooltip needs nothing from us.** It is an HTML box the component positions over the drawing,
+ * so it sits over this canvas exactly as it sits over the flat `<svg>` — no 3D projection, no
+ * re-layout, no second implementation. That is a payoff from building it in CSS.
+ *
+ * ## What only 3D can add, and what it costs
+ *
+ * The flat drawing is a strict side view, so the bike is a silhouette. Here the camera sits off-axis,
+ * which is what makes the trainer read as a machine with a body rather than an outline: you see the
+ * housing's depth, the flywheel as a disc rather than a circle, and the rider's far leg genuinely
+ * behind the near one instead of merely darker.
+ *
+ * The cost is a WebGL context. **This renderer draws on demand — one frame per `setPose`, no
+ * animation loop of its own** — because a game calling `rig.tick(dt)` already has a loop, and a
+ * decorative rig must not open a second one. It is still a second context beside the game's own
+ * scene, so prefer the flat renderer in-game and reach for this one on the screens where the picture
+ * IS the content: onboarding, a store page, a "how this works" panel.
+ *
+ * Requires the optional `three` peer dependency, like everything else in `@rydr/game-sdk/three`.
+ */
+import type { RigRendererFactory } from "../../ui/rider-rig.js";
+/**
+ * Where the camera stands.
+ *
+ * `profile` is the default, and deliberately: it is the SAME view the flat renderer draws, so the two
+ * are directly comparable and swapping the renderer changes the medium rather than the shot. It also
+ * hides the far leg behind the near one, exactly as the flat drawing does.
+ *
+ * `three-quarter` is the one that shows off the third dimension — the housing gets depth, the flywheel
+ * becomes a disc rather than a circle, and both legs are visible on their own sides of the frame.
+ */
+export type RiderRigView = "profile" | "three-quarter";
+export interface ThreeRiderRigOptions {
+    /** Where the camera stands. Default `"profile"`, matching the flat renderer's own view. */
+    view?: RiderRigView;
+    /**
+     * Which rider variant to wear, overriding the design's default (`cel` / `facet` / `neon`).
+     *
+     * Any id from `CHARACTERS` — `clay` and `knight` are there too and nothing stops a game using them.
+     */
+    character?: string;
+}
+/**
+ * Build a renderer factory with options.
+ *
+ * `RigRendererFactory` takes only the design, so anything else has to be closed over — hence a factory
+ * of a factory rather than one more argument. {@link createThreeRiderRig} is this with the defaults,
+ * and is what you pass when you have nothing to configure.
+ */
+export declare function threeRiderRig(opts?: ThreeRiderRigOptions): RigRendererFactory;
+/** The 3D renderer with its defaults — pass it straight to `mountRiderRig`'s `renderer` option. */
+export declare const createThreeRiderRig: RigRendererFactory;
+//# sourceMappingURL=three-rider-rig.d.ts.map

package/dist/three/rider/three-rider-rig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"three-rider-rig.d.ts","sourceRoot":"","sources":["../../../src/three/rider/three-rider-rig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAIH,OAAO,KAAK,EAIV,kBAAkB,EAEnB,MAAM,uBAAuB,CAAC;AAkJ/B;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,eAAe,CAAC;AAQvD,MAAM,WAAW,oBAAoB;IACnC,2FAA2F;IAC3F,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,GAAE,oBAAyB,GAAG,kBAAkB,CAEjF;AAED,mGAAmG;AACnG,eAAO,MAAM,mBAAmB,EAAE,kBAA8D,CAAC"}