From fb2908ba41c3ee42bc33bc585eafde4ff2a14154 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 12:46:40 +0200 Subject: [PATCH 01/13] docs: add flow-graph port plan and block-porting skill Add a pure-state architecture/port design for the FlowGraph system (docs/lite/architecture/42-flow-graph.md), a reusable block-porting skill (.github/copilot/skills/port-flow-graph-block.md), and wire both into the architecture TOC. The glTF KHR_interactivity spec is unratified (tracking BJS PR #18455), so all spec-dependent code is quarantined under flow-graph/gltf/ and the runtime core stays spec-agnostic. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../copilot/skills/port-flow-graph-block.md | 360 ++++++++ docs/lite/architecture/00-overview.md | 2 + docs/lite/architecture/42-flow-graph.md | 819 ++++++++++++++++++ 3 files changed, 1181 insertions(+) create mode 100644 .github/copilot/skills/port-flow-graph-block.md create mode 100644 docs/lite/architecture/42-flow-graph.md diff --git a/.github/copilot/skills/port-flow-graph-block.md b/.github/copilot/skills/port-flow-graph-block.md new file mode 100644 index 0000000000..08d91e3bfa --- /dev/null +++ b/.github/copilot/skills/port-flow-graph-block.md @@ -0,0 +1,360 @@ +# Port a Flow-Graph Block to Babylon Lite + +You are porting **one block** (node) from the Babylon.js `FlowGraph` system to +**Babylon Lite's** flow-graph subsystem. Babylon.js blocks are classes; Lite +blocks are **plain-data definitions + pure functions**. This skill is the +mechanical recipe to do that conversion correctly and to wire the block into the +glTF `KHR_interactivity` path when applicable. + +> Read first: `docs/lite/architecture/42-flow-graph.md` (the subsystem design) +> and `GUIDANCE.md` (pillars: no classes, pure-state, zero module-level side +> effects, 100% tree-shakable). This skill assumes that architecture. + +--- + +## What a block becomes + +| Babylon.js | Babylon Lite | +|---|---| +| `class FooBlock extends FlowGraphBlock` | a `const fooDef: FgBlockDef` exported from one file | +| `class … extends FlowGraphExecutionBlock` | `FgBlockDef` with an `execute()` | +| `class … extends FlowGraphAsyncExecutionBlock` | `FgBlockDef` with `execute` (start task) + `onTick(task)` + `cancelPending` | +| `class … extends FlowGraphEventBlock` | `FgBlockDef.build()` returns `{ event: FgEventType.X }` | +| constructor `registerDataInput/Output` | sockets declared in `build()` | +| `_registerSignalInput/Output` | signal sockets declared in `build()` | +| `getValue(ctx)` / `setValue(v, ctx)` | `getDataValue(ctx, env, block, name)` / `setDataValue(ctx, block, name, v)` | +| `signal._activateSignal(ctx)` | `activateSignal(ctx, env, block, name)` | +| `this.config.foo` | `block.config?.foo` | +| per-instance field / state | `ctx.executionVariables["${block.id}:key"]` | +| `RegisterClass(name, Class)` + `blockFactory` case | one `getBlockDef` switch case (dynamic import) | +| `getClassName()` returns `FlowGraphBlockNames.X` | `FgBlockType.X` string tag | + +**No classes. No `this`. No methods on data. No module-level `new`.** + +--- + +## Step-by-step + +### 1. Locate the source block + +In the Babylon.js clone (`~/Babylon.js/packages/dev/core/src/FlowGraph/Blocks/**`) +open the block's `.pure.ts` file (the `.ts` wrapper only calls `RegisterClass`, +ignore it). Identify: + +- **Kind:** data (has `_updateOutputs`), execution (has `_execute`), async + (extends `FlowGraphAsyncExecutionBlock`), or event (extends + `FlowGraphEventBlock`). +- **Data inputs/outputs:** each `registerDataInput("name", RichTypeX, default)` + and `registerDataOutput(...)`. +- **Signal inputs/outputs:** the inherited `in`/`error`, plus each + `_registerSignalOutput("name")`. +- **Config:** fields read off `this.config`. +- **Per-instance state:** anything read/written via + `context._getExecutionVariable/_setExecutionVariable`. +- **Class name:** the `FlowGraphBlockNames.X` returned by `getClassName()`. + +### 2. Add the type tag + +In `flow-graph/block-type.ts`, add a member to the `FgBlockType` const enum if it +does not exist. **Keep the string value identical to the BJS class name** +(e.g. `Branch = "Branch"` matches `FlowGraphBranchBlock` → name `"Branch"`), +so serialized graphs and the declaration mapper line up. + +### 3. Create the block file + +Path: `flow-graph/blocks//.ts`. Export a single +`FgBlockDef`. Use the matching template below. + +#### Template — DATA block (pull) + +BJS reference (`flowGraphConstantBlock.pure.ts` style): + +```typescript +// flow-graph/blocks/math/add.ts +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAdd } from "../../fg-math.js"; // type-generic add (number|vecN|…) + +export const addDef: FgBlockDef = { + type: FgBlockType.Add, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAdd(a, b)); + }, +}; +``` + +#### Template — EXECUTION block (push) + +BJS reference (`flowGraphBranchBlock.pure.ts`): + +```typescript +// flow-graph/blocks/control-flow/branch.ts +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, activateSignal } from "../../runtime.js"; +import { sockIn, sigIn, sigOut } from "../../sockets.js"; + +export const branchDef: FgBlockDef = { + type: FgBlockType.Branch, + build: () => ({ + dataIn: [sockIn("condition", FgType.Boolean, false)], + signalIn: [sigIn("in")], + signalOut: [sigOut("onTrue"), sigOut("onFalse")], + }), + execute(block, ctx, env /*, incomingSignal */) { + if (getDataValue(ctx, env, block, "condition")) { + activateSignal(ctx, env, block, "onTrue"); + } else { + activateSignal(ctx, env, block, "onFalse"); + } + }, +}; +``` + +#### Template — ASYNC block (delay / animation) + +> Async state lives on an **`FgPendingTask`** (with a unique `token`), not on the +> block and not as a single scalar — a block may have **multiple concurrent +> tasks** (e.g. several in-flight delays). `addPending` dedupes the block in the +> tick loop and returns a task; `cancelPending` marks tasks canceled and the tick +> loop skips them. + +```typescript +// flow-graph/blocks/control-flow/set-delay.ts +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, activateSignal, addPending, cancelTasksFor } from "../../runtime.js"; +import { sockIn, sigIn, sigOut } from "../../sockets.js"; + +export const setDelayDef: FgBlockDef = { + type: FgBlockType.SetDelay, + build: () => ({ + dataIn: [sockIn("duration", FgType.Number, 0)], + signalIn: [sigIn("in"), sigIn("cancel")], + signalOut: [sigOut("out"), sigOut("done"), sigOut("error")], + }), + execute(block, ctx, env, incomingSignal) { + if (incomingSignal === "cancel") { + cancelTasksFor(ctx, block); // marks this block's tasks canceled + return; + } + const seconds = getDataValue(ctx, env, block, "duration") as number; + const task = addPending(ctx, block); // unique token, deduped in tick loop + task.state.remainingMs = seconds * 1000; + activateSignal(ctx, env, block, "out"); // sync flow continues immediately + }, + onTick(block, ctx, env, deltaMs, task) { // task passed by the tick loop + if (task.canceled) { return; } + const left = (task.state.remainingMs as number) - deltaMs; + if (left <= 0) { + task.done = true; // tick loop compacts it out + activateSignal(ctx, env, block, "done"); + } else { + task.state.remainingMs = left; + } + }, +}; +``` + +#### Template — EVENT block + +```typescript +// flow-graph/blocks/events/scene-tick.ts +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { FgEventType } from "../../event-bus.js"; +import { setDataValue, activateSignal } from "../../runtime.js"; +import { sockOut, sigOut } from "../../sockets.js"; + +export const sceneTickDef: FgBlockDef = { + type: FgBlockType.SceneTick, + build: () => ({ + dataOut: [sockOut("timeSinceStart", FgType.Number), sockOut("deltaTime", FgType.Number)], + signalOut: [sigOut("out"), sigOut("done")], + event: FgEventType.Tick, // the scene driver fires this block on the tick channel + }), + // event blocks expose outputs via updateOutputs; the driver sets payload then fires signals + updateOutputs(block, ctx, env) { + // values written by the driver into connectionValues before firing + }, +}; +``` + +> Event blocks do **not** have an `in` signal (BJS removes it). The scene driver +> reads `block.event`, pushes the payload into `ctx.connectionValues`, then calls +> `activateSignal(ctx, env, block, "out")` and `"done"`. + +### 4. Map the rich types + +Replace BJS `RichTypeX` with the `FgType` tag: + +| BJS RichType | FgType | +|---|---| +| `RichTypeAny` | `FgType.Any` | +| `RichTypeNumber` | `FgType.Number` | +| `RichTypeBoolean` | `FgType.Boolean` | +| `RichTypeString` | `FgType.String` | +| `RichTypeFlowGraphInteger` | `FgType.Integer` | +| `RichTypeVector2/3/4` | `FgType.Vector2/3/4` | +| `RichTypeQuaternion` | `FgType.Quaternion` | +| `RichTypeMatrix/2D/3D` | `FgType.Matrix/Matrix2D/Matrix3D` | +| `RichTypeColor3/4` | `FgType.Color3/Color4` | + +Default values come from `defaultForType(FgType.X)` (in `rich-type.ts`), never +from a module-level `new RichType(...)`. + +### 5. Map the math + +Lite core `math/` is **Vec3-centric and minimal** — it has `addVec3`, `subVec3`, +`scaleVec3`, `dotVec3`, `crossVec3`, `lengthVec3`, `normalizeVec3`, `lerpVec3`, +`mat4Multiply`, `mat4Invert`, `mat4Compose`, `mat4Decompose`, `mat4FromQuat`, and +little else. It has **no Vec2, no general quaternion algebra, no +transpose/determinant**. + +Rule (GUIDANCE §4c′): **do not add these to core `math/`.** Put block-specific +math in `flow-graph/fg-math.ts` (and `flow-graph/custom-types/`), lazily imported +by the blocks that need it, so non-interactivity scenes stay byte-for-byte +unchanged. Reuse core `math/` only where it already covers the op. + +When a math op is type-generic (works on number/vecN/matrix), implement a small +dispatcher in `fg-math.ts` (e.g. `fgAdd`, `fgMul`, `fgLength`) that branches on +the runtime value shape — mirroring BJS's per-component handling. + +### 6. Convert per-instance state + +Anything BJS stores via `context._getExecutionVariable(this, key, def)` / +`_setExecutionVariable(this, key, v)` becomes +`getExecVar(ctx, block, key, def)` / `setExecVar(ctx, block, key, v)` (keyed by +`block.id`). **Never** add fields to `FgBlock` for mutable runtime state — it is +immutable topology data; all mutable state lives in `FgContext`. + +### 7. Register the block + +Add **one case** to the `getBlockDef` switch in `flow-graph/block-registry.ts`: + +```typescript +case FgBlockType.Branch: + return async () => (await import("./blocks/control-flow/branch.js")).branchDef; +``` + +This is the only place the block is referenced by string. It is dynamic-imported, +so a scene that never uses the block never bundles it. (`getBlockDef` returns +`null` for unknown types; the glTF interactivity parser treats that as a +loud, structured *unsupported-op* error rather than silently substituting a +no-op — don't change that.) + +### 8. (If glTF-driven) add the declaration-mapper entry + +If the block backs a `KHR_interactivity` op, add an entry to +`flow-graph/gltf/declaration-mapper.ts` mapping the glTF op name to this block. +Copy the structure from the BJS `declarationMapper.ts` entry for the same op, but +as Lite plain data: + +```typescript +"flow/branch": { + blocks: [FgBlockType.Branch], + inputs: { + values: { condition: { name: "condition", gltfType: "bool" } }, + flows: { in: { name: "in" } }, + }, + outputs: { + flows: { true: { name: "onTrue" }, false: { name: "onFalse" } }, + }, +}, +``` + +Handle BJS specifics when present: **value transformers** (e.g. animation time +`seconds → frames`: `dataTransformer: (t) => [t[0] * fps]`), **socket renames** +(`in_$N` for switch cases), **multi-block expansions** (`pointer/set` → +`SetProperty` + `JsonPointerParser` linked via `interBlockConnectors`), and +**integer validation** (switch/multiGate cases must be ints). Reproduce these as +pure functions/data, not classes. + +> **⚠️ The spec is unratified and moving.** `KHR_interactivity` is a draft and +> Babylon.js is reworking its implementation to the newer spec in +> **[PR #18455 "KHR_interactivity rework"](https://github.com/BabylonJS/Babylon.js/pull/18455)** +> (closed-for-age, to be reopened). Treat the op name, its types, and its mapping +> as **volatile**: keep changes confined to `flow-graph/gltf/` +> (mapper/parser/path-converter), never leak op-specific logic into the runtime or +> a block's `execute`/`updateOutputs`. When in doubt, check the op against the +> latest Khronos draft **and** PR #18455; record which BJS commit your mapper +> entry mirrors. If the op changed, prefer a version-tagged branch over silently +> editing the existing entry. + +### 9. Test + +Add a vitest spec next to the block (or in the subsystem test folder): + +```typescript +// build the block + a minimal context/env, drive it, assert. +const block = instantiate(branchDef, { id: "b1", config: {} }); +setDataValue(ctx, block, "condition", true); +branchDef.execute(block, ctx, env, "in"); +expect(firedSignals).toContain("onTrue"); +``` + +For async blocks, tick `onTick` with `deltaMs` and assert `done` fires at the +right time. For glTF-mapped blocks, add a parser test: a small interactivity +JSON fragment → expected `FgGraph` topology. + +### 10. Validate (mandatory before done) + +- `pnpm run lint:fix && pnpm run lint` — must pass (GUIDANCE §6). +- `pnpm test` (vitest unit) for the subsystem. +- If you added/changed an engine path that a parity scene exercises: + `pnpm build:bundle-scenes && pnpm test:parity`, and **commit the regenerated + `lab/public/bundle/manifest.json`** (GUIDANCE §0c). +- **Bundle discipline:** confirm a non-interactivity scene's bundle is unchanged + — the block must tree-shake away entirely when unused. Never raise a bundle + ceiling without explicit user approval (GUIDANCE §2 / §2b′). + +--- + +## Checklist + +- [ ] `FgBlockType` tag added, string value == BJS class name. +- [ ] One file under `blocks//`, exports a single `FgBlockDef`. +- [ ] No classes, no `this`, no module-level `new` / `Map` / `Set`. +- [ ] Sockets declared in `build()`; rich types mapped to `FgType`. +- [ ] Math reused from core where possible, else added to `fg-math.ts` (lazy). +- [ ] Per-instance state via `getExecVar/setExecVar`, not block fields. +- [ ] One `getBlockDef` switch case (dynamic import). +- [ ] Declaration-mapper entry added if glTF-driven (transformers/multi-block/validation preserved). +- [ ] Unit tests for outputs/signals/async timing; parser test if glTF-mapped. +- [ ] Lint + tests green; bundle unchanged for non-interactivity scenes. + +--- + +## Common pitfalls + +- **Pull vs push confusion.** Data inputs are *pulled* on demand inside + `execute`/`updateOutputs` via `getDataValue` — do not "push" data. Signals are + *pushed* via `activateSignal` — do not poll them. +- **Pull recompute, not cache.** `getDataValue` re-runs the producer's + `updateOutputs` on **every** read (matching BJS). `connectionValues` is a + transport slot, not a validity cache. Never short-circuit recomputation on a + cached value or skip `updateOutputs` — a `pointer/get`/`GetVariable`/`random` + output would go stale after an intervening write in the same cascade. Likewise + never cache values on the (immutable) block. +- **Event blocks with an `in` signal.** Drop it — event blocks are driven by the + bus, not an incoming signal (matches BJS `FlowGraphEventBlock`). +- **Module-level allocation.** A top-level `const x = new FgMatrix2D()` or + `new Map()` kills tree-shaking. Construct inside functions; for constants use + plain literals or typed arrays. +- **Bloating core math.** Resist adding Vec2/quaternion/matrix ops to `src/math/`. + Keep them in `flow-graph/fg-math.ts` so unrelated scenes don't grow. +- **Handedness.** glTF is right-handed; if the block reads/writes transforms via + an accessor, ensure Z/quaternion coercion happens at the accessor boundary, not + scattered in block logic. diff --git a/docs/lite/architecture/00-overview.md b/docs/lite/architecture/00-overview.md index 5282b9d5ce..d16a9ec6f9 100644 --- a/docs/lite/architecture/00-overview.md +++ b/docs/lite/architecture/00-overview.md @@ -60,6 +60,8 @@ Pages are ordered by how commonly Babylon Lite users reach for them — start wi | [38-bundle-size-tooling.md](/lite/architecture/38-bundle-size-tooling) | Bundle Size Tooling | Per-scene bundle analysis, ceilings, treemaps | | [39-animation-parity-testing.md](/lite/architecture/39-animation-parity-testing) | Animation Parity | Animated scene test methodology | | [40-material-stencil.md](/lite/architecture/40-material-stencil) | Material Stencil | Opt-in `enableMaterialStencil` per-material stencil mask/test on Standard/PBR/Shader, zero-impact hook | +| [41-audio-engine.md](/lite/architecture/41-audio-engine) | Audio Engine | WebAudio engine, sound sources, spatial audio | +| [42-flow-graph.md](/lite/architecture/42-flow-graph) | Flow Graph | Pure-state visual-scripting runtime + glTF `KHR_interactivity` port plan (DESIGN) | --- diff --git a/docs/lite/architecture/42-flow-graph.md b/docs/lite/architecture/42-flow-graph.md new file mode 100644 index 0000000000..1a8fac1a39 --- /dev/null +++ b/docs/lite/architecture/42-flow-graph.md @@ -0,0 +1,819 @@ +# Module: flow-graph + +> Package path: `packages/babylon-lite/src/flow-graph/` +> +> Status: **DESIGN / PORT PLAN** (no runtime code yet). This document is the +> formal specification for porting the Babylon.js `FlowGraph` system to Babylon +> Lite. It is written so that the subsystem can be implemented from this doc +> alone, in line with GUIDANCE §4 (Documentation-Driven Architecture). + +--- + +## Purpose + +The flow graph is Babylon's **visual scripting / behaviour runtime**: a directed +graph of nodes ("blocks") that react to engine events and drive scene behaviour +(animate properties, play sounds, branch on conditions, do math). Its primary +real-world consumer is the glTF **`KHR_interactivity`** extension, which embeds +an interactivity graph inside a `.glb` and expects the engine to execute it at +runtime. + +**Goal of this port (phase priority, locked):** load and run interactive glTF +assets. The plan therefore phases: + +1. a minimal **pure-state runtime** (graph + context + connection model), +2. the **subset of blocks** that `KHR_interactivity` actually maps to, and +3. the **`loader-gltf` extension** that parses the interactivity JSON into a + Lite graph and resolves JSON pointers to scene accessors. + +Full editor-authored parity (all ~170 BJS blocks, the BJS snippet/serialization +format, the debugger, multi-context coordinators) is explicitly **out of scope +for the MVP** and is listed as later phases. + +> **⚠️ Spec stability caveat (read before touching `flow-graph/gltf/`):** +> `KHR_interactivity` is **not yet ratified** and is actively changing; Babylon.js +> is reworking its implementation to the newer spec draft in +> **[PR #18455 "KHR_interactivity rework"](https://github.com/BabylonJS/Babylon.js/pull/18455)** +> (currently closed-for-age, expected to be reopened/merged soon). This port +> therefore **isolates all spec-dependent code in `flow-graph/gltf/`** and keeps +> the runtime core spec-agnostic, so future spec revisions are cheap, localized +> edits. See "The spec is NOT ratified" under the loader section and the risks at +> the end. + +--- + +## Architectural Decision: Pure-State, Not Classes + +Babylon.js `FlowGraph` is a deep OOP hierarchy +(`FlowGraphBlock` → `FlowGraphExecutionBlock` → `FlowGraphAsyncExecutionBlock` → +`FlowGraphEventBlock`), with methods on every node, a **global class registry** +(`RegisterClass`) used for deserialization, and module-level `new RichType(...)` +allocations. None of that is permitted in Lite (GUIDANCE §4b′ pure-state +interfaces, §4 zero module-level side effects, 100% tree-shakable). + +**Lite re-architects the same semantics as data + functions:** + +| Concern | Babylon.js (OOP) | Babylon Lite (pure-state) | +|---|---|---| +| A node | `class FooBlock extends FlowGraphBlock` with methods | `FgBlock` **plain data** + a `FgBlockDef` record of **pure functions** | +| Node behaviour | `block._execute(ctx)` method | `def.execute(block, ctx, env, signal)` standalone fn | +| Data output calc | `block._updateOutputs(ctx)` method | `def.updateOutputs(block, ctx, env)` standalone fn | +| Type info | `class RichType` instances at module scope | `const enum FgType` string tags + pure `defaultForType()` | +| className → ctor | global `RegisterClass` registry (side-effect) | tree-shakable `getBlockDef(type)` dynamic-import switch | +| Per-run state | fields on `FlowGraphContext` instance | `FgContext` **plain data** mutated by standalone fns | +| Scene access | block holds/queries `Scene` | block touches **only accessors/handles** wired by the loader; the scene **owns and drives** the graph | + +The key insight that makes this clean: **BJS already keeps per-instance state in +`FlowGraphContext` keyed by block `uniqueId`, not on the block.** The block is +nearly a stateless definition already. Lite finishes the job — the block becomes +*pure data describing topology*, and all behaviour moves into a registry of pure +functions. This also means **porting one block = writing one small data record + +one or two pure functions**, which keeps future block ports mechanical (see the +companion skill `port-flow-graph-block.md`). + +This mirrors two existing Lite patterns: + +- **`loader-gltf/gltf-feature-registry.ts`** — `[trigger, () => import(...)]` + tuples, dynamic-imported only when needed. The block registry uses the same + idea. +- **BJS's own `blockFactory`** — already a tree-shakable `switch` of dynamic + imports (no global side effect). We keep that shape; we only drop the class + bodies behind it. + +--- + +## One-Way Ownership & Scene Drive Model (Critical) + +GUIDANCE §4b forbids components from referencing the scene. A flow graph +obviously needs to read/write node transforms, fire on scene events, and play +animations — so the wiring is inverted exactly like the animation subsystem: + +- The **scene owns** the graphs: `scene._flowGraphs: FgRuntime[]` (plain data). +- The graph is **driven** by the scene's existing per-frame hook + (`onBeforeRender(scene, cb)` → `scene._beforeRender`), exactly how animation + groups are ticked (`ctx._beforeRender.push(deltaMs => …)`). +- Blocks **never see the scene**. Anything scene-dependent is pre-resolved by the + **loader** into plain capability objects stored in `FgEnv`: + - **Object accessors** (`FgAccessor { get, set?, target }`) — closures over the + already-loaded Lite scene objects, produced when a glTF JSON pointer is + resolved. A `pointer/get` block just calls `accessor.get()`. + - **Animation handles** — references to the `AnimationGroup` plain-data objects + the glTF loader already created. + - **Event sources** — an `FgEventBus` the scene driver feeds (tick, start, + pointer, key). Event blocks subscribe to the bus, not to the scene. + +This keeps the dependency arrow pointing **scene → flow-graph**, never the +reverse, preserving zero circular deps and tree-shakability. + +--- + +## Public API Surface + +All exported from `packages/babylon-lite/src/flow-graph/index.ts` and re-exported +from the package `index.ts`. Everything is plain data + standalone functions. + +### Core data types (`flow-graph/types.ts`) + +```typescript +/** A value that can flow along a data edge. */ +export type FgValue = + | number | boolean | string + | Vec2 | Vec3 | Vec4 | Quat | Mat4 + | FgInteger // tagged 32-bit int (see CustomTypes below) + | FgMatrix2D | FgMatrix3D + | Color3 | Color4 + | null | undefined; + +/** Type tags. const enum → fully erased at build, zero runtime cost. */ +export const enum FgType { + Any = "any", + Number = "number", + Boolean = "boolean", + String = "string", + Integer = "FlowGraphInteger", + Vector2 = "Vector2", + Vector3 = "Vector3", + Vector4 = "Vector4", + Quaternion = "Quaternion", + Matrix = "Matrix", + Matrix2D = "Matrix2D", + Matrix3D = "Matrix3D", + Color3 = "Color3", + Color4 = "Color4", +} + +/** A data input/output port — plain data. */ +export interface FgDataSocket { + readonly name: string; + readonly type: FgType; + /** wired source (for inputs): producing block id + its output socket name */ + source?: { blockId: string; socket: string }; + /** literal fallback used when `source` is undefined */ + defaultValue?: FgValue; +} + +/** A control-flow (signal) port — plain data. Push model. */ +export interface FgSignalSocket { + readonly name: string; + /** wired targets (for outputs): consuming block id + its input signal name */ + readonly targets: { blockId: string; socket: string }[]; +} + +/** A node instance — PURE DATA describing topology + config only. */ +export interface FgBlock { + readonly id: string; + readonly type: string; // FgBlockType value or "module/Name" + readonly config?: Readonly>; + readonly dataIn: readonly FgDataSocket[]; + readonly dataOut: readonly FgDataSocket[]; + readonly signalIn: readonly FgSignalSocket[]; + readonly signalOut: readonly FgSignalSocket[]; + /** declared by event blocks; which bus event activates them */ + readonly event?: FgEventType; +} + +/** A parsed graph — pure data. */ +export interface FgGraph { + readonly blocks: readonly FgBlock[]; + /** id → block index, for O(1) edge resolution (built by the parser) */ + readonly byId: Readonly>; + /** declared graph variables: name → { type, initialValue } */ + readonly variables: Readonly>; +} +``` + +### Behaviour definitions (`flow-graph/block-def.ts`) + +```typescript +/** The shape a def declares when a block is instantiated. */ +export interface FgBlockShape { + dataIn?: FgDataSocket[]; + dataOut?: FgDataSocket[]; + signalIn?: FgSignalSocket[]; + signalOut?: FgSignalSocket[]; + event?: FgEventType; +} + +/** + * Pure behaviour record for one block type. No classes, no `this`. + * Exactly ONE of these per block kind; this is what a porter writes. + */ +export interface FgBlockDef { + readonly type: string; + + /** Declare sockets/signals from config (called once at instantiation). */ + readonly build: (config: Readonly> | undefined) => FgBlockShape; + + /** DATA blocks: compute outputs from inputs (PULL). Pure-ish: writes via setDataValue. */ + readonly updateOutputs?: (block: FgBlock, ctx: FgContext, env: FgEnv) => void; + + /** EXECUTION blocks: run when an input signal fires (PUSH). For async blocks + * this is also where a task is started, via addPending(ctx, block). */ + readonly execute?: (block: FgBlock, ctx: FgContext, env: FgEnv, incomingSignal: string) => void; + + /** ASYNC blocks: advance one outstanding task each frame (e.g. delay countdown, + * animation progress). The tick loop passes the specific FgPendingTask. */ + readonly onTick?: (block: FgBlock, ctx: FgContext, env: FgEnv, deltaMs: number, task: FgPendingTask) => void; + /** ASYNC blocks: teardown hook called on dispose/cancel; mark tasks canceled. */ + readonly cancelPending?: (block: FgBlock, ctx: FgContext, env: FgEnv) => void; +} +``` + +### Execution context & environment (`flow-graph/context.ts`) + +```typescript +/** Per-execution-instance MUTABLE state — plain data. */ +export interface FgContext { + /** data transport slots: `${blockId}:${socket}` → last value the producer wrote. + * NOT a validity cache — producers recompute on every pull (see execution model). */ + readonly connectionValues: Record; + /** per-block scratch: `${blockId}:${key}` → value (counter state, async tokens, resolving guard) */ + readonly executionVariables: Record; + /** live graph variable values (seeded from FgGraph.variables) */ + readonly userVariables: Record; + /** async task records, ticked each frame (deduped; carry cancel tokens) */ + readonly pending: FgPendingTask[]; + /** glTF graphs are right-handed; drives Z/handedness coercion on read */ + readonly rightHanded: boolean; +} + +/** One outstanding async task (a delay, an animation). Token enables precise cancel. */ +export interface FgPendingTask { + readonly blockId: string; + readonly token: number; // unique per task; a block may own several concurrently + canceled: boolean; + state: Record; // e.g. remainingMs, delayIndex, animation handle +} + +/** Per-graph RESOLVED capabilities, wired by the loader. Read-mostly. */ +export interface FgEnv { + readonly graph: FgGraph; + /** block defs resolved up-front (awaited dynamic imports), type → def */ + readonly defs: Record; + /** scene-object accessors resolved from JSON pointers, keyed by pointer id */ + readonly accessors: Record; + /** animation handles by glTF animation index */ + readonly animations: readonly AnimationGroup[]; + /** scene-owned capabilities blocks may invoke WITHOUT a scene reference: + * play/stop animation, create a temp interpolation group, subscribe to + * animation-end, etc. Provided by the loader/animation subsystem. */ + readonly caps: FgCapabilities; + /** event bus the scene driver feeds */ + readonly events: FgEventBus; +} + +export interface FgAccessor { + readonly type: FgType; + readonly get: () => FgValue; + readonly set?: (value: FgValue) => void; + readonly target?: unknown; +} +``` + +### Standalone runtime functions (`flow-graph/runtime.ts`) + +```typescript +/** PULL a data input: resolve source, run its def.updateOutputs, read cache. */ +export function getDataValue(ctx: FgContext, env: FgEnv, block: FgBlock, socket: string): FgValue; +/** Write a data output into the cache (called from def.updateOutputs). */ +export function setDataValue(ctx: FgContext, block: FgBlock, socket: string, value: FgValue): void; +/** PUSH a signal: for each target, dispatch into its def.execute. */ +export function activateSignal(ctx: FgContext, env: FgEnv, block: FgBlock, socket: string): void; + +/** Instantiate runtime state for a parsed graph. */ +export function createFgContext(graph: FgGraph, opts?: { rightHanded?: boolean }): FgContext; +/** Build the resolved env (await needed defs, attach accessors/animations/bus). */ +export function createFgEnv(graph: FgGraph, wiring: FgWiring): Promise; + +/** One graph runtime = graph + context + env, owned by the scene. */ +export interface FgRuntime { + readonly graph: FgGraph; + readonly context: FgContext; + readonly env: FgEnv; + started: boolean; +} + +/** Start the graph: fire `onStart` event blocks once. */ +export function startFlowGraph(rt: FgRuntime): void; +/** Per-frame drive: pump tick events + advance pending async blocks. */ +export function tickFlowGraph(rt: FgRuntime, deltaMs: number): void; +/** Tear down: cancel pending, clear caches, detach bus listeners. */ +export function disposeFlowGraph(rt: FgRuntime): void; +``` + +### Block-type names & registry (`flow-graph/block-type.ts`, `block-registry.ts`) + +```typescript +/** Lite block type identifiers (const enum string tags). */ +export const enum FgBlockType { + // Events + SceneStart = "SceneReadyEvent", + SceneTick = "SceneTickEvent", + SendCustomEvent = "SendCustomEvent", + ReceiveCustomEvent = "ReceiveCustomEvent", + // Control flow + Branch = "Branch", Sequence = "Sequence", Switch = "Switch", + ForLoop = "ForLoop", WhileLoop = "WhileLoop", DoN = "DoN", + MultiGate = "MultiGate", WaitAll = "WaitAll", Throttle = "Throttle", + SetDelay = "SetDelay", CancelDelay = "CancelDelay", + // Data / math (subset; see block list) + Constant = "Constant", Add = "Add", Subtract = "Subtract", /* … */ + // Pointer / variable / animation + GetProperty = "GetProperty", SetProperty = "SetProperty", + JsonPointerParser = "JsonPointerParser", + GetVariable = "GetVariable", SetVariable = "SetVariable", + ValueInterpolation = "ValueInterpolation", + PlayAnimation = "PlayAnimation", StopAnimation = "StopAnimation", + // Debug + ConsoleLog = "ConsoleLog", +} + +/** + * Tree-shakable, side-effect-free. Returns a lazy loader for one def. + * Unused cases are code-split and never fetched — zero bytes for scenes + * without interactivity. Mirrors BJS blockFactory + Lite gltf-feature-registry. + */ +export function getBlockDef(type: string): () => Promise { + switch (type) { + case FgBlockType.Branch: + return async () => (await import("./blocks/control-flow/branch.js")).branchDef; + case FgBlockType.Add: + return async () => (await import("./blocks/math/add.js")).addDef; + // … one case per supported block … + default: + return null; // unknown type — caller decides (see note) + } +} +``` + +> **Note on side effects:** the `switch` function body is pure (no module-level +> allocation), so the registry module is fully tree-shakable. +> +> **Unknown ops:** `getBlockDef` returns `null` for unknown types; the **caller** +> chooses the policy. The **glTF interactivity parser fails loudly** (collects a +> structured `unsupportedOp` diagnostic and aborts/flags that graph) so a +> `KHR_interactivity` asset can't silently render a broken interaction. A +> permissive editor/snippet path (post-MVP) may instead substitute an explicit +> `noopDef`. Never silently swallow an unknown op on the KHR path — it makes +> parity failures undiagnosable. + +--- + +## Internal Architecture + +### Execution model (pull data, push signals) + +Identical semantics to BJS, re-expressed functionally: + +- **Data edges are PULL, and recompute on every pull.** When a block needs an + input, `getDataValue` looks at the socket's `source`. If wired, it finds the + producing block and **invokes that block's `def.updateOutputs` every time** + (matching BJS `FlowGraphDataConnection.getValue`, which calls the owner's + `_updateOutputs` on each read). `ctx.connectionValues` is the **transport slot** + the producer writes into and the consumer reads back — **not** a validity + cache. Do **not** skip recomputation based on a cached value: producers like + `pointer/get`, `GetVariable`, `random`, and event-payload outputs would return + stale data after an intervening `pointer/set`/`SetVariable` in the same + cascade. (A future optimization may add explicit dirty-tracking with cascade + IDs, but it must exclude all non-pure producers; the MVP recomputes.) +- **Cycles.** Data pulls assume an acyclic data subgraph (as glTF interactivity + requires). `getDataValue` carries an in-progress guard + (`ctx.executionVariables["${id}:resolving"]`) to break accidental data cycles + and return the socket default rather than recursing infinitely. +- **Type coercion on read.** `getDataValue` applies (a) any socket/port + `dataTransformer` declared by the declaration mapper, then (b) `coerceValue` + for the consumer socket's `FgType` — this is where BJS's RichType + `typeTransformer` lives (notably `Vector4`/`Matrix` → `Quaternion`). Coercion + happens at the boundary so block bodies stay type-clean. +- **Signal edges are PUSH.** `activateSignal` iterates `signalSocket.targets`; + for each, it looks up the target block's def and calls `def.execute`, passing + the incoming signal name. Execution blocks call `activateSignal` on their own + outputs to continue the cascade. +- **Event blocks** declare `event: FgEventType`. The scene driver, on receiving a + bus event, finds matching event blocks and fires their output signals + (`out` / `done`), starting a cascade. **Listener registration ordering is + significant:** `startFlowGraph` first subscribes/initializes *all* event + receivers (in init-priority order — `ReceiveCustomEvent` before scene-start-like + events, matching BJS `initPriority`), and *only then* fires the `onStart` + cascade. Otherwise a graph like `onStart → SendCustomEvent → ReceiveCustomEvent` + would drop the event because the receiver wasn't listening yet. Custom events + are **scene/coordinator-scoped**, not per-graph, so multiple `KHR_interactivity` + graphs in one asset can communicate. +- **Async blocks** (`SetDelay`, `PlayAnimation`) register an `FgPendingTask` via + `addPending(ctx, block)` (which assigns a unique token and **dedupes** so a + block re-entered while already pending does not double-tick), get `onTick`'d + each frame, and fire a completion signal (`done`) when finished, then remove + the task. A single block may own **multiple concurrent tasks** (BJS supports + several in-flight delays per block, tracked by index) — state lives on the + task record, not the block. `cancelPending` marks the matching task(s) + `canceled`; the tick loop skips canceled/removed tasks (see below). + +### Async task lifecycle (ordering hazards) + +The per-frame pending loop must be cancellation-safe. A task can be canceled or a +new task added **during** the loop by another block's signal cascade. Rules: + +``` +for task of ctx.pending.slice(): // snapshot + if task.canceled: continue // skip if canceled this frame + if !stillPending(ctx, task): continue // skip if already removed + env.defs[blockOf(task)].onTick(task, …) // may add/cancel further tasks +ctx.pending = ctx.pending.filter(t => !t.canceled && !t.done) // compact after +``` + +Tasks added mid-loop are picked up next frame (not retro-ticked), matching BJS. +Each `FgContext` has its own `pending` list, so multiple contexts (multi-actor) +never interfere. + +### Per-frame flow + +``` +scene._beforeRender(deltaMs) // existing Lite hook + └─ for rt of scene._flowGraphs: + if !rt.started: + registerEventListeners(rt) // subscribe ALL receivers first (init-priority order) + startFlowGraph(rt) // THEN fire onStart event blocks once + tickFlowGraph(rt, deltaMs): + resetCustomEventRecursionCounters(rt.context) // guard against runaway re-entrancy + env.events.pump("tick", { deltaTime: deltaMs/1000 }) // → onTick blocks + for task of ctx.pending.slice(): // cancellation-safe (see async lifecycle) + if task.canceled || !stillPending(ctx, task): continue + env.defs[blockOf(task)].onTick?.(task, ctx, env, deltaMs) + compactPending(ctx.context) +``` + +Pointer/key events are fed into `env.events` by the picking/input layer the same +way (the scene driver forwards them); event blocks for those simply subscribe to +the corresponding bus channel. + +### Custom math & types live IN the subsystem (bundle discipline) + +Lite's core `math/` module is intentionally minimal (Vec3-centric; **no Vec2, +no general quaternion/matrix algebra**). Flow-graph math blocks need Vec2, +quaternion mul/conjugate/slerp, matrix transpose/determinant/inverse/compose/ +decompose, integer bitwise ops, etc. Per GUIDANCE §4c′ (always extensions, never +bloat the core) these helpers live **inside `flow-graph/`** (e.g. +`flow-graph/fg-math.ts`, `flow-graph/custom-types/`), lazily imported by the +blocks that use them. Scenes without interactivity pay **zero bytes**. Core +`math/` is reused where it already suffices (`addVec3`, `dotVec3`, `crossVec3`, +`mat4Multiply`, `mat4Invert`, `mat4Compose`, `mat4Decompose`, `mat4FromQuat`). + +### Custom types (`flow-graph/custom-types/`) + +- `FgInteger` — glTF distinguishes `int` from `float`; represented as a tagged + plain object `{ value: number; __fgInt: true }` (no class) so type coercion and + bitwise ops work. Pure helpers `fgInt(n)`, `isFgInt(v)`. +- `FgMatrix2D` / `FgMatrix3D` — plain `Float32Array`-backed (`{ m: Float32Array }`) + for `float2x2` / `float3x3` glTF types, with pure op helpers. +- `Vec2` — add to `flow-graph/types.ts` (or a tiny local) since core math lacks it. + +### Rich-type behaviour without RichType instances (`flow-graph/rich-type.ts`) + +BJS's `RichType` carries three things Lite must preserve even though it drops the +class: a **default value**, a **typeTransformer**, and an **animationType**. + +- `defaultForType(t: FgType): FgValue` — pure switch returning the type's default + (e.g. `0`, `false`, fresh `Vec3.zero`, identity quaternion). Replaces + `RichType.defaultValue`. Constructs values **inside the function** (no + module-level allocation). +- `coerceValue(value, target: FgType): FgValue` — the home of BJS's + `typeTransformer`. Critically includes **`Vector4`/`Matrix` → `Quaternion`** and + numeric↔integer coercions. Invoked by `getDataValue` on read (step (b) above), + and by the mapper when a config/socket declares a `flowGraphType` different from + its `gltfType`. +- `animationTypeForFgType(t: FgType): number` — replaces `RichType.animationType`, + used by `ValueInterpolation`/animation blocks to pick the correct keyframe + interpolation (float/vector/quaternion/color/matrix). Quaternion targets must + resolve to slerp; the mapper's `useSlerp` flag forces `FgType.Quaternion`. + +These three pure functions are the complete replacement for the `RichType` class +and its module-scope instances. + +--- + +## glTF `KHR_interactivity` Loader Extension + +> Package path: `packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts` +> plus `flow-graph/gltf/` for the parser + declaration mapper. + +### ⚠️ The spec is NOT ratified — isolate everything spec-dependent + +`KHR_interactivity` is **still a draft / not ratified**; the op set, type system, +JSON pointer semantics, and node/declaration shapes **will change**. Babylon.js +is reworking its implementation to the newer spec draft in +**[PR #18455 "KHR_interactivity rework"](https://github.com/BabylonJS/Babylon.js/pull/18455)** +— currently **closed** (it was auto-closed for age) but **expected to be +reopened/merged soon**. So even BJS is a moving target here, and our mapping +tables must track that PR as it lands. + +**Design rule (mandatory):** the spec-volatile surface must be **quarantined in +`flow-graph/gltf/`** and depend on the runtime, never the reverse. The runtime +core (`runtime.ts`, `block-def.ts`, `context.ts`, blocks) must contain **zero** +glTF/`KHR_interactivity` knowledge, so a spec revision never touches the engine — +only the `gltf/` translation layer: + +- `interactivity-parser.ts` — JSON shape of nodes/declarations/variables/flows. +- `declaration-mapper.ts` — the op→block table (the part most likely to churn). +- `path-converter.ts` + `object-model-mapping.ts` — JSON-pointer semantics. +- a `gltf/spec-version.ts` constant + a place to branch behaviour if we must + support more than one draft simultaneously. + +**Practical guardrails so future spec changes are cheap:** +- Keep the op→block mapping a **plain-data table**, not code, so edits are diffs + to data (and so a future "import the BJS table" step stays mechanical). +- Treat the **BJS rework PR ([#18455 "KHR_interactivity rework"](https://github.com/BabylonJS/Babylon.js/pull/18455), + closed-for-age, to be reopened)** as the reference target; when it lands, + re-diff our `declaration-mapper.ts` against it. Record which BJS commit/PR our + table mirrors in a header comment so drift is auditable. +- **Version-tag** parser/mapper behaviour; if Khronos bumps the draft, add a + branch keyed on the asset's declared spec version rather than mutating the + existing path. +- Unknown/changed ops already **fail loudly** with a structured diagnostic (see + registry note) — that is the early-warning signal that the spec moved. +- The companion skill (`port-flow-graph-block.md`) is the routine for absorbing + new/changed ops as the spec and the BJS PR evolve. + +### Registration (no side effects, lazy) + +Add one tuple to `gltf-feature-registry.ts`, identical to every other feature: + +```typescript +["KHR_interactivity", () => import("./gltf-feature-interactivity.js")], +``` + +The feature implements `GltfFeature.applyAsset(meshes, root, ctx)`: + +1. Read `ctx._json.extensions.KHR_interactivity.graphs`. +2. For each graph, run the **interactivity parser** → `FgGraph` (plain data). +3. **Resolve JSON pointers** in the graph to `FgAccessor`s over the already-built + Lite scene objects (nodes/meshes/cameras/materials/animations) via a path + converter (Lite analogue of BJS `gltfPathToObjectConverter` + + `objectModelMapping`). +4. Build `FgEnv` (await needed block defs, attach accessors/animations/event bus). +5. Return `{ flowGraphs: [FgRuntime] }` merged into the `AssetContainer`. + `addToScene` pushes them onto `scene._flowGraphs` and registers the + `_beforeRender` driver + disposer. + +> The loader sets the equivalent of BJS's `_skipStartAnimationStep` — animations +> referenced by interactivity must **not** auto-play; the graph controls them. + +### Interactivity parser (`flow-graph/gltf/interactivity-parser.ts`) + +Pure translation of the glTF interactivity JSON +(`types`, `declarations`, `variables`, `events`, `nodes`, `flows`) into an +`FgGraph`. Stages mirror BJS `InteractivityGraphToFlowGraphParser`: +`parseTypes → parseDeclarations → parseVariables → parseEvents → parseNodes → +parseConnections`. Output is plain data — **no block instances, no class registry**. + +glTF→Lite type table (from BJS, kept verbatim): + +| glTF type | length | FgType | element | +|---|---|---|---| +| `float` | 1 | Number | number | +| `bool` | 1 | Boolean | boolean | +| `int` | 1 | Integer | number | +| `float2` | 2 | Vector2 | number | +| `float3` | 3 | Vector3 | number | +| `float4` | 4 | Vector4 | number | +| `float2x2` | 4 | Matrix2D | number | +| `float3x3` | 9 | Matrix3D | number | +| `float4x4` | 16 | Matrix | number | + +### Declaration mapper (`flow-graph/gltf/declaration-mapper.ts`) + +The largest single artefact (BJS = ~1,851 lines, **168 ops**). It is a **data +table** mapping each glTF op (`"math/add"`, `"flow/branch"`, `"pointer/set"`, …) +to: target Lite block type(s), socket renames, config translation, value +transformers (e.g. seconds→frames for animation time), and multi-block expansions +(e.g. `pointer/set` → `SetProperty` + `JsonPointerParser` linked by an +inter-block connector). This is plain data + small pure transformer functions — +no classes. Porting entries is the bulk of ongoing work and is exactly what the +companion **skill** automates. + +```typescript +export interface FgDeclMapping { + blocks: FgBlockType[]; + inputs?: { values?: Record; flows?: Record }; + outputs?: { values?: Record; flows?: Record }; + configuration?: Record; + interBlockConnectors?: { input: string; output: string; inBlock: number; outBlock: number }[]; + extraProcessor?: (gltfBlock: unknown, /* … */) => FgBlock[]; +} +export function getMappingForOp(op: string, extension?: string): FgDeclMapping | undefined; +``` + +--- + +## Block coverage for the MVP (KHR_interactivity subset) + +`KHR_interactivity` maps to ~60 distinct Lite block types (the 168 ops collapse +onto fewer blocks via config). MVP target set, by category: + +- **Events (4):** `onStart`→SceneStart, `onTick`→SceneTick, `event/send`→SendCustomEvent, `event/receive`→ReceiveCustomEvent. +- **Flow control (11):** branch, sequence, switch, while, for, doN, multiGate, waitAll, throttle, setDelay, cancelDelay. +- **Math constants/arithmetic/comparison/trig/exp (~60 ops → ~40 blocks):** E, Pi, Inf, NaN, random; abs/sign/trunc/floor/ceil/round/fract/neg; add/sub/mul/div/rem/min/max/clamp/saturate/mix; eq/lt/le/gt/ge/select; sin…atanh; exp/log/log2/log10/sqrt/cbrt/pow; isNaN/isInf; rad/deg. +- **Vector/matrix/quaternion (~25 ops):** length, normalize, dot, cross, rotate2D/3D, transform, transpose, determinant, inverse, matMul, matCompose/Decompose, combineN/extractN, quat ops. +- **Integer bitwise (9):** not/and/or/xor/asr/lsl/clz/ctz/popcnt. +- **Type conversion (6):** bool/int/float cross conversions. +- **Variables (3):** get, set, interpolate. +- **Pointers (3):** get, set, interpolate (+ JsonPointerParser). +- **Animation (3):** start, stop, stopAt (+ ArrayIndex / data provider). +- **Debug (1):** log. + +Each block is one small file under `flow-graph/blocks//.ts` +exporting a `FgBlockDef`. See the skill doc for the exact file template. + +--- + +## State Machine / Lifecycle + +``` +load .glb with KHR_interactivity + └─ gltf-feature-interactivity.applyAsset + ├─ interactivity-parser → FgGraph (pure data) + ├─ path-converter → FgAccessor map + ├─ createFgEnv (await needed defs, wire bus/accessors/animations) + ├─ createFgContext (seed userVariables) + └─ return { flowGraphs:[ FgRuntime ] } +addToScene + └─ scene._flowGraphs.push(rt); onBeforeRender(scene, drive); onSceneDispose(scene, () => disposeFlowGraph(rt)) +first frame + └─ registerEventListeners(rt) // subscribe ALL receivers first, init-priority order + └─ startFlowGraph(rt) // THEN fire onStart cascade once +each frame + └─ tickFlowGraph(rt, deltaMs) // reset recursion counters → pump tick → advance pending async +dispose + └─ disposeFlowGraph(rt) // cancel pending tasks, clear ctx, detach bus listeners +``` + +--- + +## Babylon.js Equivalence Map + +| Babylon.js | Babylon Lite | +|---|---| +| `FlowGraphBlock` (class) | `FgBlock` (data) + `FgBlockDef` (functions) | +| `FlowGraphExecutionBlock._execute` | `FgBlockDef.execute` | +| `FlowGraphBlock._updateOutputs` | `FgBlockDef.updateOutputs` | +| `FlowGraphAsyncExecutionBlock` | `FgBlockDef.execute` (starts task) + `onTick(task)` + `cancelPending` | +| `FlowGraphEventBlock` | `FgBlock.event` + scene-driven bus dispatch | +| `FlowGraphDataConnection.getValue/setValue` | `getDataValue` / `setDataValue` | +| `FlowGraphSignalConnection._activateSignal` | `activateSignal` | +| `FlowGraphContext` | `FgContext` (data) + `FgEnv` (resolved caps) | +| `FlowGraphCoordinator` (multi-graph) | `scene._flowGraphs` + scene driver | +| `FlowGraphSceneEventCoordinator` | `FgEventBus` fed by scene/input layer | +| `RichType` instances | `const enum FgType` + `defaultForType()` | +| `RegisterClass` global registry | `getBlockDef` dynamic-import switch | +| `blockFactory` (already lazy) | `getBlockDef` (same shape, no classes) | +| `gltfPathToObjectConverter` + `objectModelMapping` | `flow-graph/gltf/path-converter.ts` → `FgAccessor` | +| `InteractivityGraphToFlowGraphParser` | `flow-graph/gltf/interactivity-parser.ts` | +| `declarationMapper.ts` table | `flow-graph/gltf/declaration-mapper.ts` table | +| `KHR_interactivity` loader extension | `loader-gltf/gltf-feature-interactivity.ts` | + +--- + +## Dependencies + +- **Core math** (`src/math/`): reuse `addVec3`, `dotVec3`, `crossVec3`, + `mat4Multiply`, `mat4Invert`, `mat4Compose`, `mat4Decompose`, `mat4FromQuat`. +- **Animation** (`src/animation/`): `AnimationGroup` handles for animation blocks; + `ValueInterpolation` reuses the interpolation/easing machinery where possible. +- **Scene** (`src/scene/`): `onBeforeRender`, `onSceneDispose`, `addToScene` + dispatch, the `_flowGraphs` array (new field). +- **Loader-gltf** (`src/loader-gltf/`): `GltfFeature` hook + registry tuple; the + node/material/camera maps the path-converter resolves against. +- **Picking/input**: pointer & key events forwarded into `FgEventBus`. +- **New, subsystem-local:** `flow-graph/fg-math.ts`, `flow-graph/custom-types/`. + +--- + +## Test Specification + +- **Unit (vitest):** per-block defs — feed inputs, assert outputs/signals + (pure functions, trivial to test). Runtime: **pull recompute** (verify a + producer re-runs on every read, no stale cache), push cascade, async delay + countdown with **cancellation mid-tick** and **multiple concurrent delays per + block**, event dispatch with **listener-before-onStart ordering** (custom event + fired from `onStart` is received). +- **Math parity tests (focused):** quaternion mul/conjugate/slerp, + matrix compose/decompose/transpose/inverse, `math/transform`, and the + **accessor-boundary handedness** (right-handed glTF value → Lite LH) — these are + the easiest places to diverge on multiplication order / row-vs-column layout. +- **Coercion tests:** `Vector4`/`Matrix` → `Quaternion` via `coerceValue`; + `animationTypeForFgType` picks slerp for quaternion targets. +- **Parser unit tests:** representative interactivity JSON → expected `FgGraph` + topology; declaration-mapper entries → expected blocks/sockets/config; an + **unknown op fails loudly** with a structured diagnostic (not a silent no-op). +- **Integration / parity:** a `KHR_interactivity` sample `.glb` (e.g. a + Khronos sample like a button that animates on click, or `onStart`→rotate) + loaded in Lite; assert the driven property changes over frames. Where a visual + golden is warranted, follow §2c animated-scene golden convention + (`?seekTime=` freeze). Add a `scene-config.json` entry + bundle-size ceiling + only when a parity scene is added. +- **Bundle-size guard:** verify a non-interactivity scene's bundle is + **byte-unchanged** (the subsystem must be fully tree-shaken away when unused). + +--- + +## File Manifest (target) + +``` +packages/babylon-lite/src/flow-graph/ + index.ts # public exports + types.ts # FgValue, FgType, FgBlock, FgGraph, sockets + block-def.ts # FgBlockDef, FgBlockShape + block-type.ts # FgBlockType const enum + block-registry.ts # getBlockDef() dynamic-import switch + context.ts # FgContext, FgEnv, FgAccessor + runtime.ts # getDataValue/setDataValue/activateSignal, FgRuntime, start/tick/dispose + event-bus.ts # FgEventBus, FgEventType + fg-math.ts # Vec2 + quaternion/matrix/bitwise helpers (lazy) + rich-type.ts # defaultForType(), coerceValue(), animationTypeForFgType() + custom-types/ + fg-integer.ts + fg-matrix.ts + blocks/ + events/{scene-start,scene-tick,send-custom-event,receive-custom-event}.ts + control-flow/{branch,sequence,switch,for-loop,while-loop,do-n,multi-gate,wait-all,throttle,set-delay,cancel-delay}.ts + math/{add,subtract,…}.ts + data/{constant,get-variable,set-variable,get-property,set-property,json-pointer-parser}.ts + animation/{play-animation,stop-animation,value-interpolation}.ts + debug/console-log.ts + noop.ts + gltf/ + interactivity-parser.ts + declaration-mapper.ts + path-converter.ts + object-model-mapping.ts +packages/babylon-lite/src/loader-gltf/ + gltf-feature-interactivity.ts # GltfFeature.applyAsset + gltf-feature-registry.ts # + ["KHR_interactivity", () => import(...)] +packages/babylon-lite/src/scene/ + scene-core.ts # + _flowGraphs field + addToScene dispatch +``` + +--- + +## Phased Implementation Plan + +> Each phase is independently mergeable; engine-changing phases must pass +> `pnpm build:bundle-scenes` + `pnpm test:parity` and commit the regenerated +> `lab/public/bundle/manifest.json` (GUIDANCE §0c). + +**Phase 0 — Spec & skill (this doc + `port-flow-graph-block.md`).** ✅ no code. + +**Phase 1 — Core runtime, no blocks.** `types.ts`, `block-def.ts`, +`context.ts`, `runtime.ts`, `event-bus.ts`, `rich-type.ts`, `block-type.ts`, +empty `block-registry.ts`. Pure functions only. Full unit tests for pull +recompute, push cascade, async pending (dedupe + cancel mid-tick), event +dispatch + listener ordering, with a couple of hand-built test defs. Wire +`scene._flowGraphs` + driver (behind a no-op when empty so bundle is unchanged). +**Guard:** non-interactivity bundle byte-identical. + +**Phase 2 — Vertical slice (end-to-end EARLY).** Implement the *minimum* set that +proves the whole pipeline before the long tail of blocks: `SceneStart`, +`SceneTick`, `Branch`, `Sequence`, one math op (`Add`), `GetProperty`/`SetProperty` ++ `JsonPointerParser`, `PlayAnimation`/`StopAnimation`; plus a **minimal** +parser + declaration-mapper (just those ops) + path-converter + the +`gltf-feature-interactivity.ts` loader hook; plus **one** Khronos +`KHR_interactivity` sample running end-to-end as a parity scene. This surfaces +mapper/accessor/runtime/handedness mismatches immediately rather than after the +whole block library is written. + +**Phase 3 — Broaden block library.** Fill in the rest of the ~60 blocks +(full math/trig/exp, vector/matrix/quaternion, integer bitwise, type conversion, +variables, interpolation, control-flow remainder) + `fg-math.ts` + +`custom-types/**`; register each in `block-registry.ts`. Unit-test each def. + +**Phase 4 — Complete the declaration mapper + more scenes.** Extend `gltf/` +mapper/parser to the full 168-op surface; add further `KHR_interactivity` parity +scenes, `scene-config.json` entries, bundle ceilings. Run full `pnpm test`. + +**Phase 5+ (post-MVP, out of MVP scope):** remaining blocks toward full parity; +BJS snippet/editor serialization format; multi-context coordinator; debugger +hooks; physics/audio interactivity ops. + +--- + +## Open Questions / Risks + +- **⚠️ Unratified spec (highest-churn risk).** `KHR_interactivity` is a draft; the + op set/types/pointer semantics will change, and BJS is reworking its + implementation to the newer draft in + **[PR #18455](https://github.com/BabylonJS/Babylon.js/pull/18455)** (closed for + age, to be reopened) — so even BJS is a moving target. Mitigation is + structural — all spec-dependent code is quarantined in `flow-graph/gltf/` + (parser, mapper, path-converter), version-tagged, and mirrored against a + recorded BJS commit; the runtime core stays spec-agnostic so revisions never + touch the engine. Re-sync the mapper when #18455 lands. See the loader + section's "spec is NOT ratified" subsection. +- **Event bus surface.** Exact channels (tick/start/pointer/key/custom) and how + the picking/input layer forwards pointer & key events need a small design pass + in Phase 1; the bus must stay pure data + standalone subscribe/pump fns. +- **`ValueInterpolation` reuse.** Decide how much of `src/animation/` easing the + interpolation block can reuse vs. a subsystem-local easing helper. +- **Right-handedness.** glTF graphs are right-handed; confirm where Z/quaternion + coercion happens on accessor read/write to match Lite's LH convention. +- **Parser scale.** The declaration mapper is large; Phases 3–4 should land an + initial subset (events + flow + core math + pointer get/set) before the long + tail of math ops, so an end-to-end scene works early. From 1b7ec2839b32bdf0ac0a988e3b3c44095f631b75 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 13:18:54 +0200 Subject: [PATCH 02/13] feat(flow-graph): add pure-state core runtime (Phase 1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements the spec-agnostic FlowGraph core for Babylon Lite as plain data + standalone functions (no classes), per docs/lite/architecture/42-flow-graph.md: - types/block-def/block-type/context: FgValue, FgType, FgBlock, FgGraph, sockets, FgBlockDef, FgContext/FgEnv, FgPendingTask, custom FgInteger/FgMatrix2D/3D. - runtime: pull data edges (recompute every read, cycle guard), push signal cascade, cancellation-safe async pending loop (dedupe + cancel mid-tick), init-priority event listener ordering, start/tick/dispose lifecycle. - event-bus: pure-data bus + standalone subscribe/pump/clear. - rich-type: defaultForType/coerceValue (incl Vector4|Matrix->Quaternion) / animationTypeForFgType — the RichType replacement. - block-registry: side-effect-free getBlockDef switch (no blocks yet; Phase 2+). - scene-flow-graph: attach/detach via onBeforeRender/onSceneDispose seams so scene-core gains only an optional type-only _flowGraphs field. Scene wiring is byte-neutral: the per-scene bundle manifest is unchanged, so non-interactivity scenes pay zero bytes. 24 new unit tests (608 total) pass; full lint clean. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/lite/architecture/42-flow-graph.md | 74 +++- .../babylon-lite/src/flow-graph/block-def.ts | 40 ++ .../src/flow-graph/block-registry.ts | 25 ++ .../babylon-lite/src/flow-graph/block-type.ts | 44 ++ .../babylon-lite/src/flow-graph/context.ts | 90 ++++ .../src/flow-graph/custom-types/fg-integer.ts | 20 + .../src/flow-graph/custom-types/fg-matrix.ts | 52 +++ .../babylon-lite/src/flow-graph/event-bus.ts | 67 +++ packages/babylon-lite/src/flow-graph/index.ts | 50 +++ .../babylon-lite/src/flow-graph/rich-type.ts | 142 ++++++ .../babylon-lite/src/flow-graph/runtime.ts | 328 ++++++++++++++ .../src/flow-graph/scene-flow-graph.ts | 46 ++ packages/babylon-lite/src/flow-graph/types.ts | 92 ++++ packages/babylon-lite/src/index.ts | 30 ++ packages/babylon-lite/src/scene/scene-core.ts | 7 + tests/lite/unit/flow-graph-rich-type.test.ts | 93 ++++ tests/lite/unit/flow-graph-runtime.test.ts | 418 ++++++++++++++++++ 17 files changed, 1602 insertions(+), 16 deletions(-) create mode 100644 packages/babylon-lite/src/flow-graph/block-def.ts create mode 100644 packages/babylon-lite/src/flow-graph/block-registry.ts create mode 100644 packages/babylon-lite/src/flow-graph/block-type.ts create mode 100644 packages/babylon-lite/src/flow-graph/context.ts create mode 100644 packages/babylon-lite/src/flow-graph/custom-types/fg-integer.ts create mode 100644 packages/babylon-lite/src/flow-graph/custom-types/fg-matrix.ts create mode 100644 packages/babylon-lite/src/flow-graph/event-bus.ts create mode 100644 packages/babylon-lite/src/flow-graph/index.ts create mode 100644 packages/babylon-lite/src/flow-graph/rich-type.ts create mode 100644 packages/babylon-lite/src/flow-graph/runtime.ts create mode 100644 packages/babylon-lite/src/flow-graph/scene-flow-graph.ts create mode 100644 packages/babylon-lite/src/flow-graph/types.ts create mode 100644 tests/lite/unit/flow-graph-rich-type.test.ts create mode 100644 tests/lite/unit/flow-graph-runtime.test.ts diff --git a/docs/lite/architecture/42-flow-graph.md b/docs/lite/architecture/42-flow-graph.md index 1a8fac1a39..fa640c6fca 100644 --- a/docs/lite/architecture/42-flow-graph.md +++ b/docs/lite/architecture/42-flow-graph.md @@ -88,10 +88,17 @@ GUIDANCE §4b forbids components from referencing the scene. A flow graph obviously needs to read/write node transforms, fire on scene events, and play animations — so the wiring is inverted exactly like the animation subsystem: -- The **scene owns** the graphs: `scene._flowGraphs: FgRuntime[]` (plain data). -- The graph is **driven** by the scene's existing per-frame hook - (`onBeforeRender(scene, cb)` → `scene._beforeRender`), exactly how animation - groups are ticked (`ctx._beforeRender.push(deltaMs => …)`). +- The **scene owns** the graphs via an **optional** `scene._flowGraphs?: + FgRuntime[]` field (plain data). It is left `undefined` for non-interactivity + scenes and **lazily created by `attachFlowGraph()`** — so core stays + byte-identical when no graph is attached (verified: the per-scene bundle + manifest is unchanged by this subsystem's existence). +- The graph is **driven** through the scene's existing generic seams, NOT a + hardcoded loop in `scene-core.ts` (GUIDANCE §4c′): `attachFlowGraph()` registers + a `onBeforeRender(scene, cb)` driver (exactly how animation groups are ticked) + and an `onSceneDispose(scene, cb)` teardown. The flow-graph drive therefore + lives entirely in `flow-graph/scene-flow-graph.ts`, pulled into a bundle only + when something imports it (the glTF interactivity feature or user code). - Blocks **never see the scene**. Anything scene-dependent is pre-resolved by the **loader** into plain capability objects stored in `FgEnv`: - **Object accessors** (`FgAccessor { get, set?, target }`) — closures over the @@ -235,6 +242,8 @@ export interface FgContext { readonly pending: FgPendingTask[]; /** glTF graphs are right-handed; drives Z/handedness coercion on read */ readonly rightHanded: boolean; + /** @internal monotonic token source for addPending (unique task tokens) */ + _tokenSeq: number; } /** One outstanding async task (a delay, an animation). Token enables precise cancel. */ @@ -242,6 +251,8 @@ export interface FgPendingTask { readonly blockId: string; readonly token: number; // unique per task; a block may own several concurrently canceled: boolean; + /** set by onTick when finished; compacted out after the frame's pending loop */ + done: boolean; state: Record; // e.g. remainingMs, delayIndex, animation handle } @@ -282,8 +293,9 @@ export function activateSignal(ctx: FgContext, env: FgEnv, block: FgBlock, socke /** Instantiate runtime state for a parsed graph. */ export function createFgContext(graph: FgGraph, opts?: { rightHanded?: boolean }): FgContext; -/** Build the resolved env (await needed defs, attach accessors/animations/bus). */ -export function createFgEnv(graph: FgGraph, wiring: FgWiring): Promise; +/** Build the resolved env (await needed defs, attach accessors/animations/bus). + * FAILS LOUDLY (throws) on an unsupported block type — see registry note. */ +export function createFgEnv(graph: FgGraph, wiring?: FgWiring): Promise; /** One graph runtime = graph + context + env, owned by the scene. */ export interface FgRuntime { @@ -291,14 +303,37 @@ export interface FgRuntime { readonly context: FgContext; readonly env: FgEnv; started: boolean; + /** @internal bus unsubscribe fns registered at start, called on dispose */ + _unsub: (() => void)[]; } -/** Start the graph: fire `onStart` event blocks once. */ +/** Convenience: build env (awaiting defs) + context in one call. */ +export function createFgRuntime(graph: FgGraph, wiring?: FgWiring, opts?: { rightHanded?: boolean }): Promise; + +/** Start the graph: subscribe ALL non-start receivers first (init-priority + * order), THEN fire `onStart` event blocks once. Idempotent. */ export function startFlowGraph(rt: FgRuntime): void; /** Per-frame drive: pump tick events + advance pending async blocks. */ export function tickFlowGraph(rt: FgRuntime, deltaMs: number): void; /** Tear down: cancel pending, clear caches, detach bus listeners. */ export function disposeFlowGraph(rt: FgRuntime): void; + +// Pending-task helpers used by async block defs and the tick loop: +export function addPending(ctx: FgContext, block: FgBlock, state?: Record): FgPendingTask; +export function stillPending(ctx: FgContext, task: FgPendingTask): boolean; +export function cancelPendingForBlock(ctx: FgContext, block: FgBlock): void; +export function compactPending(ctx: FgContext): void; +``` + +### Scene attachment (`flow-graph/scene-flow-graph.ts`) + +```typescript +/** Attach a runtime to a scene: starts on the first frame, ticks every frame, + * auto-disposed on scene dispose. Lazily creates `scene._flowGraphs`. Uses the + * generic onBeforeRender/onSceneDispose seams (no scene-core loop). */ +export function attachFlowGraph(scene: SceneContext, rt: FgRuntime): void; +/** Detach + dispose a previously attached runtime. */ +export function detachFlowGraph(scene: SceneContext, rt: FgRuntime): void; ``` ### Block-type names & registry (`flow-graph/block-type.ts`, `block-registry.ts`) @@ -726,9 +761,10 @@ packages/babylon-lite/src/flow-graph/ block-registry.ts # getBlockDef() dynamic-import switch context.ts # FgContext, FgEnv, FgAccessor runtime.ts # getDataValue/setDataValue/activateSignal, FgRuntime, start/tick/dispose - event-bus.ts # FgEventBus, FgEventType + event-bus.ts # FgEventBus, FgEventType, subscribe/pump/clear fg-math.ts # Vec2 + quaternion/matrix/bitwise helpers (lazy) rich-type.ts # defaultForType(), coerceValue(), animationTypeForFgType() + scene-flow-graph.ts # attachFlowGraph/detachFlowGraph (onBeforeRender/onSceneDispose seams) custom-types/ fg-integer.ts fg-matrix.ts @@ -749,9 +785,13 @@ packages/babylon-lite/src/loader-gltf/ gltf-feature-interactivity.ts # GltfFeature.applyAsset gltf-feature-registry.ts # + ["KHR_interactivity", () => import(...)] packages/babylon-lite/src/scene/ - scene-core.ts # + _flowGraphs field + addToScene dispatch + scene-core.ts # + optional `_flowGraphs?` field (type-only; zero runtime cost) ``` +> Note: the scene driver is NOT hardcoded in `scene-core.ts`. `scene-flow-graph.ts` +> attaches via the existing `onBeforeRender`/`onSceneDispose` seams, so non- +> interactivity scenes stay byte-identical (verified against the bundle manifest). + --- ## Phased Implementation Plan @@ -760,15 +800,17 @@ packages/babylon-lite/src/scene/ > `pnpm build:bundle-scenes` + `pnpm test:parity` and commit the regenerated > `lab/public/bundle/manifest.json` (GUIDANCE §0c). -**Phase 0 — Spec & skill (this doc + `port-flow-graph-block.md`).** ✅ no code. +**Phase 0 — Spec & skill (this doc + `port-flow-graph-block.md`).** ✅ DONE — no code. -**Phase 1 — Core runtime, no blocks.** `types.ts`, `block-def.ts`, +**Phase 1 — Core runtime, no blocks.** ✅ **DONE.** `types.ts`, `block-def.ts`, `context.ts`, `runtime.ts`, `event-bus.ts`, `rich-type.ts`, `block-type.ts`, -empty `block-registry.ts`. Pure functions only. Full unit tests for pull -recompute, push cascade, async pending (dedupe + cancel mid-tick), event -dispatch + listener ordering, with a couple of hand-built test defs. Wire -`scene._flowGraphs` + driver (behind a no-op when empty so bundle is unchanged). -**Guard:** non-interactivity bundle byte-identical. +`custom-types/{fg-integer,fg-matrix}.ts`, `scene-flow-graph.ts`, and an empty +`block-registry.ts`. Pure functions only. 24 unit tests cover pull recompute, +push cascade, branch routing, async pending (countdown, dedupe, cancel +mid-tick, no retro-tick), event dispatch + custom-event-during-start ordering, +tick pump, dispose, variable seeding, loud-fail on unknown ops, and rich-type +defaults/coercion. Scene drive wired via the `onBeforeRender`/`onSceneDispose` +seams. **Guard met:** non-interactivity bundle manifest byte-identical. **Phase 2 — Vertical slice (end-to-end EARLY).** Implement the *minimum* set that proves the whole pipeline before the long tail of blocks: `SceneStart`, diff --git a/packages/babylon-lite/src/flow-graph/block-def.ts b/packages/babylon-lite/src/flow-graph/block-def.ts new file mode 100644 index 0000000000..3c434c172c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/block-def.ts @@ -0,0 +1,40 @@ +// The pure behaviour record for one block type. No classes, no `this`. +// Exactly ONE `FgBlockDef` per block kind; this is what a porter writes +// (see .github/copilot/skills/port-flow-graph-block.md). + +import type { FgContext, FgEnv, FgPendingTask } from "./context.js"; +import type { FgBlock, FgDataSocket, FgEventType, FgSignalSocket } from "./types.js"; + +/** The shape a def declares when a block is instantiated. */ +export interface FgBlockShape { + dataIn?: FgDataSocket[]; + dataOut?: FgDataSocket[]; + signalIn?: FgSignalSocket[]; + signalOut?: FgSignalSocket[]; + event?: FgEventType; +} + +/** + * Pure behaviour record for one block type. No classes, no `this`. + * A def is stateless — all per-run state lives in `FgContext`, keyed by block id. + */ +export interface FgBlockDef { + readonly type: string; + + /** Declare sockets/signals from config (called once at instantiation). */ + readonly build: (config: Readonly> | undefined) => FgBlockShape; + + /** DATA blocks: compute outputs from inputs (PULL). Writes via `setDataValue`. */ + readonly updateOutputs?: (block: FgBlock, ctx: FgContext, env: FgEnv) => void; + + /** EXECUTION blocks: run when an input signal fires (PUSH). For async blocks + * this is also where a task is started, via `addPending(ctx, block)`. */ + readonly execute?: (block: FgBlock, ctx: FgContext, env: FgEnv, incomingSignal: string) => void; + + /** ASYNC blocks: advance one outstanding task each frame (e.g. delay + * countdown, animation progress). The tick loop passes the specific task. */ + readonly onTick?: (block: FgBlock, ctx: FgContext, env: FgEnv, deltaMs: number, task: FgPendingTask) => void; + + /** ASYNC blocks: teardown hook called on dispose/cancel; mark tasks canceled. */ + readonly cancelPending?: (block: FgBlock, ctx: FgContext, env: FgEnv) => void; +} diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts new file mode 100644 index 0000000000..a11df6c23c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -0,0 +1,25 @@ +// Tree-shakable, side-effect-free block-def registry. Returns a lazy loader for +// one block def, or `null` for an unknown type. Each `case` dynamic-imports a +// single block module so unused blocks are code-split and never fetched — zero +// bytes for scenes without interactivity. Mirrors BJS `blockFactory` and Lite's +// `gltf-feature-registry`. +// +// Phase 1 ships NO blocks, so every type currently resolves to `null`. As blocks +// land (Phase 2+), add one `case` per block here. The `switch` body stays pure +// (no module-level allocation), keeping this module fully tree-shakable. +// +// Unknown-op policy lives in the CALLER: `createFgEnv` (KHR_interactivity path) +// fails loudly on `null`; a permissive editor path (post-MVP) may substitute a +// no-op. Never silently swallow an unknown op on the KHR path. + +import type { FgBlockDef } from "./block-def.js"; + +export function getBlockDef(type: string): (() => Promise) | null { + switch (type) { + // Phase 2 will add e.g.: + // case FgBlockType.Branch: + // return async () => (await import("./blocks/control-flow/branch.js")).branchDef; + default: + return null; + } +} diff --git a/packages/babylon-lite/src/flow-graph/block-type.ts b/packages/babylon-lite/src/flow-graph/block-type.ts new file mode 100644 index 0000000000..6217902d16 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/block-type.ts @@ -0,0 +1,44 @@ +// Lite block-type identifiers. `const enum` string tags → erased at build. +// String values mirror the BJS `FlowGraphBlockNames` / glTF op identifiers +// where practical so the declaration mapper can pass them through. +// Phase 1 ships NO block implementations; this enum is the stable name surface +// that block-registry.ts and the gltf mapper resolve against as blocks land. + +export const enum FgBlockType { + // ─── Events ─────────────────────────────────────────────── + SceneStart = "SceneReadyEvent", + SceneTick = "SceneTickEvent", + SendCustomEvent = "SendCustomEvent", + ReceiveCustomEvent = "ReceiveCustomEvent", + + // ─── Control flow ───────────────────────────────────────── + Branch = "Branch", + Sequence = "Sequence", + Switch = "Switch", + ForLoop = "ForLoop", + WhileLoop = "WhileLoop", + DoN = "DoN", + MultiGate = "MultiGate", + WaitAll = "WaitAll", + Throttle = "Throttle", + SetDelay = "SetDelay", + CancelDelay = "CancelDelay", + + // ─── Data / math (subset; broadened in Phase 3) ─────────── + Constant = "Constant", + Add = "Add", + Subtract = "Subtract", + + // ─── Pointer / variable / animation ─────────────────────── + GetProperty = "GetProperty", + SetProperty = "SetProperty", + JsonPointerParser = "JsonPointerParser", + GetVariable = "GetVariable", + SetVariable = "SetVariable", + ValueInterpolation = "ValueInterpolation", + PlayAnimation = "PlayAnimation", + StopAnimation = "StopAnimation", + + // ─── Debug ──────────────────────────────────────────────── + ConsoleLog = "ConsoleLog", +} diff --git a/packages/babylon-lite/src/flow-graph/context.ts b/packages/babylon-lite/src/flow-graph/context.ts new file mode 100644 index 0000000000..8e71620eb8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/context.ts @@ -0,0 +1,90 @@ +// Per-execution MUTABLE state (`FgContext`) and per-graph RESOLVED capabilities +// (`FgEnv`) — both plain data. A def is stateless; everything mutable lives here +// keyed by block id. The loader wires `FgEnv` (accessors, animations, caps, bus) +// before the graph runs so blocks never touch the scene directly. + +import type { AnimationGroup } from "../animation/animation-group.js"; +import type { FgBlockDef } from "./block-def.js"; +import type { FgEventBus } from "./event-bus.js"; +import type { FgGraph, FgType, FgValue } from "./types.js"; + +/** Per-execution-instance MUTABLE state — plain data. */ +export interface FgContext { + /** Data transport slots: `${blockId}:${socket}` → last value the producer + * wrote. NOT a validity cache — producers recompute on every pull. */ + readonly connectionValues: Record; + /** Per-block scratch: `${blockId}:${key}` → value (counters, async tokens, + * the data-pull resolving guard, last event payload). */ + readonly executionVariables: Record; + /** Live graph variable values (seeded from `FgGraph.variables`). */ + readonly userVariables: Record; + /** Async task records, ticked each frame (deduped; carry cancel tokens). */ + readonly pending: FgPendingTask[]; + /** glTF graphs are right-handed; drives Z/handedness coercion on read. */ + readonly rightHanded: boolean; + /** @internal Monotonic token source for `addPending`. */ + _tokenSeq: number; +} + +/** One outstanding async task (a delay, an animation). The unique `token` + * enables precise cancellation and lets a block own several tasks at once. */ +export interface FgPendingTask { + readonly blockId: string; + /** Unique per task; a block may own several concurrently. */ + readonly token: number; + canceled: boolean; + /** Set by a def's `onTick` when the task has finished; compacted out after + * the frame's pending loop. */ + done: boolean; + /** Task-local state (e.g. `remainingMs`, `delayIndex`, animation handle). */ + state: Record; +} + +/** Scene-owned capabilities a block may invoke WITHOUT a scene reference. + * Provided by the loader/animation subsystem. All optional — Phase 1 ships + * none; animation/interpolation blocks (Phase 3) consume these. */ +export interface FgCapabilities { + /** Play an animation group (resolved from a glTF animation index). */ + readonly playAnimation?: (group: AnimationGroup, opts?: { speed?: number; loop?: boolean; from?: number; to?: number }) => void; + /** Stop a playing animation group. */ + readonly stopAnimation?: (group: AnimationGroup) => void; + /** Subscribe to an animation group's end; returns an unsubscribe fn. */ + readonly onAnimationEnd?: (group: AnimationGroup, cb: () => void) => () => void; +} + +/** Per-graph RESOLVED capabilities, wired by the loader. Read-mostly. */ +export interface FgEnv { + readonly graph: FgGraph; + /** Block defs resolved up-front (awaited dynamic imports), type → def. */ + readonly defs: Record; + /** Scene-object accessors resolved from JSON pointers, keyed by pointer id. */ + readonly accessors: Record; + /** Animation handles by glTF animation index. */ + readonly animations: readonly AnimationGroup[]; + /** Scene-owned capabilities blocks may invoke without a scene reference. */ + readonly caps: FgCapabilities; + /** Event bus the scene driver feeds (shared across graphs in a scene). */ + readonly events: FgEventBus; +} + +/** A resolved JSON-pointer accessor onto a scene object property. */ +export interface FgAccessor { + readonly type: FgType; + readonly get: () => FgValue; + readonly set?: (value: FgValue) => void; + readonly target?: unknown; +} + +/** Pre-resolved inputs to `createFgEnv`. Everything scene-dependent is wired + * here by the loader; the runtime only resolves block defs from these + the + * registry. */ +export interface FgWiring { + accessors?: Record; + animations?: readonly AnimationGroup[]; + caps?: FgCapabilities; + /** Shared scene/coordinator bus. A fresh one is created if omitted. */ + events?: FgEventBus; + /** Pre-supplied defs by type — bypasses the dynamic-import registry. Used by + * tests (hand-built defs) and to override/extend the registry. */ + defs?: Record; +} diff --git a/packages/babylon-lite/src/flow-graph/custom-types/fg-integer.ts b/packages/babylon-lite/src/flow-graph/custom-types/fg-integer.ts new file mode 100644 index 0000000000..5bcac1e9d5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/custom-types/fg-integer.ts @@ -0,0 +1,20 @@ +// glTF `int` is distinct from `float`. Represented as a tagged plain object +// (no class) so type coercion and bitwise ops can detect and operate on it. +// Pure helpers only; zero module-level allocation. + +/** A tagged 32-bit integer value. glTF `int` maps to this. */ +export interface FgInteger { + readonly value: number; + /** @internal Discriminant tag. */ + readonly __fgInt: true; +} + +/** Construct an `FgInteger`, normalizing to a 32-bit signed integer. */ +export function fgInt(n: number): FgInteger { + return { value: n | 0, __fgInt: true }; +} + +/** Type guard for `FgInteger`. */ +export function isFgInt(v: unknown): v is FgInteger { + return typeof v === "object" && v !== null && (v as FgInteger).__fgInt === true; +} diff --git a/packages/babylon-lite/src/flow-graph/custom-types/fg-matrix.ts b/packages/babylon-lite/src/flow-graph/custom-types/fg-matrix.ts new file mode 100644 index 0000000000..2b25afd7a5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/custom-types/fg-matrix.ts @@ -0,0 +1,52 @@ +// glTF `float2x2` / `float3x3` matrix types. Core math/ only has 4x4 (`Mat4`), +// so the flow-graph subsystem owns these. Plain `Float32Array`-backed tagged +// objects (no class). Pure helpers only; zero module-level allocation. + +/** A 2x2 matrix (glTF `float2x2`), column-major, 4 elements. */ +export interface FgMatrix2D { + readonly m: Float32Array; + /** @internal Discriminant tag. */ + readonly __fgMat: 2; +} + +/** A 3x3 matrix (glTF `float3x3`), column-major, 9 elements. */ +export interface FgMatrix3D { + readonly m: Float32Array; + /** @internal Discriminant tag. */ + readonly __fgMat: 3; +} + +/** Construct an `FgMatrix2D` from 4 column-major elements (defaults to identity). */ +export function fgMatrix2D(elements?: ArrayLike): FgMatrix2D { + const m = new Float32Array(4); + if (elements) { + m.set(elements); + } else { + m[0] = 1; + m[3] = 1; + } + return { m, __fgMat: 2 }; +} + +/** Construct an `FgMatrix3D` from 9 column-major elements (defaults to identity). */ +export function fgMatrix3D(elements?: ArrayLike): FgMatrix3D { + const m = new Float32Array(9); + if (elements) { + m.set(elements); + } else { + m[0] = 1; + m[4] = 1; + m[8] = 1; + } + return { m, __fgMat: 3 }; +} + +/** Type guard for `FgMatrix2D`. */ +export function isFgMatrix2D(v: unknown): v is FgMatrix2D { + return typeof v === "object" && v !== null && (v as FgMatrix2D).__fgMat === 2; +} + +/** Type guard for `FgMatrix3D`. */ +export function isFgMatrix3D(v: unknown): v is FgMatrix3D { + return typeof v === "object" && v !== null && (v as FgMatrix3D).__fgMat === 3; +} diff --git a/packages/babylon-lite/src/flow-graph/event-bus.ts b/packages/babylon-lite/src/flow-graph/event-bus.ts new file mode 100644 index 0000000000..056c2bbe10 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/event-bus.ts @@ -0,0 +1,67 @@ +// Scene/coordinator-scoped event bus feeding flow-graph event blocks. +// Pure data (`FgEventBus`) + standalone subscribe/pump functions — NO methods +// on the interface (GUIDANCE §4b′). One bus is shared across all graphs in a +// scene so multiple `KHR_interactivity` graphs can exchange custom events. + +import { FgEventType } from "./types.js"; + +export { FgEventType }; + +/** Payload carried by a pumped event. `tick` carries `{ deltaMs, deltaTime }`; + * `customEvent` carries `{ eventName, values }`. */ +export interface FgEventPayload { + [key: string]: unknown; +} + +export type FgEventHandler = (payload: FgEventPayload) => void; + +/** Pure-data event bus. Channel name → ordered list of handlers. */ +export interface FgEventBus { + /** @internal channel → handlers, in subscription order. */ + readonly _listeners: Map; +} + +/** Create an empty event bus. (Allocation is inside the factory, never at + * module scope, so the module stays tree-shakable.) */ +export function createFgEventBus(): FgEventBus { + return { _listeners: new Map() }; +} + +/** Subscribe `handler` to a channel. Returns an unsubscribe function. + * Handlers fire in subscription order — callers control ordering by the order + * in which they subscribe (see runtime init-priority). */ +export function subscribeFgEvent(bus: FgEventBus, channel: string, handler: FgEventHandler): () => void { + let handlers = bus._listeners.get(channel); + if (!handlers) { + handlers = []; + bus._listeners.set(channel, handlers); + } + handlers.push(handler); + return () => { + const list = bus._listeners.get(channel); + if (!list) { + return; + } + const i = list.indexOf(handler); + if (i >= 0) { + list.splice(i, 1); + } + }; +} + +/** Dispatch `payload` to every handler subscribed to `channel`. Iterates a + * snapshot so a handler may safely (un)subscribe during dispatch. */ +export function pumpFgEvent(bus: FgEventBus, channel: string, payload: FgEventPayload): void { + const handlers = bus._listeners.get(channel); + if (!handlers || handlers.length === 0) { + return; + } + for (const handler of handlers.slice()) { + handler(payload); + } +} + +/** Remove every listener from the bus. */ +export function clearFgEventBus(bus: FgEventBus): void { + bus._listeners.clear(); +} diff --git a/packages/babylon-lite/src/flow-graph/index.ts b/packages/babylon-lite/src/flow-graph/index.ts new file mode 100644 index 0000000000..8f591c09e1 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/index.ts @@ -0,0 +1,50 @@ +// Public surface of the flow-graph subsystem. Pure data + standalone functions. +// Re-exported from the package root (../index.ts). + +// Core data types +export type { FgBlock, FgDataSocket, FgGraph, FgSignalSocket, FgValue, Vec2 } from "./types.js"; +export { FgEventType, FgType } from "./types.js"; + +// Behaviour definitions + block-type names +export type { FgBlockDef, FgBlockShape } from "./block-def.js"; +export { FgBlockType } from "./block-type.js"; + +// Execution context & environment +export type { FgAccessor, FgCapabilities, FgContext, FgEnv, FgPendingTask, FgWiring } from "./context.js"; + +// Event bus +export type { FgEventBus, FgEventHandler, FgEventPayload } from "./event-bus.js"; +export { clearFgEventBus, createFgEventBus, pumpFgEvent, subscribeFgEvent } from "./event-bus.js"; + +// Rich-type pure functions +export { animationTypeForFgType, coerceValue, defaultForType, FgAnimationValueType } from "./rich-type.js"; + +// Custom types +export type { FgInteger } from "./custom-types/fg-integer.js"; +export { fgInt, isFgInt } from "./custom-types/fg-integer.js"; +export type { FgMatrix2D, FgMatrix3D } from "./custom-types/fg-matrix.js"; +export { fgMatrix2D, fgMatrix3D, isFgMatrix2D, isFgMatrix3D } from "./custom-types/fg-matrix.js"; + +// Block registry +export { getBlockDef } from "./block-registry.js"; + +// Scene attachment +export { attachFlowGraph, detachFlowGraph } from "./scene-flow-graph.js"; + +// Runtime functions + FgRuntime +export type { FgRuntime } from "./runtime.js"; +export { + activateSignal, + addPending, + cancelPendingForBlock, + compactPending, + createFgContext, + createFgEnv, + createFgRuntime, + disposeFlowGraph, + getDataValue, + setDataValue, + startFlowGraph, + stillPending, + tickFlowGraph, +} from "./runtime.js"; diff --git a/packages/babylon-lite/src/flow-graph/rich-type.ts b/packages/babylon-lite/src/flow-graph/rich-type.ts new file mode 100644 index 0000000000..36f919856c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/rich-type.ts @@ -0,0 +1,142 @@ +// Pure replacements for the three things a BJS `RichType` instance carried: +// a default value, a typeTransformer (coercion), and an animationType. +// No classes, no module-level instances — three pure functions, allocating +// only inside the function body. + +import { quatFromRotationMatrix } from "../math/quat-from-rotation-matrix.js"; +import type { Color3, Color4, Mat4, Quat, Vec3, Vec4 } from "../math/types.js"; +import { fgInt, isFgInt } from "./custom-types/fg-integer.js"; +import { fgMatrix2D, fgMatrix3D } from "./custom-types/fg-matrix.js"; +import type { FgValue, Vec2 } from "./types.js"; +import { FgType } from "./types.js"; + +/** Keyframe value categories an interpolation/animation block must distinguish. + * Replaces BJS `RichType.animationType`; quaternion targets must use slerp. */ +export const enum FgAnimationValueType { + Float = 0, + Vector2 = 1, + Vector3 = 2, + Vector4 = 3, + Quaternion = 4, + Color3 = 5, + Color4 = 6, + Matrix = 7, +} + +/** The default value for a type. Constructs fresh values inside the function + * (no shared module-level instances). Replaces `RichType.defaultValue`. */ +export function defaultForType(type: FgType): FgValue { + switch (type) { + case FgType.Number: + return 0; + case FgType.Integer: + return fgInt(0); + case FgType.Boolean: + return false; + case FgType.String: + return ""; + case FgType.Vector2: + return { x: 0, y: 0 } as Vec2; + case FgType.Vector3: + return { x: 0, y: 0, z: 0 } as Vec3; + case FgType.Vector4: + return { x: 0, y: 0, z: 0, w: 0 } as Vec4; + case FgType.Quaternion: + return { x: 0, y: 0, z: 0, w: 1 } as Quat; + case FgType.Matrix: + // Identity 4x4, column-major, branded as Mat4 by convention. + return new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) as unknown as Mat4; + case FgType.Matrix2D: + return fgMatrix2D(); + case FgType.Matrix3D: + return fgMatrix3D(); + case FgType.Color3: + return { r: 0, g: 0, b: 0 } as Color3; + case FgType.Color4: + return { r: 0, g: 0, b: 0, a: 1 } as Color4; + case FgType.Any: + default: + return null; + } +} + +/** Coerce `value` to `target`. Home of BJS's `typeTransformer`, including the + * critical `Vector4`/`Matrix` → `Quaternion` and numeric↔integer conversions. + * Invoked by `getDataValue` at the consumer boundary so block bodies stay + * type-clean. Returns `value` unchanged when no conversion is needed/possible. */ +export function coerceValue(value: FgValue, target: FgType): FgValue { + if (value === null || value === undefined) { + return value; + } + switch (target) { + case FgType.Number: + if (isFgInt(value)) { + return value.value; + } + if (typeof value === "boolean") { + return value ? 1 : 0; + } + return value; + case FgType.Integer: + if (typeof value === "number") { + return fgInt(value); + } + if (typeof value === "boolean") { + return fgInt(value ? 1 : 0); + } + return value; + case FgType.Boolean: + if (isFgInt(value)) { + return value.value !== 0; + } + if (typeof value === "number") { + return value !== 0; + } + return value; + case FgType.Quaternion: + return toQuaternion(value); + default: + return value; + } +} + +/** `Vector4` (x,y,z,w) and `Matrix` (rotation) both coerce to `Quaternion`. + * glTF `useSlerp` targets force this so interpolation runs as slerp. */ +function toQuaternion(value: FgValue): FgValue { + // A Vec4 already has x,y,z,w — reinterpret as a quaternion directly. + if (typeof value === "object" && value !== null && "w" in value && "x" in value && "y" in value && "z" in value) { + const v = value as Vec4; + return { x: v.x, y: v.y, z: v.z, w: v.w } as Quat; + } + // A 4x4 matrix → extract its rotation as a quaternion. + if (value instanceof Float32Array && value.length === 16) { + return quatFromRotationMatrix(value as unknown as Mat4); + } + return value; +} + +/** The animation value category for a type. Replaces `RichType.animationType`; + * used by interpolation/animation blocks to pick the keyframe interpolation + * (quaternion ⇒ slerp). */ +export function animationTypeForFgType(type: FgType): FgAnimationValueType { + switch (type) { + case FgType.Vector2: + return FgAnimationValueType.Vector2; + case FgType.Vector3: + return FgAnimationValueType.Vector3; + case FgType.Vector4: + return FgAnimationValueType.Vector4; + case FgType.Quaternion: + return FgAnimationValueType.Quaternion; + case FgType.Color3: + return FgAnimationValueType.Color3; + case FgType.Color4: + return FgAnimationValueType.Color4; + case FgType.Matrix: + case FgType.Matrix2D: + case FgType.Matrix3D: + return FgAnimationValueType.Matrix; + default: + return FgAnimationValueType.Float; + } +} diff --git a/packages/babylon-lite/src/flow-graph/runtime.ts b/packages/babylon-lite/src/flow-graph/runtime.ts new file mode 100644 index 0000000000..096d97164a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/runtime.ts @@ -0,0 +1,328 @@ +// Standalone runtime functions — the functional re-expression of BJS's +// FlowGraph execution. Data edges PULL (recompute on every read); signal edges +// PUSH (cascade through `execute`). Async work is tracked as `FgPendingTask` +// records ticked in a cancellation-safe per-frame loop. See +// docs/lite/architecture/42-flow-graph.md → Internal Architecture. + +import type { FgBlockDef } from "./block-def.js"; +import type { FgContext, FgEnv, FgPendingTask, FgWiring } from "./context.js"; +import { createFgEventBus, pumpFgEvent, subscribeFgEvent } from "./event-bus.js"; +import { getBlockDef } from "./block-registry.js"; +import { coerceValue, defaultForType } from "./rich-type.js"; +import type { FgBlock, FgGraph, FgValue } from "./types.js"; +import { FgEventType } from "./types.js"; + +// ───────────────────────────────────────────────────────────────────────────── +// Data edges (PULL) +// ───────────────────────────────────────────────────────────────────────────── + +/** PULL a data input: resolve the wired source, run its producer's + * `updateOutputs` (every time — `connectionValues` is a transport slot, not a + * validity cache), read the produced value, then coerce to the consumer type. + * Falls back to the socket's literal default when unwired. */ +export function getDataValue(ctx: FgContext, env: FgEnv, block: FgBlock, socket: string): FgValue { + const input = block.dataIn.find((s) => s.name === socket); + if (!input) { + return undefined; + } + + let raw: FgValue; + if (input.source) { + const producer = blockById(env.graph, input.source.blockId); + if (producer) { + const guardKey = `${producer.id}:resolving`; + // Break accidental data cycles: return the default rather than recurse. + if (ctx.executionVariables[guardKey]) { + raw = input.defaultValue ?? defaultForType(input.type); + } else { + const def = env.defs[producer.type]; + ctx.executionVariables[guardKey] = true; + try { + def?.updateOutputs?.(producer, ctx, env); + } finally { + ctx.executionVariables[guardKey] = false; + } + const slot = `${producer.id}:${input.source.socket}`; + raw = slot in ctx.connectionValues ? ctx.connectionValues[slot] : (input.defaultValue ?? defaultForType(input.type)); + } + } else { + raw = input.defaultValue ?? defaultForType(input.type); + } + } else { + raw = input.defaultValue ?? defaultForType(input.type); + } + + return coerceValue(raw, input.type); +} + +/** Write a data output into the transport slot (called from `updateOutputs`). */ +export function setDataValue(ctx: FgContext, block: FgBlock, socket: string, value: FgValue): void { + ctx.connectionValues[`${block.id}:${socket}`] = value; +} + +// ───────────────────────────────────────────────────────────────────────────── +// Signal edges (PUSH) +// ───────────────────────────────────────────────────────────────────────────── + +/** PUSH a signal: for each wired target of `socket`, dispatch into the target + * block's `def.execute`, passing the target's incoming signal name. */ +export function activateSignal(ctx: FgContext, env: FgEnv, block: FgBlock, socket: string): void { + const output = block.signalOut.find((s) => s.name === socket); + if (!output) { + return; + } + for (const target of output.targets) { + const targetBlock = blockById(env.graph, target.blockId); + if (!targetBlock) { + continue; + } + env.defs[targetBlock.type]?.execute?.(targetBlock, ctx, env, target.socket); + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// Async pending tasks +// ───────────────────────────────────────────────────────────────────────────── + +/** Register a new async task owned by `block`. Returns the task (with a unique + * token) so the caller can stash handles on `task.state`. A block may own + * several concurrent tasks. */ +export function addPending(ctx: FgContext, block: FgBlock, state: Record = {}): FgPendingTask { + const task: FgPendingTask = { + blockId: block.id, + token: ctx._tokenSeq++, + canceled: false, + done: false, + state, + }; + ctx.pending.push(task); + return task; +} + +/** True while `task` is still live (present, not canceled, not done). */ +export function stillPending(ctx: FgContext, task: FgPendingTask): boolean { + return !task.canceled && !task.done && ctx.pending.indexOf(task) >= 0; +} + +/** Cancel every outstanding task owned by `block` (marks them; compacted later). */ +export function cancelPendingForBlock(ctx: FgContext, block: FgBlock): void { + for (const task of ctx.pending) { + if (task.blockId === block.id) { + task.canceled = true; + } + } +} + +/** Drop canceled/done tasks from `ctx.pending` in place (preserves order). */ +export function compactPending(ctx: FgContext): void { + let write = 0; + for (let read = 0; read < ctx.pending.length; read++) { + const task = ctx.pending[read]; + if (task && !task.canceled && !task.done) { + ctx.pending[write++] = task; + } + } + ctx.pending.length = write; +} + +// ───────────────────────────────────────────────────────────────────────────── +// Context / env / runtime construction +// ───────────────────────────────────────────────────────────────────────────── + +/** Instantiate runtime state for a parsed graph (variables seeded live). */ +export function createFgContext(graph: FgGraph, opts?: { rightHanded?: boolean }): FgContext { + const userVariables: Record = {}; + for (const name of Object.keys(graph.variables)) { + userVariables[name] = graph.variables[name]!.value; + } + return { + connectionValues: {}, + executionVariables: {}, + userVariables, + pending: [], + rightHanded: opts?.rightHanded ?? false, + _tokenSeq: 0, + }; +} + +/** Build the resolved env: await every block def the graph needs (registry or + * wiring override), then attach accessors/animations/caps/bus. + * + * Unknown op policy: the registry returns `null` for an unknown type and this + * loader FAILS LOUDLY (throws with the offending types) so a `KHR_interactivity` + * asset can't silently render a broken interaction. */ +export async function createFgEnv(graph: FgGraph, wiring: FgWiring = {}): Promise { + const defs: Record = {}; + const unsupported: string[] = []; + + for (const block of graph.blocks) { + if (defs[block.type]) { + continue; + } + const override = wiring.defs?.[block.type]; + if (override) { + defs[block.type] = override; + continue; + } + const loader = getBlockDef(block.type); + if (!loader) { + if (!unsupported.includes(block.type)) { + unsupported.push(block.type); + } + continue; + } + defs[block.type] = await loader(); + } + + if (unsupported.length > 0) { + throw new Error(`flow-graph: unsupported block type(s): ${unsupported.join(", ")}`); + } + + return { + graph, + defs, + accessors: wiring.accessors ?? {}, + animations: wiring.animations ?? [], + caps: wiring.caps ?? {}, + events: wiring.events ?? createFgEventBus(), + }; +} + +/** One graph runtime = graph + context + env, owned by the scene. */ +export interface FgRuntime { + readonly graph: FgGraph; + readonly context: FgContext; + readonly env: FgEnv; + started: boolean; + /** @internal Bus unsubscribe fns registered at start, called on dispose. */ + _unsub: (() => void)[]; +} + +/** Assemble a runtime from a graph + wiring (creates context + env). */ +export async function createFgRuntime(graph: FgGraph, wiring: FgWiring = {}, opts?: { rightHanded?: boolean }): Promise { + const env = await createFgEnv(graph, wiring); + const context = createFgContext(graph, opts); + return { graph, context, env, started: false, _unsub: [] }; +} + +// ───────────────────────────────────────────────────────────────────────────── +// Lifecycle: start / tick / dispose +// ───────────────────────────────────────────────────────────────────────────── + +/** Init priority for event blocks: lower runs/subscribes first. Custom-event + * receivers must be listening BEFORE the start cascade can send to them. */ +function eventInitPriority(event: FgEventType): number { + switch (event) { + case FgEventType.CustomEvent: + return 0; + case FgEventType.Pointer: + case FgEventType.Key: + return 1; + case FgEventType.Tick: + return 2; + case FgEventType.Start: + return 3; + default: + return 2; + } +} + +/** Subscribe every non-start event block to the bus, in init-priority order, + * then fire the `Start` blocks once. Idempotent: a started runtime is skipped. */ +export function startFlowGraph(rt: FgRuntime): void { + if (rt.started) { + return; + } + const { context: ctx, env } = rt; + + const eventBlocks = rt.graph.blocks.filter((b): b is FgBlock & { event: FgEventType } => b.event !== undefined); + eventBlocks.sort((a, b) => eventInitPriority(a.event) - eventInitPriority(b.event)); + + // 1. Subscribe ALL non-start receivers first (custom-event before start-like). + for (const block of eventBlocks) { + if (block.event === FgEventType.Start) { + continue; + } + const def = env.defs[block.type]; + const unsub = subscribeFgEvent(env.events, block.event, (payload) => { + ctx.executionVariables[`${block.id}:lastEvent`] = payload; + def?.execute?.(block, ctx, env, block.event); + }); + rt._unsub.push(unsub); + } + + rt.started = true; + + // 2. THEN fire onStart blocks once (receivers are now listening). + for (const block of eventBlocks) { + if (block.event !== FgEventType.Start) { + continue; + } + env.defs[block.type]?.execute?.(block, ctx, env, FgEventType.Start); + } +} + +/** Per-frame drive: pump the tick event, then advance pending async tasks in a + * cancellation-safe loop (a task may be canceled / a new one added mid-loop). */ +export function tickFlowGraph(rt: FgRuntime, deltaMs: number): void { + if (!rt.started) { + startFlowGraph(rt); + } + const { context: ctx, env } = rt; + + pumpFgEvent(env.events, FgEventType.Tick, { deltaMs, deltaTime: deltaMs / 1000 }); + + // Snapshot: tasks added during the loop are picked up next frame (not retro-ticked). + const snapshot = ctx.pending.slice(); + for (const task of snapshot) { + if (task.canceled || !stillPending(ctx, task)) { + continue; + } + const block = blockById(env.graph, task.blockId); + if (block) { + env.defs[block.type]?.onTick?.(block, ctx, env, deltaMs, task); + } + } + compactPending(ctx); +} + +/** Tear down: cancel pending tasks (invoking `cancelPending` once per block), + * detach bus listeners, clear caches. Safe to call more than once. */ +export function disposeFlowGraph(rt: FgRuntime): void { + const { context: ctx, env } = rt; + + for (const unsub of rt._unsub) { + unsub(); + } + rt._unsub.length = 0; + + const visited = new Set(); + for (const task of ctx.pending) { + task.canceled = true; + if (!visited.has(task.blockId)) { + visited.add(task.blockId); + const block = blockById(env.graph, task.blockId); + if (block) { + env.defs[block.type]?.cancelPending?.(block, ctx, env); + } + } + } + ctx.pending.length = 0; + + for (const key of Object.keys(ctx.connectionValues)) { + delete ctx.connectionValues[key]; + } + for (const key of Object.keys(ctx.executionVariables)) { + delete ctx.executionVariables[key]; + } + rt.started = false; +} + +// ───────────────────────────────────────────────────────────────────────────── +// Helpers +// ───────────────────────────────────────────────────────────────────────────── + +function blockById(graph: FgGraph, id: string): FgBlock | undefined { + const index = graph.byId[id]; + return index === undefined ? undefined : graph.blocks[index]; +} diff --git a/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts new file mode 100644 index 0000000000..1366f6969a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts @@ -0,0 +1,46 @@ +// Scene attachment for flow-graph runtimes. Byte-neutral for non-interactivity +// scenes: this module is only pulled into a bundle when something imports it +// (the glTF KHR_interactivity feature, or explicit user code). It drives graphs +// through the scene's generic `onBeforeRender` / `onSceneDispose` seams instead +// of hardcoding a loop in scene-core (GUIDANCE §4c′ — always extensions). + +import { onBeforeRender, onSceneDispose, type SceneContext } from "../scene/scene-core.js"; +import type { FgRuntime } from "./runtime.js"; +import { disposeFlowGraph, startFlowGraph, tickFlowGraph } from "./runtime.js"; + +/** Attach a flow-graph runtime to a scene. The runtime starts on the first + * frame (after which event listeners are live) and ticks every frame. The + * runtime is auto-disposed when the scene is disposed. */ +export function attachFlowGraph(scene: SceneContext, rt: FgRuntime): void { + let list = scene._flowGraphs; + if (!list) { + list = []; + scene._flowGraphs = list; + } + list.push(rt); + + onBeforeRender(scene, (deltaMs: number) => { + // Early-out if detached (the closure persists until scene dispose). + if (!scene._flowGraphs || scene._flowGraphs.indexOf(rt) < 0) { + return; + } + if (!rt.started) { + startFlowGraph(rt); + } + tickFlowGraph(rt, deltaMs); + }); + + onSceneDispose(scene, () => detachFlowGraph(scene, rt)); +} + +/** Detach and dispose a flow-graph runtime previously attached to `scene`. */ +export function detachFlowGraph(scene: SceneContext, rt: FgRuntime): void { + const list = scene._flowGraphs; + if (list) { + const i = list.indexOf(rt); + if (i >= 0) { + list.splice(i, 1); + } + } + disposeFlowGraph(rt); +} diff --git a/packages/babylon-lite/src/flow-graph/types.ts b/packages/babylon-lite/src/flow-graph/types.ts new file mode 100644 index 0000000000..28f75d5745 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/types.ts @@ -0,0 +1,92 @@ +// Flow-graph core data types — pure state, no classes, no attached methods. +// A graph is plain data describing topology + config only; behaviour lives in +// FgBlockDef records (block-def.ts) and standalone runtime functions +// (runtime.ts). See docs/lite/architecture/42-flow-graph.md. + +import type { Color3, Color4, Mat4, Quat, Vec3, Vec4 } from "../math/types.js"; +import type { FgInteger } from "./custom-types/fg-integer.js"; +import type { FgMatrix2D, FgMatrix3D } from "./custom-types/fg-matrix.js"; + +/** 2-component vector. Core math/ is Vec3-centric and has no Vec2, so the + * flow-graph subsystem owns its own (glTF `float2` maps to this). */ +export interface Vec2 { + x: number; + y: number; +} + +/** A value that can flow along a data edge. */ +export type FgValue = number | boolean | string | Vec2 | Vec3 | Vec4 | Quat | Mat4 | FgInteger | FgMatrix2D | FgMatrix3D | Color3 | Color4 | null | undefined; + +/** Type tags. `const enum` → fully erased at build, zero runtime cost. + * String values intentionally match the glTF / BJS `flowGraphType` identifiers + * so the declaration mapper can pass them through unchanged. */ +export const enum FgType { + Any = "any", + Number = "number", + Boolean = "boolean", + String = "string", + Integer = "FlowGraphInteger", + Vector2 = "Vector2", + Vector3 = "Vector3", + Vector4 = "Vector4", + Quaternion = "Quaternion", + Matrix = "Matrix", + Matrix2D = "Matrix2D", + Matrix3D = "Matrix3D", + Color3 = "Color3", + Color4 = "Color4", +} + +/** A data input/output port — plain data. */ +export interface FgDataSocket { + readonly name: string; + readonly type: FgType; + /** Wired source (for inputs): producing block id + its output socket name. */ + source?: { blockId: string; socket: string }; + /** Literal fallback used when `source` is undefined. */ + defaultValue?: FgValue; +} + +/** A control-flow (signal) port — plain data. Push model. */ +export interface FgSignalSocket { + readonly name: string; + /** Wired targets (for outputs): consuming block id + its input signal name. */ + readonly targets: { blockId: string; socket: string }[]; +} + +/** A node instance — PURE DATA describing topology + config only. */ +export interface FgBlock { + readonly id: string; + /** `FgBlockType` value or a `"module/Name"` custom identifier. */ + readonly type: string; + readonly config?: Readonly>; + readonly dataIn: readonly FgDataSocket[]; + readonly dataOut: readonly FgDataSocket[]; + readonly signalIn: readonly FgSignalSocket[]; + readonly signalOut: readonly FgSignalSocket[]; + /** Declared by event blocks; which bus event activates them. */ + readonly event?: FgEventType; +} + +/** A parsed graph — pure data. */ +export interface FgGraph { + readonly blocks: readonly FgBlock[]; + /** id → block index, for O(1) edge resolution (built by the parser/builder). */ + readonly byId: Readonly>; + /** Declared graph variables: name → type + initial value. */ + readonly variables: Readonly>; +} + +/** Event channels an event block can subscribe to. `const enum` → erased. */ +export const enum FgEventType { + /** Fired once when the graph starts (scene ready). */ + Start = "start", + /** Fired every frame with `{ deltaMs, deltaTime }`. */ + Tick = "tick", + /** Custom events sent between graphs; payload carries `eventName` + values. */ + CustomEvent = "customEvent", + /** Pointer events forwarded by the picking/input layer. */ + Pointer = "pointer", + /** Keyboard events forwarded by the input layer. */ + Key = "key", +} diff --git a/packages/babylon-lite/src/index.ts b/packages/babylon-lite/src/index.ts index 5614732828..00b8282421 100644 --- a/packages/babylon-lite/src/index.ts +++ b/packages/babylon-lite/src/index.ts @@ -747,3 +747,33 @@ export { createSoundBufferAsync } from "./audio/sound-buffer.js"; export type { SoundBuffer, SoundSource, SoundBufferOptions } from "./audio/sound-buffer.js"; export type { AudioSignal } from "./audio/audio-signal.js"; export type { AudioRampShape, RampOptions } from "./audio/audio-param.js"; + +// ─── Flow graph (visual scripting / glTF KHR_interactivity runtime) ─── +export type { FgBlock, FgDataSocket, FgGraph, FgSignalSocket, FgValue, Vec2 } from "./flow-graph/index.js"; +export { FgEventType, FgType } from "./flow-graph/index.js"; +export type { FgBlockDef, FgBlockShape } from "./flow-graph/index.js"; +export { FgBlockType } from "./flow-graph/index.js"; +export type { FgAccessor, FgCapabilities, FgContext, FgEnv, FgPendingTask, FgWiring } from "./flow-graph/index.js"; +export type { FgEventBus, FgEventHandler, FgEventPayload } from "./flow-graph/index.js"; +export { clearFgEventBus, createFgEventBus, pumpFgEvent, subscribeFgEvent } from "./flow-graph/index.js"; +export { animationTypeForFgType, coerceValue, defaultForType, FgAnimationValueType } from "./flow-graph/index.js"; +export type { FgInteger, FgMatrix2D, FgMatrix3D } from "./flow-graph/index.js"; +export { fgInt, fgMatrix2D, fgMatrix3D, isFgInt, isFgMatrix2D, isFgMatrix3D } from "./flow-graph/index.js"; +export { getBlockDef } from "./flow-graph/index.js"; +export { attachFlowGraph, detachFlowGraph } from "./flow-graph/index.js"; +export type { FgRuntime } from "./flow-graph/index.js"; +export { + activateSignal, + addPending, + cancelPendingForBlock, + compactPending, + createFgContext, + createFgEnv, + createFgRuntime, + disposeFlowGraph, + getDataValue, + setDataValue, + startFlowGraph, + stillPending, + tickFlowGraph, +} from "./flow-graph/index.js"; diff --git a/packages/babylon-lite/src/scene/scene-core.ts b/packages/babylon-lite/src/scene/scene-core.ts index 1d34712a7e..53424e355b 100644 --- a/packages/babylon-lite/src/scene/scene-core.ts +++ b/packages/babylon-lite/src/scene/scene-core.ts @@ -22,6 +22,7 @@ import type { AssetContainer } from "../asset-container.js"; import type { SceneLightGpuState } from "../render/lights-ubo.js"; import type { ClusteredLightContainer } from "../light/clustered.js"; import type { GaussianSplattingMesh } from "../mesh/GaussianSplatting/gaussian-splatting-mesh.js"; +import type { FgRuntime } from "../flow-graph/runtime.js"; /** Image processing configuration. */ export interface ImageProcessingConfig { @@ -134,6 +135,12 @@ export interface SceneContext extends RenderingContext { _clusteredLightContainer?: ClusteredLightContainer; /** @internal Updates clustered light cells for the camera used by the current render pass. */ _clusteredLightUpdater?: (camera: Camera | null | undefined, targetWidth: number, targetHeight: number) => void; + + /** @internal Flow-graph runtimes attached to this scene (visual scripting / + * glTF KHR_interactivity). Lazily created by `attachFlowGraph`; left + * undefined for non-interactivity scenes so core stays byte-identical. + * Driven via the generic `onBeforeRender` seam, not a hardcoded core loop. */ + _flowGraphs?: FgRuntime[]; } /** Options passed to the scene-context factory. */ diff --git a/tests/lite/unit/flow-graph-rich-type.test.ts b/tests/lite/unit/flow-graph-rich-type.test.ts new file mode 100644 index 0000000000..702662c551 --- /dev/null +++ b/tests/lite/unit/flow-graph-rich-type.test.ts @@ -0,0 +1,93 @@ +import { describe, expect, it } from "vitest"; + +import type { Mat4, Quat, Vec4 } from "../../../packages/babylon-lite/src/math/types"; +import { + animationTypeForFgType, + coerceValue, + defaultForType, + FgAnimationValueType, + FgType, + isFgInt, + isFgMatrix2D, + isFgMatrix3D, +} from "../../../packages/babylon-lite/src/flow-graph/index"; +import type { FgInteger } from "../../../packages/babylon-lite/src/flow-graph/index"; + +describe("rich-type defaultForType", () => { + it("returns the correct defaults per type", () => { + expect(defaultForType(FgType.Number)).toBe(0); + expect(defaultForType(FgType.Boolean)).toBe(false); + expect(defaultForType(FgType.String)).toBe(""); + expect(defaultForType(FgType.Vector3)).toEqual({ x: 0, y: 0, z: 0 }); + expect(defaultForType(FgType.Quaternion)).toEqual({ x: 0, y: 0, z: 0, w: 1 }); + expect(defaultForType(FgType.Color4)).toEqual({ r: 0, g: 0, b: 0, a: 1 }); + expect(isFgInt(defaultForType(FgType.Integer))).toBe(true); + expect(isFgMatrix2D(defaultForType(FgType.Matrix2D))).toBe(true); + expect(isFgMatrix3D(defaultForType(FgType.Matrix3D))).toBe(true); + expect(defaultForType(FgType.Any)).toBe(null); + }); + + it("identity matrix default has 1s on the diagonal", () => { + const m = defaultForType(FgType.Matrix) as unknown as Mat4; + expect([m[0], m[5], m[10], m[15]]).toEqual([1, 1, 1, 1]); + expect(m[1]).toBe(0); + }); + + it("constructs fresh values each call (no shared instances)", () => { + const a = defaultForType(FgType.Vector3); + const b = defaultForType(FgType.Vector3); + expect(a).not.toBe(b); + }); +}); + +describe("rich-type coerceValue", () => { + it("Vector4 → Quaternion preserves components", () => { + const v: Vec4 = { x: 0.1, y: 0.2, z: 0.3, w: 0.9 }; + const q = coerceValue(v, FgType.Quaternion) as Quat; + expect(q).toEqual({ x: 0.1, y: 0.2, z: 0.3, w: 0.9 }); + }); + + it("identity Matrix → identity Quaternion", () => { + const identity = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) as unknown as Mat4; + const q = coerceValue(identity, FgType.Quaternion) as Quat; + expect(q.x).toBeCloseTo(0, 6); + expect(q.y).toBeCloseTo(0, 6); + expect(q.z).toBeCloseTo(0, 6); + expect(q.w).toBeCloseTo(1, 6); + }); + + it("number → integer and back", () => { + const i = coerceValue(3.9, FgType.Integer) as FgInteger; + expect(isFgInt(i)).toBe(true); + expect(i.value).toBe(3); // truncated to 32-bit int + expect(coerceValue(i, FgType.Number)).toBe(3); + }); + + it("boolean ↔ number/integer coercions", () => { + expect(coerceValue(true, FgType.Number)).toBe(1); + expect(coerceValue(false, FgType.Number)).toBe(0); + expect(coerceValue(0, FgType.Boolean)).toBe(false); + expect(coerceValue(5, FgType.Boolean)).toBe(true); + }); + + it("passes null/undefined through untouched", () => { + expect(coerceValue(null, FgType.Quaternion)).toBe(null); + expect(coerceValue(undefined, FgType.Number)).toBe(undefined); + }); + + it("returns the value unchanged when no conversion applies", () => { + const v3 = { x: 1, y: 2, z: 3 }; + expect(coerceValue(v3, FgType.Vector3)).toBe(v3); + }); +}); + +describe("rich-type animationTypeForFgType", () => { + it("maps each type to its animation value category (quaternion ⇒ slerp)", () => { + expect(animationTypeForFgType(FgType.Number)).toBe(FgAnimationValueType.Float); + expect(animationTypeForFgType(FgType.Vector2)).toBe(FgAnimationValueType.Vector2); + expect(animationTypeForFgType(FgType.Vector3)).toBe(FgAnimationValueType.Vector3); + expect(animationTypeForFgType(FgType.Quaternion)).toBe(FgAnimationValueType.Quaternion); + expect(animationTypeForFgType(FgType.Color3)).toBe(FgAnimationValueType.Color3); + expect(animationTypeForFgType(FgType.Matrix)).toBe(FgAnimationValueType.Matrix); + }); +}); diff --git a/tests/lite/unit/flow-graph-runtime.test.ts b/tests/lite/unit/flow-graph-runtime.test.ts new file mode 100644 index 0000000000..66d1e6f870 --- /dev/null +++ b/tests/lite/unit/flow-graph-runtime.test.ts @@ -0,0 +1,418 @@ +import { describe, expect, it } from "vitest"; + +import type { FgBlock, FgBlockDef, FgGraph, FgPendingTask, FgValue } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { + activateSignal, + addPending, + cancelPendingForBlock, + createFgRuntime, + disposeFlowGraph, + FgEventType, + FgType, + getDataValue, + pumpFgEvent, + setDataValue, + startFlowGraph, + tickFlowGraph, +} from "../../../packages/babylon-lite/src/flow-graph/index"; + +// ─── tiny builders ────────────────────────────────────────────────────────── + +function mkBlock(partial: Partial & { id: string; type: string }): FgBlock { + return { dataIn: [], dataOut: [], signalIn: [], signalOut: [], ...partial }; +} + +function mkGraph(blocks: FgBlock[], variables: FgGraph["variables"] = {}): FgGraph { + const byId: Record = {}; + blocks.forEach((b, i) => (byId[b.id] = i)); + return { blocks, byId, variables }; +} + +// ─── reusable hand-built defs ─────────────────────────────────────────────── + +/** Data producer: emits `value` = the named user variable (recomputes each pull). */ +const getVarDef: FgBlockDef = { + type: "getVar", + build: () => ({ dataOut: [{ name: "value", type: FgType.Number }] }), + updateOutputs: (block, ctx) => { + const name = block.config?.name as string; + setDataValue(ctx, block, "value", ctx.userVariables[name] ?? 0); + }, +}; + +/** Data passthrough: `value` = pulled `in`. Used for cycle-guard test. */ +const passthroughDef: FgBlockDef = { + type: "passthrough", + build: () => ({ dataIn: [{ name: "in", type: FgType.Number }], dataOut: [{ name: "value", type: FgType.Number }] }), + updateOutputs: (block, ctx, env) => { + setDataValue(ctx, block, "value", getDataValue(ctx, env, block, "in")); + }, +}; + +const startDef: FgBlockDef = { + type: "start", + build: () => ({ event: FgEventType.Start, signalOut: [{ name: "out", targets: [] }] }), + execute: (block, ctx, env) => activateSignal(ctx, env, block, "out"), +}; + +const sequenceDef: FgBlockDef = { + type: "sequence", + build: () => ({ + signalIn: [{ name: "in", targets: [] }], + signalOut: [ + { name: "out1", targets: [] }, + { name: "out2", targets: [] }, + ], + }), + execute: (block, ctx, env) => { + activateSignal(ctx, env, block, "out1"); + activateSignal(ctx, env, block, "out2"); + }, +}; + +function recordDef(log: string[]): FgBlockDef { + return { + type: "record", + build: () => ({ signalIn: [{ name: "in", targets: [] }] }), + execute: (block) => { + log.push(block.config?.label as string); + }, + }; +} + +const branchDef: FgBlockDef = { + type: "branch", + build: () => ({ + dataIn: [{ name: "condition", type: FgType.Boolean }], + signalIn: [{ name: "in", targets: [] }], + signalOut: [ + { name: "true", targets: [] }, + { name: "false", targets: [] }, + ], + }), + execute: (block, ctx, env) => { + const cond = getDataValue(ctx, env, block, "condition"); + activateSignal(ctx, env, block, cond ? "true" : "false"); + }, +}; + +// ───────────────────────────────────────────────────────────────────────────── + +describe("flow-graph data edges (PULL)", () => { + it("recomputes on every pull — no memoization of producer output", async () => { + const producer = mkBlock({ id: "g", type: "getVar", config: { name: "x" }, dataOut: [{ name: "value", type: FgType.Number }] }); + const consumer = mkBlock({ + id: "c", + type: "passthrough", + dataIn: [{ name: "in", type: FgType.Number, source: { blockId: "g", socket: "value" } }], + }); + const graph = mkGraph([producer, consumer], { x: { type: FgType.Number, value: 0 } }); + const rt = await createFgRuntime(graph, { defs: { getVar: getVarDef, passthrough: passthroughDef } }); + + rt.context.userVariables.x = 5; + expect(getDataValue(rt.context, rt.env, consumer, "in")).toBe(5); + + rt.context.userVariables.x = 9; + expect(getDataValue(rt.context, rt.env, consumer, "in")).toBe(9); + }); + + it("falls back to the socket default when unwired", async () => { + const consumer = mkBlock({ id: "c", type: "passthrough", dataIn: [{ name: "in", type: FgType.Number, defaultValue: 42 }] }); + const graph = mkGraph([consumer]); + const rt = await createFgRuntime(graph, { defs: { passthrough: passthroughDef } }); + expect(getDataValue(rt.context, rt.env, consumer, "in")).toBe(42); + }); + + it("breaks accidental data cycles via the resolving guard (returns default, no hang)", async () => { + const a = mkBlock({ + id: "A", + type: "passthrough", + dataIn: [{ name: "in", type: FgType.Number, source: { blockId: "B", socket: "value" } }], + dataOut: [{ name: "value", type: FgType.Number }], + }); + const b = mkBlock({ + id: "B", + type: "passthrough", + dataIn: [{ name: "in", type: FgType.Number, source: { blockId: "A", socket: "value" } }], + dataOut: [{ name: "value", type: FgType.Number }], + }); + const graph = mkGraph([a, b]); + const rt = await createFgRuntime(graph, { defs: { passthrough: passthroughDef } }); + expect(getDataValue(rt.context, rt.env, a, "in")).toBe(0); + }); +}); + +describe("flow-graph signal edges (PUSH)", () => { + it("fires sequence outputs in declared order", async () => { + const log: string[] = []; + const start = mkBlock({ id: "s", type: "start", event: FgEventType.Start, signalOut: [{ name: "out", targets: [{ blockId: "seq", socket: "in" }] }] }); + const seq = mkBlock({ + id: "seq", + type: "sequence", + signalIn: [{ name: "in", targets: [] }], + signalOut: [ + { name: "out1", targets: [{ blockId: "a", socket: "in" }] }, + { name: "out2", targets: [{ blockId: "b", socket: "in" }] }, + ], + }); + const a = mkBlock({ id: "a", type: "record", config: { label: "A" }, signalIn: [{ name: "in", targets: [] }] }); + const b = mkBlock({ id: "b", type: "record", config: { label: "B" }, signalIn: [{ name: "in", targets: [] }] }); + const graph = mkGraph([start, seq, a, b]); + const rt = await createFgRuntime(graph, { defs: { start: startDef, sequence: sequenceDef, record: recordDef(log) } }); + + startFlowGraph(rt); + expect(log).toEqual(["A", "B"]); + }); + + it("branch routes to the active output only", async () => { + const log: string[] = []; + const start = mkBlock({ id: "s", type: "start", event: FgEventType.Start, signalOut: [{ name: "out", targets: [{ blockId: "br", socket: "in" }] }] }); + const br = mkBlock({ + id: "br", + type: "branch", + dataIn: [{ name: "condition", type: FgType.Boolean, defaultValue: true }], + signalIn: [{ name: "in", targets: [] }], + signalOut: [ + { name: "true", targets: [{ blockId: "a", socket: "in" }] }, + { name: "false", targets: [{ blockId: "b", socket: "in" }] }, + ], + }); + const a = mkBlock({ id: "a", type: "record", config: { label: "TRUE" }, signalIn: [{ name: "in", targets: [] }] }); + const b = mkBlock({ id: "b", type: "record", config: { label: "FALSE" }, signalIn: [{ name: "in", targets: [] }] }); + const graph = mkGraph([start, br, a, b]); + const rt = await createFgRuntime(graph, { defs: { start: startDef, branch: branchDef, record: recordDef(log) } }); + + startFlowGraph(rt); + expect(log).toEqual(["TRUE"]); + }); +}); + +describe("flow-graph async pending tasks", () => { + /** A delay that counts down `durationMs` then fires `done`. Dedupes re-entry. */ + function delayDef(): FgBlockDef { + return { + type: "delay", + build: () => ({ + dataIn: [{ name: "duration", type: FgType.Number }], + signalIn: [{ name: "in", targets: [] }], + signalOut: [{ name: "done", targets: [] }], + }), + execute: (block, ctx, env) => { + // dedupe: ignore re-entry while a task is already live + if (ctx.pending.some((t) => t.blockId === block.id && !t.canceled && !t.done)) { + return; + } + const duration = (getDataValue(ctx, env, block, "duration") as number) ?? 0; + addPending(ctx, block, { remainingMs: duration }); + }, + onTick: (block, ctx, env, deltaMs, task) => { + task.state.remainingMs = (task.state.remainingMs as number) - deltaMs; + if ((task.state.remainingMs as number) <= 0) { + task.done = true; + activateSignal(ctx, env, block, "done"); + } + }, + cancelPending: (block, ctx) => cancelPendingForBlock(ctx, block), + }; + } + + it("counts down across frames and fires done exactly once", async () => { + const log: string[] = []; + const start = mkBlock({ id: "s", type: "start", event: FgEventType.Start, signalOut: [{ name: "out", targets: [{ blockId: "d", socket: "in" }] }] }); + const d = mkBlock({ + id: "d", + type: "delay", + dataIn: [{ name: "duration", type: FgType.Number, defaultValue: 100 }], + signalIn: [{ name: "in", targets: [] }], + signalOut: [{ name: "done", targets: [{ blockId: "r", socket: "in" }] }], + }); + const r = mkBlock({ id: "r", type: "record", config: { label: "DONE" }, signalIn: [{ name: "in", targets: [] }] }); + const graph = mkGraph([start, d, r]); + const rt = await createFgRuntime(graph, { defs: { start: startDef, delay: delayDef(), record: recordDef(log) } }); + + startFlowGraph(rt); + expect(rt.context.pending.length).toBe(1); + expect(log).toEqual([]); + + tickFlowGraph(rt, 60); + expect(log).toEqual([]); // 40ms left + + tickFlowGraph(rt, 60); + expect(log).toEqual(["DONE"]); // fired + expect(rt.context.pending.length).toBe(0); // compacted out + }); + + it("dedupes re-entry — a second trigger does not add a second task", async () => { + const d = mkBlock({ + id: "d", + type: "delay", + dataIn: [{ name: "duration", type: FgType.Number, defaultValue: 100 }], + signalIn: [{ name: "in", targets: [] }], + signalOut: [{ name: "done", targets: [] }], + }); + const graph = mkGraph([d]); + const rt = await createFgRuntime(graph, { defs: { delay: delayDef() } }); + + const def = rt.env.defs.delay!; + def.execute!(d, rt.context, rt.env, "in"); + def.execute!(d, rt.context, rt.env, "in"); + expect(rt.context.pending.length).toBe(1); + }); + + it("is cancellation-safe: a task canceled mid-loop never fires", async () => { + const log: string[] = []; + // canceller's onTick cancels the target block once it elapses. + const cancellerDef: FgBlockDef = { + type: "canceller", + build: () => ({ signalIn: [{ name: "in", targets: [] }] }), + execute: (block, ctx) => addPending(ctx, block, { remainingMs: 60 }), + onTick: (block, ctx, env, deltaMs, task) => { + task.state.remainingMs = (task.state.remainingMs as number) - deltaMs; + if ((task.state.remainingMs as number) <= 0) { + task.done = true; + const targetId = block.config?.cancelId as string; + const target = env.graph.blocks[env.graph.byId[targetId]!]!; + cancelPendingForBlock(ctx, target); + } + }, + }; + const victimDef: FgBlockDef = { + type: "victim", + build: () => ({ signalIn: [{ name: "in", targets: [] }], signalOut: [{ name: "done", targets: [] }] }), + execute: (block, ctx) => addPending(ctx, block, { remainingMs: 60 }), + onTick: (_block, _ctx, _env, deltaMs, task) => { + task.state.remainingMs = (task.state.remainingMs as number) - deltaMs; + if ((task.state.remainingMs as number) <= 0) { + task.done = true; + log.push("VICTIM_FIRED"); + } + }, + }; + const canceller = mkBlock({ id: "C", type: "canceller", config: { cancelId: "V" }, signalIn: [{ name: "in", targets: [] }] }); + const victim = mkBlock({ id: "V", type: "victim", signalIn: [{ name: "in", targets: [] }], signalOut: [{ name: "done", targets: [] }] }); + const graph = mkGraph([canceller, victim]); + const rt = await createFgRuntime(graph, { defs: { canceller: cancellerDef, victim: victimDef } }); + + // Seed both tasks (C is first in pending so it ticks first and cancels V). + cancellerDef.execute!(canceller, rt.context, rt.env, "in"); + victimDef.execute!(victim, rt.context, rt.env, "in"); + expect(rt.context.pending.length).toBe(2); + + tickFlowGraph(rt, 60); + expect(log).toEqual([]); // victim was canceled before its turn + expect(rt.context.pending.length).toBe(0); + }); + + it("does not retro-tick a task added during the same frame's loop", async () => { + let addedTask: FgPendingTask | null = null; + const adderDef: FgBlockDef = { + type: "adder", + build: () => ({}), + execute: (block, ctx) => addPending(ctx, block, { ticks: 0 }), + onTick: (block, ctx, _env, _deltaMs, task) => { + task.state.ticks = (task.state.ticks as number) + 1; + task.done = true; + if (!addedTask) { + addedTask = addPending(ctx, block, { ticks: 0 }); + } + }, + }; + const adder = mkBlock({ id: "A", type: "adder" }); + const rt = await createFgRuntime(mkGraph([adder]), { defs: { adder: adderDef } }); + adderDef.execute!(adder, rt.context, rt.env, "in"); + + tickFlowGraph(rt, 16); + // The task added mid-loop must NOT have ticked this frame. + expect((addedTask! as FgPendingTask).state.ticks).toBe(0); + }); +}); + +describe("flow-graph events", () => { + it("delivers a custom event sent during the onStart cascade (receiver subscribed first)", async () => { + const log: string[] = []; + const sendDef: FgBlockDef = { + type: "send", + build: () => ({ signalIn: [{ name: "in", targets: [] }] }), + execute: (block, _ctx, env) => pumpFgEvent(env.events, FgEventType.CustomEvent, { eventName: block.config?.eventName }), + }; + const receiveDef: FgBlockDef = { + type: "receive", + build: () => ({ event: FgEventType.CustomEvent, signalOut: [{ name: "out", targets: [] }] }), + execute: (block, ctx, env) => { + const payload = ctx.executionVariables[`${block.id}:lastEvent`] as { eventName?: string } | undefined; + if (payload?.eventName === block.config?.eventName) { + activateSignal(ctx, env, block, "out"); + } + }, + }; + const start = mkBlock({ id: "s", type: "start", event: FgEventType.Start, signalOut: [{ name: "out", targets: [{ blockId: "snd", socket: "in" }] }] }); + const snd = mkBlock({ id: "snd", type: "send", config: { eventName: "ping" }, signalIn: [{ name: "in", targets: [] }] }); + const rcv = mkBlock({ + id: "rcv", + type: "receive", + event: FgEventType.CustomEvent, + config: { eventName: "ping" }, + signalOut: [{ name: "out", targets: [{ blockId: "r", socket: "in" }] }], + }); + const r = mkBlock({ id: "r", type: "record", config: { label: "GOT_PING" }, signalIn: [{ name: "in", targets: [] }] }); + const graph = mkGraph([start, snd, rcv, r]); + const rt = await createFgRuntime(graph, { defs: { start: startDef, send: sendDef, receive: receiveDef, record: recordDef(log) } }); + + startFlowGraph(rt); + expect(log).toEqual(["GOT_PING"]); + }); + + it("pumps a tick event each frame", async () => { + const log: string[] = []; + const onTickEventDef: FgBlockDef = { + type: "onTick", + build: () => ({ event: FgEventType.Tick, signalOut: [{ name: "out", targets: [] }] }), + execute: (block, ctx) => { + const payload = ctx.executionVariables[`${block.id}:lastEvent`] as { deltaMs?: number }; + log.push(`tick:${payload.deltaMs}`); + }, + }; + const t = mkBlock({ id: "t", type: "onTick", event: FgEventType.Tick, signalOut: [{ name: "out", targets: [] }] }); + const rt = await createFgRuntime(mkGraph([t]), { defs: { onTick: onTickEventDef } }); + + startFlowGraph(rt); + tickFlowGraph(rt, 16); + tickFlowGraph(rt, 32); + expect(log).toEqual(["tick:16", "tick:32"]); + }); + + it("disposeFlowGraph detaches listeners and clears state", async () => { + const log: string[] = []; + const onTickEventDef: FgBlockDef = { + type: "onTick", + build: () => ({ event: FgEventType.Tick }), + execute: (block) => log.push(block.id), + }; + const t = mkBlock({ id: "t", type: "onTick", event: FgEventType.Tick }); + const rt = await createFgRuntime(mkGraph([t]), { defs: { onTick: onTickEventDef } }); + + startFlowGraph(rt); + tickFlowGraph(rt, 16); + expect(log.length).toBe(1); + + disposeFlowGraph(rt); + // Pumping the bus directly after dispose must not reach the detached listener. + pumpFgEvent(rt.env.events, FgEventType.Tick, { deltaMs: 16 }); + expect(log.length).toBe(1); + expect(rt.started).toBe(false); + }); + + it("seeds userVariables from graph variables", async () => { + const graph = mkGraph([], { score: { type: FgType.Number, value: 7 }, name: { type: FgType.String, value: "hi" as FgValue } }); + const rt = await createFgRuntime(graph, {}); + expect(rt.context.userVariables.score).toBe(7); + expect(rt.context.userVariables.name).toBe("hi"); + }); +}); + +describe("flow-graph env resolution", () => { + it("fails loudly on an unsupported block type", async () => { + const graph = mkGraph([mkBlock({ id: "x", type: "DoesNotExist" })]); + await expect(createFgRuntime(graph, {})).rejects.toThrow(/unsupported block type/); + }); +}); From 0a57e49241af87881619b1b6617f563a32fc58ca Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 15:17:15 +0200 Subject: [PATCH 03/13] feat(flow-graph): add glTF KHR_interactivity loader + vertical-slice blocks (Phase 2) Implements the Phase 2 vertical slice of the FlowGraph port: a minimal runnable set of blocks plus the glTF KHR_interactivity load path that turns an interactive glb into a running flow graph. Runtime / blocks: - 12 blocks across events (sceneStart/sceneTick), control-flow (branch, sequence), data (get/set property + variable), math (add), debug (consoleLog) and animation (play/stop) under flow-graph/blocks/. - block-registry, sockets, fg-math and runtime helpers to support them. - runFlowGraphs + sceneAnimationCaps in scene-flow-graph.ts as the explicit public API to bind and drive loaded graphs (not auto-wired into addToScene, keeping scene-core byte-identical). - LoadedFlowGraph type in context.ts; AssetContainer.flowGraphs field. glTF loader (spec-volatile, quarantined under flow-graph/gltf/): - interactivity-parser, declaration-mapper, object-model-mapping and path-converter: parse IKHRInteractivity_Graph JSON into an FgGraph and resolve json pointers to accessors. Loud-fails on unknown ops. - gltf-feature-interactivity loader feature, registered as a lazy ["KHR_interactivity", () => import(...)] tuple in gltf-feature-registry. The tuple is never imported unless a glb declares KHR_interactivity, so all existing scenes render byte-identically (verified via content-hash invariance of every non-registry chunk). The KHR_interactivity spec is unratified; all spec-dependent code is isolated under flow-graph/gltf/ and tagged for re-sync against BJS PR #18455. Tests: 23 new unit tests (blocks, gltf parser, gltf feature); full unit suite 633 green; lint + typecheck clean. Bundle manifest regenerated for the 48 affected glTF scenes (chunk-hash renames + ~0.1KB raw bumps); bundle-size ceilings unchanged. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../copilot/skills/port-flow-graph-block.md | 4 +- lab/public/bundle/manifest.json | 208 +++++----- packages/babylon-lite/src/asset-container.ts | 3 + .../src/flow-graph/block-registry.ts | 47 ++- .../blocks/animation/play-animation.ts | 81 ++++ .../blocks/animation/stop-animation.ts | 38 ++ .../flow-graph/blocks/control-flow/branch.ts | 25 ++ .../blocks/control-flow/sequence.ts | 26 ++ .../flow-graph/blocks/data/get-property.ts | 27 ++ .../flow-graph/blocks/data/get-variable.ts | 20 + .../flow-graph/blocks/data/set-property.ts | 31 ++ .../flow-graph/blocks/data/set-variable.ts | 25 ++ .../flow-graph/blocks/debug/console-log.ts | 22 ++ .../flow-graph/blocks/events/scene-start.ts | 24 ++ .../flow-graph/blocks/events/scene-tick.ts | 41 ++ .../src/flow-graph/blocks/math/add.ts | 23 ++ .../babylon-lite/src/flow-graph/context.ts | 10 + .../babylon-lite/src/flow-graph/fg-math.ts | 45 +++ .../src/flow-graph/gltf/declaration-mapper.ts | 91 +++++ .../flow-graph/gltf/interactivity-parser.ts | 230 ++++++++++++ .../flow-graph/gltf/object-model-mapping.ts | 32 ++ .../src/flow-graph/gltf/path-converter.ts | 86 +++++ packages/babylon-lite/src/flow-graph/index.ts | 6 +- .../babylon-lite/src/flow-graph/runtime.ts | 17 + .../src/flow-graph/scene-flow-graph.ts | 34 +- .../babylon-lite/src/flow-graph/sockets.ts | 27 ++ .../loader-gltf/gltf-feature-interactivity.ts | 50 +++ .../src/loader-gltf/gltf-feature-registry.ts | 1 + tests/lite/unit/flow-graph-blocks.test.ts | 354 ++++++++++++++++++ .../lite/unit/flow-graph-gltf-feature.test.ts | 82 ++++ .../lite/unit/flow-graph-gltf-parser.test.ts | 126 +++++++ 31 files changed, 1721 insertions(+), 115 deletions(-) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/animation/play-animation.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/branch.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/sequence.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/data/get-property.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/data/get-variable.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/data/set-property.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/data/set-variable.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/events/scene-start.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/events/scene-tick.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/add.ts create mode 100644 packages/babylon-lite/src/flow-graph/fg-math.ts create mode 100644 packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts create mode 100644 packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts create mode 100644 packages/babylon-lite/src/flow-graph/gltf/object-model-mapping.ts create mode 100644 packages/babylon-lite/src/flow-graph/gltf/path-converter.ts create mode 100644 packages/babylon-lite/src/flow-graph/sockets.ts create mode 100644 packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts create mode 100644 tests/lite/unit/flow-graph-blocks.test.ts create mode 100644 tests/lite/unit/flow-graph-gltf-feature.test.ts create mode 100644 tests/lite/unit/flow-graph-gltf-parser.test.ts diff --git a/.github/copilot/skills/port-flow-graph-block.md b/.github/copilot/skills/port-flow-graph-block.md index 08d91e3bfa..7097b57a1a 100644 --- a/.github/copilot/skills/port-flow-graph-block.md +++ b/.github/copilot/skills/port-flow-graph-block.md @@ -134,7 +134,7 @@ export const branchDef: FgBlockDef = { import type { FgBlockDef } from "../../block-def.js"; import { FgBlockType } from "../../block-type.js"; import { FgType } from "../../types.js"; -import { getDataValue, activateSignal, addPending, cancelTasksFor } from "../../runtime.js"; +import { getDataValue, activateSignal, addPending, cancelPendingForBlock } from "../../runtime.js"; import { sockIn, sigIn, sigOut } from "../../sockets.js"; export const setDelayDef: FgBlockDef = { @@ -146,7 +146,7 @@ export const setDelayDef: FgBlockDef = { }), execute(block, ctx, env, incomingSignal) { if (incomingSignal === "cancel") { - cancelTasksFor(ctx, block); // marks this block's tasks canceled + cancelPendingForBlock(ctx, block); // marks this block's tasks canceled return; } const seconds = getDataValue(ctx, env, block, "duration") as number; diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index 6fa4fd7e64..81d716072e 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -57,7 +57,7 @@ ] }, "scene5": { - "rawKB": 90, + "rawKB": 90.1, "gzipKB": 38.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -68,7 +68,7 @@ "scene5-gltf-color-normalize-BtnJk1yq.js", "scene5-gltf-feature-animations-CQrRowr9.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry-CFEhSLX7.js", + "scene5-gltf-feature-registry-xSfhjloS.js", "scene5-gltf-feature-skeleton-Siixi_P0.js", "scene5-gltf-json-asset-DS0i23k1.js", "scene5-morph-fragment-BhcJT1xs.js", @@ -96,7 +96,7 @@ ] }, "scene7": { - "rawKB": 104.3, + "rawKB": 104.4, "gzipKB": 44.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -107,7 +107,7 @@ "scene7-gltf-animation-B7Xr33me.js", "scene7-gltf-feature-animations-CG5FpT6C.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-bmuzy_T3.js", + "scene7-gltf-feature-registry-DHcnblHg.js", "scene7-gltf-feature-skeleton-BCWZyzWC.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", @@ -163,7 +163,7 @@ ] }, "scene11": { - "rawKB": 87.5, + "rawKB": 87.6, "gzipKB": 36.8, "ignoredRawKB": 0, "runtimeChunks": [ @@ -173,7 +173,7 @@ "scene11-gltf-ext-spec-gloss-D60sFZYX.js", "scene11-gltf-feature-animations-Bmg0PBR4.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-1IvbX-2Q.js", + "scene11-gltf-feature-registry-_fmMv2wd.js", "scene11-gltf-feature-skeleton-CrXfHDG6.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", @@ -184,7 +184,7 @@ ] }, "scene12": { - "rawKB": 101.9, + "rawKB": 102, "gzipKB": 41.6, "ignoredRawKB": 0, "runtimeChunks": [ @@ -192,7 +192,7 @@ "scene12-generate-mipmaps-Bsp4UQ3D.js", "scene12-gltf-animation-BDKbEYQd.js", "scene12-gltf-feature-animations-Bfc5iW7L.js", - "scene12-gltf-feature-registry-BydKPGWF.js", + "scene12-gltf-feature-registry-DvhNAMde.js", "scene12-gltf-feature-skeleton-CN1CorcX.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", @@ -429,13 +429,13 @@ ] }, "scene27": { - "rawKB": 81.5, + "rawKB": 81.6, "gzipKB": 33.3, "ignoredRawKB": 0, "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-CdtcVg_o.js", + "scene27-gltf-feature-registry-BVeapFkN.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", @@ -448,14 +448,14 @@ ] }, "scene28": { - "rawKB": 85.3, + "rawKB": 85.4, "gzipKB": 34.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry-Bn70BaDI.js", + "scene28-gltf-feature-registry-BAdu1pBK.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", "scene28-pbr-renderable-BYSlPUr5.js", @@ -465,14 +465,14 @@ ] }, "scene29": { - "rawKB": 88.9, + "rawKB": 89, "gzipKB": 36.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-CfSJd3IN.js", + "scene29-gltf-feature-registry-CCAMnni_.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", @@ -487,7 +487,7 @@ ] }, "scene30": { - "rawKB": 102.1, + "rawKB": 102.2, "gzipKB": 42.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -496,7 +496,7 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-BaxqZoGN.js", + "scene30-gltf-feature-registry-BJfpepeb.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", @@ -512,14 +512,14 @@ ] }, "scene31": { - "rawKB": 79, + "rawKB": 79.1, "gzipKB": 32.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-D2YBPfA0.js", + "scene31-gltf-feature-registry-Cc2ziCEc.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", "scene31-pbr-renderable-Bg8O1LwN.js", @@ -529,13 +529,13 @@ ] }, "scene32": { - "rawKB": 78.8, - "gzipKB": 32.4, + "rawKB": 78.9, + "gzipKB": 32.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-BBrnfLsg.js", + "scene32-gltf-feature-registry-DzBFfEQu.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", "scene32-pbr-renderable-CUtjMSAl.js", @@ -546,14 +546,14 @@ ] }, "scene33": { - "rawKB": 102.2, + "rawKB": 102.3, "gzipKB": 41.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-CiNspmto.js", + "scene33-gltf-feature-registry-i-cyg-zg.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", @@ -570,7 +570,7 @@ ] }, "scene34": { - "rawKB": 95.6, + "rawKB": 95.7, "gzipKB": 39.3, "ignoredRawKB": 0, "runtimeChunks": [ @@ -579,7 +579,7 @@ "scene34-gltf-ext-node-visibility-CyR_MQR5.js", "scene34-gltf-feature-animation-pointer-dMoZNhJb.js", "scene34-gltf-feature-animations-BQSrKgM_.js", - "scene34-gltf-feature-registry-DW8yU7HD.js", + "scene34-gltf-feature-registry-se8z_8WJ.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", "scene34-pbr-renderable-BelxTmu1.js", @@ -590,13 +590,13 @@ ] }, "scene35": { - "rawKB": 82.1, + "rawKB": 82.2, "gzipKB": 33.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", - "scene35-gltf-feature-registry-DD8cSLcV.js", + "scene35-gltf-feature-registry-BduaHWJd.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", "scene35-pbr-renderable-B_cgTnJN.js", @@ -619,7 +619,7 @@ ] }, "scene37": { - "rawKB": 95.8, + "rawKB": 95.9, "gzipKB": 39.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -628,7 +628,7 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-Wt0DPKNv.js", + "scene37-gltf-feature-registry-CpEj0hHp.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", @@ -654,7 +654,7 @@ ] }, "scene39": { - "rawKB": 107.7, + "rawKB": 107.8, "gzipKB": 45.6, "ignoredRawKB": 0, "runtimeChunks": [ @@ -667,7 +667,7 @@ "scene39-gltf-feature-animation-pointer-BEWWFwP-.js", "scene39-gltf-feature-animations-BqoIrLnC.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-CfVnSAqA.js", + "scene39-gltf-feature-registry-Z3Af8l-s.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -687,7 +687,7 @@ ] }, "scene99": { - "rawKB": 90.5, + "rawKB": 90.6, "gzipKB": 37.6, "ignoredRawKB": 0, "runtimeChunks": [ @@ -696,7 +696,7 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-C5SZcHEj.js", + "scene99-gltf-feature-registry-BppSgUVr.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", @@ -717,13 +717,13 @@ ] }, "scene41": { - "rawKB": 91.8, - "gzipKB": 36.5, + "rawKB": 92, + "gzipKB": 36.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-CnFSdj0i.js", + "scene41-gltf-feature-registry-B1NXlp7Z.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -786,13 +786,13 @@ ] }, "scene47": { - "rawKB": 91.1, + "rawKB": 91.2, "gzipKB": 36.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-CaVfgPXw.js", + "scene47-gltf-feature-registry-CcT_JDHE.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1210,7 +1210,7 @@ ] }, "scene73": { - "rawKB": 142.6, + "rawKB": 142.7, "gzipKB": 57.6, "ignoredRawKB": 3.3, "runtimeChunks": [ @@ -1221,7 +1221,7 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-Bv6CUQMQ.js", + "scene73-gltf-feature-registry-H4ik3gr7.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", @@ -1736,12 +1736,12 @@ ] }, "scene104": { - "rawKB": 100.6, + "rawKB": 100.7, "gzipKB": 39, "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-r97kCXhW.js", + "scene104-gltf-feature-registry-BSF9DCxh.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1751,12 +1751,12 @@ ] }, "scene105": { - "rawKB": 101.3, + "rawKB": 101.4, "gzipKB": 39.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-DSOt3NOM.js", + "scene105-gltf-feature-registry-BiM-2LlY.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1819,7 +1819,7 @@ ] }, "scene112": { - "rawKB": 118.9, + "rawKB": 119, "gzipKB": 48.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -1829,7 +1829,7 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-Cpt2BtfK.js", + "scene112-gltf-feature-registry-B4CJUMK8.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", "scene112-pbr-refraction-DZYuYfJR.js", @@ -1867,7 +1867,7 @@ ] }, "scene115": { - "rawKB": 124.5, + "rawKB": 124.6, "gzipKB": 51.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -1878,7 +1878,7 @@ "scene115-gltf-color-normalize-BtnJk1yq.js", "scene115-gltf-feature-animations-eusiMJnc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-BlikC7-I.js", + "scene115-gltf-feature-registry-CEMV-NUp.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", @@ -2099,7 +2099,7 @@ ] }, "scene144": { - "rawKB": 109, + "rawKB": 109.1, "gzipKB": 44.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2109,7 +2109,7 @@ "scene144-gltf-ext-spec-gloss-D60sFZYX.js", "scene144-gltf-feature-animations-DOSVTx1Z.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-BPA8xk3Y.js", + "scene144-gltf-feature-registry-C4aQYjBk.js", "scene144-gltf-feature-skeleton-Dq3GN8sP.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", @@ -2173,14 +2173,14 @@ ] }, "scene147": { - "rawKB": 102.6, - "gzipKB": 41, + "rawKB": 102.7, + "gzipKB": 41.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-CRHPISh7.js", + "scene147-gltf-feature-registry-LhPTFrel.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2192,14 +2192,14 @@ ] }, "scene148": { - "rawKB": 108.5, + "rawKB": 108.6, "gzipKB": 42.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-Deb8rfIt.js", + "scene148-gltf-feature-registry-B2YmDV3Q.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2211,8 +2211,8 @@ ] }, "scene149": { - "rawKB": 107.9, - "gzipKB": 44.1, + "rawKB": 108, + "gzipKB": 44.2, "ignoredRawKB": 6.8, "runtimeChunks": [ "scene149-_math-factory-DFVyS8gB.js", @@ -2221,7 +2221,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry-D5PDjQhh.js", + "scene149-gltf-feature-registry-trd2Hl3A.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2256,7 +2256,7 @@ ] }, "scene152": { - "rawKB": 92.6, + "rawKB": 92.7, "gzipKB": 38.5, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2266,7 +2266,7 @@ "scene152-gltf-ext-spec-gloss-D60sFZYX.js", "scene152-gltf-feature-animations-z0zN7iq2.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-Kyc3p6n8.js", + "scene152-gltf-feature-registry-Bydgn2R-.js", "scene152-gltf-feature-skeleton-DdNk7nTu.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", @@ -2315,7 +2315,7 @@ ] }, "scene157": { - "rawKB": 94.1, + "rawKB": 94.2, "gzipKB": 38.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2323,7 +2323,7 @@ "scene157-generate-mipmaps-CSgsFZsy.js", "scene157-gltf-animation-97jnT3rB.js", "scene157-gltf-feature-animations-C4GEf0C-.js", - "scene157-gltf-feature-registry-D-CUXeBM.js", + "scene157-gltf-feature-registry-BMp9zetc.js", "scene157-gltf-feature-skeleton-sqEIM232.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", "scene157-multilight-wgsl-DMQZ6dS_.js", @@ -2333,7 +2333,7 @@ ] }, "scene158": { - "rawKB": 94.5, + "rawKB": 94.6, "gzipKB": 38.4, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2341,7 +2341,7 @@ "scene158-generate-mipmaps-ONVnFwM1.js", "scene158-gltf-animation-D36FWf_9.js", "scene158-gltf-feature-animations-_BY8aVDC.js", - "scene158-gltf-feature-registry-CHl2pVu-.js", + "scene158-gltf-feature-registry-BIfzwUtD.js", "scene158-gltf-feature-skeleton-BQO9mRtS.js", "scene158-gltf-glb-parser-BhqojsL9.js", "scene158-multilight-wgsl-DhVJV_xa.js", @@ -2396,7 +2396,7 @@ ] }, "scene164": { - "rawKB": 96.9, + "rawKB": 97, "gzipKB": 40.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2407,7 +2407,7 @@ "scene164-gltf-color-normalize-BtnJk1yq.js", "scene164-gltf-feature-animations-CkuodxMl.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-B8153K1-.js", + "scene164-gltf-feature-registry-DqJpf6s1.js", "scene164-gltf-feature-skeleton-DOpy65Ao.js", "scene164-gltf-json-asset-BCxbuHbB.js", "scene164-morph-fragment-29qCql2q.js", @@ -2511,14 +2511,14 @@ ] }, "scene176": { - "rawKB": 102.3, + "rawKB": 102.4, "gzipKB": 41.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-DGFPEC4N.js", + "scene176-gltf-feature-registry-DCfGHt7T.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2546,13 +2546,13 @@ ] }, "scene178": { - "rawKB": 86.7, + "rawKB": 86.8, "gzipKB": 35.3, "ignoredRawKB": 0, "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-BTzN8aW4.js", + "scene178-gltf-feature-registry-C-DjZb2A.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2719,12 +2719,12 @@ ] }, "scene210": { - "rawKB": 75.4, + "rawKB": 75.5, "gzipKB": 31.3, "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-COHuk6hF.js", + "scene210-gltf-feature-registry-B36aiNqk.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", @@ -2735,7 +2735,7 @@ ] }, "scene211": { - "rawKB": 88.3, + "rawKB": 88.5, "gzipKB": 37.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2745,7 +2745,7 @@ "scene211-gltf-ext-quantization-Do-ofjB-.js", "scene211-gltf-feature-animations-C0rPaLwN.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-BZvhWur-.js", + "scene211-gltf-feature-registry-C-tkINq8.js", "scene211-gltf-feature-skeleton-C5YXdC68.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", @@ -2756,13 +2756,13 @@ ] }, "scene212": { - "rawKB": 102.6, + "rawKB": 102.7, "gzipKB": 41.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-Bl0XFXnM.js", + "scene212-gltf-feature-registry-DuIiKAcf.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2839,7 +2839,7 @@ ] }, "scene218": { - "rawKB": 91, + "rawKB": 91.1, "gzipKB": 37.9, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2849,7 +2849,7 @@ "scene218-gltf-ext-spec-gloss-D60sFZYX.js", "scene218-gltf-feature-animations-Xir-5MtM.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-BIJQHgvB.js", + "scene218-gltf-feature-registry-D-uYHOu6.js", "scene218-gltf-feature-skeleton-CuQWo93o.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", @@ -2859,8 +2859,8 @@ ] }, "scene219": { - "rawKB": 93.5, - "gzipKB": 39, + "rawKB": 93.6, + "gzipKB": 39.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene219-create-skeleton-DNC_UZif.js", @@ -2869,7 +2869,7 @@ "scene219-gltf-ext-spec-gloss-D60sFZYX.js", "scene219-gltf-feature-animations-Cr5Rjgc6.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-6BhbARjE.js", + "scene219-gltf-feature-registry-BxYW41qV.js", "scene219-gltf-feature-skeleton-QiTS1ubb.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", @@ -2974,15 +2974,15 @@ ] }, "scene240": { - "rawKB": 89.5, - "gzipKB": 37.4, + "rawKB": 89.6, + "gzipKB": 37.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene240-flat-normal-wgsl-Cm9mM4tC.js", "scene240-generate-mipmaps-BQZ9ivTX.js", "scene240-gltf-animation-BKjmZpR3.js", "scene240-gltf-feature-animations-Deh9CXYc.js", - "scene240-gltf-feature-registry-CfgxGkTs.js", + "scene240-gltf-feature-registry-BCuCyG5Y.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", @@ -2994,7 +2994,7 @@ ] }, "scene241": { - "rawKB": 160.3, + "rawKB": 160.4, "gzipKB": 65.5, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3016,7 +3016,7 @@ "scene241-gltf-feature-animation-pointer-BJ0p5Vnu.js", "scene241-gltf-feature-animations-CSjZ3yRx.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-Bi3iZOoc.js", + "scene241-gltf-feature-registry-Bkf9WxSK.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3042,7 +3042,7 @@ ] }, "scene242": { - "rawKB": 96.2, + "rawKB": 96.3, "gzipKB": 39.8, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3053,7 +3053,7 @@ "scene242-gltf-ext-emissive-strength-CButLZnK.js", "scene242-gltf-feature-animation-pointer-7Tn5Qu5X.js", "scene242-gltf-feature-animations-B_VnRwPM.js", - "scene242-gltf-feature-registry-BUHew8Rq.js", + "scene242-gltf-feature-registry-C0aPyEVH.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", "scene242-pbr-renderable-DQEk4f7o.js", @@ -3064,8 +3064,8 @@ ] }, "scene243": { - "rawKB": 95.9, - "gzipKB": 40.4, + "rawKB": 96.1, + "gzipKB": 40.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene243-create-morph-targets-C_lcfVOA.js", @@ -3074,7 +3074,7 @@ "scene243-gltf-feature-animations-DEeCXW1Z.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-Ca6TPDdU.js", + "scene243-gltf-feature-registry-DUaqkxEu.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", @@ -3088,8 +3088,8 @@ ] }, "scene244": { - "rawKB": 132.1, - "gzipKB": 53.4, + "rawKB": 132.2, + "gzipKB": 53.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene244-animation-pointer-ext-DfeJiTkj.js", @@ -3101,7 +3101,7 @@ "scene244-gltf-ext-uv-transform-YGWG8v_J.js", "scene244-gltf-feature-animation-pointer-Cl7BygHu.js", "scene244-gltf-feature-animations-CTlvB6vN.js", - "scene244-gltf-feature-registry-BPhJRekD.js", + "scene244-gltf-feature-registry-C4SC6zCa.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", @@ -3119,7 +3119,7 @@ ] }, "scene245": { - "rawKB": 98.6, + "rawKB": 98.7, "gzipKB": 41.8, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3128,7 +3128,7 @@ "scene245-generate-mipmaps-WM6bVf2v.js", "scene245-gltf-animation-Dvm46y_g.js", "scene245-gltf-feature-animations-BV66HV-9.js", - "scene245-gltf-feature-registry-Cna9wg56.js", + "scene245-gltf-feature-registry-DmK9_cNa.js", "scene245-gltf-feature-skeleton-IRWJQHYY.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", @@ -3144,7 +3144,7 @@ ] }, "scene246": { - "rawKB": 97.5, + "rawKB": 97.6, "gzipKB": 41.4, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3153,7 +3153,7 @@ "scene246-generate-mipmaps-DzKvtUax.js", "scene246-gltf-animation-DGsaicDt.js", "scene246-gltf-feature-animations-DimU6cfM.js", - "scene246-gltf-feature-registry-Ddaviakj.js", + "scene246-gltf-feature-registry-Dt8aKR7c.js", "scene246-gltf-feature-skeleton-Bf1KbRoN.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", @@ -3169,14 +3169,14 @@ ] }, "scene247": { - "rawKB": 82.8, + "rawKB": 82.9, "gzipKB": 34.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", - "scene247-gltf-feature-registry-BH2GZ29y.js", + "scene247-gltf-feature-registry-DQCXkzEd.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", @@ -3221,7 +3221,7 @@ ] }, "scene251": { - "rawKB": 88.1, + "rawKB": 88.2, "gzipKB": 36.5, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3229,7 +3229,7 @@ "scene251-generate-mipmaps-ojYQxP8q.js", "scene251-gltf-animation-BJ2pOO_r.js", "scene251-gltf-feature-animations-Do8ooupS.js", - "scene251-gltf-feature-registry-CIpBJuh2.js", + "scene251-gltf-feature-registry-CnucUK_A.js", "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", "scene251-gltf-glb-parser-8AD91ACR.js", "scene251-multilight-wgsl-Cxg2lDtv.js", @@ -3250,7 +3250,7 @@ ] }, "scene253": { - "rawKB": 151, + "rawKB": 151.1, "gzipKB": 63.7, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3275,7 +3275,7 @@ "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-BxN0uz2i.js", + "scene253-gltf-feature-registry-BgIdVhs9.js", "scene253-gltf-feature-skeleton-Bjigd6Ok.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js", diff --git a/packages/babylon-lite/src/asset-container.ts b/packages/babylon-lite/src/asset-container.ts index d2760e610a..6fe74357fb 100644 --- a/packages/babylon-lite/src/asset-container.ts +++ b/packages/babylon-lite/src/asset-container.ts @@ -30,6 +30,9 @@ export interface AssetContainer { * `enableBoneControl()` was called before loading; otherwise `undefined`. * Drive bones via `getBoneByName()` + the `setBone*` functions. */ skeletons?: Skeleton[]; + /** Flow graphs parsed from the file (glTF KHR_interactivity). addToScene() + * binds and runs them via the scene's frame loop. */ + flowGraphs?: import("./flow-graph/context.js").LoadedFlowGraph[]; } /** diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index a11df6c23c..b7476c4836 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -4,21 +4,56 @@ // bytes for scenes without interactivity. Mirrors BJS `blockFactory` and Lite's // `gltf-feature-registry`. // -// Phase 1 ships NO blocks, so every type currently resolves to `null`. As blocks -// land (Phase 2+), add one `case` per block here. The `switch` body stays pure -// (no module-level allocation), keeping this module fully tree-shakable. +// Phase 2 lands the vertical-slice blocks (events, control-flow, one math op, +// property/variable data, animation). Add one `case` per block as more land +// (Phase 3+). The `switch` body stays pure (no module-level allocation), +// keeping this module fully tree-shakable. // // Unknown-op policy lives in the CALLER: `createFgEnv` (KHR_interactivity path) // fails loudly on `null`; a permissive editor path (post-MVP) may substitute a // no-op. Never silently swallow an unknown op on the KHR path. import type { FgBlockDef } from "./block-def.js"; +import { FgBlockType } from "./block-type.js"; export function getBlockDef(type: string): (() => Promise) | null { switch (type) { - // Phase 2 will add e.g.: - // case FgBlockType.Branch: - // return async () => (await import("./blocks/control-flow/branch.js")).branchDef; + // ─── Events ─────────────────────────────────────────────── + case FgBlockType.SceneStart: + return async () => (await import("./blocks/events/scene-start.js")).sceneStartDef; + case FgBlockType.SceneTick: + return async () => (await import("./blocks/events/scene-tick.js")).sceneTickDef; + + // ─── Control flow ───────────────────────────────────────── + case FgBlockType.Branch: + return async () => (await import("./blocks/control-flow/branch.js")).branchDef; + case FgBlockType.Sequence: + return async () => (await import("./blocks/control-flow/sequence.js")).sequenceDef; + + // ─── Math ───────────────────────────────────────────────── + case FgBlockType.Add: + return async () => (await import("./blocks/math/add.js")).addDef; + + // ─── Data: property / variable ──────────────────────────── + case FgBlockType.GetProperty: + return async () => (await import("./blocks/data/get-property.js")).getPropertyDef; + case FgBlockType.SetProperty: + return async () => (await import("./blocks/data/set-property.js")).setPropertyDef; + case FgBlockType.GetVariable: + return async () => (await import("./blocks/data/get-variable.js")).getVariableDef; + case FgBlockType.SetVariable: + return async () => (await import("./blocks/data/set-variable.js")).setVariableDef; + + // ─── Animation ──────────────────────────────────────────── + case FgBlockType.PlayAnimation: + return async () => (await import("./blocks/animation/play-animation.js")).playAnimationDef; + case FgBlockType.StopAnimation: + return async () => (await import("./blocks/animation/stop-animation.js")).stopAnimationDef; + + // ─── Debug ──────────────────────────────────────────────── + case FgBlockType.ConsoleLog: + return async () => (await import("./blocks/debug/console-log.js")).consoleLogDef; + default: return null; } diff --git a/packages/babylon-lite/src/flow-graph/blocks/animation/play-animation.ts b/packages/babylon-lite/src/flow-graph/blocks/animation/play-animation.ts new file mode 100644 index 0000000000..7973fdb797 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/animation/play-animation.ts @@ -0,0 +1,81 @@ +// PlayAnimation (BJS FlowGraphPlayAnimationBlock, glTF op `animation/start`). +// Async execution block: starts an AnimationGroup (resolved by glTF animation +// index from `env.animations`), fires `out` immediately so sync flow continues, +// and fires `done` when the animation ends. +// +// LITE DIVERGENCE: BJS wires animation/start to [PlayAnimation, ArrayIndex, +// GLTFDataProvider]. Lite pre-resolves the animation array in the loader and +// drives playback through scene-owned `env.caps` (no scene reference in the +// block). `from`/`to` frame-range playback is a Phase 3 refinement; Phase 2 +// honors `speed` + `loop`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import type { AnimationGroup } from "../../../animation/animation-group.js"; +import { activateSignal, addPending, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const playAnimationDef: FgBlockDef = { + type: FgBlockType.PlayAnimation, + build: () => ({ + dataIn: [ + sockIn("animation", FgType.Integer), + sockIn("speed", FgType.Number, 1), + sockIn("loop", FgType.Boolean, false), + sockIn("from", FgType.Number, 0), + sockIn("to", FgType.Number), + ], + signalIn: [sigIn("in")], + signalOut: [sigOut("out"), sigOut("done"), sigOut("error")], + }), + execute(block, ctx, env) { + const index = toIndex(getDataValue(ctx, env, block, "animation")); + const group = index === undefined ? undefined : env.animations[index]; + if (!group || !env.caps.playAnimation) { + activateSignal(ctx, env, block, "error"); + return; + } + const speed = getDataValue(ctx, env, block, "speed") as number; + const loop = getDataValue(ctx, env, block, "loop") as boolean; + env.caps.playAnimation(group, { speed, loop }); + activateSignal(ctx, env, block, "out"); + + const task = addPending(ctx, block, { group }); + if (env.caps.onAnimationEnd) { + task.state.unsub = env.caps.onAnimationEnd(group, () => { + task.done = true; + activateSignal(ctx, env, block, "done"); + }); + } + }, + onTick(block, ctx, env, _deltaMs, task) { + // Fallback completion when no onAnimationEnd capability is wired: a + // non-looping group that stopped playing is finished. + if (task.state.unsub) { + return; + } + const group = task.state.group as AnimationGroup | undefined; + if (group && !group.isPlaying) { + task.done = true; + activateSignal(ctx, env, block, "done"); + } + }, + cancelPending(block, ctx) { + for (const task of ctx.pending) { + if (task.blockId === block.id) { + (task.state.unsub as (() => void) | undefined)?.(); + } + } + }, +}; + +function toIndex(value: unknown): number | undefined { + if (typeof value === "number") { + return value | 0; + } + if (typeof value === "object" && value !== null && "value" in value) { + return (value as { value: number }).value | 0; + } + return undefined; +} diff --git a/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts b/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts new file mode 100644 index 0000000000..7e865f5aea --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts @@ -0,0 +1,38 @@ +// StopAnimation (BJS FlowGraphStopAnimationBlock, glTF op `animation/stop`). +// Execution block: stops an AnimationGroup resolved by glTF animation index, +// then fires `out` (or `error` when the index/capability is missing). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const stopAnimationDef: FgBlockDef = { + type: FgBlockType.StopAnimation, + build: () => ({ + dataIn: [sockIn("animation", FgType.Integer)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out"), sigOut("error")], + }), + execute(block, ctx, env) { + const index = toIndex(getDataValue(ctx, env, block, "animation")); + const group = index === undefined ? undefined : env.animations[index]; + if (group && env.caps.stopAnimation) { + env.caps.stopAnimation(group); + activateSignal(ctx, env, block, "out"); + } else { + activateSignal(ctx, env, block, "error"); + } + }, +}; + +function toIndex(value: unknown): number | undefined { + if (typeof value === "number") { + return value | 0; + } + if (typeof value === "object" && value !== null && "value" in value) { + return (value as { value: number }).value | 0; + } + return undefined; +} diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/branch.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/branch.ts new file mode 100644 index 0000000000..bb296d6dc4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/branch.ts @@ -0,0 +1,25 @@ +// Branch (BJS FlowGraphBranchBlock, glTF op `flow/branch`). +// Execution block: routes the incoming signal to `onTrue` or `onFalse` based on +// the boolean `condition` data input. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const branchDef: FgBlockDef = { + type: FgBlockType.Branch, + build: () => ({ + dataIn: [sockIn("condition", FgType.Boolean, false)], + signalIn: [sigIn("in")], + signalOut: [sigOut("onTrue"), sigOut("onFalse")], + }), + execute(block, ctx, env) { + if (getDataValue(ctx, env, block, "condition")) { + activateSignal(ctx, env, block, "onTrue"); + } else { + activateSignal(ctx, env, block, "onFalse"); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/sequence.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/sequence.ts new file mode 100644 index 0000000000..153d18e776 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/sequence.ts @@ -0,0 +1,26 @@ +// Sequence (BJS FlowGraphSequenceBlock, glTF op `flow/sequence`). +// Execution block: fires its N output flows `out_0`, `out_1`, … in order. The +// count comes from `config.outputSignalCount` (BJS) — the glTF mapper derives it +// from the node's declared output flow sockets. Defaults to 1. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { activateSignal } from "../../runtime.js"; +import { sigIn, sigOut } from "../../sockets.js"; + +export const sequenceDef: FgBlockDef = { + type: FgBlockType.Sequence, + build: (config) => { + const count = Math.max(1, (config?.outputSignalCount as number) ?? 1); + const signalOut = []; + for (let i = 0; i < count; i++) { + signalOut.push(sigOut(`out_${i}`)); + } + return { signalIn: [sigIn("in")], signalOut }; + }, + execute(block, ctx, env) { + for (const sig of block.signalOut) { + activateSignal(ctx, env, block, sig.name); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/data/get-property.ts b/packages/babylon-lite/src/flow-graph/blocks/data/get-property.ts new file mode 100644 index 0000000000..b0a4a03cd8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/data/get-property.ts @@ -0,0 +1,27 @@ +// GetProperty (BJS FlowGraphGetPropertyBlock + JsonPointerParser, glTF op +// `pointer/get`). Data block (PULL): emits `value` read through a pre-resolved +// accessor. +// +// LITE DIVERGENCE: BJS resolves the JSON pointer at runtime via a separate +// JsonPointerParser block (object + propertyName + getter/setter). Lite's loader +// pre-resolves the pointer to an `FgAccessor` (get/set closures) at load time +// and stores it in `env.accessors`, keyed by `config.accessor`. So a single +// block reads via the accessor — the parser/path-converter owns pointer +// resolution. See flow-graph/gltf/path-converter.ts. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const getPropertyDef: FgBlockDef = { + type: FgBlockType.GetProperty, + build: () => ({ + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const accessor = env.accessors[block.config?.accessor as string]; + setDataValue(ctx, block, "value", accessor ? accessor.get() : undefined); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/data/get-variable.ts b/packages/babylon-lite/src/flow-graph/blocks/data/get-variable.ts new file mode 100644 index 0000000000..5acf165eab --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/data/get-variable.ts @@ -0,0 +1,20 @@ +// GetVariable (BJS FlowGraphGetVariableBlock, glTF op `variable/get`). +// Data block (PULL): emits `value` = the live graph variable named by +// `config.variable`, recomputed on every read. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const getVariableDef: FgBlockDef = { + type: FgBlockType.GetVariable, + build: () => ({ + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx) { + const name = block.config?.variable as string; + setDataValue(ctx, block, "value", ctx.userVariables[name]); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/data/set-property.ts b/packages/babylon-lite/src/flow-graph/blocks/data/set-property.ts new file mode 100644 index 0000000000..6fa4cd0aaa --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/data/set-property.ts @@ -0,0 +1,31 @@ +// SetProperty (BJS FlowGraphSetPropertyBlock + JsonPointerParser, glTF op +// `pointer/set`). Execution block: writes `value` through a pre-resolved +// accessor, then fires `out` (or `error` when the accessor is missing / +// read-only). +// +// LITE DIVERGENCE: see get-property.ts — pointer resolution happens in the +// loader, not at runtime; the block writes via `env.accessors[config.accessor]`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const setPropertyDef: FgBlockDef = { + type: FgBlockType.SetProperty, + build: () => ({ + dataIn: [sockIn("value", FgType.Any)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out"), sigOut("error")], + }), + execute(block, ctx, env) { + const accessor = env.accessors[block.config?.accessor as string]; + if (accessor?.set) { + accessor.set(getDataValue(ctx, env, block, "value")); + activateSignal(ctx, env, block, "out"); + } else { + activateSignal(ctx, env, block, "error"); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/data/set-variable.ts b/packages/babylon-lite/src/flow-graph/blocks/data/set-variable.ts new file mode 100644 index 0000000000..fdfb9e0924 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/data/set-variable.ts @@ -0,0 +1,25 @@ +// SetVariable (BJS FlowGraphSetVariableBlock, glTF op `variable/set`). +// Execution block: writes `value` into the live graph variable named by +// `config.variable`, then fires `out`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const setVariableDef: FgBlockDef = { + type: FgBlockType.SetVariable, + build: () => ({ + dataIn: [sockIn("value", FgType.Any)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out")], + }), + execute(block, ctx, env) { + const name = block.config?.variable as string; + if (name !== undefined) { + ctx.userVariables[name] = getDataValue(ctx, env, block, "value"); + } + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts b/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts new file mode 100644 index 0000000000..1de12bace5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts @@ -0,0 +1,22 @@ +// ConsoleLog (BJS FlowGraphConsoleLogBlock, glTF op `flow/log` in the BABYLON +// extension). Execution block: logs `message` to the console, then fires `out`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const consoleLogDef: FgBlockDef = { + type: FgBlockType.ConsoleLog, + build: () => ({ + dataIn: [sockIn("message", FgType.Any)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out")], + }), + execute(block, ctx, env) { + // eslint-disable-next-line no-console + console.log(getDataValue(ctx, env, block, "message")); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/events/scene-start.ts b/packages/babylon-lite/src/flow-graph/blocks/events/scene-start.ts new file mode 100644 index 0000000000..fc19a1accb --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/events/scene-start.ts @@ -0,0 +1,24 @@ +// SceneStart (BJS FlowGraphSceneReadyEventBlock, glTF op `event/onStart`). +// Event block: fires once when the graph starts. The runtime's startFlowGraph +// invokes `execute` after all non-start receivers are subscribed. +// +// BJS event blocks fire BOTH `done` (KHR_interactivity graphs wire to this) and +// `out` (editor graphs) — we replicate that so either wiring style works. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgEventType } from "../../event-bus.js"; +import { activateSignal } from "../../runtime.js"; +import { sigOut } from "../../sockets.js"; + +export const sceneStartDef: FgBlockDef = { + type: FgBlockType.SceneStart, + build: () => ({ + signalOut: [sigOut("out"), sigOut("done")], + event: FgEventType.Start, + }), + execute(block, ctx, env) { + activateSignal(ctx, env, block, "done"); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/events/scene-tick.ts b/packages/babylon-lite/src/flow-graph/blocks/events/scene-tick.ts new file mode 100644 index 0000000000..a7a629774c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/events/scene-tick.ts @@ -0,0 +1,41 @@ +// SceneTick (BJS FlowGraphSceneTickEventBlock, glTF op `event/onTick`). +// Event block fired every frame on the Tick channel. Outputs the elapsed time +// since start and the last frame delta (both in SECONDS, matching BJS), then +// fires `out`/`done`. +// +// The scene driver pumps the Tick event each frame with payload +// `{ deltaMs, deltaTime }`; the runtime stashes it at +// `executionVariables[`${id}:lastEvent`]` before calling `execute`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { FgEventType } from "../../event-bus.js"; +import { activateSignal, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigOut, sockOut } from "../../sockets.js"; + +interface TickPayload { + deltaTime?: number; +} + +export const sceneTickDef: FgBlockDef = { + type: FgBlockType.SceneTick, + build: () => ({ + dataOut: [sockOut("timeSinceStart", FgType.Number), sockOut("deltaTime", FgType.Number)], + signalOut: [sigOut("out"), sigOut("done")], + event: FgEventType.Tick, + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "timeSinceStart", getExecVar(ctx, block, "elapsed", 0)); + setDataValue(ctx, block, "deltaTime", getExecVar(ctx, block, "delta", 0)); + }, + execute(block, ctx, env) { + const payload = getExecVar(ctx, block, "lastEvent", undefined); + const delta = payload?.deltaTime ?? 0; + setExecVar(ctx, block, "elapsed", getExecVar(ctx, block, "elapsed", 0) + delta); + setExecVar(ctx, block, "delta", delta); + this.updateOutputs!(block, ctx, env); + activateSignal(ctx, env, block, "done"); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/add.ts b/packages/babylon-lite/src/flow-graph/blocks/math/add.ts new file mode 100644 index 0000000000..a04f350062 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/add.ts @@ -0,0 +1,23 @@ +// Add (BJS FlowGraphAddBlock, glTF op `math/add`). +// Data block (PULL): emits `value` = a + b, type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgAdd`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAdd } from "../../fg-math.js"; + +export const addDef: FgBlockDef = { + type: FgBlockType.Add, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAdd(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/context.ts b/packages/babylon-lite/src/flow-graph/context.ts index 8e71620eb8..b578c5080e 100644 --- a/packages/babylon-lite/src/flow-graph/context.ts +++ b/packages/babylon-lite/src/flow-graph/context.ts @@ -88,3 +88,13 @@ export interface FgWiring { * tests (hand-built defs) and to override/extend the registry. */ defs?: Record; } + +/** A flow graph loaded from a file (e.g. glTF KHR_interactivity), carried on the + * `AssetContainer` until `addToScene` wires it to the scene. Spec-agnostic: the + * graph + its JSON-pointer accessors are fully resolved at load time; animations + * and capabilities are bound at attach time from the scene/container. */ +export interface LoadedFlowGraph { + readonly graph: FgGraph; + /** JSON-pointer-string → resolved scene-object accessor. */ + readonly accessors: Record; +} diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts new file mode 100644 index 0000000000..003c8dbd28 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -0,0 +1,45 @@ +// Block-specific math, lazily imported by the blocks that need it so core +// `math/` (Vec3-centric, minimal) stays untouched and non-interactivity scenes +// stay byte-identical (GUIDANCE pillar: tree-shakable, no core bloat). +// +// Ops here are TYPE-GENERIC: they branch on the runtime value shape +// (number | FgInteger | Vec2 | Vec3 | Vec4), mirroring BJS's per-component +// handling of the same `math/*` ops. Add more dispatchers (fgSub, fgMul, …) in +// Phase 3 as the math block library broadens. + +import { fgInt, isFgInt } from "./custom-types/fg-integer.js"; +import type { FgValue, Vec2 } from "./types.js"; +import type { Vec3, Vec4 } from "../math/types.js"; + +function isVec2(v: unknown): v is Vec2 { + return typeof v === "object" && v !== null && "x" in v && "y" in v && !("z" in v); +} +function isVec3(v: unknown): v is Vec3 { + return typeof v === "object" && v !== null && "x" in v && "y" in v && "z" in v && !("w" in v); +} +function isVec4(v: unknown): v is Vec4 { + return typeof v === "object" && v !== null && "x" in v && "y" in v && "z" in v && "w" in v; +} + +/** Type-generic component-wise add. Matches BJS `math/add` semantics across + * number, FlowGraphInteger, and Vector2/3/4. Mixed/unknown shapes fall back to + * numeric addition of `0` (BJS returns the left operand on type mismatch; we + * keep it total to avoid throwing inside the runtime loop). */ +export function fgAdd(a: FgValue, b: FgValue): FgValue { + if (isFgInt(a) && isFgInt(b)) { + return fgInt(a.value + b.value); + } + if (typeof a === "number" && typeof b === "number") { + return a + b; + } + if (isVec4(a) && isVec4(b)) { + return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z, w: a.w + b.w }; + } + if (isVec3(a) && isVec3(b)) { + return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z }; + } + if (isVec2(a) && isVec2(b)) { + return { x: a.x + b.x, y: a.y + b.y }; + } + return a; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts new file mode 100644 index 0000000000..401f90eda4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -0,0 +1,91 @@ +// ⚠️ SPEC-VOLATILE — KHR_interactivity is an UNRATIFIED glTF draft. Quarantined +// here so the runtime core never changes when the spec churns. Mirrored against +// Babylon.js commit 8f728b23ea (2026-06-24). Re-sync against BJS PR #18455 +// ("KHR_interactivity rework") when it lands. +// See docs/lite/architecture/42-flow-graph.md → glTF KHR_interactivity Loader. +// +// declaration-mapper: maps each glTF interactivity `op` string to the Lite block +// it instantiates, plus the socket/config translation. Mirrors BJS +// `declarationMapper.ts`, but COLLAPSED: BJS expands pointer/animation ops into +// multiple blocks + inter-block connectors (JsonPointerParser, ArrayIndex, +// GLTFDataProvider). Lite pre-resolves pointers to accessors and animations to +// caps in the loader, so each op maps to a SINGLE block. + +import { FgBlockType } from "../block-type.js"; + +/** Default glTF value-output socket name (used when a reference omits `socket`). */ +export const DEFAULT_VALUE_SOCKET = "value"; +/** Default glTF flow-input socket name (used when a flow omits `socket`). */ +export const DEFAULT_FLOW_SOCKET = "in"; +/** Frames-per-second used to convert animation seconds → frames (glTF default). */ +export const ANIMATION_FPS = 60; + +/** Lite-side mapping descriptor for one glTF interactivity op. */ +export interface FgOpMapping { + /** The Lite block this op instantiates. */ + readonly block: FgBlockType; + /** glTF value-INPUT socket name → Lite data-input name. Unlisted inputs that + * are NOT pointer segments are passed through by their glTF name. */ + readonly valueInputs?: Readonly>; + /** Per-input numeric transform applied to a literal value array before + * coercion (e.g. animation seconds → frames). Keyed by glTF input name. */ + readonly valueTransform?: Readonly number[]>>; + /** glTF value-OUTPUT socket name → Lite data-output name (for data references + * that read this block). Default output `value` passes through. */ + readonly outputValues?: Readonly>; + /** glTF flow-OUTPUT socket name → Lite signal-output name. */ + readonly flowOutputs?: Readonly>; + /** Pointer op: resolve `config.accessor` from the `pointer` configuration + + * literal segment value sockets; segment inputs are NOT block data inputs. */ + readonly pointer?: boolean; + /** Sequence-style: `outputSignalCount` = number of flow keys; the i-th flow + * (sorted) maps to signal `out_i`. */ + readonly dynamicSequence?: boolean; + /** Variable op: the glTF configuration key holding the variable index/indices + * (`variable` for get, `variables` for set). */ + readonly variableConfigKey?: string; +} + +const FPS = (arr: number[]): number[] => [(arr[0] ?? 0) * ANIMATION_FPS]; + +/** Native (no-extension) KHR_interactivity op → Lite block mapping. */ +const NATIVE_OPS: Readonly> = { + "event/onStart": { block: FgBlockType.SceneStart, flowOutputs: { out: "done" } }, + "event/onTick": { block: FgBlockType.SceneTick, outputValues: { timeSinceLastTick: "deltaTime" }, flowOutputs: { out: "done" } }, + + "flow/branch": { block: FgBlockType.Branch, valueInputs: { condition: "condition" }, flowOutputs: { true: "onTrue", false: "onFalse" } }, + "flow/sequence": { block: FgBlockType.Sequence, dynamicSequence: true }, + + "math/add": { block: FgBlockType.Add, valueInputs: { a: "a", b: "b" } }, + + "variable/get": { block: FgBlockType.GetVariable, variableConfigKey: "variable" }, + "variable/set": { block: FgBlockType.SetVariable, variableConfigKey: "variables", valueInputs: { value: "value" } }, + + "pointer/get": { block: FgBlockType.GetProperty, pointer: true }, + "pointer/set": { block: FgBlockType.SetProperty, pointer: true, valueInputs: { value: "value" }, flowOutputs: { err: "error" } }, + + "animation/start": { + block: FgBlockType.PlayAnimation, + valueInputs: { animation: "animation", speed: "speed", startTime: "from", endTime: "to" }, + valueTransform: { startTime: FPS, endTime: FPS }, + flowOutputs: { err: "error" }, + }, + "animation/stop": { block: FgBlockType.StopAnimation, valueInputs: { animation: "animation" }, flowOutputs: { err: "error" } }, +}; + +/** Babylon-extension ops (`declaration.extension === "BABYLON"`). */ +const BABYLON_OPS: Readonly> = { + "flow/log": { block: FgBlockType.ConsoleLog, valueInputs: { message: "message" } }, +}; + +/** Look up the Lite mapping for a glTF op, honoring the declaration `extension`. + * Returns `null` for an unknown op so the parser can fail loudly. */ +export function getOpMapping(op: string, extension?: string): FgOpMapping | null { + if (extension === "BABYLON") { + return BABYLON_OPS[op] ?? null; + } + if (extension) { + return null; // unknown extension — Phase 3+ may add pass-through blocks + } + return NATIVE_OPS[op] ?? null; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts new file mode 100644 index 0000000000..d4dfced376 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts @@ -0,0 +1,230 @@ +// ⚠️ SPEC-VOLATILE — KHR_interactivity is an UNRATIFIED glTF draft. Quarantined +// here so the runtime core never changes when the spec churns. Mirrored against +// Babylon.js commit 8f728b23ea (2026-06-24). Re-sync against BJS PR #18455 +// ("KHR_interactivity rework") when it lands. +// See docs/lite/architecture/42-flow-graph.md → glTF KHR_interactivity Loader. +// +// interactivity-parser: walks a `glTF.extensions.KHR_interactivity` graph object +// (types → declarations → variables → nodes/values/flows) and produces a +// spec-agnostic `FgGraph` plus the list of JSON pointers to resolve into +// accessors. Mirrors BJS `interactivityGraphParser.ts`, collapsed for Lite's +// pre-resolved-accessor model (see declaration-mapper.ts). +// +// Unknown ops FAIL LOUDLY (structured error listing every offending op) so a +// KHR_interactivity asset can't silently render a broken interaction. + +import { fgInt } from "../custom-types/fg-integer.js"; +import { getBlockDef } from "../block-registry.js"; +import type { FgBlock, FgDataSocket, FgGraph, FgSignalSocket, FgValue } from "../types.js"; +import { FgType } from "../types.js"; +import { DEFAULT_FLOW_SOCKET, DEFAULT_VALUE_SOCKET, getOpMapping, type FgOpMapping } from "./declaration-mapper.js"; + +// ─── glTF wire-format shapes (loose; spec-volatile) ────────────────────────── + +interface GltfValueEntry { + value?: number[]; + type?: number; + node?: number; + socket?: string; +} +interface GltfFlowEntry { + node: number; + socket?: string; +} +interface GltfNode { + declaration: number; + configuration?: Record; + values?: Record; + flows?: Record; +} +export interface GltfInteractivityGraph { + types?: { signature: string }[]; + declarations?: { op: string; extension?: string }[]; + variables?: { type: number; value?: number[] }[]; + events?: unknown[]; + nodes?: GltfNode[]; +} + +/** Result of parsing one interactivity graph. */ +export interface FgParseResult { + readonly graph: FgGraph; + /** Resolved JSON-pointer strings the loader must turn into accessors + * (keyed identically in `block.config.accessor`). */ + readonly pointers: readonly string[]; +} + +const SIGNATURE_TO_FGTYPE: Readonly> = { + bool: FgType.Boolean, + int: FgType.Integer, + float: FgType.Number, + float2: FgType.Vector2, + float3: FgType.Vector3, + float4: FgType.Vector4, + float2x2: FgType.Matrix2D, + float3x3: FgType.Matrix3D, + float4x4: FgType.Matrix, +}; + +/** Coerce a glTF flat value array into an `FgValue` of the given type. */ +function arrayToFgValue(arr: number[] | undefined, type: FgType): FgValue { + const a = arr ?? []; + switch (type) { + case FgType.Boolean: + return !!a[0]; + case FgType.Integer: + return fgInt(a[0] ?? 0); + case FgType.Number: + return a[0] ?? 0; + case FgType.Vector2: + return { x: a[0] ?? 0, y: a[1] ?? 0 }; + case FgType.Vector3: + return { x: a[0] ?? 0, y: a[1] ?? 0, z: a[2] ?? 0 }; + case FgType.Vector4: + case FgType.Quaternion: + return { x: a[0] ?? 0, y: a[1] ?? 0, z: a[2] ?? 0, w: a[3] ?? 0 }; + default: + return a[0] ?? 0; + } +} + +/** Substitute `{segment}` template variables in a pointer with their literal + * value-socket values. Returns `null` if a segment is missing or non-literal. */ +function resolvePointerTemplate(template: string, node: GltfNode): string | null { + let ok = true; + const resolved = template.replace(/\{(\w+)\}/g, (_m, seg: string) => { + const entry = node.values?.[seg]; + const literal = entry?.value?.[0]; + if (literal === undefined || entry?.node !== undefined) { + ok = false; + return _m; + } + return String(literal); + }); + return ok ? resolved : null; +} + +/** Compute a node's per-flow-key → Lite signal-output-name map (handles the + * dynamic sequence renaming). */ +function flowOutputName(mapping: FgOpMapping, flowKeys: string[], key: string): string { + if (mapping.dynamicSequence) { + return `out_${flowKeys.indexOf(key)}`; + } + return mapping.flowOutputs?.[key] ?? key; +} + +/** Parse one KHR_interactivity graph object into an `FgGraph` + pointer list. */ +export async function parseInteractivityGraph(json: GltfInteractivityGraph): Promise { + const types = (json.types ?? []).map((t) => SIGNATURE_TO_FGTYPE[t.signature] ?? FgType.Any); + const declarations = json.declarations ?? []; + const nodes = json.nodes ?? []; + + // Resolve the mapping for every node first, collecting unknown ops. + const mappings: FgOpMapping[] = []; + const unsupported: string[] = []; + for (const node of nodes) { + const decl = declarations[node.declaration]; + const mapping = decl ? getOpMapping(decl.op, decl.extension) : null; + if (!mapping) { + const label = decl ? `${decl.extension ? decl.extension + ":" : ""}${decl.op}` : `declaration#${node.declaration}`; + if (!unsupported.includes(label)) { + unsupported.push(label); + } + } + mappings.push(mapping as FgOpMapping); + } + if (unsupported.length > 0) { + throw new Error(`KHR_interactivity: unsupported op(s): ${unsupported.join(", ")}`); + } + + // Graph variables (keyed by index, mirroring BJS getVariableName(i)). + const variables: Record = {}; + (json.variables ?? []).forEach((v, i) => { + const t = types[v.type] ?? FgType.Any; + variables[String(i)] = { type: t, value: arrayToFgValue(v.value, t) }; + }); + + // Pass 1: instantiate each block's socket shape from its def + config. + const blocks: FgBlock[] = []; + const pointers: string[] = []; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]!; + const mapping = mappings[i]!; + const config: Record = {}; + + if (mapping.dynamicSequence) { + config.outputSignalCount = Object.keys(node.flows ?? {}).length; + } + if (mapping.variableConfigKey) { + const idx = (node.configuration?.[mapping.variableConfigKey]?.value?.[0] as number) ?? 0; + config.variable = String(idx); + } + if (mapping.pointer) { + const template = node.configuration?.pointer?.value?.[0] as string | undefined; + const resolved = template ? resolvePointerTemplate(template, node) : null; + if (resolved === null) { + throw new Error(`KHR_interactivity: node ${i} has an unresolvable pointer ${JSON.stringify(template)} (dynamic segments are not yet supported)`); + } + config.accessor = resolved; + if (!pointers.includes(resolved)) { + pointers.push(resolved); + } + } + + const def = await getBlockDef(mapping.block)!(); + const shape = def.build(config); + blocks.push({ + id: `node_${i}`, + type: mapping.block, + config, + dataIn: [...(shape.dataIn ?? [])], + dataOut: shape.dataOut ?? [], + signalIn: shape.signalIn ?? [], + signalOut: (shape.signalOut ?? []).map((s) => ({ name: s.name, targets: [] as { blockId: string; socket: string }[] })), + event: shape.event, + }); + } + + // Pass 2: wire data sources (values) and signal targets (flows). + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]!; + const mapping = mappings[i]!; + const block = blocks[i]!; + + // Data inputs. + for (const [gltfKey, entry] of Object.entries(node.values ?? {})) { + if (mapping.pointer && gltfKey !== "value") { + continue; // pointer segment — consumed by accessor resolution + } + const inputName = mapping.valueInputs?.[gltfKey] ?? gltfKey; + const socket = block.dataIn.find((d) => d.name === inputName) as (FgDataSocket & { source?: unknown; defaultValue?: FgValue }) | undefined; + if (!socket) { + continue; + } + if (entry.node !== undefined) { + const producer = mappings[entry.node]!; + const gltfSocket = entry.socket ?? DEFAULT_VALUE_SOCKET; + socket.source = { blockId: `node_${entry.node}`, socket: producer.outputValues?.[gltfSocket] ?? gltfSocket }; + } else { + const transform = mapping.valueTransform?.[gltfKey]; + const arr = transform ? transform(entry.value ?? []) : entry.value; + socket.defaultValue = arrayToFgValue(arr, types[entry.type ?? -1] ?? socket.type); + } + } + + // Signal outputs (flows). + const flowKeys = Object.keys(node.flows ?? {}); + for (const key of flowKeys) { + const flow = node.flows![key]!; + const outName = flowOutputName(mapping, flowKeys, key); + const out = block.signalOut.find((s) => s.name === outName) as FgSignalSocket | undefined; + if (!out) { + continue; + } + (out.targets as { blockId: string; socket: string }[]).push({ blockId: `node_${flow.node}`, socket: flow.socket ?? DEFAULT_FLOW_SOCKET }); + } + } + + const byId: Record = {}; + blocks.forEach((b, i) => (byId[b.id] = i)); + return { graph: { blocks, byId, variables }, pointers }; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/object-model-mapping.ts b/packages/babylon-lite/src/flow-graph/gltf/object-model-mapping.ts new file mode 100644 index 0000000000..a6f660733f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/gltf/object-model-mapping.ts @@ -0,0 +1,32 @@ +// ⚠️ SPEC-VOLATILE — KHR_interactivity is an UNRATIFIED glTF draft. All code in +// flow-graph/gltf/ is quarantined here so the runtime core never changes when +// the spec churns. Mirrored against Babylon.js commit 8f728b23ea (2026-06-24). +// Re-sync against BJS PR #18455 ("KHR_interactivity rework") when it lands. +// See docs/lite/architecture/42-flow-graph.md → glTF KHR_interactivity Loader. +// +// object-model-mapping: maps glTF JSON-pointer object-model paths to the Lite +// scene property they address + the FgType of that property. Phase 2 covers the +// node TRS triplet (the vertical-slice surface). Broaden in Phase 3+ (materials, +// cameras, lights, extensions) — mirror BJS `objectModelMapping.ts`. + +import { FgType } from "../types.js"; + +/** A scene-graph node TRS property addressable by a JSON pointer. */ +export type NodeTrsProp = "translation" | "rotation" | "scale"; + +/** Object-model entry: which node property a pointer tail addresses + its type. */ +export interface ObjectModelEntry { + /** The pointer tail after `/nodes/{index}/` (e.g. "translation"). */ + readonly prop: NodeTrsProp; + readonly type: FgType; +} + +/** Supported `/nodes/{index}/` tails. glTF uses RH coordinates; the Lite + * import root carries the RH→LH conversion, so accessors read/write the node's + * LOCAL TRS with raw glTF values (no per-accessor handedness flip for + * translation/scale). Rotation handedness is revisited in Phase 3. */ +export const NODE_TRS_PROPS: Record = { + translation: { prop: "translation", type: FgType.Vector3 }, + rotation: { prop: "rotation", type: FgType.Quaternion }, + scale: { prop: "scale", type: FgType.Vector3 }, +}; diff --git a/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts b/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts new file mode 100644 index 0000000000..07eae99b2c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts @@ -0,0 +1,86 @@ +// ⚠️ SPEC-VOLATILE — see object-model-mapping.ts. Mirrored against BJS commit +// 8f728b23ea. Re-sync against BJS PR #18455 when it lands. +// +// path-converter: resolves a (literal-substituted) JSON pointer string such as +// "/nodes/0/translation" to an FgAccessor (get/set closures) over the addressed +// scene node's TRS. The KHR_interactivity loader feeds the glTF `_nodeMap` +// (glTF-node-index → TransformNode) so accessors never hold a scene reference — +// they close over the resolved node only. +// +// LITE DIVERGENCE: BJS resolves pointers at RUNTIME via JsonPointerParser + +// gltfPathToObjectConverter. Lite pre-resolves them here at LOAD time, collapsing +// the JsonPointerParser/GetProperty/SetProperty trio into a single block reading +// a pre-resolved accessor. See blocks/data/{get,set}-property.ts. + +import type { FgAccessor } from "../context.js"; +import type { FgValue, Vec2 } from "../types.js"; +import type { TransformNode } from "../../scene/transform-node.js"; +import type { Quat, Vec3, Vec4 } from "../../math/types.js"; +import { NODE_TRS_PROPS } from "./object-model-mapping.js"; + +/** Parse `/nodes/{index}/{prop}` → `{ nodeIndex, prop }`, or `null` when the + * pointer is not a supported node-TRS path. */ +function parseNodeTrsPointer(pointer: string): { nodeIndex: number; prop: string } | null { + const m = /^\/nodes\/(\d+)\/(translation|rotation|scale)$/.exec(pointer); + if (!m) { + return null; + } + return { nodeIndex: Number(m[1]), prop: m[2]! }; +} + +/** Resolve a literal-substituted JSON pointer to an `FgAccessor`, or `null` when + * it addresses an unsupported path or an unreachable node. */ +export function resolvePointerAccessor(pointer: string, nodeMap: readonly (TransformNode | undefined)[]): FgAccessor | null { + const parsed = parseNodeTrsPointer(pointer); + if (!parsed) { + return null; + } + const node = nodeMap[parsed.nodeIndex]; + if (!node) { + return null; + } + const entry = NODE_TRS_PROPS[parsed.prop]!; + + if (parsed.prop === "translation") { + return { + type: entry.type, + target: node, + get: () => ({ x: node.position.x, y: node.position.y, z: node.position.z }), + set: (v) => { + const p = toVec3(v); + node.position.set(p.x, p.y, p.z); + }, + }; + } + if (parsed.prop === "scale") { + return { + type: entry.type, + target: node, + get: () => ({ x: node.scaling.x, y: node.scaling.y, z: node.scaling.z }), + set: (v) => { + const p = toVec3(v); + node.scaling.set(p.x, p.y, p.z); + }, + }; + } + // rotation (quaternion) + return { + type: entry.type, + target: node, + get: () => ({ x: node.rotationQuaternion.x, y: node.rotationQuaternion.y, z: node.rotationQuaternion.z, w: node.rotationQuaternion.w }), + set: (v) => { + const q = toQuat(v); + node.rotationQuaternion.set(q.x, q.y, q.z, q.w); + }, + }; +} + +function toVec3(v: FgValue): Vec3 { + const o = (v ?? {}) as Partial; + return { x: o.x ?? 0, y: o.y ?? 0, z: (o as Vec3).z ?? 0 }; +} + +function toQuat(v: FgValue): Quat { + const o = (v ?? {}) as Partial; + return { x: o.x ?? 0, y: o.y ?? 0, z: o.z ?? 0, w: o.w ?? 1 }; +} diff --git a/packages/babylon-lite/src/flow-graph/index.ts b/packages/babylon-lite/src/flow-graph/index.ts index 8f591c09e1..c1f5b4ac16 100644 --- a/packages/babylon-lite/src/flow-graph/index.ts +++ b/packages/babylon-lite/src/flow-graph/index.ts @@ -10,7 +10,7 @@ export type { FgBlockDef, FgBlockShape } from "./block-def.js"; export { FgBlockType } from "./block-type.js"; // Execution context & environment -export type { FgAccessor, FgCapabilities, FgContext, FgEnv, FgPendingTask, FgWiring } from "./context.js"; +export type { FgAccessor, FgCapabilities, FgContext, FgEnv, FgPendingTask, FgWiring, LoadedFlowGraph } from "./context.js"; // Event bus export type { FgEventBus, FgEventHandler, FgEventPayload } from "./event-bus.js"; @@ -29,7 +29,7 @@ export { fgMatrix2D, fgMatrix3D, isFgMatrix2D, isFgMatrix3D } from "./custom-typ export { getBlockDef } from "./block-registry.js"; // Scene attachment -export { attachFlowGraph, detachFlowGraph } from "./scene-flow-graph.js"; +export { attachFlowGraph, detachFlowGraph, runFlowGraphs } from "./scene-flow-graph.js"; // Runtime functions + FgRuntime export type { FgRuntime } from "./runtime.js"; @@ -43,7 +43,9 @@ export { createFgRuntime, disposeFlowGraph, getDataValue, + getExecVar, setDataValue, + setExecVar, startFlowGraph, stillPending, tickFlowGraph, diff --git a/packages/babylon-lite/src/flow-graph/runtime.ts b/packages/babylon-lite/src/flow-graph/runtime.ts index 096d97164a..0dc6a34b2c 100644 --- a/packages/babylon-lite/src/flow-graph/runtime.ts +++ b/packages/babylon-lite/src/flow-graph/runtime.ts @@ -60,6 +60,23 @@ export function setDataValue(ctx: FgContext, block: FgBlock, socket: string, val ctx.connectionValues[`${block.id}:${socket}`] = value; } +// ───────────────────────────────────────────────────────────────────────────── +// Per-block execution variables (mutable runtime state, keyed by block id) +// ───────────────────────────────────────────────────────────────────────────── + +/** Read a block-local execution variable, falling back to `def` when unset. + * Replaces BJS `context._getExecutionVariable(this, key, def)`. */ +export function getExecVar(ctx: FgContext, block: FgBlock, key: string, def: T): T { + const slot = `${block.id}:${key}`; + return slot in ctx.executionVariables ? (ctx.executionVariables[slot] as T) : def; +} + +/** Write a block-local execution variable. + * Replaces BJS `context._setExecutionVariable(this, key, value)`. */ +export function setExecVar(ctx: FgContext, block: FgBlock, key: string, value: unknown): void { + ctx.executionVariables[`${block.id}:${key}`] = value; +} + // ───────────────────────────────────────────────────────────────────────────── // Signal edges (PUSH) // ───────────────────────────────────────────────────────────────────────────── diff --git a/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts index 1366f6969a..7ecfbbdabd 100644 --- a/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts +++ b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts @@ -6,7 +6,10 @@ import { onBeforeRender, onSceneDispose, type SceneContext } from "../scene/scene-core.js"; import type { FgRuntime } from "./runtime.js"; -import { disposeFlowGraph, startFlowGraph, tickFlowGraph } from "./runtime.js"; +import { createFgRuntime, disposeFlowGraph, startFlowGraph, tickFlowGraph } from "./runtime.js"; +import type { AnimationGroup } from "../animation/animation-group.js"; +import { playAnimation as agPlay, stopAnimation as agStop } from "../animation/animation-group.js"; +import type { FgCapabilities, LoadedFlowGraph } from "./context.js"; /** Attach a flow-graph runtime to a scene. The runtime starts on the first * frame (after which event listeners are live) and ticks every frame. The @@ -44,3 +47,32 @@ export function detachFlowGraph(scene: SceneContext, rt: FgRuntime): void { } disposeFlowGraph(rt); } + +/** Scene-owned animation capabilities backing the Play/Stop animation blocks. + * Pure delegation to the animation-group functions so blocks never import the + * scene. `from`/`to` frame-range playback is a Phase 3 refinement. */ +function sceneAnimationCaps(): FgCapabilities { + return { + playAnimation: (group: AnimationGroup, opts) => { + group.speedRatio = opts?.speed ?? 1; + group.loopAnimation = opts?.loop ?? false; + agPlay(group); + }, + stopAnimation: (group: AnimationGroup) => agStop(group), + }; +} + +/** Build + attach a runtime for every flow graph loaded onto a container. Binds + * the graph's pre-resolved accessors, the container's animation groups (indexed + * by glTF order), and scene-owned animation capabilities, then drives each + * runtime through the scene's frame loop. Returns the attached runtimes. */ +export async function runFlowGraphs(scene: SceneContext, loaded: readonly LoadedFlowGraph[], animations: readonly AnimationGroup[] = []): Promise { + const caps = sceneAnimationCaps(); + const runtimes: FgRuntime[] = []; + for (const lg of loaded) { + const rt = await createFgRuntime(lg.graph, { accessors: lg.accessors, animations, caps }, { rightHanded: true }); + attachFlowGraph(scene, rt); + runtimes.push(rt); + } + return runtimes; +} diff --git a/packages/babylon-lite/src/flow-graph/sockets.ts b/packages/babylon-lite/src/flow-graph/sockets.ts new file mode 100644 index 0000000000..da28ae22b5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/sockets.ts @@ -0,0 +1,27 @@ +// Tiny socket constructors used by block `build()` shapes. Pure functions, no +// state. The parser/builder later fills `source` (data inputs) and `targets` +// (signal outputs) from the graph edges; these helpers just produce the +// skeleton a def declares. Keeps block files terse and consistent with the +// porting skill (.github/copilot/skills/port-flow-graph-block.md). + +import type { FgDataSocket, FgSignalSocket, FgType, FgValue } from "./types.js"; + +/** Declare a data INPUT socket (optional literal fallback). */ +export function sockIn(name: string, type: FgType, defaultValue?: FgValue): FgDataSocket { + return defaultValue === undefined ? { name, type } : { name, type, defaultValue }; +} + +/** Declare a data OUTPUT socket. */ +export function sockOut(name: string, type: FgType): FgDataSocket { + return { name, type }; +} + +/** Declare a signal INPUT socket. */ +export function sigIn(name: string): FgSignalSocket { + return { name, targets: [] }; +} + +/** Declare a signal OUTPUT socket. */ +export function sigOut(name: string): FgSignalSocket { + return { name, targets: [] }; +} diff --git a/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts b/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts new file mode 100644 index 0000000000..2dcde61d5c --- /dev/null +++ b/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts @@ -0,0 +1,50 @@ +// ⚠️ SPEC-VOLATILE — KHR_interactivity is an UNRATIFIED glTF draft. This feature +// is the ONLY loader-side entrypoint for it; all spec-dependent parsing lives +// under flow-graph/gltf/. Mirrored against Babylon.js commit 8f728b23ea. Re-sync +// against BJS PR #18455 ("KHR_interactivity rework") when it lands. +// +// gltf-feature-interactivity: a per-asset glTF feature. At applyAsset time the +// node hierarchy (`ctx._nodeMap`) is built but animation groups are NOT yet +// available, so this feature only does the spec-volatile, node-dependent work — +// parse each graph and pre-resolve its JSON pointers to TRS accessors — and +// hands the result to the AssetContainer. Binding animations + scene capabilities +// and driving the runtime happens later, in addToScene → runFlowGraphs. + +import type { GltfFeature, GltfLoadCtx } from "./gltf-feature.js"; +import type { Mesh } from "../mesh/mesh.js"; +import type { TransformNode } from "../scene/transform-node.js"; +import type { AssetContainer } from "../asset-container.js"; +import type { FgAccessor, LoadedFlowGraph } from "../flow-graph/context.js"; +import { parseInteractivityGraph, type GltfInteractivityGraph } from "../flow-graph/gltf/interactivity-parser.js"; +import { resolvePointerAccessor } from "../flow-graph/gltf/path-converter.js"; + +interface IKHRInteractivity { + graphs?: GltfInteractivityGraph[]; +} + +const feature: GltfFeature = { + id: "KHR_interactivity", + async applyAsset(_meshes: Mesh[], _root: TransformNode, ctx: GltfLoadCtx): Promise> { + const ext = ctx._json.extensions?.KHR_interactivity as IKHRInteractivity | undefined; + const graphs = ext?.graphs ?? []; + const nodeMap = ctx._nodeMap ?? []; + + const flowGraphs: LoadedFlowGraph[] = []; + for (const graphJson of graphs) { + const { graph, pointers } = await parseInteractivityGraph(graphJson); + const accessors: Record = {}; + for (const pointer of pointers) { + const accessor = resolvePointerAccessor(pointer, nodeMap); + if (!accessor) { + throw new Error(`KHR_interactivity: cannot resolve pointer ${JSON.stringify(pointer)} (unsupported path or unreachable node)`); + } + accessors[pointer] = accessor; + } + flowGraphs.push({ graph, accessors }); + } + + return flowGraphs.length > 0 ? { flowGraphs } : {}; + }, +}; + +export default feature; diff --git a/packages/babylon-lite/src/loader-gltf/gltf-feature-registry.ts b/packages/babylon-lite/src/loader-gltf/gltf-feature-registry.ts index 01a6885dc6..d0164eaf9a 100644 --- a/packages/babylon-lite/src/loader-gltf/gltf-feature-registry.ts +++ b/packages/babylon-lite/src/loader-gltf/gltf-feature-registry.ts @@ -59,6 +59,7 @@ const _features: [Trigger, Loader][] = [ ["KHR_animation_pointer", () => import("./gltf-feature-animation-pointer.js")], ["EXT_mesh_gpu_instancing", () => import("./gltf-feature-gpu-instancing.js")], ["KHR_xmp_json_ld", () => import("./gltf-feature-xmp.js")], + ["KHR_interactivity", () => import("./gltf-feature-interactivity.js")], ]; /** Dynamic-import every feature the asset triggers. */ diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts new file mode 100644 index 0000000000..f97f085bca --- /dev/null +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -0,0 +1,354 @@ +import { describe, expect, it, vi } from "vitest"; + +import type { AnimationGroup } from "../../../packages/babylon-lite/src/animation/animation-group"; +import type { FgAccessor, FgBlock, FgBlockDef, FgGraph, FgValue, FgWiring } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { createFgRuntime, FgType, getBlockDef, getDataValue, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; + +// ─── graph + runtime builder driven by the REAL registry ──────────────────── + +interface Edge { + blockId: string; + socket: string; +} +interface NodeSpec { + id: string; + type: string; + config?: Record; + /** signal output socket name → wired targets */ + signalTargets?: Record; + /** data input socket name → wired source */ + dataSources?: Record; + /** data input socket name → literal fallback (when unwired) */ + dataDefaults?: Record; +} + +/** Instantiate each node's shape from its def (resolved via the production + * `getBlockDef` registry, unless supplied in `defs`), then wire edges. */ +async function buildGraph(specs: NodeSpec[], variables: FgGraph["variables"], defs: Record): Promise { + const blocks: FgBlock[] = []; + for (const spec of specs) { + const def = defs[spec.type] ?? (await getBlockDef(spec.type)!()); + const shape = def.build(spec.config); + blocks.push({ + id: spec.id, + type: spec.type, + config: spec.config, + dataIn: (shape.dataIn ?? []).map((d) => ({ + name: d.name, + type: d.type, + source: spec.dataSources?.[d.name], + defaultValue: spec.dataDefaults?.[d.name] ?? d.defaultValue, + })), + dataOut: shape.dataOut ?? [], + signalIn: shape.signalIn ?? [], + signalOut: (shape.signalOut ?? []).map((s) => ({ name: s.name, targets: spec.signalTargets?.[s.name] ?? [] })), + event: shape.event, + }); + } + const byId: Record = {}; + blocks.forEach((b, i) => (byId[b.id] = i)); + return { blocks, byId, variables }; +} + +/** Build a graph + runtime, threading test-only `defs` (e.g. the recorder) into + * BOTH shape instantiation and the runtime env so blocks under test still + * resolve via the production registry. */ +async function makeRuntime(specs: NodeSpec[], opts: { variables?: FgGraph["variables"]; wiring?: FgWiring; defs?: Record } = {}) { + const defs = opts.defs ?? {}; + const graph = await buildGraph(specs, opts.variables ?? {}, defs); + return createFgRuntime(graph, { ...(opts.wiring ?? {}), defs }); +} + +/** Test-only recorder: logs incoming signal label + the pulled `value` input. + * Passed via `defs` so blocks UNDER TEST still resolve via the registry. */ +const RECORD = "test/record"; +function recorderDef(log: { label: string; value: FgValue }[]): FgBlockDef { + return { + type: RECORD, + build: () => ({ signalIn: [{ name: "in", targets: [] }], dataIn: [{ name: "value", type: FgType.Any }] }), + execute: (block, ctx, env) => log.push({ label: (block.config?.label as string) ?? "", value: getDataValue(ctx, env, block, "value") }), + }; +} + +// ─── tests ─────────────────────────────────────────────────────────────────── + +describe("flow-graph blocks — events", () => { + it("SceneStart fires its out signal once on start", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "rec", type: RECORD, config: { label: "started" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + startFlowGraph(rt); // idempotent + expect(log.map((e) => e.label)).toEqual(["started"]); + }); + + it("SceneTick accumulates timeSinceStart and exposes deltaTime", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "tick", type: "SceneTickEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "tick", socket: "timeSinceStart" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + tickFlowGraph(rt, 1000); // +1s + tickFlowGraph(rt, 500); // +0.5s + expect(log.map((e) => e.value)).toEqual([1, 1.5]); + }); +}); + +describe("flow-graph blocks — control flow", () => { + it("Branch routes to onTrue / onFalse by condition", async () => { + for (const [cond, expected] of [ + [true, "T"], + [false, "F"], + ] as const) { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "br", socket: "in" }] } }, + { + id: "br", + type: "Branch", + dataDefaults: { condition: cond }, + signalTargets: { onTrue: [{ blockId: "t", socket: "in" }], onFalse: [{ blockId: "f", socket: "in" }] }, + }, + { id: "t", type: RECORD, config: { label: "T" } }, + { id: "f", type: RECORD, config: { label: "F" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual([expected]); + } + }); + + it("Sequence fires out_0..out_N in order", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "seq", socket: "in" }] } }, + { + id: "seq", + type: "Sequence", + config: { outputSignalCount: 3 }, + signalTargets: { + out_0: [{ blockId: "a", socket: "in" }], + out_1: [{ blockId: "b", socket: "in" }], + out_2: [{ blockId: "c", socket: "in" }], + }, + }, + { id: "a", type: RECORD, config: { label: "0" } }, + { id: "b", type: RECORD, config: { label: "1" } }, + { id: "c", type: RECORD, config: { label: "2" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["0", "1", "2"]); + }); +}); + +describe("flow-graph blocks — math/data", () => { + it("Add sums numbers (pulled through to a recorder)", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "add", type: "Add", dataDefaults: { a: 1, b: 2 } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "add", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(3); + }); + + it("Add is component-wise for vectors", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "add", type: "Add", dataDefaults: { a: { x: 1, y: 2, z: 3 }, b: { x: 4, y: 5, z: 6 } } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "add", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toEqual({ x: 5, y: 7, z: 9 }); + }); + + it("Get/SetVariable round-trips a live graph variable", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "set", socket: "in" }] } }, + { + id: "set", + type: "SetVariable", + config: { variable: "score" }, + dataDefaults: { value: 42 }, + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "get", type: "GetVariable", config: { variable: "score" } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "get", socket: "value" } } }, + ], + { variables: { score: { type: FgType.Number, value: 0 } }, defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(rt.context.userVariables.score).toBe(42); + expect(log[0]!.value).toBe(42); + }); +}); + +describe("flow-graph blocks — property accessors", () => { + function vec3Accessor(initial: { x: number; y: number; z: number }): { acc: FgAccessor; box: { v: FgValue } } { + const box = { v: initial as FgValue }; + return { + box, + acc: { + type: FgType.Vector3, + get: () => box.v, + set: (value) => { + box.v = value; + }, + }, + }; + } + + it("SetProperty writes through a resolved accessor and fires out", async () => { + const log: { label: string; value: FgValue }[] = []; + const { acc, box } = vec3Accessor({ x: 0, y: 0, z: 0 }); + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "set", socket: "in" }] } }, + { + id: "set", + type: "SetProperty", + config: { accessor: "/nodes/0/translation" }, + dataDefaults: { value: { x: 1, y: 1, z: 1 } }, + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "ok" } }, + ], + { wiring: { accessors: { "/nodes/0/translation": acc } }, defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(box.v).toEqual({ x: 1, y: 1, z: 1 }); + expect(log.map((e) => e.label)).toEqual(["ok"]); + }); + + it("SetProperty fires error when the accessor is missing", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "set", socket: "in" }] } }, + { + id: "set", + type: "SetProperty", + config: { accessor: "/missing" }, + dataDefaults: { value: 1 }, + signalTargets: { error: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "err" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["err"]); + }); + + it("GetProperty reads through a resolved accessor", async () => { + const log: { label: string; value: FgValue }[] = []; + const { acc } = vec3Accessor({ x: 7, y: 8, z: 9 }); + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "get", type: "GetProperty", config: { accessor: "p" } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "get", socket: "value" } } }, + ], + { wiring: { accessors: { p: acc } }, defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toEqual({ x: 7, y: 8, z: 9 }); + }); +}); + +describe("flow-graph blocks — animation", () => { + function mockGroup(): AnimationGroup { + return { + name: "anim", + duration: 1, + isPlaying: false, + currentTime: 0, + targetedAnimations: [], + speedRatio: 1, + loopAnimation: false, + weight: 1, + _stopped: false, + } as AnimationGroup; + } + + it("PlayAnimation invokes the play capability and fires out, then done on end", async () => { + const log: { label: string; value: FgValue }[] = []; + const group = mockGroup(); + let endCb: (() => void) | undefined; + const wiring: FgWiring = { + animations: [group], + caps: { + playAnimation: vi.fn((g, opts) => { + g.isPlaying = true; + if (opts?.speed !== undefined) { + g.speedRatio = opts.speed; + } + }), + onAnimationEnd: (_g, cb) => { + endCb = cb; + return () => { + endCb = undefined; + }; + }, + }, + }; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "play", socket: "in" }] } }, + { + id: "play", + type: "PlayAnimation", + dataDefaults: { animation: 0, speed: 2 }, + signalTargets: { out: [{ blockId: "o", socket: "in" }], done: [{ blockId: "d", socket: "in" }] }, + }, + { id: "o", type: RECORD, config: { label: "out" } }, + { id: "d", type: RECORD, config: { label: "done" } }, + ], + { wiring, defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(wiring.caps!.playAnimation).toHaveBeenCalledTimes(1); + expect(group.speedRatio).toBe(2); + expect(log.map((e) => e.label)).toEqual(["out"]); + endCb?.(); // simulate the animation ending + expect(log.map((e) => e.label)).toEqual(["out", "done"]); + }); + + it("StopAnimation invokes the stop capability", async () => { + const group = mockGroup(); + const stop = vi.fn(); + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "stop", socket: "in" }] } }, + { id: "stop", type: "StopAnimation", dataDefaults: { animation: 0 } }, + ], + { wiring: { animations: [group], caps: { stopAnimation: stop } } } + ); + startFlowGraph(rt); + expect(stop).toHaveBeenCalledWith(group); + }); +}); diff --git a/tests/lite/unit/flow-graph-gltf-feature.test.ts b/tests/lite/unit/flow-graph-gltf-feature.test.ts new file mode 100644 index 0000000000..ff78d08b5c --- /dev/null +++ b/tests/lite/unit/flow-graph-gltf-feature.test.ts @@ -0,0 +1,82 @@ +import { describe, expect, it, vi } from "vitest"; + +import { createTransformNode } from "../../../packages/babylon-lite/src/scene/transform-node"; +import type { TransformNode } from "../../../packages/babylon-lite/src/scene/transform-node"; +import { resolvePointerAccessor } from "../../../packages/babylon-lite/src/flow-graph/gltf/path-converter"; +import interactivityFeature from "../../../packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity"; +import { createFgRuntime, startFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; +import type { GltfLoadCtx } from "../../../packages/babylon-lite/src/loader-gltf/gltf-feature"; + +const worldPointerExtension = { + graphs: [ + { + declarations: [{ op: "event/onStart" }, { op: "pointer/set" }], + nodes: [ + { declaration: 0, flows: { out: { node: 1, socket: "in" } } }, + { + declaration: 1, + configuration: { pointer: { value: ["/nodes/0/translation"] } }, + values: { value: { value: [1, 2, 3], type: 0 } }, + }, + ], + types: [{ signature: "float3" }], + }, + ], +}; + +describe("path-converter resolvePointerAccessor", () => { + it("reads + writes a node's translation through the TRS accessor", () => { + const node = createTransformNode("n0"); + const accessor = resolvePointerAccessor("/nodes/0/translation", [node]); + expect(accessor).not.toBeNull(); + expect(accessor!.get()).toEqual({ x: 0, y: 0, z: 0 }); + accessor!.set!({ x: 4, y: 5, z: 6 }); + expect(node.position.x).toBe(4); + expect(node.position.y).toBe(5); + expect(node.position.z).toBe(6); + }); + + it("reads + writes a node's scale", () => { + const node = createTransformNode("n0"); + const accessor = resolvePointerAccessor("/nodes/0/scale", [node])!; + accessor.set!({ x: 2, y: 2, z: 2 }); + expect(node.scaling.x).toBe(2); + }); + + it("returns null for unsupported paths and unreachable nodes", () => { + expect(resolvePointerAccessor("/materials/0/baseColor", [createTransformNode("n0")])).toBeNull(); + expect(resolvePointerAccessor("/nodes/3/translation", [createTransformNode("n0")])).toBeNull(); + }); +}); + +describe("gltf-feature-interactivity applyAsset", () => { + it("parses graphs and resolves pointers into the container", async () => { + const node = createTransformNode("n0"); + const ctx = { _json: { extensions: { KHR_interactivity: worldPointerExtension } }, _nodeMap: [node] as (TransformNode | undefined)[] } as unknown as GltfLoadCtx; + + const result = await interactivityFeature.applyAsset!([], node, ctx); + expect(result.flowGraphs).toHaveLength(1); + const lg = result.flowGraphs![0]!; + expect(Object.keys(lg.accessors)).toEqual(["/nodes/0/translation"]); + + // Run it: onStart → pointer/set writes (1,2,3) into the real node. + const rt = await createFgRuntime(lg.graph, { accessors: lg.accessors }, { rightHanded: true }); + startFlowGraph(rt); + expect(node.position.x).toBe(1); + expect(node.position.y).toBe(2); + expect(node.position.z).toBe(3); + }); + + it("throws when a pointer cannot be resolved against the node map", async () => { + const ctx = { _json: { extensions: { KHR_interactivity: worldPointerExtension } }, _nodeMap: [] as (TransformNode | undefined)[] } as unknown as GltfLoadCtx; + await expect(interactivityFeature.applyAsset!([], createTransformNode("x"), ctx)).rejects.toThrow(/cannot resolve pointer/); + }); + + it("returns an empty fragment when the asset has no interactivity extension", async () => { + const ctx = { _json: { extensions: {} }, _nodeMap: [] as (TransformNode | undefined)[] } as unknown as GltfLoadCtx; + const result = await interactivityFeature.applyAsset!([], createTransformNode("x"), ctx); + expect(result.flowGraphs).toBeUndefined(); + }); +}); + +vi.spyOn(console, "log").mockImplementation(() => {}); diff --git a/tests/lite/unit/flow-graph-gltf-parser.test.ts b/tests/lite/unit/flow-graph-gltf-parser.test.ts new file mode 100644 index 0000000000..31dce81751 --- /dev/null +++ b/tests/lite/unit/flow-graph-gltf-parser.test.ts @@ -0,0 +1,126 @@ +import { describe, expect, it, vi } from "vitest"; + +import type { FgAccessor, FgValue } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { createFgRuntime, startFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { parseInteractivityGraph, type GltfInteractivityGraph } from "../../../packages/babylon-lite/src/flow-graph/gltf/interactivity-parser"; + +// Fixtures mirror Babylon.js loaders/test/unit/Interactivity/testData.ts verbatim +// (commit 8f728b23ea) so the Lite parser is validated against the real wire format. + +const worldPointerExample: GltfInteractivityGraph = { + declarations: [{ op: "event/onStart" }, { op: "pointer/set" }, { op: "pointer/get" }, { op: "flow/log", extension: "BABYLON" }], + nodes: [ + { declaration: 0, flows: { out: { node: 1, socket: "in" } } }, + { + declaration: 1, + configuration: { pointer: { value: ["/nodes/0/translation"] } }, + values: { value: { value: [1, 1, 1], type: 4 } }, + flows: { out: { node: 3, socket: "in" } }, + }, + { + declaration: 2, + configuration: { pointer: { value: ["/nodes/{nodeIndex}/translation"] } }, + values: { nodeIndex: { value: [0], type: 1 } }, + }, + { declaration: 3, values: { message: { node: 2, socket: "value" } } }, + ], + variables: [], + events: [], + types: [{ signature: "bool" }, { signature: "int" }, { signature: "float" }, { signature: "float2" }, { signature: "float3" }], +}; + +const loggerExample: GltfInteractivityGraph = { + declarations: [{ op: "event/onStart" }, { op: "flow/log", extension: "BABYLON" }, { op: "math/add" }], + nodes: [ + { declaration: 0, flows: { out: { node: 2, socket: "in" } } }, + { + declaration: 2, + values: { + a: { value: [1, 2, 3, 4], type: 0 }, + b: { value: [1, 2, 3, 4], type: 0 }, + }, + }, + { declaration: 1, values: { message: { node: 1, socket: "value" } } }, + ], + types: [{ signature: "float4" }], +}; + +describe("KHR_interactivity parser", () => { + it("parses the worldPointer graph: topology, config, pointers", async () => { + const { graph, pointers } = await parseInteractivityGraph(worldPointerExample); + + expect(graph.blocks.map((b) => b.type)).toEqual(["SceneReadyEvent", "SetProperty", "GetProperty", "ConsoleLog"]); + expect(pointers).toEqual(["/nodes/0/translation"]); + + // onStart `out` flow maps to the SceneReadyEvent `done` signal → node_1.in + const start = graph.blocks[0]!; + const done = start.signalOut.find((s) => s.name === "done")!; + expect(done.targets).toEqual([{ blockId: "node_1", socket: "in" }]); + + // pointer/set resolves config.accessor + literal Vector3 value, and wires out→node_3 + const set = graph.blocks[1]!; + expect(set.config?.accessor).toBe("/nodes/0/translation"); + expect(set.dataIn.find((d) => d.name === "value")!.defaultValue).toEqual({ x: 1, y: 1, z: 1 }); + expect(set.signalOut.find((s) => s.name === "out")!.targets).toEqual([{ blockId: "node_3", socket: "in" }]); + + // pointer/get template `{nodeIndex}` substituted from the literal value socket + expect(graph.blocks[2]!.config?.accessor).toBe("/nodes/0/translation"); + + // ConsoleLog pulls `message` from GetProperty.value + const log = graph.blocks[3]!; + expect(log.dataIn.find((d) => d.name === "message")!.source).toEqual({ blockId: "node_2", socket: "value" }); + }); + + it("coerces a float4 literal into a Vector4 and wires a data reference", async () => { + const { graph } = await parseInteractivityGraph(loggerExample); + const add = graph.blocks[1]!; + expect(add.type).toBe("Add"); + expect(add.dataIn.find((d) => d.name === "a")!.defaultValue).toEqual({ x: 1, y: 2, z: 3, w: 4 }); + // ConsoleLog message references the add node's default `value` output + expect(graph.blocks[2]!.dataIn.find((d) => d.name === "message")!.source).toEqual({ blockId: "node_1", socket: "value" }); + }); + + it("runs end-to-end: onStart → pointer/set writes through the resolved accessor", async () => { + const { graph, pointers } = await parseInteractivityGraph(worldPointerExample); + const box = { v: { x: 0, y: 0, z: 0 } as FgValue }; + const accessor: FgAccessor = { + type: graph.blocks[1]!.dataIn[0]!.type, + get: () => box.v, + set: (value) => { + box.v = value; + }, + }; + const accessors = Object.fromEntries(pointers.map((p) => [p, accessor])); + const rt = await createFgRuntime(graph, { accessors }); + startFlowGraph(rt); + expect(box.v).toEqual({ x: 1, y: 1, z: 1 }); + }); + + it("fails loudly on an unknown op", async () => { + const bad: GltfInteractivityGraph = { + declarations: [{ op: "event/onStart" }, { op: "math/teleport" }], + nodes: [{ declaration: 0, flows: { out: { node: 1, socket: "in" } } }, { declaration: 1 }], + types: [], + }; + await expect(parseInteractivityGraph(bad)).rejects.toThrow(/unsupported op\(s\): math\/teleport/); + }); + + it("rejects a pointer with an unresolved dynamic segment", async () => { + const dyn: GltfInteractivityGraph = { + declarations: [{ op: "pointer/set" }], + nodes: [ + { + declaration: 0, + configuration: { pointer: { value: ["/nodes/{nodeIndex}/translation"] } }, + // nodeIndex is a node reference (runtime-dynamic), not a literal + values: { nodeIndex: { node: 5 }, value: { value: [1, 1, 1], type: 0 } }, + }, + ], + types: [{ signature: "float3" }], + }; + await expect(parseInteractivityGraph(dyn)).rejects.toThrow(/unresolvable pointer/); + }); +}); + +// Silence the ConsoleLog block's console.log in the end-to-end run. +vi.spyOn(console, "log").mockImplementation(() => {}); From c10d7f755d866ee7daa1fd74ec47f43d455de3d4 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 17:10:55 +0200 Subject: [PATCH 04/13] feat(flow-graph): port math/event blocks + pointer templating; add Calculator demo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 2d of the FlowGraph → Babylon Lite port. Adds the block coverage, pointer-template handling and glTF path-converter extensions needed to load and run the Khronos Calculator KHR_interactivity sample, plus a runnable demo. Runtime / blocks: - fg-math: refactor to shared binary/unary helpers; add sub, mul, div, rem, abs, floor, lt, clamp, combine2, extract2 dispatchers. - New math block defs (subtract, multiply, divide, modulo, less-than, abs, floor, combine2, extract2, clamp) + OnSelect event block (reuses the existing Pointer event channel, filtered by node index). - block-type / block-registry: enum entries + lazy registry cases. glTF bridge (spec-volatile, re-sync to BJS PR #18455): - declaration-mapper: all 11 math ops in NATIVE_OPS; EXTENSION_OPS table routes BABYLON + KHR_node_selectability; nodeConfigKey support. - interactivity-parser: ref-index extraction + relative-prefix in resolvePointerTemplate; widened value type; nodeConfigKey config handling. - path-converter: new resolve-context signature; material UV-transform get/set, node visibility set, selectability no-op (reuses the animation-pointer writer for per-texture isolation + visibility-epoch bumps). - gltf-feature-interactivity: build glTF-material → runtime-material map. API / demo: - Export runFlowGraphs from the package entry. - Add the Calculator demo (lab/lite/src/demos/calculator.ts + demo HTML + demos-config entry + asset-copy step). On load the onStart graph resets the display to "00" (texture-transform offsets), hides the minus sign, and seeds scene variables — exercising the new math/pointer/event blocks. Verified in a WebGPU browser probe. KHR_interactivity remains an unratified draft; all spec-dependent code stays quarantined under flow-graph/gltf/. Tests: 657 unit pass; lint + all typechecks clean; 198 bundle-size ceilings pass; bundle manifest regenerated. No rendering chunk changed (only the inert gltf-feature-registry chunk hashes cascade). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- demos-config.json | 7 + lab/lite/demo-calculator.html | 140 +++++++++++++++ lab/lite/src/demos/calculator.ts | 146 ++++++++++++++++ lab/public/bundle/demos-manifest.json | 4 + lab/public/bundle/manifest.json | 160 +++++++++--------- lab/public/models/Calculator.glb | Bin 0 -> 1738360 bytes .../src/flow-graph/block-registry.ts | 22 +++ .../babylon-lite/src/flow-graph/block-type.ts | 10 ++ .../src/flow-graph/blocks/events/on-select.ts | 43 +++++ .../src/flow-graph/blocks/math/abs.ts | 21 +++ .../src/flow-graph/blocks/math/clamp.ts | 25 +++ .../src/flow-graph/blocks/math/combine2.ts | 23 +++ .../src/flow-graph/blocks/math/divide.ts | 23 +++ .../src/flow-graph/blocks/math/extract2.ts | 24 +++ .../src/flow-graph/blocks/math/floor.ts | 21 +++ .../src/flow-graph/blocks/math/less-than.ts | 23 +++ .../src/flow-graph/blocks/math/modulo.ts | 23 +++ .../src/flow-graph/blocks/math/multiply.ts | 23 +++ .../src/flow-graph/blocks/math/subtract.ts | 23 +++ .../babylon-lite/src/flow-graph/fg-math.ts | 109 ++++++++++-- .../src/flow-graph/gltf/declaration-mapper.ts | 29 +++- .../flow-graph/gltf/interactivity-parser.ts | 60 ++++++- .../src/flow-graph/gltf/path-converter.ts | 142 ++++++++++++++-- packages/babylon-lite/src/index.ts | 2 +- .../loader-gltf/gltf-feature-interactivity.ts | 30 +++- scripts/bundle-demos-core.ts | 7 + tests/lite/unit/flow-graph-blocks.test.ts | 156 ++++++++++++++++- .../lite/unit/flow-graph-gltf-feature.test.ts | 48 +++++- .../lite/unit/flow-graph-gltf-parser.test.ts | 70 ++++++++ 29 files changed, 1299 insertions(+), 115 deletions(-) create mode 100644 lab/lite/demo-calculator.html create mode 100644 lab/lite/src/demos/calculator.ts create mode 100644 lab/public/models/Calculator.glb create mode 100644 packages/babylon-lite/src/flow-graph/blocks/events/on-select.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/abs.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/clamp.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine2.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/divide.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract2.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/floor.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/less-than.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/modulo.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/multiply.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/subtract.ts diff --git a/demos-config.json b/demos-config.json index 0eb2a1e31a..e8ebc469ee 100644 --- a/demos-config.json +++ b/demos-config.json @@ -66,6 +66,13 @@ "tags": ["showcase"], "mobile": true }, + { + "slug": "calculator", + "name": "Calculator (KHR_interactivity)", + "description": "Interactive glTF showcase: the Khronos \"Calculator\" sample driven by Babylon Lite's flow-graph runtime (glTF KHR_interactivity). On load the embedded interactivity graph runs — resetting the display to \"00\" by scrolling the digit materials' texture-transform offset, hiding the minus sign via KHR_node_visibility, and seeding scene variables — exercising the ported math, pointer and event blocks. KHR_interactivity is an unratified draft; the runtime tracks the current spec. Khronos glTF-Test-Assets-Interactivity (CC0).", + "tags": ["showcase", "interactivity", "gltf"], + "mobile": true + }, { "slug": "littlest-tokyo", "name": "Littlest Tokyo", diff --git a/lab/lite/demo-calculator.html b/lab/lite/demo-calculator.html new file mode 100644 index 0000000000..3c52f0871c --- /dev/null +++ b/lab/lite/demo-calculator.html @@ -0,0 +1,140 @@ + + + + + + + Babylon Lite — Demo: Calculator (KHR_interactivity) + + + + + + + + “Calculator” Khronos glTF KHR_interactivity test asset + +
+
+ +
Loading Calculator…
+
Fetching interactive glTF model & studio environment…
+ + +
+
+ + + + + diff --git a/lab/lite/src/demos/calculator.ts b/lab/lite/src/demos/calculator.ts new file mode 100644 index 0000000000..ba033eb885 --- /dev/null +++ b/lab/lite/src/demos/calculator.ts @@ -0,0 +1,146 @@ +// Demo — Calculator (glTF KHR_interactivity showcase) +// +// Loads the Khronos "Calculator" sample glb and runs its embedded +// KHR_interactivity graph with Babylon Lite's flow-graph runtime. On load the +// graph's `event/onStart` chain fires: it resets the two display digits to "00" +// by driving `pointer/set` on the digit materials' KHR_texture_transform offset +// (the digit atlas is scrolled so both wheels show "0"), hides the minus sign +// via KHR_node_visibility, and seeds the calculator's scene variables. The math +// blocks (add/sub/mul/div/rem/abs/floor/lt/clamp + combine2/extract2) and the +// pointer get/set accessors are all exercised by this graph. +// +// ⚠️ KHR_interactivity is an UNRATIFIED glTF draft; this demo (and the runtime +// behind it) tracks the current draft and will be re-synced when the spec and +// Babylon.js PR #18455 land. +// +// Model: "Calculator" from the Khronos glTF-Test-Assets-Interactivity repo +// https://github.com/KhronosGroup/glTF-Test-Assets-Interactivity (CC0 / public +// domain test asset). The directional light ships in the glb via +// KHR_lights_punctual; a studio HDR cube is loaded for PBR image-based lighting. + +import { + addToScene, + attachControl, + createArcRotateCamera, + createEngine, + createSceneContext, + loadGltf, + onBeforeRender, + registerScene, + runFlowGraphs, + setCameraLimits, + startEngine, +} from "babylon-lite"; +import { loadDdsEnvironment } from "babylon-lite/loader-env/load-dds-env"; +import { configureDemoDecoderBases, demoAssetUrl } from "./demo-asset-url.js"; +import { installFetchProgress } from "./loading-progress.js"; + +// Studio HDR cube used for image-based lighting only (no visible skybox — the +// calculator reads as a clean product shot on a neutral background). +const ENV_URL = "https://playground.babylonjs.com/textures/environment.dds"; + +// ArcRotate pose reconstructed from the glb's authored "Main Camera" (eye at +// roughly (-0.07, 1.59, 1.72) looking down on the calculator lying flat on the +// XZ plane, display at the far -Z edge, buttons toward +Z). Targets the body +// centre and looks down the authored ~44° tilt. +const CAM = { + alpha: 1.6115, + beta: 0.8736, + radius: 2.2443, + target: { x: 0, y: 0.15, z: 0 }, + fov: 1.0471975, // glb Main Camera yfov (60°) +}; + +// Gentle auto-rotation so the showcase slowly turns; paused while the user +// interacts and for a short grace period afterwards. +const AUTO_ROTATE_SPEED = 0.0025; // radians per frame +const IDLE_DELAY_MS = 2500; + +async function main(): Promise { + const __initStart = performance.now(); + const canvas = document.getElementById("renderCanvas") as HTMLCanvasElement; + const progress = installFetchProgress(canvas, { estimatedBytes: 1_900_000 }); + + const engine = await createEngine(canvas); + const scene = createSceneContext(engine); + + const cam = createArcRotateCamera(CAM.alpha, CAM.beta, CAM.radius, CAM.target); + cam.fov = CAM.fov; + scene.camera = cam; + attachControl(cam, canvas, scene); + setCameraLimits( + cam, + { + lowerRadiusLimit: CAM.radius * 0.45, + upperRadiusLimit: CAM.radius * 2.5, + }, + scene, + ); + + // The model is uncompressed, but configure the decoder bases anyway so the + // demo stays subpath-safe if the asset is ever re-exported compressed. + await configureDemoDecoderBases(import.meta.url); + + const [asset] = await Promise.all([ + loadGltf(engine, demoAssetUrl("./Calculator.glb", import.meta.url)), + loadDdsEnvironment(scene, ENV_URL, { + skipSkybox: true, + skipGround: true, + brdfUrl: demoAssetUrl("./brdf-lut.png", import.meta.url), + }), + ]); + addToScene(scene, asset); + + // Drive the embedded KHR_interactivity graph(s). The runtime starts on the + // first frame and runs the onStart chain → display resets to "00". + if (asset.flowGraphs?.length) { + await runFlowGraphs(scene, asset.flowGraphs, asset.animationGroups); + } + + // Slow continuous orbit, paused during/after user interaction so it never + // fights a manual orbit or zoom. + let lastInteractionMs = -Infinity; + const markInteraction = (): void => { + lastInteractionMs = performance.now(); + }; + canvas.addEventListener("pointerdown", markInteraction); + canvas.addEventListener("wheel", markInteraction, { passive: true }); + canvas.addEventListener("pointermove", (e) => { + if (e.buttons !== 0) { + markInteraction(); + } + }); + canvas.addEventListener("touchstart", markInteraction, { passive: true }); + canvas.addEventListener("touchmove", markInteraction, { passive: true }); + + let autoRotateEnabled = true; + const rotateBtn = document.getElementById("rotateToggle"); + if (rotateBtn) { + rotateBtn.addEventListener("click", () => { + autoRotateEnabled = !autoRotateEnabled; + rotateBtn.textContent = autoRotateEnabled ? "⏸ Auto-rotate" : "▶ Auto-rotate"; + rotateBtn.setAttribute("aria-pressed", String(autoRotateEnabled)); + }); + } + + onBeforeRender(scene, () => { + if (autoRotateEnabled && performance.now() - lastInteractionMs > IDLE_DELAY_MS) { + cam.alpha += AUTO_ROTATE_SPEED; + } + }); + + await registerScene(scene); + progress.done(); + await startEngine(engine); + + canvas.dataset.drawCalls = String(engine.drawCallCount); + canvas.dataset.camAlpha = String(cam.alpha); + canvas.dataset.camBeta = String(cam.beta); + canvas.dataset.camRadius = String(cam.radius); + canvas.dataset.camTarget = `${cam.target.x},${cam.target.y},${cam.target.z}`; + canvas.dataset.camFov = String(cam.fov); + canvas.dataset.initMs = String(performance.now() - __initStart); + canvas.dataset.ready = "true"; +} + +main().catch(console.error); diff --git a/lab/public/bundle/demos-manifest.json b/lab/public/bundle/demos-manifest.json index 32ba8c8cf2..3b8e5230d8 100644 --- a/lab/public/bundle/demos-manifest.json +++ b/lab/public/bundle/demos-manifest.json @@ -42,5 +42,9 @@ "platformer": { "rawKB": 82.2, "gzipKB": 29.1 + }, + "calculator": { + "rawKB": 131.6, + "gzipKB": 55.4 } } \ No newline at end of file diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index 81d716072e..13dc30976a 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -57,7 +57,7 @@ ] }, "scene5": { - "rawKB": 90.1, + "rawKB": 90, "gzipKB": 38.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -68,7 +68,7 @@ "scene5-gltf-color-normalize-BtnJk1yq.js", "scene5-gltf-feature-animations-CQrRowr9.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry-xSfhjloS.js", + "scene5-gltf-feature-registry-BEtNr2v7.js", "scene5-gltf-feature-skeleton-Siixi_P0.js", "scene5-gltf-json-asset-DS0i23k1.js", "scene5-morph-fragment-BhcJT1xs.js", @@ -107,7 +107,7 @@ "scene7-gltf-animation-B7Xr33me.js", "scene7-gltf-feature-animations-CG5FpT6C.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-DHcnblHg.js", + "scene7-gltf-feature-registry-BRfh3Hnn.js", "scene7-gltf-feature-skeleton-BCWZyzWC.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", @@ -173,7 +173,7 @@ "scene11-gltf-ext-spec-gloss-D60sFZYX.js", "scene11-gltf-feature-animations-Bmg0PBR4.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-_fmMv2wd.js", + "scene11-gltf-feature-registry-By6hZL1J.js", "scene11-gltf-feature-skeleton-CrXfHDG6.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", @@ -192,7 +192,7 @@ "scene12-generate-mipmaps-Bsp4UQ3D.js", "scene12-gltf-animation-BDKbEYQd.js", "scene12-gltf-feature-animations-Bfc5iW7L.js", - "scene12-gltf-feature-registry-DvhNAMde.js", + "scene12-gltf-feature-registry-KecitxtL.js", "scene12-gltf-feature-skeleton-CN1CorcX.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", @@ -435,7 +435,7 @@ "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-BVeapFkN.js", + "scene27-gltf-feature-registry-Du_PAvYL.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", @@ -455,7 +455,7 @@ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry-BAdu1pBK.js", + "scene28-gltf-feature-registry-CwSpGf6N.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", "scene28-pbr-renderable-BYSlPUr5.js", @@ -472,7 +472,7 @@ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-CCAMnni_.js", + "scene29-gltf-feature-registry-Cj1wtwRd.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", @@ -496,7 +496,7 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-BJfpepeb.js", + "scene30-gltf-feature-registry-CkU0gBzv.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", @@ -512,14 +512,14 @@ ] }, "scene31": { - "rawKB": 79.1, + "rawKB": 79, "gzipKB": 32.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-Cc2ziCEc.js", + "scene31-gltf-feature-registry-BQUTNjEI.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", "scene31-pbr-renderable-Bg8O1LwN.js", @@ -530,12 +530,12 @@ }, "scene32": { "rawKB": 78.9, - "gzipKB": 32.5, + "gzipKB": 32.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-DzBFfEQu.js", + "scene32-gltf-feature-registry-BSzsEdPh.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", "scene32-pbr-renderable-CUtjMSAl.js", @@ -553,7 +553,7 @@ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-i-cyg-zg.js", + "scene33-gltf-feature-registry-CDLrfb6C.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", @@ -571,15 +571,16 @@ }, "scene34": { "rawKB": 95.7, - "gzipKB": 39.3, + "gzipKB": 39.5, "ignoredRawKB": 0, "runtimeChunks": [ + "scene34-animation-pointer-Ddy-YJnh.js", "scene34-generate-mipmaps-C244DQVV.js", "scene34-gltf-animation-Cz7h58Nc.js", "scene34-gltf-ext-node-visibility-CyR_MQR5.js", - "scene34-gltf-feature-animation-pointer-dMoZNhJb.js", + "scene34-gltf-feature-animation-pointer-rAfd1hLG.js", "scene34-gltf-feature-animations-BQSrKgM_.js", - "scene34-gltf-feature-registry-se8z_8WJ.js", + "scene34-gltf-feature-registry-C6wT_LXN.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", "scene34-pbr-renderable-BelxTmu1.js", @@ -596,7 +597,7 @@ "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", - "scene35-gltf-feature-registry-BduaHWJd.js", + "scene35-gltf-feature-registry-A2wPHQPW.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", "scene35-pbr-renderable-B_cgTnJN.js", @@ -619,7 +620,7 @@ ] }, "scene37": { - "rawKB": 95.9, + "rawKB": 95.8, "gzipKB": 39.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -628,7 +629,7 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-CpEj0hHp.js", + "scene37-gltf-feature-registry-p7qXzJw4.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", @@ -655,19 +656,20 @@ }, "scene39": { "rawKB": 107.8, - "gzipKB": 45.6, + "gzipKB": 45.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene39-alpha-test-fragment-C7zCAOOO.js", - "scene39-animation-pointer-lights-CZ0oCcbR.js", + "scene39-animation-pointer-BF6gVQTl.js", + "scene39-animation-pointer-lights-CYbYE0zn.js", "scene39-emissive-fragment-q97NxqgU.js", "scene39-generate-mipmaps-DHGFn5-s.js", "scene39-gltf-animation-h1jXkBbl.js", "scene39-gltf-ext-uv-transform-DhfZ3GtK.js", - "scene39-gltf-feature-animation-pointer-BEWWFwP-.js", + "scene39-gltf-feature-animation-pointer-BOWPlTMd.js", "scene39-gltf-feature-animations-BqoIrLnC.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-Z3Af8l-s.js", + "scene39-gltf-feature-registry-DOC3-wAQ.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -687,7 +689,7 @@ ] }, "scene99": { - "rawKB": 90.6, + "rawKB": 90.5, "gzipKB": 37.6, "ignoredRawKB": 0, "runtimeChunks": [ @@ -696,7 +698,7 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-BppSgUVr.js", + "scene99-gltf-feature-registry-qkIIJtPq.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", @@ -717,13 +719,13 @@ ] }, "scene41": { - "rawKB": 92, + "rawKB": 91.9, "gzipKB": 36.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-B1NXlp7Z.js", + "scene41-gltf-feature-registry-NfOBA8tz.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -792,7 +794,7 @@ "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-CcT_JDHE.js", + "scene47-gltf-feature-registry-Bgg2beBQ.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1221,7 +1223,7 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-H4ik3gr7.js", + "scene73-gltf-feature-registry-grbIvkoI.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", @@ -1741,7 +1743,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-BSF9DCxh.js", + "scene104-gltf-feature-registry-D5CQh1T2.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1756,7 +1758,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-BiM-2LlY.js", + "scene105-gltf-feature-registry-B3PDweu7.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1829,7 +1831,7 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-B4CJUMK8.js", + "scene112-gltf-feature-registry-BMiQBC3G.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", "scene112-pbr-refraction-DZYuYfJR.js", @@ -1878,7 +1880,7 @@ "scene115-gltf-color-normalize-BtnJk1yq.js", "scene115-gltf-feature-animations-eusiMJnc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-CEMV-NUp.js", + "scene115-gltf-feature-registry-CE6UfrSg.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", @@ -2109,7 +2111,7 @@ "scene144-gltf-ext-spec-gloss-D60sFZYX.js", "scene144-gltf-feature-animations-DOSVTx1Z.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-C4aQYjBk.js", + "scene144-gltf-feature-registry-CRgM-ljP.js", "scene144-gltf-feature-skeleton-Dq3GN8sP.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", @@ -2180,7 +2182,7 @@ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-LhPTFrel.js", + "scene147-gltf-feature-registry-DwKnZUdV.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2199,7 +2201,7 @@ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-B2YmDV3Q.js", + "scene148-gltf-feature-registry-DR36s7II.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2221,7 +2223,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry-trd2Hl3A.js", + "scene149-gltf-feature-registry--vvDdr6j.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2266,7 +2268,7 @@ "scene152-gltf-ext-spec-gloss-D60sFZYX.js", "scene152-gltf-feature-animations-z0zN7iq2.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-Bydgn2R-.js", + "scene152-gltf-feature-registry-_RVNeJFh.js", "scene152-gltf-feature-skeleton-DdNk7nTu.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", @@ -2315,7 +2317,7 @@ ] }, "scene157": { - "rawKB": 94.2, + "rawKB": 94.1, "gzipKB": 38.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2323,7 +2325,7 @@ "scene157-generate-mipmaps-CSgsFZsy.js", "scene157-gltf-animation-97jnT3rB.js", "scene157-gltf-feature-animations-C4GEf0C-.js", - "scene157-gltf-feature-registry-BMp9zetc.js", + "scene157-gltf-feature-registry-CJbcMlHm.js", "scene157-gltf-feature-skeleton-sqEIM232.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", "scene157-multilight-wgsl-DMQZ6dS_.js", @@ -2341,7 +2343,7 @@ "scene158-generate-mipmaps-ONVnFwM1.js", "scene158-gltf-animation-D36FWf_9.js", "scene158-gltf-feature-animations-_BY8aVDC.js", - "scene158-gltf-feature-registry-BIfzwUtD.js", + "scene158-gltf-feature-registry-oTYrL4Un.js", "scene158-gltf-feature-skeleton-BQO9mRtS.js", "scene158-gltf-glb-parser-BhqojsL9.js", "scene158-multilight-wgsl-DhVJV_xa.js", @@ -2407,7 +2409,7 @@ "scene164-gltf-color-normalize-BtnJk1yq.js", "scene164-gltf-feature-animations-CkuodxMl.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-DqJpf6s1.js", + "scene164-gltf-feature-registry-Cu0jdI_y.js", "scene164-gltf-feature-skeleton-DOpy65Ao.js", "scene164-gltf-json-asset-BCxbuHbB.js", "scene164-morph-fragment-29qCql2q.js", @@ -2511,14 +2513,14 @@ ] }, "scene176": { - "rawKB": 102.4, + "rawKB": 102.3, "gzipKB": 41.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-DCfGHt7T.js", + "scene176-gltf-feature-registry-CbrMvlqa.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2552,7 +2554,7 @@ "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-C-DjZb2A.js", + "scene178-gltf-feature-registry-CcbumFad.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2724,7 +2726,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-B36aiNqk.js", + "scene210-gltf-feature-registry-GNnVvRcM.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", @@ -2735,7 +2737,7 @@ ] }, "scene211": { - "rawKB": 88.5, + "rawKB": 88.4, "gzipKB": 37.1, "ignoredRawKB": 0, "runtimeChunks": [ @@ -2745,7 +2747,7 @@ "scene211-gltf-ext-quantization-Do-ofjB-.js", "scene211-gltf-feature-animations-C0rPaLwN.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-C-tkINq8.js", + "scene211-gltf-feature-registry-vbpGogWS.js", "scene211-gltf-feature-skeleton-C5YXdC68.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", @@ -2762,7 +2764,7 @@ "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-DuIiKAcf.js", + "scene212-gltf-feature-registry-QC-CezfU.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2849,7 +2851,7 @@ "scene218-gltf-ext-spec-gloss-D60sFZYX.js", "scene218-gltf-feature-animations-Xir-5MtM.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-D-uYHOu6.js", + "scene218-gltf-feature-registry-ChazQVDx.js", "scene218-gltf-feature-skeleton-CuQWo93o.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", @@ -2869,7 +2871,7 @@ "scene219-gltf-ext-spec-gloss-D60sFZYX.js", "scene219-gltf-feature-animations-Cr5Rjgc6.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-BxYW41qV.js", + "scene219-gltf-feature-registry-D6HyVJkQ.js", "scene219-gltf-feature-skeleton-QiTS1ubb.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", @@ -2982,7 +2984,7 @@ "scene240-generate-mipmaps-BQZ9ivTX.js", "scene240-gltf-animation-BKjmZpR3.js", "scene240-gltf-feature-animations-Deh9CXYc.js", - "scene240-gltf-feature-registry-BCuCyG5Y.js", + "scene240-gltf-feature-registry-D4HslOs2.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", @@ -2994,12 +2996,13 @@ ] }, "scene241": { - "rawKB": 160.4, - "gzipKB": 65.5, + "rawKB": 160.3, + "gzipKB": 65.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene241-alpha-test-fragment-BpzeKSEk.js", - "scene241-animation-pointer-ext-Bwn0pDBw.js", + "scene241-animation-pointer-ext-C2fdauTX.js", + "scene241-animation-pointer-laGxw-Ac.js", "scene241-anisotropy-fragment-CbNkTpSR.js", "scene241-clearcoat-fragment-Bi0N7tnR.js", "scene241-directional-light-BIPgtvfI.js", @@ -3013,10 +3016,10 @@ "scene241-gltf-ext-sheen-Dv23b_3T.js", "scene241-gltf-ext-unlit-1vUYfF7v.js", "scene241-gltf-ext-uv-transform-CXwEpHUI.js", - "scene241-gltf-feature-animation-pointer-BJ0p5Vnu.js", + "scene241-gltf-feature-animation-pointer-CepPGaOM.js", "scene241-gltf-feature-animations-CSjZ3yRx.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-Bkf9WxSK.js", + "scene241-gltf-feature-registry-5ljxta2x.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3043,17 +3046,18 @@ }, "scene242": { "rawKB": 96.3, - "gzipKB": 39.8, + "gzipKB": 40, "ignoredRawKB": 0, "runtimeChunks": [ + "scene242-animation-pointer-CtucZ4IY.js", "scene242-animation-pointer-basecolor-C0cq9A_I.js", "scene242-emissive-fragment-BjnF3duS.js", "scene242-generate-mipmaps-BCxjeJMR.js", "scene242-gltf-animation-Dm97A3mz.js", "scene242-gltf-ext-emissive-strength-CButLZnK.js", - "scene242-gltf-feature-animation-pointer-7Tn5Qu5X.js", + "scene242-gltf-feature-animation-pointer-DuUn5-xJ.js", "scene242-gltf-feature-animations-B_VnRwPM.js", - "scene242-gltf-feature-registry-C0aPyEVH.js", + "scene242-gltf-feature-registry-BdPdqiFU.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", "scene242-pbr-renderable-DQEk4f7o.js", @@ -3064,7 +3068,7 @@ ] }, "scene243": { - "rawKB": 96.1, + "rawKB": 96, "gzipKB": 40.5, "ignoredRawKB": 0, "runtimeChunks": [ @@ -3074,7 +3078,7 @@ "scene243-gltf-feature-animations-DEeCXW1Z.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-DUaqkxEu.js", + "scene243-gltf-feature-registry-qa72KuNd.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", @@ -3089,19 +3093,20 @@ }, "scene244": { "rawKB": 132.2, - "gzipKB": 53.5, + "gzipKB": 53.6, "ignoredRawKB": 0, "runtimeChunks": [ - "scene244-animation-pointer-ext-DfeJiTkj.js", + "scene244-animation-pointer-ext-CoOxzYYy.js", + "scene244-animation-pointer-jEniq5im.js", "scene244-clearcoat-fragment-fqLK-qje.js", "scene244-generate-mipmaps-BY39y9hS.js", "scene244-gltf-animation-BkhOo1GS.js", "scene244-gltf-ext-clearcoat-BgaLgSgD.js", "scene244-gltf-ext-dielectric-C6hvXXiF.js", "scene244-gltf-ext-uv-transform-YGWG8v_J.js", - "scene244-gltf-feature-animation-pointer-Cl7BygHu.js", + "scene244-gltf-feature-animation-pointer-Cv2YzJgj.js", "scene244-gltf-feature-animations-CTlvB6vN.js", - "scene244-gltf-feature-registry-C4SC6zCa.js", + "scene244-gltf-feature-registry-DCOjiWUE.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", @@ -3128,7 +3133,7 @@ "scene245-generate-mipmaps-WM6bVf2v.js", "scene245-gltf-animation-Dvm46y_g.js", "scene245-gltf-feature-animations-BV66HV-9.js", - "scene245-gltf-feature-registry-DmK9_cNa.js", + "scene245-gltf-feature-registry-BaUUkpZL.js", "scene245-gltf-feature-skeleton-IRWJQHYY.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", @@ -3153,7 +3158,7 @@ "scene246-generate-mipmaps-DzKvtUax.js", "scene246-gltf-animation-DGsaicDt.js", "scene246-gltf-feature-animations-DimU6cfM.js", - "scene246-gltf-feature-registry-Dt8aKR7c.js", + "scene246-gltf-feature-registry-CcRjPF6A.js", "scene246-gltf-feature-skeleton-Bf1KbRoN.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", @@ -3176,7 +3181,7 @@ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", - "scene247-gltf-feature-registry-DQCXkzEd.js", + "scene247-gltf-feature-registry-doudKWoN.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", @@ -3229,7 +3234,7 @@ "scene251-generate-mipmaps-ojYQxP8q.js", "scene251-gltf-animation-BJ2pOO_r.js", "scene251-gltf-feature-animations-Do8ooupS.js", - "scene251-gltf-feature-registry-CnucUK_A.js", + "scene251-gltf-feature-registry-CXmopchE.js", "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", "scene251-gltf-glb-parser-8AD91ACR.js", "scene251-multilight-wgsl-Cxg2lDtv.js", @@ -3250,14 +3255,15 @@ ] }, "scene253": { - "rawKB": 151.1, - "gzipKB": 63.7, + "rawKB": 151, + "gzipKB": 63.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene253-alpha-test-fragment-CBuxkQtx.js", + "scene253-animation-pointer-4eq964B7.js", "scene253-animation-pointer-basecolor-C0cq9A_I.js", - "scene253-animation-pointer-ext-CIs10IPN.js", - "scene253-animation-pointer-lights-BUYIPQbK.js", + "scene253-animation-pointer-ext-VMAJienr.js", + "scene253-animation-pointer-lights-ZnjZL09g.js", "scene253-create-morph-targets-D5qHDYGj.js", "scene253-create-skeleton-DJ2P-GNN.js", "scene253-directional-light-C7HjjUeW.js", @@ -3270,12 +3276,12 @@ "scene253-gltf-ext-iridescence-b4LVniAM.js", "scene253-gltf-ext-unlit-1vUYfF7v.js", "scene253-gltf-ext-uv-transform-DixkPR9o.js", - "scene253-gltf-feature-animation-pointer-D2g4esdb.js", + "scene253-gltf-feature-animation-pointer-B4es0u03.js", "scene253-gltf-feature-animations-DQAfdhkC.js", "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-BgIdVhs9.js", + "scene253-gltf-feature-registry-53j4iw67.js", "scene253-gltf-feature-skeleton-Bjigd6Ok.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js", diff --git a/lab/public/models/Calculator.glb b/lab/public/models/Calculator.glb new file mode 100644 index 0000000000000000000000000000000000000000..f8cbd986c4f68e0d627cfa202a374cca5519e0e1 GIT binary patch literal 1738360 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
3-nUz+%UG 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%0AYiM+KA|vi{w=Q{0vx-`EY9NZJJ;4|r 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 mw=yKWadA2D_y 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 lETf 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

`7cZ){)UjLJE&)&C%iyoI{|UU0 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

c?}Pek4=J_BQWx>cZ-dZacv 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�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

}CBt@M> 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

}d1dvnTb7 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

wKJuuT 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⁣u0d*S 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

uk_ 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 `Dwa%y8pKDA@1IF50#2`nsPAS2jX}ES4JhVNhXY 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%0D1uQfb|2uc0&Kx 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 literal 0 HcmV?d00001 diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index b7476c4836..d988cdfb19 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -23,6 +23,8 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/events/scene-start.js")).sceneStartDef; case FgBlockType.SceneTick: return async () => (await import("./blocks/events/scene-tick.js")).sceneTickDef; + case FgBlockType.OnSelect: + return async () => (await import("./blocks/events/on-select.js")).onSelectDef; // ─── Control flow ───────────────────────────────────────── case FgBlockType.Branch: @@ -33,6 +35,26 @@ export function getBlockDef(type: string): (() => Promise) | null { // ─── Math ───────────────────────────────────────────────── case FgBlockType.Add: return async () => (await import("./blocks/math/add.js")).addDef; + case FgBlockType.Subtract: + return async () => (await import("./blocks/math/subtract.js")).subtractDef; + case FgBlockType.Multiply: + return async () => (await import("./blocks/math/multiply.js")).multiplyDef; + case FgBlockType.Divide: + return async () => (await import("./blocks/math/divide.js")).divideDef; + case FgBlockType.Modulo: + return async () => (await import("./blocks/math/modulo.js")).moduloDef; + case FgBlockType.Abs: + return async () => (await import("./blocks/math/abs.js")).absDef; + case FgBlockType.Floor: + return async () => (await import("./blocks/math/floor.js")).floorDef; + case FgBlockType.LessThan: + return async () => (await import("./blocks/math/less-than.js")).lessThanDef; + case FgBlockType.Clamp: + return async () => (await import("./blocks/math/clamp.js")).clampDef; + case FgBlockType.CombineVector2: + return async () => (await import("./blocks/math/combine2.js")).combine2Def; + case FgBlockType.ExtractVector2: + return async () => (await import("./blocks/math/extract2.js")).extract2Def; // ─── Data: property / variable ──────────────────────────── case FgBlockType.GetProperty: diff --git a/packages/babylon-lite/src/flow-graph/block-type.ts b/packages/babylon-lite/src/flow-graph/block-type.ts index 6217902d16..6b4213683c 100644 --- a/packages/babylon-lite/src/flow-graph/block-type.ts +++ b/packages/babylon-lite/src/flow-graph/block-type.ts @@ -8,6 +8,7 @@ export const enum FgBlockType { // ─── Events ─────────────────────────────────────────────── SceneStart = "SceneReadyEvent", SceneTick = "SceneTickEvent", + OnSelect = "OnSelect", SendCustomEvent = "SendCustomEvent", ReceiveCustomEvent = "ReceiveCustomEvent", @@ -28,6 +29,15 @@ export const enum FgBlockType { Constant = "Constant", Add = "Add", Subtract = "Subtract", + Multiply = "Multiply", + Divide = "Divide", + Modulo = "Modulo", + Abs = "Abs", + Floor = "Floor", + LessThan = "LessThan", + Clamp = "Clamp", + CombineVector2 = "CombineVector2", + ExtractVector2 = "ExtractVector2", // ─── Pointer / variable / animation ─────────────────────── GetProperty = "GetProperty", diff --git a/packages/babylon-lite/src/flow-graph/blocks/events/on-select.ts b/packages/babylon-lite/src/flow-graph/blocks/events/on-select.ts new file mode 100644 index 0000000000..d91b29ccb6 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/events/on-select.ts @@ -0,0 +1,43 @@ +// OnSelect (glTF op `event/onSelect`, extension `KHR_node_selectability`). +// Event block: fires when its configured node (`config.nodeIndex`) is picked. +// The picking/input layer pumps the Pointer channel with `{ nodeIndex, +// controllerIndex }`; this block fires `out`/`done` only when the payload's +// node matches its own. With no picking wired (e.g. an onStart-only demo) it +// stays inert. +// +// ⚠️ SPEC-VOLATILE — KHR_node_selectability is an UNRATIFIED draft; re-sync the +// output sockets against BJS PR #18455 when it lands. The Calculator sample +// reads none of onSelect's value outputs, so they are best-effort. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { FgEventType } from "../../event-bus.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; +import { activateSignal, getExecVar, setDataValue } from "../../runtime.js"; +import { sigOut, sockOut } from "../../sockets.js"; + +interface SelectPayload { + nodeIndex?: number; + controllerIndex?: number; +} + +export const onSelectDef: FgBlockDef = { + type: FgBlockType.OnSelect, + build: () => ({ + dataOut: [sockOut("selectedNodeIndex", FgType.Integer), sockOut("controllerIndex", FgType.Integer)], + signalOut: [sigOut("out"), sigOut("done")], + event: FgEventType.Pointer, + }), + execute(block, ctx, env) { + const payload = getExecVar(ctx, block, "lastEvent", undefined); + const target = block.config?.nodeIndex as number | undefined; + if (!payload || payload.nodeIndex !== target) { + return; + } + setDataValue(ctx, block, "selectedNodeIndex", fgInt(payload.nodeIndex ?? -1)); + setDataValue(ctx, block, "controllerIndex", fgInt(payload.controllerIndex ?? 0)); + activateSignal(ctx, env, block, "done"); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/abs.ts b/packages/babylon-lite/src/flow-graph/blocks/math/abs.ts new file mode 100644 index 0000000000..0c4f6f5721 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/abs.ts @@ -0,0 +1,21 @@ +// Abs (BJS FlowGraphAbsBlock, glTF op `math/abs`). +// Data block (PULL): emits `value` = |a|, type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgAbs`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAbs } from "../../fg-math.js"; + +export const absDef: FgBlockDef = { + type: FgBlockType.Abs, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + setDataValue(ctx, block, "value", fgAbs(getDataValue(ctx, env, block, "a"))); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/clamp.ts b/packages/babylon-lite/src/flow-graph/blocks/math/clamp.ts new file mode 100644 index 0000000000..7a9d6de01f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/clamp.ts @@ -0,0 +1,25 @@ +// Clamp (BJS FlowGraphClampBlock, glTF op `math/clamp`). +// Data block (PULL): emits `value` = min(max(a, b), c) — `b` is the lower bound, +// `c` the upper — type-generic across number / FlowGraphInteger / Vector2-4 via +// fg-math's `fgClamp`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgClamp } from "../../fg-math.js"; + +export const clampDef: FgBlockDef = { + type: FgBlockType.Clamp, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any), sockIn("c", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + const c = getDataValue(ctx, env, block, "c"); + setDataValue(ctx, block, "value", fgClamp(a, b, c)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine2.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine2.ts new file mode 100644 index 0000000000..fb97aeba62 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine2.ts @@ -0,0 +1,23 @@ +// CombineVector2 (BJS FlowGraphCombineVector2Block, glTF op `math/combine2`). +// Data block (PULL): emits `value` = Vec2{x:a, y:b} from two scalars via +// fg-math's `fgCombine2`. glTF input sockets are `a`/`b`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombine2 } from "../../fg-math.js"; + +export const combine2Def: FgBlockDef = { + type: FgBlockType.CombineVector2, + build: () => ({ + dataIn: [sockIn("a", FgType.Number), sockIn("b", FgType.Number)], + dataOut: [sockOut("value", FgType.Vector2)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgCombine2(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/divide.ts b/packages/babylon-lite/src/flow-graph/blocks/math/divide.ts new file mode 100644 index 0000000000..6f1f0bfffa --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/divide.ts @@ -0,0 +1,23 @@ +// Divide (BJS FlowGraphDivideBlock, glTF op `math/div`). +// Data block (PULL): emits `value` = a ÷ b, type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgDiv`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgDiv } from "../../fg-math.js"; + +export const divideDef: FgBlockDef = { + type: FgBlockType.Divide, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgDiv(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract2.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract2.ts new file mode 100644 index 0000000000..fb5bba27b8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract2.ts @@ -0,0 +1,24 @@ +// ExtractVector2 (BJS FlowGraphExtractVector2Block, glTF op `math/extract2`). +// Data block (PULL): one Vec2 input `a` → two scalar outputs. glTF names the +// outputs by index ("0"/"1"); the declaration mapper maps those to Lite sockets +// `x`/`y`. Values come from fg-math's `fgExtract2`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtract2 } from "../../fg-math.js"; + +export const extract2Def: FgBlockDef = { + type: FgBlockType.ExtractVector2, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector2)], + dataOut: [sockOut("x", FgType.Number), sockOut("y", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const [x, y] = fgExtract2(getDataValue(ctx, env, block, "a")); + setDataValue(ctx, block, "x", x); + setDataValue(ctx, block, "y", y); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/floor.ts b/packages/babylon-lite/src/flow-graph/blocks/math/floor.ts new file mode 100644 index 0000000000..361ab7ba01 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/floor.ts @@ -0,0 +1,21 @@ +// Floor (BJS FlowGraphFloorBlock, glTF op `math/floor`). +// Data block (PULL): emits `value` = floor(a), type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgFloor`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgFloor } from "../../fg-math.js"; + +export const floorDef: FgBlockDef = { + type: FgBlockType.Floor, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + setDataValue(ctx, block, "value", fgFloor(getDataValue(ctx, env, block, "a"))); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/less-than.ts b/packages/babylon-lite/src/flow-graph/blocks/math/less-than.ts new file mode 100644 index 0000000000..4023e75e8f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/less-than.ts @@ -0,0 +1,23 @@ +// LessThan (BJS FlowGraphLessThanBlock, glTF op `math/lt`). +// Data block (PULL): emits boolean `value` = a < b (scalar comparison on the +// numeric payload of number / FlowGraphInteger) via fg-math's `fgLt`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLt } from "../../fg-math.js"; + +export const lessThanDef: FgBlockDef = { + type: FgBlockType.LessThan, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgLt(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/modulo.ts b/packages/babylon-lite/src/flow-graph/blocks/math/modulo.ts new file mode 100644 index 0000000000..9aadf36677 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/modulo.ts @@ -0,0 +1,23 @@ +// Modulo (BJS FlowGraphModuloBlock, glTF op `math/rem`). +// Data block (PULL): emits `value` = a mod b, type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgRem`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRem } from "../../fg-math.js"; + +export const moduloDef: FgBlockDef = { + type: FgBlockType.Modulo, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgRem(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/multiply.ts b/packages/babylon-lite/src/flow-graph/blocks/math/multiply.ts new file mode 100644 index 0000000000..dd06fe016b --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/multiply.ts @@ -0,0 +1,23 @@ +// Multiply (BJS FlowGraphMultiplyBlock, glTF op `math/mul`). +// Data block (PULL): emits `value` = a · b (per-component), type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgMul`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMul } from "../../fg-math.js"; + +export const multiplyDef: FgBlockDef = { + type: FgBlockType.Multiply, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgMul(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/subtract.ts b/packages/babylon-lite/src/flow-graph/blocks/math/subtract.ts new file mode 100644 index 0000000000..9424b50f6e --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/subtract.ts @@ -0,0 +1,23 @@ +// Subtract (BJS FlowGraphSubtractBlock, glTF op `math/sub`). +// Data block (PULL): emits `value` = a − b, type-generic across number / +// FlowGraphInteger / Vector2-4 via fg-math's `fgSub`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSub } from "../../fg-math.js"; + +export const subtractDef: FgBlockDef = { + type: FgBlockType.Subtract, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgSub(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts index 003c8dbd28..68df1bc4f1 100644 --- a/packages/babylon-lite/src/flow-graph/fg-math.ts +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -21,25 +21,114 @@ function isVec4(v: unknown): v is Vec4 { return typeof v === "object" && v !== null && "x" in v && "y" in v && "z" in v && "w" in v; } -/** Type-generic component-wise add. Matches BJS `math/add` semantics across - * number, FlowGraphInteger, and Vector2/3/4. Mixed/unknown shapes fall back to - * numeric addition of `0` (BJS returns the left operand on type mismatch; we - * keep it total to avoid throwing inside the runtime loop). */ -export function fgAdd(a: FgValue, b: FgValue): FgValue { +/** Apply a component-wise binary op across number / FlowGraphInteger / Vector2-4. + * Mixed/unknown shapes return the left operand (BJS behaviour) so the runtime + * loop never throws. */ +function binary(a: FgValue, b: FgValue, f: (x: number, y: number) => number): FgValue { if (isFgInt(a) && isFgInt(b)) { - return fgInt(a.value + b.value); + return fgInt(f(a.value, b.value)); } if (typeof a === "number" && typeof b === "number") { - return a + b; + return f(a, b); } if (isVec4(a) && isVec4(b)) { - return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z, w: a.w + b.w }; + return { x: f(a.x, b.x), y: f(a.y, b.y), z: f(a.z, b.z), w: f(a.w, b.w) }; } if (isVec3(a) && isVec3(b)) { - return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z }; + return { x: f(a.x, b.x), y: f(a.y, b.y), z: f(a.z, b.z) }; } if (isVec2(a) && isVec2(b)) { - return { x: a.x + b.x, y: a.y + b.y }; + return { x: f(a.x, b.x), y: f(a.y, b.y) }; + } + return a; +} + +/** Apply a component-wise unary op across number / FlowGraphInteger / Vector2-4. */ +function unary(a: FgValue, f: (x: number) => number): FgValue { + if (isFgInt(a)) { + return fgInt(f(a.value)); + } + if (typeof a === "number") { + return f(a); + } + if (isVec4(a)) { + return { x: f(a.x), y: f(a.y), z: f(a.z), w: f(a.w) }; + } + if (isVec3(a)) { + return { x: f(a.x), y: f(a.y), z: f(a.z) }; + } + if (isVec2(a)) { + return { x: f(a.x), y: f(a.y) }; } return a; } + +/** Type-generic component-wise add (glTF `math/add`). */ +export function fgAdd(a: FgValue, b: FgValue): FgValue { + return binary(a, b, (x, y) => x + y); +} + +/** Type-generic component-wise subtract, a − b (glTF `math/sub`). */ +export function fgSub(a: FgValue, b: FgValue): FgValue { + return binary(a, b, (x, y) => x - y); +} + +/** Type-generic component-wise (Hadamard) multiply (glTF `math/mul`, which is + * per-component for vectors — `useMatrixPerComponent` in BJS). */ +export function fgMul(a: FgValue, b: FgValue): FgValue { + return binary(a, b, (x, y) => x * y); +} + +/** Type-generic component-wise divide, a ÷ b (glTF `math/div`). */ +export function fgDiv(a: FgValue, b: FgValue): FgValue { + return binary(a, b, (x, y) => x / y); +} + +/** Type-generic component-wise remainder, a − b·trunc(a/b) (glTF `math/rem`, + * matching JS `%`). */ +export function fgRem(a: FgValue, b: FgValue): FgValue { + return binary(a, b, (x, y) => x % y); +} + +/** Type-generic component-wise absolute value (glTF `math/abs`). */ +export function fgAbs(a: FgValue): FgValue { + return unary(a, Math.abs); +} + +/** Type-generic component-wise floor (glTF `math/floor`). */ +export function fgFloor(a: FgValue): FgValue { + return unary(a, Math.floor); +} + +/** Type-generic component-wise clamp, min(max(a, b), c) (glTF `math/clamp`, + * b = min, c = max). */ +export function fgClamp(a: FgValue, b: FgValue, c: FgValue): FgValue { + const lo = binary(a, b, (x, y) => Math.max(x, y)); + return binary(lo, c, (x, y) => Math.min(x, y)); +} + +/** Scalar less-than, `a < b` → boolean (glTF `math/lt`). Operates on the numeric + * payload of number / FlowGraphInteger; returns false for non-scalar shapes. */ +export function fgLt(a: FgValue, b: FgValue): boolean { + const x = isFgInt(a) ? a.value : a; + const y = isFgInt(b) ? b.value : b; + if (typeof x === "number" && typeof y === "number") { + return x < y; + } + return false; +} + +/** Combine two scalars into a Vector2 (glTF `math/combine2`). */ +export function fgCombine2(a: FgValue, b: FgValue): Vec2 { + const x = isFgInt(a) ? a.value : (a as number); + const y = isFgInt(b) ? b.value : (b as number); + return { x: x ?? 0, y: y ?? 0 }; +} + +/** Extract a Vector2's components (glTF `math/extract2`) → `[x, y]`. */ +export function fgExtract2(v: FgValue): [number, number] { + if (isVec2(v) || isVec3(v) || isVec4(v)) { + return [v.x, v.y]; + } + return [0, 0]; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index 401f90eda4..c283f7e139 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -44,6 +44,9 @@ export interface FgOpMapping { /** Variable op: the glTF configuration key holding the variable index/indices * (`variable` for get, `variables` for set). */ readonly variableConfigKey?: string; + /** Event op: copy a numeric glTF `configuration` value into `config[key]` + * (e.g. `nodeIndex` for `event/onSelect`). */ + readonly nodeConfigKey?: string; } const FPS = (arr: number[]): number[] => [(arr[0] ?? 0) * ANIMATION_FPS]; @@ -57,6 +60,16 @@ const NATIVE_OPS: Readonly> = { "flow/sequence": { block: FgBlockType.Sequence, dynamicSequence: true }, "math/add": { block: FgBlockType.Add, valueInputs: { a: "a", b: "b" } }, + "math/sub": { block: FgBlockType.Subtract, valueInputs: { a: "a", b: "b" } }, + "math/mul": { block: FgBlockType.Multiply, valueInputs: { a: "a", b: "b" } }, + "math/div": { block: FgBlockType.Divide, valueInputs: { a: "a", b: "b" } }, + "math/rem": { block: FgBlockType.Modulo, valueInputs: { a: "a", b: "b" } }, + "math/abs": { block: FgBlockType.Abs, valueInputs: { a: "a" } }, + "math/floor": { block: FgBlockType.Floor, valueInputs: { a: "a" } }, + "math/lt": { block: FgBlockType.LessThan, valueInputs: { a: "a", b: "b" } }, + "math/clamp": { block: FgBlockType.Clamp, valueInputs: { a: "a", b: "b", c: "c" } }, + "math/combine2": { block: FgBlockType.CombineVector2, valueInputs: { a: "a", b: "b" } }, + "math/extract2": { block: FgBlockType.ExtractVector2, valueInputs: { a: "a" }, outputValues: { "0": "x", "1": "y" } }, "variable/get": { block: FgBlockType.GetVariable, variableConfigKey: "variable" }, "variable/set": { block: FgBlockType.SetVariable, variableConfigKey: "variables", valueInputs: { value: "value" } }, @@ -78,14 +91,22 @@ const BABYLON_OPS: Readonly> = { "flow/log": { block: FgBlockType.ConsoleLog, valueInputs: { message: "message" } }, }; +/** KHR_node_selectability ops (`declaration.extension === "KHR_node_selectability"`). */ +const KHR_NODE_SELECTABILITY_OPS: Readonly> = { + "event/onSelect": { block: FgBlockType.OnSelect, nodeConfigKey: "nodeIndex" }, +}; + +/** Extension-namespaced op tables, keyed by `declaration.extension`. */ +const EXTENSION_OPS: Readonly>>> = { + BABYLON: BABYLON_OPS, + KHR_node_selectability: KHR_NODE_SELECTABILITY_OPS, +}; + /** Look up the Lite mapping for a glTF op, honoring the declaration `extension`. * Returns `null` for an unknown op so the parser can fail loudly. */ export function getOpMapping(op: string, extension?: string): FgOpMapping | null { - if (extension === "BABYLON") { - return BABYLON_OPS[op] ?? null; - } if (extension) { - return null; // unknown extension — Phase 3+ may add pass-through blocks + return EXTENSION_OPS[extension]?.[op] ?? null; } return NATIVE_OPS[op] ?? null; } diff --git a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts index d4dfced376..bb462a9e89 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts @@ -22,7 +22,9 @@ import { DEFAULT_FLOW_SOCKET, DEFAULT_VALUE_SOCKET, getOpMapping, type FgOpMappi // ─── glTF wire-format shapes (loose; spec-volatile) ────────────────────────── interface GltfValueEntry { - value?: number[]; + /** Literal payload. Numeric for scalar/vector literals; a single-element + * STRING array (`["/materials/4/"]`) for `ref`-typed pointer values. */ + value?: (number | string)[]; type?: number; node?: number; socket?: string; @@ -87,10 +89,29 @@ function arrayToFgValue(arr: number[] | undefined, type: FgType): FgValue { } } -/** Substitute `{segment}` template variables in a pointer with their literal - * value-socket values. Returns `null` if a segment is missing or non-literal. */ +/** Extract the trailing integer index from a glTF `ref` path string + * (`"/materials/4/"` → `"4"`). Returns `null` when there's no trailing index. */ +function refPathIndex(ref: string): string | null { + const m = /(\d+)\/?$/.exec(ref); + return m ? m[1]! : null; +} + +/** Resolve a pointer template against a node's value sockets. + * + * Two spec forms are supported (mirrors BJS `FlowGraphPathConverterComponent` + * + the newer relative-pointer draft targeted by PR #18455): + * 1. **Absolute + `{seg}` placeholders** — each `{seg}` reads `node.values[seg]`. + * A `ref`-typed value (`["/materials/4/"]`) contributes its trailing index + * (`4`); a numeric value is substituted directly. + * 2. **Relative** — when the substituted result doesn't start with `/`, prepend + * the path of a `ref`-typed value socket that wasn't consumed as a + * placeholder (e.g. `nodeRef` = `["/nodes/22/"]`). + * + * Returns `null` if a placeholder segment is missing/non-literal, or a relative + * template has no ref prefix to anchor it. */ function resolvePointerTemplate(template: string, node: GltfNode): string | null { let ok = true; + const usedSegments = new Set(); const resolved = template.replace(/\{(\w+)\}/g, (_m, seg: string) => { const entry = node.values?.[seg]; const literal = entry?.value?.[0]; @@ -98,9 +119,34 @@ function resolvePointerTemplate(template: string, node: GltfNode): string | null ok = false; return _m; } + usedSegments.add(seg); + if (typeof literal === "string") { + const idx = refPathIndex(literal); + if (idx === null) { + ok = false; + return _m; + } + return idx; + } return String(literal); }); - return ok ? resolved : null; + if (!ok) { + return null; + } + if (resolved.startsWith("/")) { + return resolved; + } + // Relative pointer: anchor it on an unused ref-typed value socket. + for (const [key, entry] of Object.entries(node.values ?? {})) { + if (usedSegments.has(key) || entry.node !== undefined) { + continue; + } + const v = entry.value?.[0]; + if (typeof v === "string" && v.startsWith("/")) { + return v.replace(/\/$/, "") + "/" + resolved; + } + } + return null; } /** Compute a node's per-flow-key → Lite signal-output-name map (handles the @@ -158,6 +204,9 @@ export async function parseInteractivityGraph(json: GltfInteractivityGraph): Pro const idx = (node.configuration?.[mapping.variableConfigKey]?.value?.[0] as number) ?? 0; config.variable = String(idx); } + if (mapping.nodeConfigKey) { + config[mapping.nodeConfigKey] = node.configuration?.[mapping.nodeConfigKey]?.value?.[0] as number; + } if (mapping.pointer) { const template = node.configuration?.pointer?.value?.[0] as string | undefined; const resolved = template ? resolvePointerTemplate(template, node) : null; @@ -205,8 +254,9 @@ export async function parseInteractivityGraph(json: GltfInteractivityGraph): Pro const gltfSocket = entry.socket ?? DEFAULT_VALUE_SOCKET; socket.source = { blockId: `node_${entry.node}`, socket: producer.outputValues?.[gltfSocket] ?? gltfSocket }; } else { + const raw = (entry.value ?? []) as number[]; const transform = mapping.valueTransform?.[gltfKey]; - const arr = transform ? transform(entry.value ?? []) : entry.value; + const arr = transform ? transform(raw) : raw; socket.defaultValue = arrayToFgValue(arr, types[entry.type ?? -1] ?? socket.type); } } diff --git a/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts b/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts index 07eae99b2c..72fe651c15 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/path-converter.ts @@ -3,9 +3,15 @@ // // path-converter: resolves a (literal-substituted) JSON pointer string such as // "/nodes/0/translation" to an FgAccessor (get/set closures) over the addressed -// scene node's TRS. The KHR_interactivity loader feeds the glTF `_nodeMap` -// (glTF-node-index → TransformNode) so accessors never hold a scene reference — -// they close over the resolved node only. +// object. The KHR_interactivity loader feeds the glTF node map + runtime material +// map so accessors never hold a scene reference — they close over the resolved +// node/material only. +// +// DRY: material UV-transform and node-visibility WRITES delegate to the shared +// KHR_animation_pointer resolver (`resolveAnimationPointer`), which already owns +// the tricky per-texture isolation (so two materials sharing one atlas texture +// don't clobber each other) and the UBO/visibility-epoch invalidation. Pointer +// GETs read the runtime fields directly (the animation registry is write-only). // // LITE DIVERGENCE: BJS resolves pointers at RUNTIME via JsonPointerParser + // gltfPathToObjectConverter. Lite pre-resolves them here at LOAD time, collapsing @@ -14,9 +20,25 @@ import type { FgAccessor } from "../context.js"; import type { FgValue, Vec2 } from "../types.js"; +import { FgType } from "../types.js"; import type { TransformNode } from "../../scene/transform-node.js"; import type { Quat, Vec3, Vec4 } from "../../math/types.js"; import { NODE_TRS_PROPS } from "./object-model-mapping.js"; +import { resolveAnimationPointer, type PointerContext, type PointerMaterial } from "../../loader-gltf/animation-pointer.js"; + +/** Loader-supplied resolution context: the glTF node map plus the runtime + * material map (glTF material index → PBR material) and raw JSON for reuse of + * the KHR_animation_pointer writers. */ +export interface PointerResolveContext { + nodeMap: readonly (TransformNode | undefined)[]; + materials?: readonly (PointerMaterial | undefined)[]; + json?: object; +} + +/** Build the PointerContext the animation-pointer registry expects. */ +function animCtx(ctx: PointerResolveContext): PointerContext { + return { nodes: ctx.nodeMap as PointerContext["nodes"], materials: ctx.materials, _json: ctx.json }; +} /** Parse `/nodes/{index}/{prop}` → `{ nodeIndex, prop }`, or `null` when the * pointer is not a supported node-TRS path. */ @@ -28,20 +50,45 @@ function parseNodeTrsPointer(pointer: string): { nodeIndex: number; prop: string return { nodeIndex: Number(m[1]), prop: m[2]! }; } +const MAT_UV_RE = + /^\/materials\/(\d+)\/(?:pbrMetallicRoughness\/baseColorTexture|emissiveTexture|normalTexture|occlusionTexture)\/extensions\/KHR_texture_transform\/(offset|scale)$/; +const VISIBILITY_RE = /^\/nodes\/(\d+)\/extensions\/KHR_node_visibility\/visible$/; +const SELECTABILITY_RE = /^\/nodes\/(\d+)\/extensions\/KHR_node_selectability\/selectable$/; + /** Resolve a literal-substituted JSON pointer to an `FgAccessor`, or `null` when - * it addresses an unsupported path or an unreachable node. */ -export function resolvePointerAccessor(pointer: string, nodeMap: readonly (TransformNode | undefined)[]): FgAccessor | null { - const parsed = parseNodeTrsPointer(pointer); - if (!parsed) { - return null; + * it addresses an unsupported path or an unreachable node/material. */ +export function resolvePointerAccessor(pointer: string, ctx: PointerResolveContext): FgAccessor | null { + const trs = parseNodeTrsPointer(pointer); + if (trs) { + return resolveNodeTrs(trs.nodeIndex, trs.prop, ctx); + } + + const uv = MAT_UV_RE.exec(pointer); + if (uv) { + return resolveMaterialUvTransform(pointer, Number(uv[1]), uv[2]!, ctx); + } + + const vis = VISIBILITY_RE.exec(pointer); + if (vis) { + return resolveVisibility(pointer, Number(vis[1]), ctx); } - const node = nodeMap[parsed.nodeIndex]; + + const sel = SELECTABILITY_RE.exec(pointer); + if (sel) { + return resolveSelectability(Number(sel[1]), ctx); + } + + return null; +} + +function resolveNodeTrs(nodeIndex: number, prop: string, ctx: PointerResolveContext): FgAccessor | null { + const node = ctx.nodeMap[nodeIndex]; if (!node) { return null; } - const entry = NODE_TRS_PROPS[parsed.prop]!; + const entry = NODE_TRS_PROPS[prop]!; - if (parsed.prop === "translation") { + if (prop === "translation") { return { type: entry.type, target: node, @@ -52,7 +99,7 @@ export function resolvePointerAccessor(pointer: string, nodeMap: readonly (Trans }, }; } - if (parsed.prop === "scale") { + if (prop === "scale") { return { type: entry.type, target: node, @@ -75,6 +122,77 @@ export function resolvePointerAccessor(pointer: string, nodeMap: readonly (Trans }; } +/** Material `KHR_texture_transform` offset/scale (Vec2). WRITES reuse the shared + * animation-pointer writer (per-texture isolation + UBO bump); READS sample the + * runtime baseColorTexture's UV fields directly. */ +function resolveMaterialUvTransform(pointer: string, matIndex: number, kind: string, ctx: PointerResolveContext): FgAccessor | null { + const mat = ctx.materials?.[matIndex]; + if (!mat) { + return null; + } + const resolved = resolveAnimationPointer(pointer, animCtx(ctx)); + return { + type: FgType.Vector2, + target: mat, + get: () => { + const tex = mat.baseColorTexture; + if (kind === "scale") { + return { x: tex?.uScale ?? 1, y: tex?.vScale ?? 1 }; + } + return { x: tex?.uOffset ?? 0, y: tex?.vOffset ?? 0 }; + }, + set: resolved + ? (v) => { + const p = toVec2(v); + resolved.writer(Float32Array.of(p.x, p.y), 0); + } + : undefined, + }; +} + +/** `KHR_node_visibility/visible` (boolean). WRITES reuse the shared + * animation-pointer writer (subtree cascade + visibility-epoch bump). */ +function resolveVisibility(pointer: string, nodeIndex: number, ctx: PointerResolveContext): FgAccessor | null { + const node = ctx.nodeMap[nodeIndex]; + if (!node) { + return null; + } + const resolved = resolveAnimationPointer(pointer, animCtx(ctx)); + return { + type: FgType.Boolean, + target: node, + get: () => node.visible !== false, + set: resolved + ? (v) => { + resolved.writer(Float32Array.of(v ? 1 : 0), 0); + } + : undefined, + }; +} + +/** `KHR_node_selectability/selectable` (boolean). Lite has no picking gate, so + * this is a no-op accessor: the value round-trips but has no visual effect. */ +function resolveSelectability(nodeIndex: number, ctx: PointerResolveContext): FgAccessor | null { + const node = ctx.nodeMap[nodeIndex]; + if (!node) { + return null; + } + let selectable = true; + return { + type: FgType.Boolean, + target: node, + get: () => selectable, + set: (v) => { + selectable = !!v; + }, + }; +} + +function toVec2(v: FgValue): Vec2 { + const o = (v ?? {}) as Partial; + return { x: o.x ?? 0, y: o.y ?? 0 }; +} + function toVec3(v: FgValue): Vec3 { const o = (v ?? {}) as Partial; return { x: o.x ?? 0, y: o.y ?? 0, z: (o as Vec3).z ?? 0 }; diff --git a/packages/babylon-lite/src/index.ts b/packages/babylon-lite/src/index.ts index 00b8282421..8a5963a150 100644 --- a/packages/babylon-lite/src/index.ts +++ b/packages/babylon-lite/src/index.ts @@ -760,7 +760,7 @@ export { animationTypeForFgType, coerceValue, defaultForType, FgAnimationValueTy export type { FgInteger, FgMatrix2D, FgMatrix3D } from "./flow-graph/index.js"; export { fgInt, fgMatrix2D, fgMatrix3D, isFgInt, isFgMatrix2D, isFgMatrix3D } from "./flow-graph/index.js"; export { getBlockDef } from "./flow-graph/index.js"; -export { attachFlowGraph, detachFlowGraph } from "./flow-graph/index.js"; +export { attachFlowGraph, detachFlowGraph, runFlowGraphs } from "./flow-graph/index.js"; export type { FgRuntime } from "./flow-graph/index.js"; export { activateSignal, diff --git a/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts b/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts index 2dcde61d5c..3f677faf23 100644 --- a/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts +++ b/packages/babylon-lite/src/loader-gltf/gltf-feature-interactivity.ts @@ -15,6 +15,7 @@ import type { Mesh } from "../mesh/mesh.js"; import type { TransformNode } from "../scene/transform-node.js"; import type { AssetContainer } from "../asset-container.js"; import type { FgAccessor, LoadedFlowGraph } from "../flow-graph/context.js"; +import type { PointerMaterial } from "./animation-pointer.js"; import { parseInteractivityGraph, type GltfInteractivityGraph } from "../flow-graph/gltf/interactivity-parser.js"; import { resolvePointerAccessor } from "../flow-graph/gltf/path-converter.js"; @@ -22,19 +23,46 @@ interface IKHRInteractivity { graphs?: GltfInteractivityGraph[]; } +/** Build a glTF-material-index → runtime-material map by walking the node→mesh→ + * primitive hierarchy in the same order the loader instantiates GPU meshes + * (mirrors KHR_animation_pointer's `materialMap`). Lets a `pointer/{get,set}` on + * a material's UV transform reach the live PBR material. */ +function buildMaterialMap(json: { nodes?: { mesh?: number }[]; meshes?: { primitives?: { material?: number }[] }[] }, meshes: readonly Mesh[]): (PointerMaterial | undefined)[] { + const map: (PointerMaterial | undefined)[] = []; + const nodes = json.nodes ?? []; + let gpuIdx = 0; + for (let ni = 0; ni < nodes.length; ni++) { + const meshRef = nodes[ni]?.mesh; + if (meshRef === undefined) { + continue; + } + const prims = json.meshes?.[meshRef]?.primitives ?? []; + for (let p = 0; p < prims.length; p++) { + const matIdx = prims[p]?.material; + const mesh = meshes[gpuIdx++]; + if (matIdx !== undefined && mesh) { + map[matIdx] = mesh.material as unknown as PointerMaterial; + } + } + } + return map; +} + const feature: GltfFeature = { id: "KHR_interactivity", async applyAsset(_meshes: Mesh[], _root: TransformNode, ctx: GltfLoadCtx): Promise> { const ext = ctx._json.extensions?.KHR_interactivity as IKHRInteractivity | undefined; const graphs = ext?.graphs ?? []; const nodeMap = ctx._nodeMap ?? []; + const materials = buildMaterialMap(ctx._json, _meshes); + const resolveCtx = { nodeMap, materials, json: ctx._json }; const flowGraphs: LoadedFlowGraph[] = []; for (const graphJson of graphs) { const { graph, pointers } = await parseInteractivityGraph(graphJson); const accessors: Record = {}; for (const pointer of pointers) { - const accessor = resolvePointerAccessor(pointer, nodeMap); + const accessor = resolvePointerAccessor(pointer, resolveCtx); if (!accessor) { throw new Error(`KHR_interactivity: cannot resolve pointer ${JSON.stringify(pointer)} (unsupported path or unreachable node)`); } diff --git a/scripts/bundle-demos-core.ts b/scripts/bundle-demos-core.ts index 1a38b42238..3fe735f3f3 100644 --- a/scripts/bundle-demos-core.ts +++ b/scripts/bundle-demos-core.ts @@ -225,6 +225,13 @@ function copyDemoRuntimeAssets(demos: DemoConfigEntry[]): void { } } + if (demos.some((demo) => demo.slug === "calculator")) { + const glb = resolve(labDir, "public", "models", "Calculator.glb"); + if (existsSync(glb)) { + cpSync(glb, resolve(demosDir, "Calculator.glb")); + } + } + if (demos.some((demo) => demo.slug === "tetris")) { // Tetris geometry/texture assets (consolidated under lab/public/tetris/) // plus its local studio HDR environment, copied flat so the demo resolves diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index f97f085bca..3ee15e9683 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest"; import type { AnimationGroup } from "../../../packages/babylon-lite/src/animation/animation-group"; import type { FgAccessor, FgBlock, FgBlockDef, FgGraph, FgValue, FgWiring } from "../../../packages/babylon-lite/src/flow-graph/index"; -import { createFgRuntime, FgType, getBlockDef, getDataValue, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { createFgRuntime, FgEventType, FgType, getBlockDef, getDataValue, pumpFgEvent, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; // ─── graph + runtime builder driven by the REAL registry ──────────────────── @@ -101,6 +101,23 @@ describe("flow-graph blocks — events", () => { tickFlowGraph(rt, 500); // +0.5s expect(log.map((e) => e.value)).toEqual([1, 1.5]); }); + + it("OnSelect fires only when its configured node is picked", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "sel", type: "OnSelect", config: { nodeIndex: 14 }, signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "sel", socket: "selectedNodeIndex" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + pumpFgEvent(rt.env.events, FgEventType.Pointer, { nodeIndex: 99 }); + expect(log).toHaveLength(0); // wrong node — inert + pumpFgEvent(rt.env.events, FgEventType.Pointer, { nodeIndex: 14 }); + expect(log).toHaveLength(1); + expect(log[0]!.value).toEqual({ value: 14, __fgInt: true }); + }); }); describe("flow-graph blocks — control flow", () => { @@ -184,6 +201,143 @@ describe("flow-graph blocks — math/data", () => { expect(log[0]!.value).toEqual({ x: 5, y: 7, z: 9 }); }); + it.each([ + ["Subtract", 7, 4, 3], + ["Multiply", 6, 7, 42], + ["Divide", 20, 5, 4], + ["Modulo", 17, 5, 2], + ])("%s computes a∘b on numbers", async (type, a, b, expected) => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type, dataDefaults: { a, b } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(expected); + }); + + it("Subtract/Multiply are component-wise for vectors", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "rs", socket: "in" }, + { blockId: "rm", socket: "in" }, + ], + }, + }, + { id: "sub", type: "Subtract", dataDefaults: { a: { x: 5, y: 7 }, b: { x: 1, y: 2 } } }, + { id: "mul", type: "Multiply", dataDefaults: { a: { x: 2, y: 3 }, b: { x: 4, y: 5 } } }, + { id: "rs", type: RECORD, config: { label: "sub" }, dataSources: { value: { blockId: "sub", socket: "value" } } }, + { id: "rm", type: RECORD, config: { label: "mul" }, dataSources: { value: { blockId: "mul", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.find((l) => l.label === "sub")!.value).toEqual({ x: 4, y: 5 }); + expect(log.find((l) => l.label === "mul")!.value).toEqual({ x: 8, y: 15 }); + }); + + it.each([ + ["Abs", -3.5, 3.5], + ["Floor", 3.9, 3], + ])("%s is unary", async (type, a, expected) => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type, dataDefaults: { a } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(expected); + }); + + it.each([ + [1, 2, true], + [2, 2, false], + [3, 2, false], + ])("LessThan(%d, %d) → %s", async (a, b, expected) => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type: "LessThan", dataDefaults: { a, b } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(expected); + }); + + it.each([ + [-5, -3, 7, -3], + [10, -3, 7, 7], + [4, -3, 7, 4], + ])("Clamp(%d, %d, %d) → %d", async (a, b, c, expected) => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type: "Clamp", dataDefaults: { a, b, c } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(expected); + }); + + it("CombineVector2 builds a Vec2 from two scalars", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type: "CombineVector2", dataDefaults: { a: 0.8, b: 0.1 } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toEqual({ x: 0.8, y: 0.1 }); + }); + + it("ExtractVector2 splits a Vec2 into x/y outputs", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "rx", socket: "in" }, + { blockId: "ry", socket: "in" }, + ], + }, + }, + { id: "op", type: "ExtractVector2", dataDefaults: { a: { x: 3, y: 4 } } }, + { id: "rx", type: RECORD, config: { label: "x" }, dataSources: { value: { blockId: "op", socket: "x" } } }, + { id: "ry", type: RECORD, config: { label: "y" }, dataSources: { value: { blockId: "op", socket: "y" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.find((l) => l.label === "x")!.value).toBe(3); + expect(log.find((l) => l.label === "y")!.value).toBe(4); + }); + it("Get/SetVariable round-trips a live graph variable", async () => { const log: { label: string; value: FgValue }[] = []; const rt = await makeRuntime( diff --git a/tests/lite/unit/flow-graph-gltf-feature.test.ts b/tests/lite/unit/flow-graph-gltf-feature.test.ts index ff78d08b5c..2b48bd34d6 100644 --- a/tests/lite/unit/flow-graph-gltf-feature.test.ts +++ b/tests/lite/unit/flow-graph-gltf-feature.test.ts @@ -27,7 +27,7 @@ const worldPointerExtension = { describe("path-converter resolvePointerAccessor", () => { it("reads + writes a node's translation through the TRS accessor", () => { const node = createTransformNode("n0"); - const accessor = resolvePointerAccessor("/nodes/0/translation", [node]); + const accessor = resolvePointerAccessor("/nodes/0/translation", { nodeMap: [node] }); expect(accessor).not.toBeNull(); expect(accessor!.get()).toEqual({ x: 0, y: 0, z: 0 }); accessor!.set!({ x: 4, y: 5, z: 6 }); @@ -38,14 +38,54 @@ describe("path-converter resolvePointerAccessor", () => { it("reads + writes a node's scale", () => { const node = createTransformNode("n0"); - const accessor = resolvePointerAccessor("/nodes/0/scale", [node])!; + const accessor = resolvePointerAccessor("/nodes/0/scale", { nodeMap: [node] })!; accessor.set!({ x: 2, y: 2, z: 2 }); expect(node.scaling.x).toBe(2); }); it("returns null for unsupported paths and unreachable nodes", () => { - expect(resolvePointerAccessor("/materials/0/baseColor", [createTransformNode("n0")])).toBeNull(); - expect(resolvePointerAccessor("/nodes/3/translation", [createTransformNode("n0")])).toBeNull(); + expect(resolvePointerAccessor("/materials/0/baseColor", { nodeMap: [createTransformNode("n0")] })).toBeNull(); + expect(resolvePointerAccessor("/nodes/3/translation", { nodeMap: [createTransformNode("n0")] })).toBeNull(); + }); + + it("reads a material's baseColorTexture UV scale (pointer/get)", () => { + const mat = { _uboVersion: 0, baseColorTexture: { uScale: 0.1, vScale: 1, uOffset: 0.8, vOffset: 0 } }; + const ptr = "/materials/4/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale"; + const accessor = resolvePointerAccessor(ptr, { nodeMap: [], materials: [undefined, undefined, undefined, undefined, mat] })!; + expect(accessor.get()).toEqual({ x: 0.1, y: 1 }); + }); + + it("writes a material's UV offset and isolates the shared texture (pointer/set)", () => { + const shared = { uScale: 0.1, vScale: 1, uOffset: 0.8, vOffset: 0 }; + const matA = { _uboVersion: 0, baseColorTexture: shared }; + const matB = { _uboVersion: 0, baseColorTexture: shared }; + const ptr = "/materials/0/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/offset"; + const accessor = resolvePointerAccessor(ptr, { nodeMap: [], materials: [matA, matB] })!; + accessor.set!({ x: 0, y: 0 }); + expect(matA.baseColorTexture.uOffset).toBe(0); + expect(matA._uboVersion).toBe(1); + // matB still references the original shared wrapper — untouched (per-texture isolation). + expect(matB.baseColorTexture).toBe(shared); + expect(shared.uOffset).toBe(0.8); + }); + + it("toggles node visibility through the KHR_node_visibility accessor", () => { + const node = createTransformNode("n0"); + const accessor = resolvePointerAccessor("/nodes/0/extensions/KHR_node_visibility/visible", { nodeMap: [node] })!; + expect(accessor.get()).toBe(true); + accessor.set!(false); + expect(node.visible).toBe(false); + accessor.set!(true); + expect(node.visible).toBe(true); + }); + + it("treats node selectability as a no-op value round-trip", () => { + const node = createTransformNode("n0"); + const accessor = resolvePointerAccessor("/nodes/0/extensions/KHR_node_selectability/selectable", { nodeMap: [node] })!; + expect(accessor.get()).toBe(true); + accessor.set!(false); + expect(accessor.get()).toBe(false); + expect(node.visible).toBeUndefined(); // selectability never touches visibility }); }); diff --git a/tests/lite/unit/flow-graph-gltf-parser.test.ts b/tests/lite/unit/flow-graph-gltf-parser.test.ts index 31dce81751..72135fd014 100644 --- a/tests/lite/unit/flow-graph-gltf-parser.test.ts +++ b/tests/lite/unit/flow-graph-gltf-parser.test.ts @@ -122,5 +122,75 @@ describe("KHR_interactivity parser", () => { }); }); +describe("KHR_interactivity parser — pointer templating & new ops", () => { + it("extracts the trailing index from a `ref` placeholder value (/materials/4/ → 4)", async () => { + const g: GltfInteractivityGraph = { + declarations: [{ op: "pointer/get" }], + nodes: [ + { + declaration: 0, + configuration: { pointer: { value: ["/materials/{materialRef}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale"] } }, + values: { materialRef: { type: 5, value: ["/materials/4/"] } }, + }, + ], + types: [{ signature: "bool" }, { signature: "int" }, { signature: "float" }, { signature: "float2" }, { signature: "float3" }, { signature: "ref" }], + }; + const { graph, pointers } = await parseInteractivityGraph(g); + expect(pointers).toEqual(["/materials/4/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale"]); + expect(graph.blocks[0]!.config?.accessor).toBe("/materials/4/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale"); + }); + + it("anchors a relative pointer on an unused `nodeRef` ref value", async () => { + const g: GltfInteractivityGraph = { + declarations: [{ op: "pointer/set" }], + nodes: [ + { + declaration: 0, + configuration: { pointer: { value: ["extensions/KHR_node_visibility/visible"] } }, + values: { value: { value: [1], type: 0 }, nodeRef: { type: 5, value: ["/nodes/22/"] } }, + }, + ], + types: [{ signature: "bool" }, { signature: "int" }, { signature: "float" }, { signature: "float2" }, { signature: "float3" }, { signature: "ref" }], + }; + const { pointers } = await parseInteractivityGraph(g); + expect(pointers).toEqual(["/nodes/22/extensions/KHR_node_visibility/visible"]); + }); + + it("maps the new math ops and renames extract2 outputs to x/y", async () => { + const g: GltfInteractivityGraph = { + declarations: [ + { op: "math/extract2" }, // 0 + { op: "math/combine2" }, // 1 + { op: "math/clamp" }, // 2 + { op: "math/sub" }, // 3 + { op: "flow/log", extension: "BABYLON" }, // 4 + ], + nodes: [ + { declaration: 0, values: { a: { value: [3, 4], type: 3 } } }, + { declaration: 1, values: { a: { value: [1], type: 2 }, b: { value: [2], type: 2 } } }, + { declaration: 2, values: { a: { value: [5], type: 2 }, b: { value: [0], type: 2 }, c: { value: [9], type: 2 } } }, + { declaration: 3, values: { a: { value: [7], type: 2 }, b: { value: [2], type: 2 } } }, + // ConsoleLog pulls extract2's "1" output → must resolve to the Lite `y` socket + { declaration: 4, values: { message: { node: 0, socket: "1" } } }, + ], + types: [{ signature: "bool" }, { signature: "int" }, { signature: "float" }, { signature: "float2" }], + }; + const { graph } = await parseInteractivityGraph(g); + expect(graph.blocks.map((b) => b.type)).toEqual(["ExtractVector2", "CombineVector2", "Clamp", "Subtract", "ConsoleLog"]); + expect(graph.blocks[4]!.dataIn.find((d) => d.name === "message")!.source).toEqual({ blockId: "node_0", socket: "y" }); + }); + + it("maps event/onSelect (KHR_node_selectability) and copies nodeIndex into config", async () => { + const g: GltfInteractivityGraph = { + declarations: [{ op: "event/onSelect", extension: "KHR_node_selectability" }], + nodes: [{ declaration: 0, configuration: { nodeIndex: { value: [14] } } }], + types: [], + }; + const { graph } = await parseInteractivityGraph(g); + expect(graph.blocks[0]!.type).toBe("OnSelect"); + expect(graph.blocks[0]!.config?.nodeIndex).toBe(14); + }); +}); + // Silence the ConsoleLog block's console.log in the end-to-end run. vi.spyOn(console, "log").mockImplementation(() => {}); From 72f3f660fe81bcc9416877ec70298dab964f8805 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 17:37:10 +0200 Subject: [PATCH 05/13] docs(flow-graph): detail Phase 5 BJS-native serialization parsing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Spell out the planned BJS FlowGraph serialization (editor / coordinator) JSON support as a concrete Phase 5 deliverable: a second parser front-end producing the same FgGraph, a className→FgBlockType map, rich-type de/serialization, and a scene-object-reference binding layer. Records that it is gated on BJS-editor interop need and on the format settling after BJS PR #18455. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/lite/architecture/42-flow-graph.md | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/docs/lite/architecture/42-flow-graph.md b/docs/lite/architecture/42-flow-graph.md index fa640c6fca..f6b2d0f8e9 100644 --- a/docs/lite/architecture/42-flow-graph.md +++ b/docs/lite/architecture/42-flow-graph.md @@ -832,8 +832,19 @@ mapper/parser to the full 168-op surface; add further `KHR_interactivity` parity scenes, `scene-config.json` entries, bundle ceilings. Run full `pnpm test`. **Phase 5+ (post-MVP, out of MVP scope):** remaining blocks toward full parity; -BJS snippet/editor serialization format; multi-context coordinator; debugger -hooks; physics/audio interactivity ops. +multi-context coordinator; debugger hooks; physics/audio interactivity ops; and +**BJS-native FlowGraph serialization parsing** (the editor / `FlowGraphCoordinator.serialize()` +JSON — `{ allBlocks: [{ className, config, dataInputs/Outputs, signalInputs/Outputs }], +executionContexts: [...] }`). The pure-data runtime already consumes any `FgGraph`, +so this is a **second parser front-end** alongside `gltf/interactivity-parser.ts`, +producing the same `FgGraph`. Concrete sub-tasks: (1) a parser reading +`allBlocks` + the connection-point graph; (2) a `className → FgBlockType` map for +the registry; (3) rich-type value de/serialization (Vec2/3, quaternion, matrix, +integer); (4) a scene-object-reference binding layer (BJS serializes mesh/node/ +material refs by Babylon className + id/name — analogous to the glTF path-converter +but for BJS's asset-ref scheme). Gated on actually needing BJS-editor interop, and +on the format settling after #18455 (it is a BJS-*internal*, higher-churn format +than the standardized glTF draft). --- From 65a3a4bcde94ecac2fb89297a8c87350e790b36a Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 18:18:41 +0200 Subject: [PATCH 06/13] feat(flow-graph): add Phase 3 scalar/trig/comparison/bitwise/vector + conversion blocks Broaden the Lite flow-graph block library with the non-matrix math surface and type conversions, wired through the registry and glTF declaration mapper: - fg-math.ts: ~50 type-generic dispatchers (neg/sign/rounding/exp/log/roots, full trig, min/max/pow/atan2, eq/le/gt/ge, isNaN/isInf, mix, random, bitwise and/or/xor/not + shifts + clz/ctz/popcnt, length/normalize/dot/cross, rotate2D/3D, combine3/4, extract3/4, conjugate). - blocks/math/*: 55 new data blocks (scalar, trig, comparison, constants E/PI/Inf/NaN, bitwise, vector, combine/extract, select, data-switch). - blocks/conversion/*: 6 type-conversion blocks (bool/int/float). - block-registry.ts + gltf/declaration-mapper.ts: lazy registry cases and NATIVE_OPS entries (pass-through a/b/c; explicit mapping for extract3/4, rotate2D, select). - tests: Phase 3 unit coverage (729 unit tests green). - Regenerated lab/public/bundle/manifest.json (hash-only chunk cascade from the inert gltf-feature-registry; no bundle-size change). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- lab/public/bundle/manifest.json | 102 ++-- .../src/flow-graph/block-registry.ts | 142 ++++++ .../babylon-lite/src/flow-graph/block-type.ts | 116 ++++- .../blocks/conversion/boolean-to-float.ts | 19 + .../blocks/conversion/boolean-to-int.ts | 20 + .../blocks/conversion/float-to-boolean.ts | 19 + .../blocks/conversion/float-to-int.ts | 24 + .../blocks/conversion/int-to-boolean.ts | 21 + .../blocks/conversion/int-to-float.ts | 21 + .../src/flow-graph/blocks/math/acos.ts | 21 + .../src/flow-graph/blocks/math/acosh.ts | 21 + .../src/flow-graph/blocks/math/asin.ts | 21 + .../src/flow-graph/blocks/math/asinh.ts | 21 + .../src/flow-graph/blocks/math/atan.ts | 21 + .../src/flow-graph/blocks/math/atan2.ts | 22 + .../src/flow-graph/blocks/math/atanh.ts | 21 + .../src/flow-graph/blocks/math/bitwise-and.ts | 22 + .../blocks/math/bitwise-left-shift.ts | 22 + .../src/flow-graph/blocks/math/bitwise-not.ts | 21 + .../src/flow-graph/blocks/math/bitwise-or.ts | 22 + .../blocks/math/bitwise-right-shift.ts | 22 + .../src/flow-graph/blocks/math/bitwise-xor.ts | 22 + .../src/flow-graph/blocks/math/ceil.ts | 21 + .../src/flow-graph/blocks/math/combine3.ts | 23 + .../src/flow-graph/blocks/math/combine4.ts | 24 + .../src/flow-graph/blocks/math/conditional.ts | 22 + .../src/flow-graph/blocks/math/constant-e.ts | 18 + .../flow-graph/blocks/math/constant-inf.ts | 18 + .../flow-graph/blocks/math/constant-nan.ts | 18 + .../src/flow-graph/blocks/math/constant-pi.ts | 18 + .../src/flow-graph/blocks/math/cos.ts | 21 + .../src/flow-graph/blocks/math/cosh.ts | 21 + .../src/flow-graph/blocks/math/cross.ts | 22 + .../src/flow-graph/blocks/math/cube-root.ts | 21 + .../src/flow-graph/blocks/math/data-switch.ts | 31 ++ .../src/flow-graph/blocks/math/deg-to-rad.ts | 21 + .../src/flow-graph/blocks/math/dot.ts | 22 + .../src/flow-graph/blocks/math/equality.ts | 22 + .../src/flow-graph/blocks/math/exponential.ts | 21 + .../src/flow-graph/blocks/math/extract3.ts | 24 + .../src/flow-graph/blocks/math/extract4.ts | 25 + .../src/flow-graph/blocks/math/fraction.ts | 21 + .../blocks/math/greater-than-or-equal.ts | 22 + .../flow-graph/blocks/math/greater-than.ts | 22 + .../src/flow-graph/blocks/math/is-infinity.ts | 21 + .../src/flow-graph/blocks/math/is-nan.ts | 21 + .../flow-graph/blocks/math/leading-zeros.ts | 21 + .../src/flow-graph/blocks/math/length.ts | 21 + .../blocks/math/less-than-or-equal.ts | 22 + .../src/flow-graph/blocks/math/log.ts | 21 + .../src/flow-graph/blocks/math/log10.ts | 21 + .../src/flow-graph/blocks/math/log2.ts | 21 + .../src/flow-graph/blocks/math/max.ts | 22 + .../src/flow-graph/blocks/math/min.ts | 22 + .../src/flow-graph/blocks/math/mix.ts | 23 + .../src/flow-graph/blocks/math/negation.ts | 21 + .../src/flow-graph/blocks/math/normalize.ts | 21 + .../blocks/math/one-bits-counter.ts | 21 + .../src/flow-graph/blocks/math/power.ts | 22 + .../src/flow-graph/blocks/math/rad-to-deg.ts | 21 + .../src/flow-graph/blocks/math/random.ts | 24 + .../src/flow-graph/blocks/math/rotate2d.ts | 23 + .../src/flow-graph/blocks/math/rotate3d.ts | 22 + .../src/flow-graph/blocks/math/round.ts | 21 + .../src/flow-graph/blocks/math/saturate.ts | 21 + .../src/flow-graph/blocks/math/sign.ts | 21 + .../src/flow-graph/blocks/math/sin.ts | 21 + .../src/flow-graph/blocks/math/sinh.ts | 21 + .../src/flow-graph/blocks/math/square-root.ts | 21 + .../src/flow-graph/blocks/math/tan.ts | 21 + .../src/flow-graph/blocks/math/tanh.ts | 21 + .../flow-graph/blocks/math/trailing-zeros.ts | 21 + .../src/flow-graph/blocks/math/trunc.ts | 21 + .../babylon-lite/src/flow-graph/fg-math.ts | 445 +++++++++++++++++- .../src/flow-graph/gltf/declaration-mapper.ts | 71 +++ tests/lite/unit/flow-graph-blocks.test.ts | 212 ++++++++- 76 files changed, 2535 insertions(+), 55 deletions(-) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-float.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-int.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-boolean.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-int.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-boolean.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-float.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/acos.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/acosh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/asin.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/asinh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/atan.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/atan2.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/atanh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-and.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-left-shift.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-not.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-or.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-right-shift.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/bitwise-xor.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/ceil.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine3.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine4.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/conditional.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/constant-e.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/constant-inf.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/constant-nan.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/constant-pi.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/cos.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/cosh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/cross.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/cube-root.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/data-switch.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/deg-to-rad.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/dot.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/equality.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/exponential.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract3.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract4.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/fraction.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/greater-than-or-equal.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/greater-than.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/is-infinity.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/is-nan.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/leading-zeros.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/length.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/less-than-or-equal.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/log.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/log10.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/log2.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/max.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/min.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/mix.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/negation.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/normalize.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/one-bits-counter.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/power.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/rad-to-deg.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/random.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/rotate2d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/rotate3d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/round.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/saturate.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/sign.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/sin.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/sinh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/square-root.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/tan.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/tanh.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/trailing-zeros.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/trunc.ts diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index 13dc30976a..e11b9a3adf 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -68,7 +68,7 @@ "scene5-gltf-color-normalize-BtnJk1yq.js", "scene5-gltf-feature-animations-CQrRowr9.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry-BEtNr2v7.js", + "scene5-gltf-feature-registry--nXe1DF5.js", "scene5-gltf-feature-skeleton-Siixi_P0.js", "scene5-gltf-json-asset-DS0i23k1.js", "scene5-morph-fragment-BhcJT1xs.js", @@ -107,7 +107,7 @@ "scene7-gltf-animation-B7Xr33me.js", "scene7-gltf-feature-animations-CG5FpT6C.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-BRfh3Hnn.js", + "scene7-gltf-feature-registry-CB2PmYGi.js", "scene7-gltf-feature-skeleton-BCWZyzWC.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", @@ -173,7 +173,7 @@ "scene11-gltf-ext-spec-gloss-D60sFZYX.js", "scene11-gltf-feature-animations-Bmg0PBR4.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-By6hZL1J.js", + "scene11-gltf-feature-registry-C7hwLHSw.js", "scene11-gltf-feature-skeleton-CrXfHDG6.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", @@ -192,7 +192,7 @@ "scene12-generate-mipmaps-Bsp4UQ3D.js", "scene12-gltf-animation-BDKbEYQd.js", "scene12-gltf-feature-animations-Bfc5iW7L.js", - "scene12-gltf-feature-registry-KecitxtL.js", + "scene12-gltf-feature-registry-B3m6qlCk.js", "scene12-gltf-feature-skeleton-CN1CorcX.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", @@ -435,7 +435,7 @@ "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-Du_PAvYL.js", + "scene27-gltf-feature-registry-BgpF1m7m.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", @@ -455,7 +455,7 @@ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry-CwSpGf6N.js", + "scene28-gltf-feature-registry-ZTlsFOBl.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", "scene28-pbr-renderable-BYSlPUr5.js", @@ -472,7 +472,7 @@ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-Cj1wtwRd.js", + "scene29-gltf-feature-registry-CHIA8ktl.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", @@ -496,7 +496,7 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-CkU0gBzv.js", + "scene30-gltf-feature-registry-BTz1SdJl.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", @@ -519,7 +519,7 @@ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-BQUTNjEI.js", + "scene31-gltf-feature-registry-DHWtFb0K.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", "scene31-pbr-renderable-Bg8O1LwN.js", @@ -535,7 +535,7 @@ "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-BSzsEdPh.js", + "scene32-gltf-feature-registry-DJXe2woQ.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", "scene32-pbr-renderable-CUtjMSAl.js", @@ -553,7 +553,7 @@ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-CDLrfb6C.js", + "scene33-gltf-feature-registry-xCrbrsGP.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", @@ -580,7 +580,7 @@ "scene34-gltf-ext-node-visibility-CyR_MQR5.js", "scene34-gltf-feature-animation-pointer-rAfd1hLG.js", "scene34-gltf-feature-animations-BQSrKgM_.js", - "scene34-gltf-feature-registry-C6wT_LXN.js", + "scene34-gltf-feature-registry-CRyMahIV.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", "scene34-pbr-renderable-BelxTmu1.js", @@ -597,7 +597,7 @@ "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", - "scene35-gltf-feature-registry-A2wPHQPW.js", + "scene35-gltf-feature-registry-CYDnesiH.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", "scene35-pbr-renderable-B_cgTnJN.js", @@ -629,7 +629,7 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-p7qXzJw4.js", + "scene37-gltf-feature-registry-BVOrVtrK.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", @@ -669,7 +669,7 @@ "scene39-gltf-feature-animation-pointer-BOWPlTMd.js", "scene39-gltf-feature-animations-BqoIrLnC.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-DOC3-wAQ.js", + "scene39-gltf-feature-registry-BQ_RvOvp.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -698,7 +698,7 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-qkIIJtPq.js", + "scene99-gltf-feature-registry-BPEPrqN6.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", @@ -725,7 +725,7 @@ "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-NfOBA8tz.js", + "scene41-gltf-feature-registry-DtnAz1y3.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -794,7 +794,7 @@ "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-Bgg2beBQ.js", + "scene47-gltf-feature-registry-PYkTux97.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1223,7 +1223,7 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-grbIvkoI.js", + "scene73-gltf-feature-registry-nEutQpi_.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", @@ -1743,7 +1743,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-D5CQh1T2.js", + "scene104-gltf-feature-registry-B5rSINEH.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1758,7 +1758,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-B3PDweu7.js", + "scene105-gltf-feature-registry-Bsidhh9s.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1831,7 +1831,7 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-BMiQBC3G.js", + "scene112-gltf-feature-registry-hw2KrODl.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", "scene112-pbr-refraction-DZYuYfJR.js", @@ -1880,7 +1880,7 @@ "scene115-gltf-color-normalize-BtnJk1yq.js", "scene115-gltf-feature-animations-eusiMJnc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-CE6UfrSg.js", + "scene115-gltf-feature-registry-CL3PlpTx.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", @@ -2111,7 +2111,7 @@ "scene144-gltf-ext-spec-gloss-D60sFZYX.js", "scene144-gltf-feature-animations-DOSVTx1Z.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-CRgM-ljP.js", + "scene144-gltf-feature-registry-dnInYLDI.js", "scene144-gltf-feature-skeleton-Dq3GN8sP.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", @@ -2182,7 +2182,7 @@ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-DwKnZUdV.js", + "scene147-gltf-feature-registry-vuAjDSxD.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2201,7 +2201,7 @@ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-DR36s7II.js", + "scene148-gltf-feature-registry-hZMMcMJn.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2223,7 +2223,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry--vvDdr6j.js", + "scene149-gltf-feature-registry-CVYLM4Lj.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2268,7 +2268,7 @@ "scene152-gltf-ext-spec-gloss-D60sFZYX.js", "scene152-gltf-feature-animations-z0zN7iq2.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-_RVNeJFh.js", + "scene152-gltf-feature-registry-Dwi5plrR.js", "scene152-gltf-feature-skeleton-DdNk7nTu.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", @@ -2325,7 +2325,7 @@ "scene157-generate-mipmaps-CSgsFZsy.js", "scene157-gltf-animation-97jnT3rB.js", "scene157-gltf-feature-animations-C4GEf0C-.js", - "scene157-gltf-feature-registry-CJbcMlHm.js", + "scene157-gltf-feature-registry-BbddfnfE.js", "scene157-gltf-feature-skeleton-sqEIM232.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", "scene157-multilight-wgsl-DMQZ6dS_.js", @@ -2343,7 +2343,7 @@ "scene158-generate-mipmaps-ONVnFwM1.js", "scene158-gltf-animation-D36FWf_9.js", "scene158-gltf-feature-animations-_BY8aVDC.js", - "scene158-gltf-feature-registry-oTYrL4Un.js", + "scene158-gltf-feature-registry-DkceuqWi.js", "scene158-gltf-feature-skeleton-BQO9mRtS.js", "scene158-gltf-glb-parser-BhqojsL9.js", "scene158-multilight-wgsl-DhVJV_xa.js", @@ -2409,7 +2409,7 @@ "scene164-gltf-color-normalize-BtnJk1yq.js", "scene164-gltf-feature-animations-CkuodxMl.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-Cu0jdI_y.js", + "scene164-gltf-feature-registry-D8b0tlwu.js", "scene164-gltf-feature-skeleton-DOpy65Ao.js", "scene164-gltf-json-asset-BCxbuHbB.js", "scene164-morph-fragment-29qCql2q.js", @@ -2449,7 +2449,7 @@ "runtimeChunks": [ "scene171-generate-mipmaps-DXPozdXM.js", "scene171-gltf-glb-parser-COBAbifQ.js", - "scene171-pbr-renderable-N1i0xSLG.js", + "scene171-pbr-renderable-Y_ydn5yE.js", "scene171-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene171-shader-composer-CgJmQyJj.js", "scene171-singlelight-hemispheric-wgsl-CeuKqi92.js", @@ -2487,7 +2487,7 @@ "runtimeChunks": [ "scene174-generate-mipmaps-oyz7Zcb3.js", "scene174-gltf-glb-parser-V10AO6Mf.js", - "scene174-pbr-renderable-khVBcoiw.js", + "scene174-pbr-renderable-B8C0TAcA.js", "scene174-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene174-shader-composer-CgJmQyJj.js", "scene174-singlelight-hemispheric-wgsl-STW_78f5.js", @@ -2503,7 +2503,7 @@ "runtimeChunks": [ "scene175-generate-mipmaps-B-d91NI_.js", "scene175-gltf-glb-parser-BmlEZ507.js", - "scene175-pbr-renderable-_CMUP1sf.js", + "scene175-pbr-renderable-BLomY6Qz.js", "scene175-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene175-shader-composer-CgJmQyJj.js", "scene175-singlelight-hemispheric-wgsl-D-nS_1oq.js", @@ -2520,7 +2520,7 @@ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-CbrMvlqa.js", + "scene176-gltf-feature-registry-D8npAK5m.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2554,7 +2554,7 @@ "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-CcbumFad.js", + "scene178-gltf-feature-registry-DlG94CAQ.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2726,7 +2726,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-GNnVvRcM.js", + "scene210-gltf-feature-registry-B8xs8jyW.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", @@ -2747,7 +2747,7 @@ "scene211-gltf-ext-quantization-Do-ofjB-.js", "scene211-gltf-feature-animations-C0rPaLwN.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-vbpGogWS.js", + "scene211-gltf-feature-registry-CGBWVHjZ.js", "scene211-gltf-feature-skeleton-C5YXdC68.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", @@ -2764,7 +2764,7 @@ "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-QC-CezfU.js", + "scene212-gltf-feature-registry-C2eFgAy6.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2851,7 +2851,7 @@ "scene218-gltf-ext-spec-gloss-D60sFZYX.js", "scene218-gltf-feature-animations-Xir-5MtM.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-ChazQVDx.js", + "scene218-gltf-feature-registry-z1m5ttRm.js", "scene218-gltf-feature-skeleton-CuQWo93o.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", @@ -2871,7 +2871,7 @@ "scene219-gltf-ext-spec-gloss-D60sFZYX.js", "scene219-gltf-feature-animations-Cr5Rjgc6.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-D6HyVJkQ.js", + "scene219-gltf-feature-registry-33kxOhgb.js", "scene219-gltf-feature-skeleton-QiTS1ubb.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", @@ -2984,7 +2984,7 @@ "scene240-generate-mipmaps-BQZ9ivTX.js", "scene240-gltf-animation-BKjmZpR3.js", "scene240-gltf-feature-animations-Deh9CXYc.js", - "scene240-gltf-feature-registry-D4HslOs2.js", + "scene240-gltf-feature-registry-BvKGUGT8.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", @@ -3019,7 +3019,7 @@ "scene241-gltf-feature-animation-pointer-CepPGaOM.js", "scene241-gltf-feature-animations-CSjZ3yRx.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-5ljxta2x.js", + "scene241-gltf-feature-registry-DOTWrkKX.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3057,7 +3057,7 @@ "scene242-gltf-ext-emissive-strength-CButLZnK.js", "scene242-gltf-feature-animation-pointer-DuUn5-xJ.js", "scene242-gltf-feature-animations-B_VnRwPM.js", - "scene242-gltf-feature-registry-BdPdqiFU.js", + "scene242-gltf-feature-registry-CiUAlMx2.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", "scene242-pbr-renderable-DQEk4f7o.js", @@ -3078,7 +3078,7 @@ "scene243-gltf-feature-animations-DEeCXW1Z.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-qa72KuNd.js", + "scene243-gltf-feature-registry-CWLdf1b8.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", @@ -3106,7 +3106,7 @@ "scene244-gltf-ext-uv-transform-YGWG8v_J.js", "scene244-gltf-feature-animation-pointer-Cv2YzJgj.js", "scene244-gltf-feature-animations-CTlvB6vN.js", - "scene244-gltf-feature-registry-DCOjiWUE.js", + "scene244-gltf-feature-registry-BXNc8oEO.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", @@ -3133,7 +3133,7 @@ "scene245-generate-mipmaps-WM6bVf2v.js", "scene245-gltf-animation-Dvm46y_g.js", "scene245-gltf-feature-animations-BV66HV-9.js", - "scene245-gltf-feature-registry-BaUUkpZL.js", + "scene245-gltf-feature-registry-BgWXssIv.js", "scene245-gltf-feature-skeleton-IRWJQHYY.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", @@ -3158,7 +3158,7 @@ "scene246-generate-mipmaps-DzKvtUax.js", "scene246-gltf-animation-DGsaicDt.js", "scene246-gltf-feature-animations-DimU6cfM.js", - "scene246-gltf-feature-registry-CcRjPF6A.js", + "scene246-gltf-feature-registry-DsY2cQH8.js", "scene246-gltf-feature-skeleton-Bf1KbRoN.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", @@ -3181,7 +3181,7 @@ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", - "scene247-gltf-feature-registry-doudKWoN.js", + "scene247-gltf-feature-registry-DcRcf-aT.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", @@ -3234,7 +3234,7 @@ "scene251-generate-mipmaps-ojYQxP8q.js", "scene251-gltf-animation-BJ2pOO_r.js", "scene251-gltf-feature-animations-Do8ooupS.js", - "scene251-gltf-feature-registry-CXmopchE.js", + "scene251-gltf-feature-registry-Dc_R0Y-b.js", "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", "scene251-gltf-glb-parser-8AD91ACR.js", "scene251-multilight-wgsl-Cxg2lDtv.js", @@ -3281,7 +3281,7 @@ "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-53j4iw67.js", + "scene253-gltf-feature-registry-B09JNhRe.js", "scene253-gltf-feature-skeleton-Bjigd6Ok.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js", diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index d988cdfb19..98ca52c4ac 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -56,6 +56,148 @@ export function getBlockDef(type: string): (() => Promise) | null { case FgBlockType.ExtractVector2: return async () => (await import("./blocks/math/extract2.js")).extract2Def; + // ─── Math: Phase 3 (scalar / trig / compare / bitwise / vector) ── + case FgBlockType.Negation: + return async () => (await import("./blocks/math/negation.js")).negationDef; + case FgBlockType.Sign: + return async () => (await import("./blocks/math/sign.js")).signDef; + case FgBlockType.Ceil: + return async () => (await import("./blocks/math/ceil.js")).ceilDef; + case FgBlockType.Round: + return async () => (await import("./blocks/math/round.js")).roundDef; + case FgBlockType.Trunc: + return async () => (await import("./blocks/math/trunc.js")).truncDef; + case FgBlockType.Fraction: + return async () => (await import("./blocks/math/fraction.js")).fractionDef; + case FgBlockType.Saturate: + return async () => (await import("./blocks/math/saturate.js")).saturateDef; + case FgBlockType.SquareRoot: + return async () => (await import("./blocks/math/square-root.js")).squareRootDef; + case FgBlockType.CubeRoot: + return async () => (await import("./blocks/math/cube-root.js")).cubeRootDef; + case FgBlockType.Exponential: + return async () => (await import("./blocks/math/exponential.js")).exponentialDef; + case FgBlockType.Log: + return async () => (await import("./blocks/math/log.js")).logDef; + case FgBlockType.Log2: + return async () => (await import("./blocks/math/log2.js")).log2Def; + case FgBlockType.Log10: + return async () => (await import("./blocks/math/log10.js")).log10Def; + case FgBlockType.DegToRad: + return async () => (await import("./blocks/math/deg-to-rad.js")).degToRadDef; + case FgBlockType.RadToDeg: + return async () => (await import("./blocks/math/rad-to-deg.js")).radToDegDef; + case FgBlockType.Sin: + return async () => (await import("./blocks/math/sin.js")).sinDef; + case FgBlockType.Cos: + return async () => (await import("./blocks/math/cos.js")).cosDef; + case FgBlockType.Tan: + return async () => (await import("./blocks/math/tan.js")).tanDef; + case FgBlockType.Asin: + return async () => (await import("./blocks/math/asin.js")).asinDef; + case FgBlockType.Acos: + return async () => (await import("./blocks/math/acos.js")).acosDef; + case FgBlockType.Atan: + return async () => (await import("./blocks/math/atan.js")).atanDef; + case FgBlockType.Sinh: + return async () => (await import("./blocks/math/sinh.js")).sinhDef; + case FgBlockType.Cosh: + return async () => (await import("./blocks/math/cosh.js")).coshDef; + case FgBlockType.Tanh: + return async () => (await import("./blocks/math/tanh.js")).tanhDef; + case FgBlockType.Asinh: + return async () => (await import("./blocks/math/asinh.js")).asinhDef; + case FgBlockType.Acosh: + return async () => (await import("./blocks/math/acosh.js")).acoshDef; + case FgBlockType.Atanh: + return async () => (await import("./blocks/math/atanh.js")).atanhDef; + case FgBlockType.Min: + return async () => (await import("./blocks/math/min.js")).minDef; + case FgBlockType.Max: + return async () => (await import("./blocks/math/max.js")).maxDef; + case FgBlockType.Power: + return async () => (await import("./blocks/math/power.js")).powerDef; + case FgBlockType.Atan2: + return async () => (await import("./blocks/math/atan2.js")).atan2Def; + case FgBlockType.Equality: + return async () => (await import("./blocks/math/equality.js")).equalityDef; + case FgBlockType.LessThanOrEqual: + return async () => (await import("./blocks/math/less-than-or-equal.js")).lessThanOrEqualDef; + case FgBlockType.GreaterThan: + return async () => (await import("./blocks/math/greater-than.js")).greaterThanDef; + case FgBlockType.GreaterThanOrEqual: + return async () => (await import("./blocks/math/greater-than-or-equal.js")).greaterThanOrEqualDef; + case FgBlockType.IsNaN: + return async () => (await import("./blocks/math/is-nan.js")).isNaNDef; + case FgBlockType.IsInfinity: + return async () => (await import("./blocks/math/is-infinity.js")).isInfinityDef; + case FgBlockType.BitwiseAnd: + return async () => (await import("./blocks/math/bitwise-and.js")).bitwiseAndDef; + case FgBlockType.BitwiseOr: + return async () => (await import("./blocks/math/bitwise-or.js")).bitwiseOrDef; + case FgBlockType.BitwiseXor: + return async () => (await import("./blocks/math/bitwise-xor.js")).bitwiseXorDef; + case FgBlockType.BitwiseNot: + return async () => (await import("./blocks/math/bitwise-not.js")).bitwiseNotDef; + case FgBlockType.BitwiseLeftShift: + return async () => (await import("./blocks/math/bitwise-left-shift.js")).bitwiseLeftShiftDef; + case FgBlockType.BitwiseRightShift: + return async () => (await import("./blocks/math/bitwise-right-shift.js")).bitwiseRightShiftDef; + case FgBlockType.LeadingZeros: + return async () => (await import("./blocks/math/leading-zeros.js")).leadingZerosDef; + case FgBlockType.TrailingZeros: + return async () => (await import("./blocks/math/trailing-zeros.js")).trailingZerosDef; + case FgBlockType.OneBitsCounter: + return async () => (await import("./blocks/math/one-bits-counter.js")).oneBitsCounterDef; + case FgBlockType.Length: + return async () => (await import("./blocks/math/length.js")).lengthDef; + case FgBlockType.Normalize: + return async () => (await import("./blocks/math/normalize.js")).normalizeDef; + case FgBlockType.Dot: + return async () => (await import("./blocks/math/dot.js")).dotDef; + case FgBlockType.Cross: + return async () => (await import("./blocks/math/cross.js")).crossDef; + case FgBlockType.Rotate2D: + return async () => (await import("./blocks/math/rotate2d.js")).rotate2DDef; + case FgBlockType.Rotate3D: + return async () => (await import("./blocks/math/rotate3d.js")).rotate3DDef; + case FgBlockType.MathInterpolation: + return async () => (await import("./blocks/math/mix.js")).mathInterpolationDef; + case FgBlockType.CombineVector3: + return async () => (await import("./blocks/math/combine3.js")).combine3Def; + case FgBlockType.CombineVector4: + return async () => (await import("./blocks/math/combine4.js")).combine4Def; + case FgBlockType.ExtractVector3: + return async () => (await import("./blocks/math/extract3.js")).extract3Def; + case FgBlockType.ExtractVector4: + return async () => (await import("./blocks/math/extract4.js")).extract4Def; + case FgBlockType.E: + return async () => (await import("./blocks/math/constant-e.js")).eDef; + case FgBlockType.PI: + return async () => (await import("./blocks/math/constant-pi.js")).piDef; + case FgBlockType.Inf: + return async () => (await import("./blocks/math/constant-inf.js")).infDef; + case FgBlockType.NaN: + return async () => (await import("./blocks/math/constant-nan.js")).nanDef; + case FgBlockType.Random: + return async () => (await import("./blocks/math/random.js")).randomDef; + case FgBlockType.Conditional: + return async () => (await import("./blocks/math/conditional.js")).conditionalDef; + case FgBlockType.DataSwitch: + return async () => (await import("./blocks/math/data-switch.js")).dataSwitchDef; + case FgBlockType.BooleanToFloat: + return async () => (await import("./blocks/conversion/boolean-to-float.js")).booleanToFloatDef; + case FgBlockType.BooleanToInt: + return async () => (await import("./blocks/conversion/boolean-to-int.js")).booleanToIntDef; + case FgBlockType.FloatToBoolean: + return async () => (await import("./blocks/conversion/float-to-boolean.js")).floatToBooleanDef; + case FgBlockType.IntToBoolean: + return async () => (await import("./blocks/conversion/int-to-boolean.js")).intToBooleanDef; + case FgBlockType.IntToFloat: + return async () => (await import("./blocks/conversion/int-to-float.js")).intToFloatDef; + case FgBlockType.FloatToInt: + return async () => (await import("./blocks/conversion/float-to-int.js")).floatToIntDef; + // ─── Data: property / variable ──────────────────────────── case FgBlockType.GetProperty: return async () => (await import("./blocks/data/get-property.js")).getPropertyDef; diff --git a/packages/babylon-lite/src/flow-graph/block-type.ts b/packages/babylon-lite/src/flow-graph/block-type.ts index 6b4213683c..2dd64f98c1 100644 --- a/packages/babylon-lite/src/flow-graph/block-type.ts +++ b/packages/babylon-lite/src/flow-graph/block-type.ts @@ -25,19 +25,131 @@ export const enum FgBlockType { SetDelay = "SetDelay", CancelDelay = "CancelDelay", - // ─── Data / math (subset; broadened in Phase 3) ─────────── + // ─── Data / math: arithmetic ────────────────────────────── Constant = "Constant", Add = "Add", Subtract = "Subtract", Multiply = "Multiply", Divide = "Divide", Modulo = "Modulo", + Min = "Min", + Max = "Max", + Power = "Power", + Negation = "Negation", + + // ─── Data / math: rounding + sign ───────────────────────── Abs = "Abs", + Sign = "Sign", Floor = "Floor", - LessThan = "LessThan", + Ceil = "Ceil", + Round = "Round", + Trunc = "Trunc", + Fraction = "Fraction", + Saturate = "Saturate", Clamp = "Clamp", + + // ─── Data / math: exp / log / roots ─────────────────────── + Exponential = "Exponential", + Log = "Log", + Log2 = "Log2", + Log10 = "Log10", + SquareRoot = "SquareRoot", + CubeRoot = "CubeRoot", + + // ─── Data / math: trig + angles ─────────────────────────── + DegToRad = "DegToRad", + RadToDeg = "RadToDeg", + Sin = "Sin", + Cos = "Cos", + Tan = "Tan", + Asin = "Asin", + Acos = "Acos", + Atan = "Atan", + Atan2 = "Atan2", + Sinh = "Sinh", + Cosh = "Cosh", + Tanh = "Tanh", + Asinh = "Asinh", + Acosh = "Acosh", + Atanh = "Atanh", + + // ─── Data / math: comparison ────────────────────────────── + Equality = "Equality", + LessThan = "LessThan", + LessThanOrEqual = "LessThanOrEqual", + GreaterThan = "GreaterThan", + GreaterThanOrEqual = "GreaterThanOrEqual", + IsNaN = "IsNaN", + IsInfinity = "IsInfinity", + + // ─── Data / math: constants ─────────────────────────────── + E = "E", + PI = "PI", + Inf = "Inf", + NaN = "NaN", + Random = "Random", + + // ─── Data / math: selection ─────────────────────────────── + Conditional = "Conditional", + DataSwitch = "DataSwitch", + + // ─── Data / math: integer bitwise ───────────────────────── + BitwiseAnd = "BitwiseAnd", + BitwiseOr = "BitwiseOr", + BitwiseXor = "BitwiseXor", + BitwiseNot = "BitwiseNot", + BitwiseLeftShift = "BitwiseLeftShift", + BitwiseRightShift = "BitwiseRightShift", + LeadingZeros = "LeadingZeros", + TrailingZeros = "TrailingZeros", + OneBitsCounter = "OneBitsCounter", + + // ─── Data / math: vector ops ────────────────────────────── + Length = "Length", + Normalize = "Normalize", + Dot = "Dot", + Cross = "Cross", + MathInterpolation = "MathInterpolation", + Rotate2D = "Rotate2D", + Rotate3D = "Rotate3D", + TransformVector = "TransformVector", + + // ─── Data / math: combine / extract ─────────────────────── CombineVector2 = "CombineVector2", + CombineVector3 = "CombineVector3", + CombineVector4 = "CombineVector4", + CombineMatrix2D = "CombineMatrix2D", + CombineMatrix3D = "CombineMatrix3D", + CombineMatrix = "CombineMatrix", ExtractVector2 = "ExtractVector2", + ExtractVector3 = "ExtractVector3", + ExtractVector4 = "ExtractVector4", + ExtractMatrix2D = "ExtractMatrix2D", + ExtractMatrix3D = "ExtractMatrix3D", + ExtractMatrix = "ExtractMatrix", + + // ─── Data / math: matrix ────────────────────────────────── + Transpose = "Transpose", + Determinant = "Determinant", + InvertMatrix = "InvertMatrix", + MatrixMultiplication = "MatrixMultiplication", + MatrixCompose = "MatrixCompose", + MatrixDecompose = "MatrixDecompose", + + // ─── Data / math: quaternion ────────────────────────────── + Conjugate = "Conjugate", + AngleBetween = "AngleBetween", + QuaternionFromAxisAngle = "QuaternionFromAxisAngle", + AxisAngleFromQuaternion = "AxisAngleFromQuaternion", + QuaternionFromDirections = "QuaternionFromDirections", + + // ─── Data / type conversion ─────────────────────────────── + BooleanToFloat = "BooleanToFloat", + BooleanToInt = "BooleanToInt", + FloatToBoolean = "FloatToBoolean", + IntToBoolean = "IntToBoolean", + IntToFloat = "IntToFloat", + FloatToInt = "FloatToInt", // ─── Pointer / variable / animation ─────────────────────── GetProperty = "GetProperty", diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-float.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-float.ts new file mode 100644 index 0000000000..a57a16b24a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-float.ts @@ -0,0 +1,19 @@ +// BooleanToFloat (BJS FlowGraphBooleanToFloat, glTF op `type/boolToFloat`). +// Data block (PULL): boolean -> number (true->1, false->0). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; + +export const booleanToFloatDef: FgBlockDef = { + type: FgBlockType.BooleanToFloat, + build: () => ({ + dataIn: [sockIn("a", FgType.Boolean, false)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + setDataValue(ctx, block, "value", getDataValue(ctx, env, block, "a") ? 1 : 0); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-int.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-int.ts new file mode 100644 index 0000000000..ad508eb4c8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/boolean-to-int.ts @@ -0,0 +1,20 @@ +// BooleanToInt (BJS FlowGraphBooleanToInt, glTF op `type/boolToInt`). +// Data block (PULL): boolean -> FlowGraphInteger (true->1, false->0). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; + +export const booleanToIntDef: FgBlockDef = { + type: FgBlockType.BooleanToInt, + build: () => ({ + dataIn: [sockIn("a", FgType.Boolean, false)], + dataOut: [sockOut("value", FgType.Integer)], + }), + updateOutputs(block, ctx, env) { + setDataValue(ctx, block, "value", fgInt(getDataValue(ctx, env, block, "a") ? 1 : 0)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-boolean.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-boolean.ts new file mode 100644 index 0000000000..482a159377 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-boolean.ts @@ -0,0 +1,19 @@ +// FloatToBoolean (BJS FlowGraphFloatToBoolean, glTF op `type/floatToBool`). +// Data block (PULL): number -> boolean (0 and NaN -> false, else true). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; + +export const floatToBooleanDef: FgBlockDef = { + type: FgBlockType.FloatToBoolean, + build: () => ({ + dataIn: [sockIn("a", FgType.Number, 0)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + setDataValue(ctx, block, "value", !!(getDataValue(ctx, env, block, "a") as number)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-int.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-int.ts new file mode 100644 index 0000000000..f532d11f95 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/float-to-int.ts @@ -0,0 +1,24 @@ +// FloatToInt (BJS FlowGraphFloatToInt, glTF op `type/floatToInt`). +// Data block (PULL): number -> FlowGraphInteger. `config.roundingMode` selects +// floor/ceil/round; default truncates toward zero (BJS `value | 0`). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; + +export const floatToIntDef: FgBlockDef = { + type: FgBlockType.FloatToInt, + build: () => ({ + dataIn: [sockIn("a", FgType.Number, 0)], + dataOut: [sockOut("value", FgType.Integer)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a") as number; + const mode = block.config?.roundingMode as string | undefined; + const r = mode === "floor" ? Math.floor(a) : mode === "ceil" ? Math.ceil(a) : mode === "round" ? Math.round(a) : Math.trunc(a); + setDataValue(ctx, block, "value", fgInt(r)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-boolean.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-boolean.ts new file mode 100644 index 0000000000..00b200e3ef --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-boolean.ts @@ -0,0 +1,21 @@ +// IntToBoolean (BJS FlowGraphIntToBoolean, glTF op `type/intToBool`). +// Data block (PULL): FlowGraphInteger -> boolean (0 -> false, else true). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { isFgInt } from "../../custom-types/fg-integer.js"; + +export const intToBooleanDef: FgBlockDef = { + type: FgBlockType.IntToBoolean, + build: () => ({ + dataIn: [sockIn("a", FgType.Integer)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", isFgInt(a) ? a.value !== 0 : !!a); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-float.ts b/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-float.ts new file mode 100644 index 0000000000..bcb5e8831f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/conversion/int-to-float.ts @@ -0,0 +1,21 @@ +// IntToFloat (BJS FlowGraphIntToFloat, glTF op `type/intToFloat`). +// Data block (PULL): FlowGraphInteger -> number (direct payload). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { isFgInt } from "../../custom-types/fg-integer.js"; + +export const intToFloatDef: FgBlockDef = { + type: FgBlockType.IntToFloat, + build: () => ({ + dataIn: [sockIn("a", FgType.Integer)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", isFgInt(a) ? a.value : (a as number)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/acos.ts b/packages/babylon-lite/src/flow-graph/blocks/math/acos.ts new file mode 100644 index 0000000000..2f20076f6c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/acos.ts @@ -0,0 +1,21 @@ +// Acos (BJS FlowGraphAcosBlock, glTF op `math/acos`). +// Data block (PULL): emits `value` via fg-math's `fgAcos`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAcos } from "../../fg-math.js"; + +export const acosDef: FgBlockDef = { + type: FgBlockType.Acos, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAcos(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/acosh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/acosh.ts new file mode 100644 index 0000000000..7173a6515e --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/acosh.ts @@ -0,0 +1,21 @@ +// Acosh (BJS FlowGraphAcoshBlock, glTF op `math/acosh`). +// Data block (PULL): emits `value` via fg-math's `fgAcosh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAcosh } from "../../fg-math.js"; + +export const acoshDef: FgBlockDef = { + type: FgBlockType.Acosh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAcosh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/asin.ts b/packages/babylon-lite/src/flow-graph/blocks/math/asin.ts new file mode 100644 index 0000000000..157979dc0d --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/asin.ts @@ -0,0 +1,21 @@ +// Asin (BJS FlowGraphAsinBlock, glTF op `math/asin`). +// Data block (PULL): emits `value` via fg-math's `fgAsin`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAsin } from "../../fg-math.js"; + +export const asinDef: FgBlockDef = { + type: FgBlockType.Asin, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAsin(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/asinh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/asinh.ts new file mode 100644 index 0000000000..bf59198ad7 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/asinh.ts @@ -0,0 +1,21 @@ +// Asinh (BJS FlowGraphAsinhBlock, glTF op `math/asinh`). +// Data block (PULL): emits `value` via fg-math's `fgAsinh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAsinh } from "../../fg-math.js"; + +export const asinhDef: FgBlockDef = { + type: FgBlockType.Asinh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAsinh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/atan.ts b/packages/babylon-lite/src/flow-graph/blocks/math/atan.ts new file mode 100644 index 0000000000..0a64f9e07c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/atan.ts @@ -0,0 +1,21 @@ +// Atan (BJS FlowGraphAtanBlock, glTF op `math/atan`). +// Data block (PULL): emits `value` via fg-math's `fgAtan`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAtan } from "../../fg-math.js"; + +export const atanDef: FgBlockDef = { + type: FgBlockType.Atan, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAtan(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/atan2.ts b/packages/babylon-lite/src/flow-graph/blocks/math/atan2.ts new file mode 100644 index 0000000000..15692b8294 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/atan2.ts @@ -0,0 +1,22 @@ +// Atan2 (BJS FlowGraphATan2Block, glTF op `math/atan2`). +// Data block (PULL): emits `value` via fg-math's `fgAtan2`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAtan2 } from "../../fg-math.js"; + +export const atan2Def: FgBlockDef = { + type: FgBlockType.Atan2, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAtan2(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/atanh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/atanh.ts new file mode 100644 index 0000000000..cc978593bd --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/atanh.ts @@ -0,0 +1,21 @@ +// Atanh (BJS FlowGraphAtanhBlock, glTF op `math/atanh`). +// Data block (PULL): emits `value` via fg-math's `fgAtanh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAtanh } from "../../fg-math.js"; + +export const atanhDef: FgBlockDef = { + type: FgBlockType.Atanh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgAtanh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-and.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-and.ts new file mode 100644 index 0000000000..ca83870784 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-and.ts @@ -0,0 +1,22 @@ +// BitwiseAnd (BJS FlowGraphBitwiseAndBlock, glTF op `math/and`). +// Data block (PULL): emits `value` via fg-math's `fgAnd`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAnd } from "../../fg-math.js"; + +export const bitwiseAndDef: FgBlockDef = { + type: FgBlockType.BitwiseAnd, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAnd(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-left-shift.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-left-shift.ts new file mode 100644 index 0000000000..7e2c88fcc6 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-left-shift.ts @@ -0,0 +1,22 @@ +// BitwiseLeftShift (BJS FlowGraphBitwiseLeftShiftBlock, glTF op `math/lsl`). +// Data block (PULL): emits `value` via fg-math's `fgLsl`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLsl } from "../../fg-math.js"; + +export const bitwiseLeftShiftDef: FgBlockDef = { + type: FgBlockType.BitwiseLeftShift, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgLsl(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-not.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-not.ts new file mode 100644 index 0000000000..92ec4c14c8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-not.ts @@ -0,0 +1,21 @@ +// BitwiseNot (BJS FlowGraphBitwiseNotBlock, glTF op `math/not`). +// Data block (PULL): emits `value` via fg-math's `fgNot`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgNot } from "../../fg-math.js"; + +export const bitwiseNotDef: FgBlockDef = { + type: FgBlockType.BitwiseNot, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgNot(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-or.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-or.ts new file mode 100644 index 0000000000..3e25eab419 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-or.ts @@ -0,0 +1,22 @@ +// BitwiseOr (BJS FlowGraphBitwiseOrBlock, glTF op `math/or`). +// Data block (PULL): emits `value` via fg-math's `fgOr`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgOr } from "../../fg-math.js"; + +export const bitwiseOrDef: FgBlockDef = { + type: FgBlockType.BitwiseOr, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgOr(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-right-shift.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-right-shift.ts new file mode 100644 index 0000000000..17008c2223 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-right-shift.ts @@ -0,0 +1,22 @@ +// BitwiseRightShift (BJS FlowGraphBitwiseRightShiftBlock, glTF op `math/asr`). +// Data block (PULL): emits `value` via fg-math's `fgAsr`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAsr } from "../../fg-math.js"; + +export const bitwiseRightShiftDef: FgBlockDef = { + type: FgBlockType.BitwiseRightShift, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAsr(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-xor.ts b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-xor.ts new file mode 100644 index 0000000000..a4a91edf0e --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/bitwise-xor.ts @@ -0,0 +1,22 @@ +// BitwiseXor (BJS FlowGraphBitwiseXorBlock, glTF op `math/xor`). +// Data block (PULL): emits `value` via fg-math's `fgXor`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgXor } from "../../fg-math.js"; + +export const bitwiseXorDef: FgBlockDef = { + type: FgBlockType.BitwiseXor, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgXor(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/ceil.ts b/packages/babylon-lite/src/flow-graph/blocks/math/ceil.ts new file mode 100644 index 0000000000..ab7a4725b0 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/ceil.ts @@ -0,0 +1,21 @@ +// Ceil (BJS FlowGraphCeilBlock, glTF op `math/ceil`). +// Data block (PULL): emits `value` via fg-math's `fgCeil`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCeil } from "../../fg-math.js"; + +export const ceilDef: FgBlockDef = { + type: FgBlockType.Ceil, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgCeil(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine3.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine3.ts new file mode 100644 index 0000000000..a198a10bcd --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine3.ts @@ -0,0 +1,23 @@ +// CombineVector3 (BJS FlowGraphCombineVector3Block, glTF op `math/combine3`). +// Data block (PULL): emits Vec3{a,b,c} from three scalars via fg-math. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombine3 } from "../../fg-math.js"; + +export const combine3Def: FgBlockDef = { + type: FgBlockType.CombineVector3, + build: () => ({ + dataIn: [sockIn("a", FgType.Number), sockIn("b", FgType.Number), sockIn("c", FgType.Number)], + dataOut: [sockOut("value", FgType.Vector3)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + const c = getDataValue(ctx, env, block, "c"); + setDataValue(ctx, block, "value", fgCombine3(a, b, c)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine4.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine4.ts new file mode 100644 index 0000000000..67f12535fc --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine4.ts @@ -0,0 +1,24 @@ +// CombineVector4 (BJS FlowGraphCombineVector4Block, glTF op `math/combine4`). +// Data block (PULL): emits Vec4{a,b,c,d} from four scalars via fg-math. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombine4 } from "../../fg-math.js"; + +export const combine4Def: FgBlockDef = { + type: FgBlockType.CombineVector4, + build: () => ({ + dataIn: [sockIn("a", FgType.Number), sockIn("b", FgType.Number), sockIn("c", FgType.Number), sockIn("d", FgType.Number)], + dataOut: [sockOut("value", FgType.Vector4)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + const c = getDataValue(ctx, env, block, "c"); + const d = getDataValue(ctx, env, block, "d"); + setDataValue(ctx, block, "value", fgCombine4(a, b, c, d)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/conditional.ts b/packages/babylon-lite/src/flow-graph/blocks/math/conditional.ts new file mode 100644 index 0000000000..e26c5bf3ad --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/conditional.ts @@ -0,0 +1,22 @@ +// Conditional / select (BJS FlowGraphConditionalBlock, glTF op `math/select`). +// Data block (PULL): emits `onTrue` when `condition` is truthy, else `onFalse`. +// glTF inputs a/b map to onTrue/onFalse (see declaration-mapper). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; + +export const conditionalDef: FgBlockDef = { + type: FgBlockType.Conditional, + build: () => ({ + dataIn: [sockIn("condition", FgType.Boolean, false), sockIn("onTrue", FgType.Any), sockIn("onFalse", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const condition = getDataValue(ctx, env, block, "condition"); + const chosen = condition ? getDataValue(ctx, env, block, "onTrue") : getDataValue(ctx, env, block, "onFalse"); + setDataValue(ctx, block, "value", chosen); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/constant-e.ts b/packages/babylon-lite/src/flow-graph/blocks/math/constant-e.ts new file mode 100644 index 0000000000..e89ade2fa0 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/constant-e.ts @@ -0,0 +1,18 @@ +// E constant (BJS FlowGraphEBlock, glTF op `math/E`). +// Data block (PULL): emits the constant `value`; no inputs. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const eDef: FgBlockDef = { + type: FgBlockType.E, + build: () => ({ + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "value", Math.E); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/constant-inf.ts b/packages/babylon-lite/src/flow-graph/blocks/math/constant-inf.ts new file mode 100644 index 0000000000..583d22f517 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/constant-inf.ts @@ -0,0 +1,18 @@ +// Inf constant (BJS FlowGraphInfBlock, glTF op `math/Inf`). +// Data block (PULL): emits the constant `value`; no inputs. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const infDef: FgBlockDef = { + type: FgBlockType.Inf, + build: () => ({ + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "value", Number.POSITIVE_INFINITY); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/constant-nan.ts b/packages/babylon-lite/src/flow-graph/blocks/math/constant-nan.ts new file mode 100644 index 0000000000..a41631b7cd --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/constant-nan.ts @@ -0,0 +1,18 @@ +// NaN constant (BJS FlowGraphNaNBlock, glTF op `math/NaN`). +// Data block (PULL): emits the constant `value`; no inputs. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const nanDef: FgBlockDef = { + type: FgBlockType.NaN, + build: () => ({ + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "value", Number.NaN); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/constant-pi.ts b/packages/babylon-lite/src/flow-graph/blocks/math/constant-pi.ts new file mode 100644 index 0000000000..8088aedac5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/constant-pi.ts @@ -0,0 +1,18 @@ +// PI constant (BJS FlowGraphPIBlock, glTF op `math/Pi`). +// Data block (PULL): emits the constant `value`; no inputs. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const piDef: FgBlockDef = { + type: FgBlockType.PI, + build: () => ({ + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "value", Math.PI); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/cos.ts b/packages/babylon-lite/src/flow-graph/blocks/math/cos.ts new file mode 100644 index 0000000000..5d66d65176 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/cos.ts @@ -0,0 +1,21 @@ +// Cos (BJS FlowGraphCosBlock, glTF op `math/cos`). +// Data block (PULL): emits `value` via fg-math's `fgCos`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCos } from "../../fg-math.js"; + +export const cosDef: FgBlockDef = { + type: FgBlockType.Cos, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgCos(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/cosh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/cosh.ts new file mode 100644 index 0000000000..3bc6ba9486 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/cosh.ts @@ -0,0 +1,21 @@ +// Cosh (BJS FlowGraphCoshBlock, glTF op `math/cosh`). +// Data block (PULL): emits `value` via fg-math's `fgCosh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCosh } from "../../fg-math.js"; + +export const coshDef: FgBlockDef = { + type: FgBlockType.Cosh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgCosh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/cross.ts b/packages/babylon-lite/src/flow-graph/blocks/math/cross.ts new file mode 100644 index 0000000000..187177e7e3 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/cross.ts @@ -0,0 +1,22 @@ +// Cross (BJS FlowGraphCrossBlock, glTF op `math/cross`). +// Data block (PULL): emits `value` via fg-math's `fgCross`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCross } from "../../fg-math.js"; + +export const crossDef: FgBlockDef = { + type: FgBlockType.Cross, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Vector3)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgCross(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/cube-root.ts b/packages/babylon-lite/src/flow-graph/blocks/math/cube-root.ts new file mode 100644 index 0000000000..e2291cf4f5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/cube-root.ts @@ -0,0 +1,21 @@ +// CubeRoot (BJS FlowGraphCubeRootBlock, glTF op `math/cbrt`). +// Data block (PULL): emits `value` via fg-math's `fgCbrt`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCbrt } from "../../fg-math.js"; + +export const cubeRootDef: FgBlockDef = { + type: FgBlockType.CubeRoot, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgCbrt(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/data-switch.ts b/packages/babylon-lite/src/flow-graph/blocks/math/data-switch.ts new file mode 100644 index 0000000000..3d3e6fe565 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/data-switch.ts @@ -0,0 +1,31 @@ +// DataSwitch (BJS FlowGraphDataSwitchBlock, glTF op `math/switch`). +// Data block (PULL): selects one of several value inputs by a numeric selector. +// `config.cases` is an array of numeric case keys; each creates an `in_` +// data input. Reads `case`, looks up `in_`, falls back to `default`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { isFgInt } from "../../custom-types/fg-integer.js"; + +export const dataSwitchDef: FgBlockDef = { + type: FgBlockType.DataSwitch, + build: (config) => { + const cases = (config?.cases as number[] | undefined) ?? []; + const dataIn = [sockIn("case", FgType.Any), sockIn("default", FgType.Any)]; + for (const c of cases) { + dataIn.push(sockIn(`in_${c | 0}`, FgType.Any)); + } + return { dataIn, dataOut: [sockOut("value", FgType.Any)] }; + }, + updateOutputs(block, ctx, env) { + const cases = (block.config?.cases as number[] | undefined) ?? []; + const selector = getDataValue(ctx, env, block, "case"); + const key = isFgInt(selector) ? selector.value : (selector as number); + const matched = typeof key === "number" && cases.some((c) => (c | 0) === (key | 0)); + const socket = matched ? `in_${key | 0}` : "default"; + setDataValue(ctx, block, "value", getDataValue(ctx, env, block, socket)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/deg-to-rad.ts b/packages/babylon-lite/src/flow-graph/blocks/math/deg-to-rad.ts new file mode 100644 index 0000000000..eabeceef4b --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/deg-to-rad.ts @@ -0,0 +1,21 @@ +// DegToRad (BJS FlowGraphDegToRadBlock, glTF op `math/rad`). +// Data block (PULL): emits `value` via fg-math's `fgDegToRad`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgDegToRad } from "../../fg-math.js"; + +export const degToRadDef: FgBlockDef = { + type: FgBlockType.DegToRad, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgDegToRad(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/dot.ts b/packages/babylon-lite/src/flow-graph/blocks/math/dot.ts new file mode 100644 index 0000000000..41a5088fd7 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/dot.ts @@ -0,0 +1,22 @@ +// Dot (BJS FlowGraphDotBlock, glTF op `math/dot`). +// Data block (PULL): emits `value` via fg-math's `fgDot`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgDot } from "../../fg-math.js"; + +export const dotDef: FgBlockDef = { + type: FgBlockType.Dot, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgDot(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/equality.ts b/packages/babylon-lite/src/flow-graph/blocks/math/equality.ts new file mode 100644 index 0000000000..a4b8d21083 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/equality.ts @@ -0,0 +1,22 @@ +// Equality (BJS FlowGraphEqualityBlock, glTF op `math/eq`). +// Data block (PULL): emits `value` via fg-math's `fgEq`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgEq } from "../../fg-math.js"; + +export const equalityDef: FgBlockDef = { + type: FgBlockType.Equality, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgEq(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/exponential.ts b/packages/babylon-lite/src/flow-graph/blocks/math/exponential.ts new file mode 100644 index 0000000000..a0a39fff64 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/exponential.ts @@ -0,0 +1,21 @@ +// Exponential (BJS FlowGraphExpBlock, glTF op `math/exp`). +// Data block (PULL): emits `value` via fg-math's `fgExp`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExp } from "../../fg-math.js"; + +export const exponentialDef: FgBlockDef = { + type: FgBlockType.Exponential, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgExp(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract3.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract3.ts new file mode 100644 index 0000000000..b441989ece --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract3.ts @@ -0,0 +1,24 @@ +// ExtractVector3 (BJS FlowGraphExtractVector3Block, glTF op `math/extract3`). +// Data block (PULL): one Vec3 input `a` -> three scalar outputs x/y/z (glTF +// indices 0/1/2 remapped in declaration-mapper). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtract3 } from "../../fg-math.js"; + +export const extract3Def: FgBlockDef = { + type: FgBlockType.ExtractVector3, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector3)], + dataOut: [sockOut("x", FgType.Number), sockOut("y", FgType.Number), sockOut("z", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const [x, y, z] = fgExtract3(getDataValue(ctx, env, block, "a")); + setDataValue(ctx, block, "x", x); + setDataValue(ctx, block, "y", y); + setDataValue(ctx, block, "z", z); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract4.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract4.ts new file mode 100644 index 0000000000..60da37ef44 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract4.ts @@ -0,0 +1,25 @@ +// ExtractVector4 (BJS FlowGraphExtractVector4Block, glTF op `math/extract4`). +// Data block (PULL): one Vec4 input `a` -> four scalar outputs x/y/z/w (glTF +// indices 0/1/2/3 remapped in declaration-mapper). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtract4 } from "../../fg-math.js"; + +export const extract4Def: FgBlockDef = { + type: FgBlockType.ExtractVector4, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector4)], + dataOut: [sockOut("x", FgType.Number), sockOut("y", FgType.Number), sockOut("z", FgType.Number), sockOut("w", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const [x, y, z, w] = fgExtract4(getDataValue(ctx, env, block, "a")); + setDataValue(ctx, block, "x", x); + setDataValue(ctx, block, "y", y); + setDataValue(ctx, block, "z", z); + setDataValue(ctx, block, "w", w); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/fraction.ts b/packages/babylon-lite/src/flow-graph/blocks/math/fraction.ts new file mode 100644 index 0000000000..2293019756 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/fraction.ts @@ -0,0 +1,21 @@ +// Fraction (BJS FlowGraphFractionBlock, glTF op `math/fract`). +// Data block (PULL): emits `value` via fg-math's `fgFract`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgFract } from "../../fg-math.js"; + +export const fractionDef: FgBlockDef = { + type: FgBlockType.Fraction, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgFract(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/greater-than-or-equal.ts b/packages/babylon-lite/src/flow-graph/blocks/math/greater-than-or-equal.ts new file mode 100644 index 0000000000..c0a0e9b3c4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/greater-than-or-equal.ts @@ -0,0 +1,22 @@ +// GreaterThanOrEqual (BJS FlowGraphGreaterThanOrEqualBlock, glTF op `math/ge`). +// Data block (PULL): emits `value` via fg-math's `fgGe`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgGe } from "../../fg-math.js"; + +export const greaterThanOrEqualDef: FgBlockDef = { + type: FgBlockType.GreaterThanOrEqual, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgGe(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/greater-than.ts b/packages/babylon-lite/src/flow-graph/blocks/math/greater-than.ts new file mode 100644 index 0000000000..e95c71f58f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/greater-than.ts @@ -0,0 +1,22 @@ +// GreaterThan (BJS FlowGraphGreaterThanBlock, glTF op `math/gt`). +// Data block (PULL): emits `value` via fg-math's `fgGt`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgGt } from "../../fg-math.js"; + +export const greaterThanDef: FgBlockDef = { + type: FgBlockType.GreaterThan, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgGt(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/is-infinity.ts b/packages/babylon-lite/src/flow-graph/blocks/math/is-infinity.ts new file mode 100644 index 0000000000..0b8779945a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/is-infinity.ts @@ -0,0 +1,21 @@ +// IsInfinity (BJS FlowGraphIsInfBlock, glTF op `math/isInf`). +// Data block (PULL): emits `value` via fg-math's `fgIsInf`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgIsInf } from "../../fg-math.js"; + +export const isInfinityDef: FgBlockDef = { + type: FgBlockType.IsInfinity, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgIsInf(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/is-nan.ts b/packages/babylon-lite/src/flow-graph/blocks/math/is-nan.ts new file mode 100644 index 0000000000..256e4469be --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/is-nan.ts @@ -0,0 +1,21 @@ +// IsNaN (BJS FlowGraphIsNaNBlock, glTF op `math/isNaN`). +// Data block (PULL): emits `value` via fg-math's `fgIsNaN`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgIsNaN } from "../../fg-math.js"; + +export const isNaNDef: FgBlockDef = { + type: FgBlockType.IsNaN, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgIsNaN(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/leading-zeros.ts b/packages/babylon-lite/src/flow-graph/blocks/math/leading-zeros.ts new file mode 100644 index 0000000000..1ac33fc15d --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/leading-zeros.ts @@ -0,0 +1,21 @@ +// LeadingZeros (BJS FlowGraphLeadingZerosBlock, glTF op `math/clz`). +// Data block (PULL): emits `value` via fg-math's `fgClz`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgClz } from "../../fg-math.js"; + +export const leadingZerosDef: FgBlockDef = { + type: FgBlockType.LeadingZeros, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgClz(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/length.ts b/packages/babylon-lite/src/flow-graph/blocks/math/length.ts new file mode 100644 index 0000000000..d98efc3876 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/length.ts @@ -0,0 +1,21 @@ +// Length (BJS FlowGraphLengthBlock, glTF op `math/length`). +// Data block (PULL): emits `value` via fg-math's `fgLength`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLength } from "../../fg-math.js"; + +export const lengthDef: FgBlockDef = { + type: FgBlockType.Length, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgLength(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/less-than-or-equal.ts b/packages/babylon-lite/src/flow-graph/blocks/math/less-than-or-equal.ts new file mode 100644 index 0000000000..ca187f99f3 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/less-than-or-equal.ts @@ -0,0 +1,22 @@ +// LessThanOrEqual (BJS FlowGraphLessThanOrEqualBlock, glTF op `math/le`). +// Data block (PULL): emits `value` via fg-math's `fgLe`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLe } from "../../fg-math.js"; + +export const lessThanOrEqualDef: FgBlockDef = { + type: FgBlockType.LessThanOrEqual, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgLe(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/log.ts b/packages/babylon-lite/src/flow-graph/blocks/math/log.ts new file mode 100644 index 0000000000..d2c83cfc7e --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/log.ts @@ -0,0 +1,21 @@ +// Log (BJS FlowGraphLogBlock, glTF op `math/log`). +// Data block (PULL): emits `value` via fg-math's `fgLog`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLog } from "../../fg-math.js"; + +export const logDef: FgBlockDef = { + type: FgBlockType.Log, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgLog(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/log10.ts b/packages/babylon-lite/src/flow-graph/blocks/math/log10.ts new file mode 100644 index 0000000000..a3570cd543 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/log10.ts @@ -0,0 +1,21 @@ +// Log10 (BJS FlowGraphLog10Block, glTF op `math/log10`). +// Data block (PULL): emits `value` via fg-math's `fgLog10`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLog10 } from "../../fg-math.js"; + +export const log10Def: FgBlockDef = { + type: FgBlockType.Log10, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgLog10(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/log2.ts b/packages/babylon-lite/src/flow-graph/blocks/math/log2.ts new file mode 100644 index 0000000000..4b1e98699c --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/log2.ts @@ -0,0 +1,21 @@ +// Log2 (BJS FlowGraphLog2Block, glTF op `math/log2`). +// Data block (PULL): emits `value` via fg-math's `fgLog2`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgLog2 } from "../../fg-math.js"; + +export const log2Def: FgBlockDef = { + type: FgBlockType.Log2, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgLog2(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/max.ts b/packages/babylon-lite/src/flow-graph/blocks/math/max.ts new file mode 100644 index 0000000000..45960d0fe3 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/max.ts @@ -0,0 +1,22 @@ +// Max (BJS FlowGraphMaxBlock, glTF op `math/max`). +// Data block (PULL): emits `value` via fg-math's `fgMax`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMax } from "../../fg-math.js"; + +export const maxDef: FgBlockDef = { + type: FgBlockType.Max, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgMax(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/min.ts b/packages/babylon-lite/src/flow-graph/blocks/math/min.ts new file mode 100644 index 0000000000..d65f3a6350 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/min.ts @@ -0,0 +1,22 @@ +// Min (BJS FlowGraphMinBlock, glTF op `math/min`). +// Data block (PULL): emits `value` via fg-math's `fgMin`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMin } from "../../fg-math.js"; + +export const minDef: FgBlockDef = { + type: FgBlockType.Min, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgMin(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/mix.ts b/packages/babylon-lite/src/flow-graph/blocks/math/mix.ts new file mode 100644 index 0000000000..b8f2d46748 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/mix.ts @@ -0,0 +1,23 @@ +// MathInterpolation (BJS FlowGraphMathInterpolationBlock, glTF op `math/mix`). +// Data block (PULL): linear blend (1 - c)*a + c*b via fg-math (`a`,`b`,`c`). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMix } from "../../fg-math.js"; + +export const mathInterpolationDef: FgBlockDef = { + type: FgBlockType.MathInterpolation, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any), sockIn("c", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + const c = getDataValue(ctx, env, block, "c"); + setDataValue(ctx, block, "value", fgMix(a, b, c)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/negation.ts b/packages/babylon-lite/src/flow-graph/blocks/math/negation.ts new file mode 100644 index 0000000000..c4747fb6fe --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/negation.ts @@ -0,0 +1,21 @@ +// Negation (BJS FlowGraphNegationBlock, glTF op `math/neg`). +// Data block (PULL): emits `value` via fg-math's `fgNeg`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgNeg } from "../../fg-math.js"; + +export const negationDef: FgBlockDef = { + type: FgBlockType.Negation, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgNeg(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/normalize.ts b/packages/babylon-lite/src/flow-graph/blocks/math/normalize.ts new file mode 100644 index 0000000000..244812c6c3 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/normalize.ts @@ -0,0 +1,21 @@ +// Normalize (BJS FlowGraphNormalizeBlock, glTF op `math/normalize`). +// Data block (PULL): emits `value` via fg-math's `fgNormalize`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgNormalize } from "../../fg-math.js"; + +export const normalizeDef: FgBlockDef = { + type: FgBlockType.Normalize, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgNormalize(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/one-bits-counter.ts b/packages/babylon-lite/src/flow-graph/blocks/math/one-bits-counter.ts new file mode 100644 index 0000000000..fe0dd764c7 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/one-bits-counter.ts @@ -0,0 +1,21 @@ +// OneBitsCounter (BJS FlowGraphOneBitsCounterBlock, glTF op `math/popcnt`). +// Data block (PULL): emits `value` via fg-math's `fgPopcnt`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgPopcnt } from "../../fg-math.js"; + +export const oneBitsCounterDef: FgBlockDef = { + type: FgBlockType.OneBitsCounter, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgPopcnt(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/power.ts b/packages/babylon-lite/src/flow-graph/blocks/math/power.ts new file mode 100644 index 0000000000..7bc6d54b85 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/power.ts @@ -0,0 +1,22 @@ +// Power (BJS FlowGraphPowerBlock, glTF op `math/pow`). +// Data block (PULL): emits `value` via fg-math's `fgPow`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgPow } from "../../fg-math.js"; + +export const powerDef: FgBlockDef = { + type: FgBlockType.Power, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgPow(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/rad-to-deg.ts b/packages/babylon-lite/src/flow-graph/blocks/math/rad-to-deg.ts new file mode 100644 index 0000000000..c0af8c9b6e --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/rad-to-deg.ts @@ -0,0 +1,21 @@ +// RadToDeg (BJS FlowGraphRadToDegBlock, glTF op `math/deg`). +// Data block (PULL): emits `value` via fg-math's `fgRadToDeg`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRadToDeg } from "../../fg-math.js"; + +export const radToDegDef: FgBlockDef = { + type: FgBlockType.RadToDeg, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgRadToDeg(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/random.ts b/packages/babylon-lite/src/flow-graph/blocks/math/random.ts new file mode 100644 index 0000000000..b17b9e7be9 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/random.ts @@ -0,0 +1,24 @@ +// Random (BJS FlowGraphRandomBlock, glTF op `math/random`). +// Data block (PULL): emits a fresh random `value` in [min, max) each pull +// (min/max default 0/1). getDataValue re-runs updateOutputs on every read, so a +// downstream consumer that reads twice in one cascade sees two draws. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRandom } from "../../fg-math.js"; + +export const randomDef: FgBlockDef = { + type: FgBlockType.Random, + build: () => ({ + dataIn: [sockIn("min", FgType.Number, 0), sockIn("max", FgType.Number, 1)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const min = getDataValue(ctx, env, block, "min") as number; + const max = getDataValue(ctx, env, block, "max") as number; + setDataValue(ctx, block, "value", fgRandom(min, max)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/rotate2d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/rotate2d.ts new file mode 100644 index 0000000000..96abc1771f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/rotate2d.ts @@ -0,0 +1,23 @@ +// Rotate2D (BJS FlowGraphRotate2DBlock, glTF op `math/rotate2D`). +// Data block (PULL): rotates Vector2 `a` by `b` radians (CCW) via fg-math. +// glTF input `angle` maps to socket `b` (see declaration-mapper). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRotate2D } from "../../fg-math.js"; + +export const rotate2DDef: FgBlockDef = { + type: FgBlockType.Rotate2D, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector2), sockIn("b", FgType.Number)], + dataOut: [sockOut("value", FgType.Vector2)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgRotate2D(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/rotate3d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/rotate3d.ts new file mode 100644 index 0000000000..7ca5991f90 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/rotate3d.ts @@ -0,0 +1,22 @@ +// Rotate3D (BJS FlowGraphRotate3DBlock, glTF op `math/rotate3D`). +// Data block (PULL): rotates Vector3 `a` by Quaternion `b` via fg-math. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRotate3D } from "../../fg-math.js"; + +export const rotate3DDef: FgBlockDef = { + type: FgBlockType.Rotate3D, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector3), sockIn("b", FgType.Quaternion)], + dataOut: [sockOut("value", FgType.Vector3)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgRotate3D(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/round.ts b/packages/babylon-lite/src/flow-graph/blocks/math/round.ts new file mode 100644 index 0000000000..2a975212c4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/round.ts @@ -0,0 +1,21 @@ +// Round (BJS FlowGraphRoundBlock, glTF op `math/round`). +// Data block (PULL): emits `value` via fg-math's `fgRound`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgRound } from "../../fg-math.js"; + +export const roundDef: FgBlockDef = { + type: FgBlockType.Round, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgRound(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/saturate.ts b/packages/babylon-lite/src/flow-graph/blocks/math/saturate.ts new file mode 100644 index 0000000000..7fb94dac26 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/saturate.ts @@ -0,0 +1,21 @@ +// Saturate (BJS FlowGraphSaturateBlock, glTF op `math/saturate`). +// Data block (PULL): emits `value` via fg-math's `fgSaturate`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSaturate } from "../../fg-math.js"; + +export const saturateDef: FgBlockDef = { + type: FgBlockType.Saturate, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgSaturate(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/sign.ts b/packages/babylon-lite/src/flow-graph/blocks/math/sign.ts new file mode 100644 index 0000000000..b31e6da6f4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/sign.ts @@ -0,0 +1,21 @@ +// Sign (BJS FlowGraphSignBlock, glTF op `math/sign`). +// Data block (PULL): emits `value` via fg-math's `fgSign`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSign } from "../../fg-math.js"; + +export const signDef: FgBlockDef = { + type: FgBlockType.Sign, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgSign(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/sin.ts b/packages/babylon-lite/src/flow-graph/blocks/math/sin.ts new file mode 100644 index 0000000000..8ebc898d00 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/sin.ts @@ -0,0 +1,21 @@ +// Sin (BJS FlowGraphSinBlock, glTF op `math/sin`). +// Data block (PULL): emits `value` via fg-math's `fgSin`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSin } from "../../fg-math.js"; + +export const sinDef: FgBlockDef = { + type: FgBlockType.Sin, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgSin(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/sinh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/sinh.ts new file mode 100644 index 0000000000..c903f403fb --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/sinh.ts @@ -0,0 +1,21 @@ +// Sinh (BJS FlowGraphSinhBlock, glTF op `math/sinh`). +// Data block (PULL): emits `value` via fg-math's `fgSinh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSinh } from "../../fg-math.js"; + +export const sinhDef: FgBlockDef = { + type: FgBlockType.Sinh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgSinh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/square-root.ts b/packages/babylon-lite/src/flow-graph/blocks/math/square-root.ts new file mode 100644 index 0000000000..4ca5164ac0 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/square-root.ts @@ -0,0 +1,21 @@ +// SquareRoot (BJS FlowGraphSquareRootBlock, glTF op `math/sqrt`). +// Data block (PULL): emits `value` via fg-math's `fgSqrt`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgSqrt } from "../../fg-math.js"; + +export const squareRootDef: FgBlockDef = { + type: FgBlockType.SquareRoot, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgSqrt(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/tan.ts b/packages/babylon-lite/src/flow-graph/blocks/math/tan.ts new file mode 100644 index 0000000000..1c2a9ca4b8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/tan.ts @@ -0,0 +1,21 @@ +// Tan (BJS FlowGraphTanBlock, glTF op `math/tan`). +// Data block (PULL): emits `value` via fg-math's `fgTan`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgTan } from "../../fg-math.js"; + +export const tanDef: FgBlockDef = { + type: FgBlockType.Tan, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgTan(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/tanh.ts b/packages/babylon-lite/src/flow-graph/blocks/math/tanh.ts new file mode 100644 index 0000000000..b1ec680a25 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/tanh.ts @@ -0,0 +1,21 @@ +// Tanh (BJS FlowGraphTanhBlock, glTF op `math/tanh`). +// Data block (PULL): emits `value` via fg-math's `fgTanh`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgTanh } from "../../fg-math.js"; + +export const tanhDef: FgBlockDef = { + type: FgBlockType.Tanh, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgTanh(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/trailing-zeros.ts b/packages/babylon-lite/src/flow-graph/blocks/math/trailing-zeros.ts new file mode 100644 index 0000000000..11061ab572 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/trailing-zeros.ts @@ -0,0 +1,21 @@ +// TrailingZeros (BJS FlowGraphTrailingZerosBlock, glTF op `math/ctz`). +// Data block (PULL): emits `value` via fg-math's `fgCtz`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCtz } from "../../fg-math.js"; + +export const trailingZerosDef: FgBlockDef = { + type: FgBlockType.TrailingZeros, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgCtz(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/trunc.ts b/packages/babylon-lite/src/flow-graph/blocks/math/trunc.ts new file mode 100644 index 0000000000..402727b07b --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/trunc.ts @@ -0,0 +1,21 @@ +// Trunc (BJS FlowGraphTruncBlock, glTF op `math/trunc`). +// Data block (PULL): emits `value` via fg-math's `fgTrunc`. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgTrunc } from "../../fg-math.js"; + +export const truncDef: FgBlockDef = { + type: FgBlockType.Trunc, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgTrunc(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts index 68df1bc4f1..224a266e42 100644 --- a/packages/babylon-lite/src/flow-graph/fg-math.ts +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -9,7 +9,9 @@ import { fgInt, isFgInt } from "./custom-types/fg-integer.js"; import type { FgValue, Vec2 } from "./types.js"; -import type { Vec3, Vec4 } from "../math/types.js"; +import type { Quat, Vec3, Vec4 } from "../math/types.js"; +import { crossVec3 } from "../math/cross-vec3.js"; +import { dotVec3 } from "../math/dot-vec3.js"; function isVec2(v: unknown): v is Vec2 { return typeof v === "object" && v !== null && "x" in v && "y" in v && !("z" in v); @@ -132,3 +134,444 @@ export function fgExtract2(v: FgValue): [number, number] { } return [0, 0]; } + +// ─── Phase 3 helpers ──────────────────────────────────────────────────────── + +/** Numeric payload of a number / FlowGraphInteger; `NaN` for other shapes. */ +function num(v: FgValue): number { + if (isFgInt(v)) { + return v.value; + } + return typeof v === "number" ? v : NaN; +} +/** Numeric payload, or 0 when the value is not scalar (combine inputs). */ +function num0(v: FgValue): number { + const n = num(v); + return Number.isNaN(n) && !(typeof v === "number") ? 0 : n; +} +/** True for number | FlowGraphInteger (the comparison/bitwise scalar domain). */ +function isNumeric(v: FgValue): boolean { + return typeof v === "number" || isFgInt(v); +} +/** Coerce to a 32-bit signed int payload (integer bitwise ops). */ +function toI(v: FgValue): number { + return (isFgInt(v) ? v.value : (v as number)) | 0; +} + +/** Component-wise ternary across number / FlowGraphInteger / Vector2-4. */ +function ternary(a: FgValue, b: FgValue, c: FgValue, f: (x: number, y: number, z: number) => number): FgValue { + if (isFgInt(a) && isFgInt(b) && isFgInt(c)) { + return fgInt(f(a.value, b.value, c.value)); + } + if (typeof a === "number" && typeof b === "number" && typeof c === "number") { + return f(a, b, c); + } + if (isVec4(a) && isVec4(b) && isVec4(c)) { + return { x: f(a.x, b.x, c.x), y: f(a.y, b.y, c.y), z: f(a.z, b.z, c.z), w: f(a.w, b.w, c.w) }; + } + if (isVec3(a) && isVec3(b) && isVec3(c)) { + return { x: f(a.x, b.x, c.x), y: f(a.y, b.y, c.y), z: f(a.z, b.z, c.z) }; + } + if (isVec2(a) && isVec2(b) && isVec2(c)) { + return { x: f(a.x, b.x, c.x), y: f(a.y, b.y, c.y) }; + } + return a; +} + +// ─── Arithmetic (binary) ──────────────────────────────────────────────────── + +/** Component-wise minimum (glTF `math/min`). */ +export function fgMin(a: FgValue, b: FgValue): FgValue { + return binary(a, b, Math.min); +} +/** Component-wise maximum (glTF `math/max`). */ +export function fgMax(a: FgValue, b: FgValue): FgValue { + return binary(a, b, Math.max); +} +/** Component-wise power, a^b (glTF `math/pow`). */ +export function fgPow(a: FgValue, b: FgValue): FgValue { + return binary(a, b, Math.pow); +} +/** Component-wise atan2(a, b) where a = y, b = x (glTF `math/atan2`). */ +export function fgAtan2(a: FgValue, b: FgValue): FgValue { + return binary(a, b, Math.atan2); +} + +// ─── Unary scalar / component-wise ────────────────────────────────────────── + +/** Component-wise negation, −a (glTF `math/neg`). */ +export function fgNeg(a: FgValue): FgValue { + return unary(a, (x) => -x); +} +/** Component-wise sign (glTF `math/sign`). */ +export function fgSign(a: FgValue): FgValue { + return unary(a, Math.sign); +} +/** Component-wise ceil (glTF `math/ceil`). */ +export function fgCeil(a: FgValue): FgValue { + return unary(a, Math.ceil); +} +/** Component-wise round, half toward +∞ (glTF `math/round`). */ +export function fgRound(a: FgValue): FgValue { + return unary(a, Math.round); +} +/** Component-wise truncation toward zero (glTF `math/trunc`). */ +export function fgTrunc(a: FgValue): FgValue { + return unary(a, Math.trunc); +} +/** Component-wise fractional part, `x − floor(x)` (glTF `math/fract`). */ +export function fgFract(a: FgValue): FgValue { + return unary(a, (x) => x - Math.floor(x)); +} +/** Component-wise clamp to [0, 1] (glTF `math/saturate`). */ +export function fgSaturate(a: FgValue): FgValue { + return unary(a, (x) => Math.min(Math.max(x, 0), 1)); +} +/** Component-wise square root (glTF `math/sqrt`). */ +export function fgSqrt(a: FgValue): FgValue { + return unary(a, Math.sqrt); +} +/** Component-wise cube root (glTF `math/cbrt`). */ +export function fgCbrt(a: FgValue): FgValue { + return unary(a, Math.cbrt); +} +/** Component-wise e^x (glTF `math/exp`). */ +export function fgExp(a: FgValue): FgValue { + return unary(a, Math.exp); +} +/** Component-wise natural log (glTF `math/log`). */ +export function fgLog(a: FgValue): FgValue { + return unary(a, Math.log); +} +/** Component-wise base-2 log (glTF `math/log2`). */ +export function fgLog2(a: FgValue): FgValue { + return unary(a, Math.log2); +} +/** Component-wise base-10 log (glTF `math/log10`). */ +export function fgLog10(a: FgValue): FgValue { + return unary(a, Math.log10); +} +/** Component-wise degrees → radians (glTF `math/rad`). */ +export function fgDegToRad(a: FgValue): FgValue { + return unary(a, (x) => (x * Math.PI) / 180); +} +/** Component-wise radians → degrees (glTF `math/deg`). */ +export function fgRadToDeg(a: FgValue): FgValue { + return unary(a, (x) => (x * 180) / Math.PI); +} +/** Component-wise sine (glTF `math/sin`). */ +export function fgSin(a: FgValue): FgValue { + return unary(a, Math.sin); +} +/** Component-wise cosine (glTF `math/cos`). */ +export function fgCos(a: FgValue): FgValue { + return unary(a, Math.cos); +} +/** Component-wise tangent (glTF `math/tan`). */ +export function fgTan(a: FgValue): FgValue { + return unary(a, Math.tan); +} +/** Component-wise arcsine (glTF `math/asin`). */ +export function fgAsin(a: FgValue): FgValue { + return unary(a, Math.asin); +} +/** Component-wise arccosine (glTF `math/acos`). */ +export function fgAcos(a: FgValue): FgValue { + return unary(a, Math.acos); +} +/** Component-wise arctangent (glTF `math/atan`). */ +export function fgAtan(a: FgValue): FgValue { + return unary(a, Math.atan); +} +/** Component-wise hyperbolic sine (glTF `math/sinh`). */ +export function fgSinh(a: FgValue): FgValue { + return unary(a, Math.sinh); +} +/** Component-wise hyperbolic cosine (glTF `math/cosh`). */ +export function fgCosh(a: FgValue): FgValue { + return unary(a, Math.cosh); +} +/** Component-wise hyperbolic tangent (glTF `math/tanh`). */ +export function fgTanh(a: FgValue): FgValue { + return unary(a, Math.tanh); +} +/** Component-wise inverse hyperbolic sine (glTF `math/asinh`). */ +export function fgAsinh(a: FgValue): FgValue { + return unary(a, Math.asinh); +} +/** Component-wise inverse hyperbolic cosine (glTF `math/acosh`). */ +export function fgAcosh(a: FgValue): FgValue { + return unary(a, Math.acosh); +} +/** Component-wise inverse hyperbolic tangent (glTF `math/atanh`). */ +export function fgAtanh(a: FgValue): FgValue { + return unary(a, Math.atanh); +} + +// ─── Interpolation (ternary) ──────────────────────────────────────────────── + +/** Linear blend `(1 − t)·a + t·b` (glTF `math/mix`). Supports vector a/b with a + * scalar `t`, mirroring BJS's component-wise interpolation. */ +export function fgMix(a: FgValue, b: FgValue, t: FgValue): FgValue { + const tv = num(t); + if (Number.isNaN(tv)) { + return a; + } + const lerp = (x: number, y: number): number => (1 - tv) * x + tv * y; + if (isVec4(a) && isVec4(b)) { + return { x: lerp(a.x, b.x), y: lerp(a.y, b.y), z: lerp(a.z, b.z), w: lerp(a.w, b.w) }; + } + if (isVec3(a) && isVec3(b)) { + return { x: lerp(a.x, b.x), y: lerp(a.y, b.y), z: lerp(a.z, b.z) }; + } + if (isVec2(a) && isVec2(b)) { + return { x: lerp(a.x, b.x), y: lerp(a.y, b.y) }; + } + if (isNumeric(a) && isNumeric(b)) { + const r = lerp(num(a), num(b)); + return isFgInt(a) && isFgInt(b) ? fgInt(r) : r; + } + return ternary(a, b, t, (x, y, z) => (1 - z) * x + z * y); +} + +// ─── Comparison (→ boolean) ───────────────────────────────────────────────── + +/** Strict equality (glTF `math/eq`): exact, zero-tolerance, component-wise for + * vectors/quaternions; mismatched types compare unequal (BJS behaviour). */ +export function fgEq(a: FgValue, b: FgValue): boolean { + if (isFgInt(a) && isFgInt(b)) { + return a.value === b.value; + } + if (isFgInt(a) !== isFgInt(b)) { + return false; + } + if (isVec4(a) && isVec4(b)) { + return a.x === b.x && a.y === b.y && a.z === b.z && a.w === b.w; + } + if (isVec3(a) && isVec3(b)) { + return a.x === b.x && a.y === b.y && a.z === b.z; + } + if (isVec2(a) && isVec2(b)) { + return a.x === b.x && a.y === b.y; + } + return a === b; +} +/** Scalar `a ≤ b` (glTF `math/le`); false for non-scalar shapes. */ +export function fgLe(a: FgValue, b: FgValue): boolean { + return isNumeric(a) && isNumeric(b) ? num(a) <= num(b) : false; +} +/** Scalar `a > b` (glTF `math/gt`); false for non-scalar shapes. */ +export function fgGt(a: FgValue, b: FgValue): boolean { + return isNumeric(a) && isNumeric(b) ? num(a) > num(b) : false; +} +/** Scalar `a ≥ b` (glTF `math/ge`); false for non-scalar shapes. */ +export function fgGe(a: FgValue, b: FgValue): boolean { + return isNumeric(a) && isNumeric(b) ? num(a) >= num(b) : false; +} +/** Scalar NaN test (glTF `math/isNaN`); false for non-scalar shapes. */ +export function fgIsNaN(a: FgValue): boolean { + return isNumeric(a) ? Number.isNaN(num(a)) : false; +} +/** Scalar non-finite test — ±Infinity and NaN (glTF `math/isInf`). */ +export function fgIsInf(a: FgValue): boolean { + return isNumeric(a) ? !Number.isFinite(num(a)) : false; +} + +/** Random value in `[min, max)` (glTF `math/random`); defaults to `[0, 1)`. */ +export function fgRandom(min = 0, max = 1): number { + return Math.random() * (max - min) + min; +} + +// ─── Boolean / bitwise (type-dispatched) ──────────────────────────────────── + +/** Logical/bitwise AND (glTF `math/and`): `&&` for booleans, `&` for ints. */ +export function fgAnd(a: FgValue, b: FgValue): FgValue { + if (typeof a === "boolean" && typeof b === "boolean") { + return a && b; + } + if (typeof a === "number" && typeof b === "number") { + return a & b; + } + if (isFgInt(a) && isFgInt(b)) { + return fgInt(a.value & b.value); + } + return a; +} +/** Logical/bitwise OR (glTF `math/or`): `||` for booleans, `|` for ints. */ +export function fgOr(a: FgValue, b: FgValue): FgValue { + if (typeof a === "boolean" && typeof b === "boolean") { + return a || b; + } + if (typeof a === "number" && typeof b === "number") { + return a | b; + } + if (isFgInt(a) && isFgInt(b)) { + return fgInt(a.value | b.value); + } + return a; +} +/** Logical/bitwise XOR (glTF `math/xor`): `a≠b` for booleans, `^` for ints. */ +export function fgXor(a: FgValue, b: FgValue): FgValue { + if (typeof a === "boolean" && typeof b === "boolean") { + return a !== b; + } + if (typeof a === "number" && typeof b === "number") { + return a ^ b; + } + if (isFgInt(a) && isFgInt(b)) { + return fgInt(a.value ^ b.value); + } + return a; +} +/** Logical/bitwise NOT (glTF `math/not`): `!a` for booleans, `~a` for ints. */ +export function fgNot(a: FgValue): FgValue { + if (typeof a === "boolean") { + return !a; + } + if (typeof a === "number") { + return ~a; + } + if (isFgInt(a)) { + return fgInt(~a.value); + } + return a; +} + +// ─── Integer bitwise ──────────────────────────────────────────────────────── + +/** Logical left shift, `a << b` (glTF `math/lsl`). */ +export function fgLsl(a: FgValue, b: FgValue): FgValue { + return fgInt(toI(a) << toI(b)); +} +/** Arithmetic right shift, `a >> b`, sign-extending (glTF `math/asr`). */ +export function fgAsr(a: FgValue, b: FgValue): FgValue { + return fgInt(toI(a) >> toI(b)); +} +/** Count leading zero bits over 32 bits (glTF `math/clz`). */ +export function fgClz(a: FgValue): FgValue { + return fgInt(Math.clz32(toI(a))); +} +/** Count trailing zero bits; 32 for input 0 (glTF `math/ctz`). */ +export function fgCtz(a: FgValue): FgValue { + const n = toI(a); + return fgInt(n ? 31 - Math.clz32(n & -n) : 32); +} +/** Population count — number of set bits over 32 bits (glTF `math/popcnt`). */ +export function fgPopcnt(a: FgValue): FgValue { + let n = toI(a) >>> 0; + let r = 0; + while (n) { + r += n & 1; + n >>>= 1; + } + return fgInt(r); +} + +// ─── Vector ops ───────────────────────────────────────────────────────────── + +/** Euclidean length of a Vector2/3/4 or Quaternion (glTF `math/length`). */ +export function fgLength(a: FgValue): number { + if (isVec2(a)) { + return Math.hypot(a.x, a.y); + } + if (isVec4(a)) { + return Math.hypot(a.x, a.y, a.z, a.w); + } + if (isVec3(a)) { + return Math.hypot(a.x, a.y, a.z); + } + return 0; +} +/** Normalize a Vector2/3/4 or Quaternion to unit length; zero-vector stays zero + * (glTF `math/normalize`). */ +export function fgNormalize(a: FgValue): FgValue { + const len = fgLength(a); + const s = len === 0 ? 0 : 1 / len; + if (isVec2(a)) { + return { x: a.x * s, y: a.y * s }; + } + if (isVec4(a)) { + return { x: a.x * s, y: a.y * s, z: a.z * s, w: a.w * s }; + } + if (isVec3(a)) { + return { x: a.x * s, y: a.y * s, z: a.z * s }; + } + return a; +} +/** Dot product of two same-size vectors/quaternions (glTF `math/dot`). */ +export function fgDot(a: FgValue, b: FgValue): number { + if (isVec2(a) && isVec2(b)) { + return a.x * b.x + a.y * b.y; + } + if (isVec4(a) && isVec4(b)) { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + } + if (isVec3(a) && isVec3(b)) { + return dotVec3(a, b); + } + return 0; +} +/** 3D cross product (glTF `math/cross`); Vector3 only. */ +export function fgCross(a: FgValue, b: FgValue): FgValue { + if (isVec3(a) && isVec3(b)) { + return crossVec3(a, b); + } + return a; +} +/** Rotate a Vector2 by `angle` radians, CCW (glTF `math/rotate2D`). */ +export function fgRotate2D(a: FgValue, angle: FgValue): FgValue { + if (isVec2(a) && typeof angle === "number") { + const c = Math.cos(angle); + const s = Math.sin(angle); + return { x: c * a.x - s * a.y, y: s * a.x + c * a.y }; + } + return a; +} +/** Rotate a Vector3 by a Quaternion (glTF `math/rotate3D`). */ +export function fgRotate3D(a: FgValue, q: FgValue): FgValue { + if (isVec3(a) && isVec4(q)) { + const { x, y, z } = a; + const tx = 2 * (q.y * z - q.z * y); + const ty = 2 * (q.z * x - q.x * z); + const tz = 2 * (q.x * y - q.y * x); + return { + x: x + q.w * tx + (q.y * tz - q.z * ty), + y: y + q.w * ty + (q.z * tx - q.x * tz), + z: z + q.w * tz + (q.x * ty - q.y * tx), + }; + } + return a; +} + +// ─── Combine / extract (vectors) ──────────────────────────────────────────── + +/** Combine three scalars into a Vector3 (glTF `math/combine3`). */ +export function fgCombine3(a: FgValue, b: FgValue, c: FgValue): Vec3 { + return { x: num0(a), y: num0(b), z: num0(c) }; +} +/** Combine four scalars into a Vector4 (glTF `math/combine4`). */ +export function fgCombine4(a: FgValue, b: FgValue, c: FgValue, d: FgValue): Vec4 { + return { x: num0(a), y: num0(b), z: num0(c), w: num0(d) }; +} +/** Extract a Vector3's components (glTF `math/extract3`) → `[x, y, z]`. */ +export function fgExtract3(v: FgValue): [number, number, number] { + if (isVec3(v) || isVec4(v)) { + return [v.x, v.y, v.z]; + } + return [0, 0, 0]; +} +/** Extract a Vector4's / Quaternion's components (glTF `math/extract4`). */ +export function fgExtract4(v: FgValue): [number, number, number, number] { + if (isVec4(v)) { + return [v.x, v.y, v.z, v.w]; + } + return [0, 0, 0, 0]; +} + +/** Quaternion conjugate, `(−x, −y, −z, w)` (glTF `math/quatConjugate`). */ +export function fgConjugate(a: FgValue): FgValue { + if (isVec4(a)) { + return { x: -a.x, y: -a.y, z: -a.z, w: a.w } as Quat; + } + return a; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index c283f7e139..9516eca1f4 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -70,6 +70,77 @@ const NATIVE_OPS: Readonly> = { "math/clamp": { block: FgBlockType.Clamp, valueInputs: { a: "a", b: "b", c: "c" } }, "math/combine2": { block: FgBlockType.CombineVector2, valueInputs: { a: "a", b: "b" } }, "math/extract2": { block: FgBlockType.ExtractVector2, valueInputs: { a: "a" }, outputValues: { "0": "x", "1": "y" } }, + // ─── Phase 3 math (pass-through a/b/c sockets) ─────────────────────────── + "math/neg": { block: FgBlockType.Negation }, + "math/sign": { block: FgBlockType.Sign }, + "math/ceil": { block: FgBlockType.Ceil }, + "math/round": { block: FgBlockType.Round }, + "math/trunc": { block: FgBlockType.Trunc }, + "math/fract": { block: FgBlockType.Fraction }, + "math/saturate": { block: FgBlockType.Saturate }, + "math/sqrt": { block: FgBlockType.SquareRoot }, + "math/cbrt": { block: FgBlockType.CubeRoot }, + "math/exp": { block: FgBlockType.Exponential }, + "math/log": { block: FgBlockType.Log }, + "math/log2": { block: FgBlockType.Log2 }, + "math/log10": { block: FgBlockType.Log10 }, + "math/rad": { block: FgBlockType.DegToRad }, + "math/deg": { block: FgBlockType.RadToDeg }, + "math/sin": { block: FgBlockType.Sin }, + "math/cos": { block: FgBlockType.Cos }, + "math/tan": { block: FgBlockType.Tan }, + "math/asin": { block: FgBlockType.Asin }, + "math/acos": { block: FgBlockType.Acos }, + "math/atan": { block: FgBlockType.Atan }, + "math/sinh": { block: FgBlockType.Sinh }, + "math/cosh": { block: FgBlockType.Cosh }, + "math/tanh": { block: FgBlockType.Tanh }, + "math/asinh": { block: FgBlockType.Asinh }, + "math/acosh": { block: FgBlockType.Acosh }, + "math/atanh": { block: FgBlockType.Atanh }, + "math/min": { block: FgBlockType.Min }, + "math/max": { block: FgBlockType.Max }, + "math/pow": { block: FgBlockType.Power }, + "math/atan2": { block: FgBlockType.Atan2 }, + "math/eq": { block: FgBlockType.Equality }, + "math/le": { block: FgBlockType.LessThanOrEqual }, + "math/gt": { block: FgBlockType.GreaterThan }, + "math/ge": { block: FgBlockType.GreaterThanOrEqual }, + "math/isNaN": { block: FgBlockType.IsNaN }, + "math/isInf": { block: FgBlockType.IsInfinity }, + "math/and": { block: FgBlockType.BitwiseAnd }, + "math/or": { block: FgBlockType.BitwiseOr }, + "math/xor": { block: FgBlockType.BitwiseXor }, + "math/not": { block: FgBlockType.BitwiseNot }, + "math/lsl": { block: FgBlockType.BitwiseLeftShift }, + "math/asr": { block: FgBlockType.BitwiseRightShift }, + "math/clz": { block: FgBlockType.LeadingZeros }, + "math/ctz": { block: FgBlockType.TrailingZeros }, + "math/popcnt": { block: FgBlockType.OneBitsCounter }, + "math/length": { block: FgBlockType.Length }, + "math/normalize": { block: FgBlockType.Normalize }, + "math/dot": { block: FgBlockType.Dot }, + "math/cross": { block: FgBlockType.Cross }, + "math/rotate3D": { block: FgBlockType.Rotate3D }, + "math/mix": { block: FgBlockType.MathInterpolation }, + "math/combine3": { block: FgBlockType.CombineVector3 }, + "math/combine4": { block: FgBlockType.CombineVector4 }, + "math/E": { block: FgBlockType.E }, + "math/Pi": { block: FgBlockType.PI }, + "math/Inf": { block: FgBlockType.Inf }, + "math/NaN": { block: FgBlockType.NaN }, + "math/random": { block: FgBlockType.Random }, + "type/boolToFloat": { block: FgBlockType.BooleanToFloat }, + "type/boolToInt": { block: FgBlockType.BooleanToInt }, + "type/floatToBool": { block: FgBlockType.FloatToBoolean }, + "type/intToBool": { block: FgBlockType.IntToBoolean }, + "type/intToFloat": { block: FgBlockType.IntToFloat }, + "type/floatToInt": { block: FgBlockType.FloatToInt }, + // ─── Phase 3 math (custom socket / output mapping) ─────────────────────── + "math/extract3": { block: FgBlockType.ExtractVector3, outputValues: { "0": "x", "1": "y", "2": "z" } }, + "math/extract4": { block: FgBlockType.ExtractVector4, outputValues: { "0": "x", "1": "y", "2": "z", "3": "w" } }, + "math/rotate2D": { block: FgBlockType.Rotate2D, valueInputs: { a: "a", angle: "b" } }, + "math/select": { block: FgBlockType.Conditional, valueInputs: { condition: "condition", a: "onTrue", b: "onFalse" } }, "variable/get": { block: FgBlockType.GetVariable, variableConfigKey: "variable" }, "variable/set": { block: FgBlockType.SetVariable, variableConfigKey: "variables", valueInputs: { value: "value" } }, diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index 3ee15e9683..fdfc374492 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest"; import type { AnimationGroup } from "../../../packages/babylon-lite/src/animation/animation-group"; import type { FgAccessor, FgBlock, FgBlockDef, FgGraph, FgValue, FgWiring } from "../../../packages/babylon-lite/src/flow-graph/index"; -import { createFgRuntime, FgEventType, FgType, getBlockDef, getDataValue, pumpFgEvent, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { createFgRuntime, fgInt, FgEventType, FgType, getBlockDef, getDataValue, pumpFgEvent, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; // ─── graph + runtime builder driven by the REAL registry ──────────────────── @@ -361,6 +361,216 @@ describe("flow-graph blocks — math/data", () => { }); }); +describe("flow-graph blocks — math Phase 3", () => { + /** Build start→op→recorder, fire start, return the value pulled off `outSocket`. */ + async function evalOp( + type: string, + dataDefaults: Record, + opts: { config?: Record; outSocket?: string } = {} + ): Promise { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type, config: opts.config, dataDefaults }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: opts.outSocket ?? "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + return log[0]!.value; + } + + it.each([ + ["Negation", -5, 5], + ["Sign", -2, -1], + ["Sign", 0, 0], + ["Ceil", 3.2, 4], + ["Round", 2.5, 3], + ["Round", -2.5, -2], + ["Trunc", -3.9, -3], + ["Fraction", 3.25, 0.25], + ["Saturate", 1.5, 1], + ["Saturate", -0.5, 0], + ["SquareRoot", 9, 3], + ["CubeRoot", 27, 3], + ["Exponential", 0, 1], + ["Log2", 8, 3], + ["Log10", 1000, 3], + ])("%s(%d) → %d", async (type, a, expected) => { + expect(await evalOp(type, { a })).toBeCloseTo(expected as number, 10); + }); + + it.each([ + ["Sin", 0, 0], + ["Cos", 0, 1], + ["Tan", 0, 0], + ["Asin", 1, Math.PI / 2], + ["Acos", 1, 0], + ["Atan", 0, 0], + ["Sinh", 0, 0], + ["Cosh", 0, 1], + ["Tanh", 0, 0], + ["DegToRad", 180, Math.PI], + ["RadToDeg", Math.PI, 180], + ])("%s(%d) trig/conv", async (type, a, expected) => { + expect(await evalOp(type, { a })).toBeCloseTo(expected as number, 10); + }); + + it.each([ + ["Min", 3, 5, 3], + ["Max", 3, 5, 5], + ["Power", 2, 10, 1024], + ["Atan2", 1, 1, Math.PI / 4], + ])("%s(%d, %d) → %d", async (type, a, b, expected) => { + expect(await evalOp(type, { a, b })).toBeCloseTo(expected as number, 10); + }); + + it.each([ + ["Equality", 2, 2, true], + ["Equality", 2, 3, false], + ["LessThanOrEqual", 2, 2, true], + ["LessThanOrEqual", 3, 2, false], + ["GreaterThan", 3, 2, true], + ["GreaterThan", 2, 2, false], + ["GreaterThanOrEqual", 2, 2, true], + ["GreaterThanOrEqual", 1, 2, false], + ])("%s(%d, %d) → %s", async (type, a, b, expected) => { + expect(await evalOp(type, { a, b })).toBe(expected); + }); + + it.each([ + ["IsNaN", NaN, true], + ["IsNaN", 3, false], + ["IsInfinity", Infinity, true], + ["IsInfinity", 3, false], + ])("%s(%d) → %s", async (type, a, expected) => { + expect(await evalOp(type, { a })).toBe(expected); + }); + + it.each([ + ["BitwiseAnd", 6, 3, 2], + ["BitwiseOr", 6, 1, 7], + ["BitwiseXor", 6, 3, 5], + ["BitwiseLeftShift", 1, 4, 16], + ["BitwiseRightShift", 16, 2, 4], + ])("%s(%d, %d) on numbers → %d", async (type, a, b, expected) => { + const r = await evalOp(type, { a, b }); + expect(isFgIntResult(r) ? (r as { value: number }).value : r).toBe(expected); + }); + + it.each([ + ["LeadingZeros", 1, 31], + ["TrailingZeros", 8, 3], + ["OneBitsCounter", 7, 3], + ["BitwiseNot", 0, -1], + ])("%s(%d) on numbers → %d", async (type, a, expected) => { + const r = await evalOp(type, { a }); + expect(isFgIntResult(r) ? (r as { value: number }).value : r).toBe(expected); + }); + + it("bitwise and/or/not dispatch booleans logically", async () => { + expect(await evalOp("BitwiseAnd", { a: true, b: false })).toBe(false); + expect(await evalOp("BitwiseOr", { a: true, b: false })).toBe(true); + expect(await evalOp("BitwiseNot", { a: true })).toBe(false); + }); + + it("bitwise ops round-trip FlowGraphInteger", async () => { + const r = await evalOp("BitwiseAnd", { a: fgInt(6), b: fgInt(3) }); + expect(isFgIntResult(r)).toBe(true); + expect((r as { value: number }).value).toBe(2); + }); + + it.each([ + ["Length", { x: 3, y: 4, z: 0 }, 5], + ["Dot", undefined, 32], + ] as const)("vector scalar op %s", async (type) => { + if (type === "Length") { + expect(await evalOp("Length", { a: { x: 3, y: 4, z: 0 } })).toBeCloseTo(5, 10); + } else { + expect(await evalOp("Dot", { a: { x: 1, y: 2, z: 3 }, b: { x: 4, y: 5, z: 6 } })).toBeCloseTo(32, 10); + } + }); + + it("Normalize returns a unit vector", async () => { + const r = (await evalOp("Normalize", { a: { x: 3, y: 4, z: 0 } })) as { x: number; y: number; z: number }; + expect(r.x).toBeCloseTo(0.6, 10); + expect(r.y).toBeCloseTo(0.8, 10); + expect(r.z).toBeCloseTo(0, 10); + }); + + it("Cross computes the right-handed cross product", async () => { + expect(await evalOp("Cross", { a: { x: 1, y: 0, z: 0 }, b: { x: 0, y: 1, z: 0 } })).toEqual({ x: 0, y: 0, z: 1 }); + }); + + it("Rotate2D rotates a Vec2 CCW by angle (b)", async () => { + const r = (await evalOp("Rotate2D", { a: { x: 1, y: 0 }, b: Math.PI / 2 })) as { x: number; y: number }; + expect(r.x).toBeCloseTo(0, 10); + expect(r.y).toBeCloseTo(1, 10); + }); + + it("Rotate3D by identity quaternion is a no-op", async () => { + const r = (await evalOp("Rotate3D", { a: { x: 1, y: 2, z: 3 }, b: { x: 0, y: 0, z: 0, w: 1 } })) as { x: number; y: number; z: number }; + expect(r.x).toBeCloseTo(1, 10); + expect(r.y).toBeCloseTo(2, 10); + expect(r.z).toBeCloseTo(3, 10); + }); + + it("CombineVector3/4 build vectors from scalars", async () => { + expect(await evalOp("CombineVector3", { a: 1, b: 2, c: 3 })).toEqual({ x: 1, y: 2, z: 3 }); + expect(await evalOp("CombineVector4", { a: 1, b: 2, c: 3, d: 4 })).toEqual({ x: 1, y: 2, z: 3, w: 4 }); + }); + + it("ExtractVector3/4 split vectors into component sockets", async () => { + expect(await evalOp("ExtractVector3", { a: { x: 7, y: 8, z: 9 } }, { outSocket: "z" })).toBe(9); + expect(await evalOp("ExtractVector4", { a: { x: 7, y: 8, z: 9, w: 10 } }, { outSocket: "w" })).toBe(10); + }); + + it.each([ + ["E", Math.E], + ["PI", Math.PI], + ])("constant %s emits its value", async (type, expected) => { + expect(await evalOp(type, {})).toBeCloseTo(expected as number, 12); + }); + + it("Inf and NaN constants", async () => { + expect(await evalOp("Inf", {})).toBe(Infinity); + expect(Number.isNaN(await evalOp("NaN", {}))).toBe(true); + }); + + it("MathInterpolation mixes a→b by t = (1-t)a + t·b", async () => { + expect(await evalOp("MathInterpolation", { a: 0, b: 10, c: 0.25 })).toBeCloseTo(2.5, 10); + }); + + it("Conditional (select) picks onTrue/onFalse from condition", async () => { + expect(await evalOp("Conditional", { condition: true, onTrue: 11, onFalse: 22 })).toBe(11); + expect(await evalOp("Conditional", { condition: false, onTrue: 11, onFalse: 22 })).toBe(22); + }); + + it("DataSwitch selects the matching case, else default", async () => { + const config = { cases: [0, 1, 2] }; + expect(await evalOp("DataSwitch", { case: 1, default: -1, in_0: 10, in_1: 20, in_2: 30 }, { config })).toBe(20); + expect(await evalOp("DataSwitch", { case: 9, default: -1, in_0: 10, in_1: 20, in_2: 30 }, { config })).toBe(-1); + }); + + it.each([ + ["BooleanToFloat", true, 1], + ["BooleanToInt", false, 0], + ["FloatToBoolean", 0, false], + ["FloatToBoolean", 2.5, true], + ["IntToFloat", 5, 5], + ])("conversion %s", async (type, a, expected) => { + const r = await evalOp(type, { a }); + const v = isFgIntResult(r) ? (r as { value: number }).value : r; + expect(v).toBe(expected); + }); +}); + +/** True when a value is a FlowGraphInteger box (re-wrapped by bitwise/int ops). */ +function isFgIntResult(v: FgValue): boolean { + return typeof v === "object" && v !== null && "value" in (v as Record) && typeof (v as { value: unknown }).value === "number" && !("x" in (v as Record)); +} + describe("flow-graph blocks — property accessors", () => { function vec3Accessor(initial: { x: number; y: number; z: number }): { acc: FgAccessor; box: { v: FgValue } } { const box = { v: initial as FgValue }; From 3e928c6b24d467e2ecd8cd8fd184cd0aa3eee629 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 18:45:58 +0200 Subject: [PATCH 07/13] feat(flow-graph): add Phase 3f matrix + quaternion blocks Add the matrix and quaternion math surface, using Lite's column-major storage convention (flow-graph 4x4 == core Mat4; FgMatrix2D/3D column-major), which is mathematically equivalent to BJS's row-major implementation: - fg-math.ts: column-major dispatchers for transform, matMul, transpose, determinant, inverse, compose/decompose (4x4 reuses core mat4Multiply/ mat4Invert/mat4Compose/mat4Decompose; 2x2/3x3 + transpose/determinant self-contained), plus quaternion conjugate/angleBetween/fromAxisAngle/ toAxisAngle/fromDirections. - blocks/math/*: 18 new block defs (transform-vector, combine/extract matrix 2d/3d/4x4, transpose, determinant, invert-matrix, matrix-multiplication, matrix-compose, matrix-decompose, quat-conjugate, angle-between, quaternion-from-axis-angle, axis-angle-from-quaternion, quaternion-from-directions). - interactivity-parser.ts: load float2x2/3x3/4x4 literals (column-major direct). - block-registry.ts + gltf/declaration-mapper.ts: lazy cases + NATIVE_OPS entries (glTF op strings verified against pinned BJS declarationMapper). - tests: matrix/quaternion unit coverage with hand-computed assertions (749 unit tests green). Quaternion multiply is intentionally left out of the generic Multiply block: Vec4 and Quaternion are shape-identical at runtime in Lite, so Hamilton-product dispatch would break component-wise Vec4 math. A dedicated block can be added later if needed. Note: bundle manifest regeneration deferred to the end of Phase 3. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../src/flow-graph/block-registry.ts | 38 ++ .../flow-graph/blocks/math/angle-between.ts | 22 ++ .../blocks/math/axis-angle-from-quaternion.ts | 25 ++ .../flow-graph/blocks/math/combine-matrix.ts | 25 ++ .../blocks/math/combine-matrix2d.ts | 25 ++ .../blocks/math/combine-matrix3d.ts | 25 ++ .../src/flow-graph/blocks/math/determinant.ts | 22 ++ .../flow-graph/blocks/math/extract-matrix.ts | 24 ++ .../blocks/math/extract-matrix2d.ts | 24 ++ .../blocks/math/extract-matrix3d.ts | 24 ++ .../flow-graph/blocks/math/invert-matrix.ts | 22 ++ .../flow-graph/blocks/math/matrix-compose.ts | 24 ++ .../blocks/math/matrix-decompose.ts | 26 ++ .../blocks/math/matrix-multiplication.ts | 23 ++ .../flow-graph/blocks/math/quat-conjugate.ts | 21 + .../blocks/math/quaternion-from-axis-angle.ts | 24 ++ .../blocks/math/quaternion-from-directions.ts | 24 ++ .../blocks/math/transform-vector.ts | 23 ++ .../src/flow-graph/blocks/math/transpose.ts | 22 ++ .../babylon-lite/src/flow-graph/fg-math.ts | 374 +++++++++++++++++- .../src/flow-graph/gltf/declaration-mapper.ts | 82 ++++ .../flow-graph/gltf/interactivity-parser.ts | 14 + tests/lite/unit/flow-graph-blocks.test.ts | 292 +++++++++++++- 23 files changed, 1213 insertions(+), 12 deletions(-) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/angle-between.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/axis-angle-from-quaternion.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix2d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix3d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/determinant.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix2d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix3d.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/invert-matrix.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/matrix-compose.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/matrix-decompose.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/matrix-multiplication.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/quat-conjugate.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-axis-angle.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-directions.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/transform-vector.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/transpose.ts diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index 98ca52c4ac..5ba3ef65db 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -185,6 +185,44 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/math/conditional.js")).conditionalDef; case FgBlockType.DataSwitch: return async () => (await import("./blocks/math/data-switch.js")).dataSwitchDef; + + // ─── Math: Phase 3f (matrix + quaternion) ──────────────────────────── + case FgBlockType.TransformVector: + return async () => (await import("./blocks/math/transform-vector.js")).transformVectorDef; + case FgBlockType.CombineMatrix2D: + return async () => (await import("./blocks/math/combine-matrix2d.js")).combineMatrix2DDef; + case FgBlockType.CombineMatrix3D: + return async () => (await import("./blocks/math/combine-matrix3d.js")).combineMatrix3DDef; + case FgBlockType.CombineMatrix: + return async () => (await import("./blocks/math/combine-matrix.js")).combineMatrixDef; + case FgBlockType.ExtractMatrix2D: + return async () => (await import("./blocks/math/extract-matrix2d.js")).extractMatrix2DDef; + case FgBlockType.ExtractMatrix3D: + return async () => (await import("./blocks/math/extract-matrix3d.js")).extractMatrix3DDef; + case FgBlockType.ExtractMatrix: + return async () => (await import("./blocks/math/extract-matrix.js")).extractMatrixDef; + case FgBlockType.Transpose: + return async () => (await import("./blocks/math/transpose.js")).transposeDef; + case FgBlockType.Determinant: + return async () => (await import("./blocks/math/determinant.js")).determinantDef; + case FgBlockType.InvertMatrix: + return async () => (await import("./blocks/math/invert-matrix.js")).invertMatrixDef; + case FgBlockType.MatrixMultiplication: + return async () => (await import("./blocks/math/matrix-multiplication.js")).matrixMultiplicationDef; + case FgBlockType.MatrixCompose: + return async () => (await import("./blocks/math/matrix-compose.js")).matrixComposeDef; + case FgBlockType.MatrixDecompose: + return async () => (await import("./blocks/math/matrix-decompose.js")).matrixDecomposeDef; + case FgBlockType.Conjugate: + return async () => (await import("./blocks/math/quat-conjugate.js")).quatConjugateDef; + case FgBlockType.AngleBetween: + return async () => (await import("./blocks/math/angle-between.js")).angleBetweenDef; + case FgBlockType.QuaternionFromAxisAngle: + return async () => (await import("./blocks/math/quaternion-from-axis-angle.js")).quaternionFromAxisAngleDef; + case FgBlockType.AxisAngleFromQuaternion: + return async () => (await import("./blocks/math/axis-angle-from-quaternion.js")).axisAngleFromQuaternionDef; + case FgBlockType.QuaternionFromDirections: + return async () => (await import("./blocks/math/quaternion-from-directions.js")).quaternionFromDirectionsDef; case FgBlockType.BooleanToFloat: return async () => (await import("./blocks/conversion/boolean-to-float.js")).booleanToFloatDef; case FgBlockType.BooleanToInt: diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/angle-between.ts b/packages/babylon-lite/src/flow-graph/blocks/math/angle-between.ts new file mode 100644 index 0000000000..6f0ed9afff --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/angle-between.ts @@ -0,0 +1,22 @@ +// AngleBetween (BJS FlowGraphAngleBetweenBlock, glTF op `math/quatAngleBetween`). +// Data block (PULL): emits scalar `value` = 2·acos(clamp(dot(a,b),-1,1)). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAngleBetween } from "../../fg-math.js"; + +export const angleBetweenDef: FgBlockDef = { + type: FgBlockType.AngleBetween, + build: () => ({ + dataIn: [sockIn("a", FgType.Quaternion), sockIn("b", FgType.Quaternion)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgAngleBetween(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/axis-angle-from-quaternion.ts b/packages/babylon-lite/src/flow-graph/blocks/math/axis-angle-from-quaternion.ts new file mode 100644 index 0000000000..1687528db0 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/axis-angle-from-quaternion.ts @@ -0,0 +1,25 @@ +// AxisAngleFromQuaternion (BJS FlowGraphAxisAngleFromQuaternionBlock, +// glTF op `math/quatToAxisAngle`). +// Data block (PULL): `a` = Quaternion → `axis` (Vec3), `angle` (number), +// `isValid` (boolean). When sin(angle/2) is near zero, axis defaults to (1,0,0). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgAxisAngleFromQuaternion } from "../../fg-math.js"; + +export const axisAngleFromQuaternionDef: FgBlockDef = { + type: FgBlockType.AxisAngleFromQuaternion, + build: () => ({ + dataIn: [sockIn("a", FgType.Quaternion)], + dataOut: [sockOut("axis", FgType.Vector3), sockOut("angle", FgType.Number), sockOut("isValid", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const { axis, angle, isValid } = fgAxisAngleFromQuaternion(getDataValue(ctx, env, block, "a")); + setDataValue(ctx, block, "axis", axis); + setDataValue(ctx, block, "angle", angle); + setDataValue(ctx, block, "isValid", isValid); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix.ts new file mode 100644 index 0000000000..fc4c09faa6 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix.ts @@ -0,0 +1,25 @@ +// CombineMatrix (BJS FlowGraphCombineMatrixBlock, glTF op `math/combine4x4`). +// Data block (PULL): 16 scalar inputs `input_0..input_15` (column-major order) +// → `value` (Mat4). Inputs map directly: input_i = m[i]. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombineMatrix } from "../../fg-math.js"; + +export const combineMatrixDef: FgBlockDef = { + type: FgBlockType.CombineMatrix, + build: () => ({ + dataIn: Array.from({ length: 16 }, (_, i) => sockIn(`input_${i}`, FgType.Number)), + dataOut: [sockOut("value", FgType.Matrix)], + }), + updateOutputs(block, ctx, env) { + const inputs = Array.from({ length: 16 }, (_, i) => { + const v = getDataValue(ctx, env, block, `input_${i}`); + return typeof v === "number" ? v : 0; + }); + setDataValue(ctx, block, "value", fgCombineMatrix(inputs)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix2d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix2d.ts new file mode 100644 index 0000000000..a04ce881e4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix2d.ts @@ -0,0 +1,25 @@ +// CombineMatrix2D (BJS FlowGraphCombineMatrix2DBlock, glTF op `math/combine2x2`). +// Data block (PULL): 4 scalar inputs `input_0..input_3` (column-major order) +// → `value` (FgMatrix2D). Inputs map directly: input_i = m[i]. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombineMatrix2D } from "../../fg-math.js"; + +export const combineMatrix2DDef: FgBlockDef = { + type: FgBlockType.CombineMatrix2D, + build: () => ({ + dataIn: Array.from({ length: 4 }, (_, i) => sockIn(`input_${i}`, FgType.Number)), + dataOut: [sockOut("value", FgType.Matrix2D)], + }), + updateOutputs(block, ctx, env) { + const inputs = Array.from({ length: 4 }, (_, i) => { + const v = getDataValue(ctx, env, block, `input_${i}`); + return typeof v === "number" ? v : 0; + }); + setDataValue(ctx, block, "value", fgCombineMatrix2D(inputs)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix3d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix3d.ts new file mode 100644 index 0000000000..3deab1317b --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/combine-matrix3d.ts @@ -0,0 +1,25 @@ +// CombineMatrix3D (BJS FlowGraphCombineMatrix3DBlock, glTF op `math/combine3x3`). +// Data block (PULL): 9 scalar inputs `input_0..input_8` (column-major order) +// → `value` (FgMatrix3D). Inputs map directly: input_i = m[i]. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgCombineMatrix3D } from "../../fg-math.js"; + +export const combineMatrix3DDef: FgBlockDef = { + type: FgBlockType.CombineMatrix3D, + build: () => ({ + dataIn: Array.from({ length: 9 }, (_, i) => sockIn(`input_${i}`, FgType.Number)), + dataOut: [sockOut("value", FgType.Matrix3D)], + }), + updateOutputs(block, ctx, env) { + const inputs = Array.from({ length: 9 }, (_, i) => { + const v = getDataValue(ctx, env, block, `input_${i}`); + return typeof v === "number" ? v : 0; + }); + setDataValue(ctx, block, "value", fgCombineMatrix3D(inputs)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/determinant.ts b/packages/babylon-lite/src/flow-graph/blocks/math/determinant.ts new file mode 100644 index 0000000000..2ad30b2b6a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/determinant.ts @@ -0,0 +1,22 @@ +// Determinant (BJS FlowGraphDeterminantBlock, glTF op `math/determinant`). +// Data block (PULL): emits scalar `value` = det(a). +// Supports FgMatrix2D, FgMatrix3D, and Mat4. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgDeterminant } from "../../fg-math.js"; + +export const determinantDef: FgBlockDef = { + type: FgBlockType.Determinant, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Number)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgDeterminant(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix.ts new file mode 100644 index 0000000000..4c2b777b79 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix.ts @@ -0,0 +1,24 @@ +// ExtractMatrix (BJS FlowGraphExtractMatrixBlock, glTF op `math/extract4x4`). +// Data block (PULL): Mat4 input `input` → 16 scalar outputs `output_0..output_15` +// in column-major order (output_i = m[i]). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtractMatrix } from "../../fg-math.js"; + +export const extractMatrixDef: FgBlockDef = { + type: FgBlockType.ExtractMatrix, + build: () => ({ + dataIn: [sockIn("input", FgType.Matrix)], + dataOut: Array.from({ length: 16 }, (_, i) => sockOut(`output_${i}`, FgType.Number)), + }), + updateOutputs(block, ctx, env) { + const elems = fgExtractMatrix(getDataValue(ctx, env, block, "input")); + for (let i = 0; i < 16; i++) { + setDataValue(ctx, block, `output_${i}`, elems[i]!); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix2d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix2d.ts new file mode 100644 index 0000000000..c7d0f137f5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix2d.ts @@ -0,0 +1,24 @@ +// ExtractMatrix2D (BJS FlowGraphExtractMatrix2DBlock, glTF op `math/extract2x2`). +// Data block (PULL): FgMatrix2D input `input` → 4 scalar outputs `output_0..output_3` +// in column-major order (output_i = m.m[i]). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtractMatrix2D } from "../../fg-math.js"; + +export const extractMatrix2DDef: FgBlockDef = { + type: FgBlockType.ExtractMatrix2D, + build: () => ({ + dataIn: [sockIn("input", FgType.Matrix2D)], + dataOut: Array.from({ length: 4 }, (_, i) => sockOut(`output_${i}`, FgType.Number)), + }), + updateOutputs(block, ctx, env) { + const elems = fgExtractMatrix2D(getDataValue(ctx, env, block, "input")); + for (let i = 0; i < 4; i++) { + setDataValue(ctx, block, `output_${i}`, elems[i]!); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix3d.ts b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix3d.ts new file mode 100644 index 0000000000..9a905b0c44 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/extract-matrix3d.ts @@ -0,0 +1,24 @@ +// ExtractMatrix3D (BJS FlowGraphExtractMatrix3DBlock, glTF op `math/extract3x3`). +// Data block (PULL): FgMatrix3D input `input` → 9 scalar outputs `output_0..output_8` +// in column-major order (output_i = m.m[i]). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgExtractMatrix3D } from "../../fg-math.js"; + +export const extractMatrix3DDef: FgBlockDef = { + type: FgBlockType.ExtractMatrix3D, + build: () => ({ + dataIn: [sockIn("input", FgType.Matrix3D)], + dataOut: Array.from({ length: 9 }, (_, i) => sockOut(`output_${i}`, FgType.Number)), + }), + updateOutputs(block, ctx, env) { + const elems = fgExtractMatrix3D(getDataValue(ctx, env, block, "input")); + for (let i = 0; i < 9; i++) { + setDataValue(ctx, block, `output_${i}`, elems[i]!); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/invert-matrix.ts b/packages/babylon-lite/src/flow-graph/blocks/math/invert-matrix.ts new file mode 100644 index 0000000000..48915fd53f --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/invert-matrix.ts @@ -0,0 +1,22 @@ +// InvertMatrix (BJS FlowGraphInvertMatrixBlock, glTF op `math/inverse`). +// Data block (PULL): emits `value` = inverse of input matrix `a`. +// Returns identity when singular. Supports FgMatrix2D, FgMatrix3D, and Mat4. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgInvertMatrix } from "../../fg-math.js"; + +export const invertMatrixDef: FgBlockDef = { + type: FgBlockType.InvertMatrix, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgInvertMatrix(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/matrix-compose.ts b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-compose.ts new file mode 100644 index 0000000000..0462a6eee5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-compose.ts @@ -0,0 +1,24 @@ +// MatrixCompose (BJS FlowGraphMatrixComposeBlock, glTF op `math/matCompose`). +// Data block (PULL): composes a Mat4 from position (Vec3), rotationQuaternion +// (Quaternion), and scaling (Vec3). Uses core mat4Compose (column-major). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMatrixCompose } from "../../fg-math.js"; + +export const matrixComposeDef: FgBlockDef = { + type: FgBlockType.MatrixCompose, + build: () => ({ + dataIn: [sockIn("position", FgType.Vector3), sockIn("rotationQuaternion", FgType.Quaternion), sockIn("scaling", FgType.Vector3)], + dataOut: [sockOut("value", FgType.Matrix)], + }), + updateOutputs(block, ctx, env) { + const pos = getDataValue(ctx, env, block, "position"); + const quat = getDataValue(ctx, env, block, "rotationQuaternion"); + const scale = getDataValue(ctx, env, block, "scaling"); + setDataValue(ctx, block, "value", fgMatrixCompose(pos, quat, scale)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/matrix-decompose.ts b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-decompose.ts new file mode 100644 index 0000000000..8974c607ac --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-decompose.ts @@ -0,0 +1,26 @@ +// MatrixDecompose (BJS FlowGraphMatrixDecomposeBlock, glTF op `math/matDecompose`). +// Data block (PULL): decomposes a Mat4 into position (Vec3), rotationQuaternion +// (Quaternion), scaling (Vec3), and isValid (boolean). +// `isValid` is false if the matrix is not a valid TRS matrix (bottom row ≠ [0,0,0,1]). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMatrixDecompose } from "../../fg-math.js"; + +export const matrixDecomposeDef: FgBlockDef = { + type: FgBlockType.MatrixDecompose, + build: () => ({ + dataIn: [sockIn("input", FgType.Matrix)], + dataOut: [sockOut("position", FgType.Vector3), sockOut("rotationQuaternion", FgType.Quaternion), sockOut("scaling", FgType.Vector3), sockOut("isValid", FgType.Boolean)], + }), + updateOutputs(block, ctx, env) { + const { position, rotationQuaternion, scaling, isValid } = fgMatrixDecompose(getDataValue(ctx, env, block, "input")); + setDataValue(ctx, block, "position", position); + setDataValue(ctx, block, "rotationQuaternion", rotationQuaternion); + setDataValue(ctx, block, "scaling", scaling); + setDataValue(ctx, block, "isValid", isValid); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/matrix-multiplication.ts b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-multiplication.ts new file mode 100644 index 0000000000..0c3a36ba80 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/matrix-multiplication.ts @@ -0,0 +1,23 @@ +// MatrixMultiplication (BJS FlowGraphMatrixMultiplicationBlock, glTF op `math/matMul`). +// Data block (PULL): emits `value` = a × b (standard matrix product). +// Supports FgMatrix2D×FgMatrix2D, FgMatrix3D×FgMatrix3D, Mat4×Mat4. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgMatrixMultiplication } from "../../fg-math.js"; + +export const matrixMultiplicationDef: FgBlockDef = { + type: FgBlockType.MatrixMultiplication, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgMatrixMultiplication(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/quat-conjugate.ts b/packages/babylon-lite/src/flow-graph/blocks/math/quat-conjugate.ts new file mode 100644 index 0000000000..eb13f96761 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/quat-conjugate.ts @@ -0,0 +1,21 @@ +// QuatConjugate (BJS FlowGraphConjugateBlock, glTF op `math/quatConjugate`). +// Data block (PULL): emits `value` = (-x, -y, -z, w) via fg-math's fgConjugate. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgConjugate } from "../../fg-math.js"; + +export const quatConjugateDef: FgBlockDef = { + type: FgBlockType.Conjugate, + build: () => ({ + dataIn: [sockIn("a", FgType.Quaternion)], + dataOut: [sockOut("value", FgType.Quaternion)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgConjugate(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-axis-angle.ts b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-axis-angle.ts new file mode 100644 index 0000000000..f218d2f7f5 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-axis-angle.ts @@ -0,0 +1,24 @@ +// QuaternionFromAxisAngle (BJS FlowGraphQuaternionFromAxisAngleBlock, +// glTF op `math/quatFromAxisAngle`). +// Data block (PULL): `a` = Vec3 axis, `b` = number angle → `value` = Quaternion. +// Does NOT pre-normalize axis (replicates BJS Quaternion.RotationAxis). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgQuaternionFromAxisAngle } from "../../fg-math.js"; + +export const quaternionFromAxisAngleDef: FgBlockDef = { + type: FgBlockType.QuaternionFromAxisAngle, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector3), sockIn("b", FgType.Number)], + dataOut: [sockOut("value", FgType.Quaternion)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgQuaternionFromAxisAngle(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-directions.ts b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-directions.ts new file mode 100644 index 0000000000..beab3b1e17 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-from-directions.ts @@ -0,0 +1,24 @@ +// QuaternionFromDirections (BJS FlowGraphQuaternionFromDirectionsBlock, +// glTF op `math/quatFromDirections`). +// Data block (PULL): `a`, `b` = Vec3 (assumed unit) → `value` = Quaternion. +// Does NOT pre-normalize inputs. Computes cross(a,b) as axis, acos(dot(a,b)) as angle. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgQuaternionFromDirections } from "../../fg-math.js"; + +export const quaternionFromDirectionsDef: FgBlockDef = { + type: FgBlockType.QuaternionFromDirections, + build: () => ({ + dataIn: [sockIn("a", FgType.Vector3), sockIn("b", FgType.Vector3)], + dataOut: [sockOut("value", FgType.Quaternion)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgQuaternionFromDirections(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/transform-vector.ts b/packages/babylon-lite/src/flow-graph/blocks/math/transform-vector.ts new file mode 100644 index 0000000000..9cd8c07750 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/transform-vector.ts @@ -0,0 +1,23 @@ +// TransformVector (BJS FlowGraphTransformVectorBlock, glTF op `math/transform`). +// Data block (PULL): `value` = M · v. Input `a` is the vector, `b` is the matrix. +// Dispatches on runtime shape: Vec2×Matrix2D, Vec3×Matrix3D, Vec4×Mat4. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgTransformVector } from "../../fg-math.js"; + +export const transformVectorDef: FgBlockDef = { + type: FgBlockType.TransformVector, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgTransformVector(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/transpose.ts b/packages/babylon-lite/src/flow-graph/blocks/math/transpose.ts new file mode 100644 index 0000000000..305b53d514 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/transpose.ts @@ -0,0 +1,22 @@ +// Transpose (BJS FlowGraphTransposeBlock, glTF op `math/transpose`). +// Data block (PULL): emits `value` = transpose of input matrix `a`. +// Supports FgMatrix2D, FgMatrix3D, and Mat4 (all column-major). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgTranspose } from "../../fg-math.js"; + +export const transposeDef: FgBlockDef = { + type: FgBlockType.Transpose, + build: () => ({ + dataIn: [sockIn("a", FgType.Any)], + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + setDataValue(ctx, block, "value", fgTranspose(a)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts index 224a266e42..69beba1e1d 100644 --- a/packages/babylon-lite/src/flow-graph/fg-math.ts +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -8,14 +8,25 @@ // Phase 3 as the math block library broadens. import { fgInt, isFgInt } from "./custom-types/fg-integer.js"; +import { isFgMatrix2D, isFgMatrix3D, fgMatrix2D, fgMatrix3D } from "./custom-types/fg-matrix.js"; +import type { FgMatrix2D, FgMatrix3D } from "./custom-types/fg-matrix.js"; import type { FgValue, Vec2 } from "./types.js"; -import type { Quat, Vec3, Vec4 } from "../math/types.js"; +import type { Mat4, Quat, Vec3, Vec4 } from "../math/types.js"; import { crossVec3 } from "../math/cross-vec3.js"; import { dotVec3 } from "../math/dot-vec3.js"; +import { mat4Multiply } from "../math/mat4-multiply.js"; +import { mat4Invert } from "../math/mat4-invert.js"; +import { mat4Compose } from "../math/mat4-compose.js"; +import { mat4Decompose } from "../math/mat4-decompose.js"; +import { mat4Identity } from "../math/mat4-identity.js"; function isVec2(v: unknown): v is Vec2 { return typeof v === "object" && v !== null && "x" in v && "y" in v && !("z" in v); } +/** Runtime guard for `Mat4` (column-major Float32Array of length 16). */ +function isMat4(v: unknown): v is Mat4 { + return (v instanceof Float32Array || v instanceof Float64Array) && v.length === 16; +} function isVec3(v: unknown): v is Vec3 { return typeof v === "object" && v !== null && "x" in v && "y" in v && "z" in v && !("w" in v); } @@ -575,3 +586,364 @@ export function fgConjugate(a: FgValue): FgValue { } return a; } + +// ─── Matrix ops (Phase 3f) ──────────────────────────────────────────────────── + +/** + * Transform a vector by a matrix (`M · v`, column-major). + * + * Dispatch: + * - `Vec2 × FgMatrix2D` — 2×2 column-major multiply + * - `Vec3 × FgMatrix3D` — 3×3 column-major multiply + * - `Vec4 × Mat4` — 4×4 column-major multiply (glTF `math/transform`) + * + * Equivalent to BJS `v × M` (row-vector) because Lite stores column-major while + * BJS stores row-major: the mathematical result is identical. + */ +export function fgTransformVector(v: FgValue, m: FgValue): FgValue { + if (isVec2(v) && isFgMatrix2D(m)) { + const mm = m.m; + return { x: mm[0]! * v.x + mm[2]! * v.y, y: mm[1]! * v.x + mm[3]! * v.y }; + } + if (isVec3(v) && isFgMatrix3D(m)) { + const mm = m.m; + return { + x: mm[0]! * v.x + mm[3]! * v.y + mm[6]! * v.z, + y: mm[1]! * v.x + mm[4]! * v.y + mm[7]! * v.z, + z: mm[2]! * v.x + mm[5]! * v.y + mm[8]! * v.z, + }; + } + if (isVec4(v) && isMat4(m)) { + return { + x: m[0]! * v.x + m[4]! * v.y + m[8]! * v.z + m[12]! * v.w, + y: m[1]! * v.x + m[5]! * v.y + m[9]! * v.z + m[13]! * v.w, + z: m[2]! * v.x + m[6]! * v.y + m[10]! * v.z + m[14]! * v.w, + w: m[3]! * v.x + m[7]! * v.y + m[11]! * v.z + m[15]! * v.w, + }; + } + return v; +} + +/** + * Build an `FgMatrix2D` from 4 column-major scalar inputs (glTF `math/combine2x2`). + * Inputs map directly to storage: `input_i = m[i]`. + */ +export function fgCombineMatrix2D(inputs: readonly number[]): FgMatrix2D { + return fgMatrix2D(inputs); +} + +/** + * Build an `FgMatrix3D` from 9 column-major scalar inputs (glTF `math/combine3x3`). + * Inputs map directly to storage: `input_i = m[i]`. + */ +export function fgCombineMatrix3D(inputs: readonly number[]): FgMatrix3D { + return fgMatrix3D(inputs); +} + +/** + * Build a `Mat4` from 16 column-major scalar inputs (glTF `math/combine4x4`). + * Inputs map directly to storage: `input_i = m[i]`. + */ +export function fgCombineMatrix(inputs: readonly number[]): Mat4 { + const out = new Float32Array(16); + for (let i = 0; i < 16; i++) { + out[i] = inputs[i] ?? 0; + } + return out as unknown as Mat4; +} + +/** + * Extract `FgMatrix2D` elements in column-major order (glTF `math/extract2x2`). + * Output `output_i = m.m[i]` — Lite's column-major storage order. + */ +export function fgExtractMatrix2D(m: FgValue): [number, number, number, number] { + if (isFgMatrix2D(m)) { + return [m.m[0]!, m.m[1]!, m.m[2]!, m.m[3]!]; + } + return [0, 0, 0, 0]; +} + +/** + * Extract `FgMatrix3D` elements in column-major order (glTF `math/extract3x3`). + * Output `output_i = m.m[i]` — Lite's column-major storage order. + */ +export function fgExtractMatrix3D(m: FgValue): [number, number, number, number, number, number, number, number, number] { + if (isFgMatrix3D(m)) { + return [m.m[0]!, m.m[1]!, m.m[2]!, m.m[3]!, m.m[4]!, m.m[5]!, m.m[6]!, m.m[7]!, m.m[8]!]; + } + return [0, 0, 0, 0, 0, 0, 0, 0, 0]; +} + +/** + * Extract `Mat4` elements in column-major order (glTF `math/extract4x4`). + * Output `output_i = m[i]` — Lite's column-major storage order. + */ +export function fgExtractMatrix(m: FgValue): number[] { + if (isMat4(m)) { + return Array.from({ length: 16 }, (_, i) => m[i]!); + } + return Array.from({ length: 16 }, () => 0); +} + +/** + * Transpose a matrix (glTF `math/transpose`). Column-major in, column-major out. + * Supports `FgMatrix2D`, `FgMatrix3D`, and `Mat4`. + */ +export function fgTranspose(m: FgValue): FgValue { + if (isFgMatrix2D(m)) { + const mm = m.m; + // swap off-diagonal: [m0,m1,m2,m3] → [m0,m2,m1,m3] + return fgMatrix2D([mm[0]!, mm[2]!, mm[1]!, mm[3]!]); + } + if (isFgMatrix3D(m)) { + const mm = m.m; + return fgMatrix3D([mm[0]!, mm[3]!, mm[6]!, mm[1]!, mm[4]!, mm[7]!, mm[2]!, mm[5]!, mm[8]!]); + } + if (isMat4(m)) { + const out = new Float32Array(16); + for (let i = 0; i < 4; i++) { + for (let j = 0; j < 4; j++) { + out[j * 4 + i] = m[i * 4 + j]!; + } + } + return out as unknown as Mat4; + } + return m; +} + +/** + * Compute the scalar determinant of a matrix (glTF `math/determinant`). + * Determinant is layout-independent (`det(M) = det(M^T)`), so the column-major + * formula yields the same scalar as BJS's row-major formula. + */ +export function fgDeterminant(m: FgValue): number { + if (isFgMatrix2D(m)) { + const mm = m.m; + return mm[0]! * mm[3]! - mm[1]! * mm[2]!; + } + if (isFgMatrix3D(m)) { + const mm = m.m; + return mm[0]! * (mm[4]! * mm[8]! - mm[7]! * mm[5]!) - mm[3]! * (mm[1]! * mm[8]! - mm[7]! * mm[2]!) + mm[6]! * (mm[1]! * mm[5]! - mm[4]! * mm[2]!); + } + if (isMat4(m)) { + const a00 = m[0]!, + a01 = m[1]!, + a02 = m[2]!, + a03 = m[3]!; + const a10 = m[4]!, + a11 = m[5]!, + a12 = m[6]!, + a13 = m[7]!; + const a20 = m[8]!, + a21 = m[9]!, + a22 = m[10]!, + a23 = m[11]!; + const a30 = m[12]!, + a31 = m[13]!, + a32 = m[14]!, + a33 = m[15]!; + const b00 = a00 * a11 - a01 * a10, + b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10, + b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11, + b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30, + b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30, + b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31, + b11 = a22 * a33 - a23 * a32; + return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + } + return 0; +} + +/** + * Invert a matrix (glTF `math/inverse`). Returns the identity when singular. + * Supports `FgMatrix2D`, `FgMatrix3D`, and `Mat4` (via core `mat4Invert`). + */ +export function fgInvertMatrix(m: FgValue): FgValue { + if (isFgMatrix2D(m)) { + const mm = m.m; + const det = mm[0]! * mm[3]! - mm[1]! * mm[2]!; + if (Math.abs(det) < 1e-10) { + return fgMatrix2D(); + } + const d = 1 / det; + return fgMatrix2D([mm[3]! * d, -mm[1]! * d, -mm[2]! * d, mm[0]! * d]); + } + if (isFgMatrix3D(m)) { + const mm = m.m; + const det = mm[0]! * (mm[4]! * mm[8]! - mm[7]! * mm[5]!) - mm[3]! * (mm[1]! * mm[8]! - mm[7]! * mm[2]!) + mm[6]! * (mm[1]! * mm[5]! - mm[4]! * mm[2]!); + if (Math.abs(det) < 1e-10) { + return fgMatrix3D(); + } + const d = 1 / det; + return fgMatrix3D([ + (mm[4]! * mm[8]! - mm[7]! * mm[5]!) * d, + -(mm[1]! * mm[8]! - mm[7]! * mm[2]!) * d, + (mm[1]! * mm[5]! - mm[4]! * mm[2]!) * d, + -(mm[3]! * mm[8]! - mm[6]! * mm[5]!) * d, + (mm[0]! * mm[8]! - mm[6]! * mm[2]!) * d, + -(mm[0]! * mm[5]! - mm[3]! * mm[2]!) * d, + (mm[3]! * mm[7]! - mm[6]! * mm[4]!) * d, + -(mm[0]! * mm[7]! - mm[6]! * mm[1]!) * d, + (mm[0]! * mm[4]! - mm[3]! * mm[1]!) * d, + ]); + } + if (isMat4(m)) { + return mat4Invert(m) ?? mat4Identity(); + } + return m; +} + +/** + * Multiply two same-size matrices: `out = A × B` (standard matrix product). + * Supports `FgMatrix2D × FgMatrix2D`, `FgMatrix3D × FgMatrix3D`, and + * `Mat4 × Mat4` (via core `mat4Multiply`). (glTF `math/matMul`) + */ +export function fgMatrixMultiplication(a: FgValue, b: FgValue): FgValue { + if (isFgMatrix2D(a) && isFgMatrix2D(b)) { + const am = a.m, + bm = b.m; + return fgMatrix2D([am[0]! * bm[0]! + am[2]! * bm[1]!, am[1]! * bm[0]! + am[3]! * bm[1]!, am[0]! * bm[2]! + am[2]! * bm[3]!, am[1]! * bm[2]! + am[3]! * bm[3]!]); + } + if (isFgMatrix3D(a) && isFgMatrix3D(b)) { + const am = a.m, + bm = b.m; + return fgMatrix3D([ + am[0]! * bm[0]! + am[3]! * bm[1]! + am[6]! * bm[2]!, + am[1]! * bm[0]! + am[4]! * bm[1]! + am[7]! * bm[2]!, + am[2]! * bm[0]! + am[5]! * bm[1]! + am[8]! * bm[2]!, + am[0]! * bm[3]! + am[3]! * bm[4]! + am[6]! * bm[5]!, + am[1]! * bm[3]! + am[4]! * bm[4]! + am[7]! * bm[5]!, + am[2]! * bm[3]! + am[5]! * bm[4]! + am[8]! * bm[5]!, + am[0]! * bm[6]! + am[3]! * bm[7]! + am[6]! * bm[8]!, + am[1]! * bm[6]! + am[4]! * bm[7]! + am[7]! * bm[8]!, + am[2]! * bm[6]! + am[5]! * bm[7]! + am[8]! * bm[8]!, + ]); + } + if (isMat4(a) && isMat4(b)) { + return mat4Multiply(a, b); + } + return a; +} + +/** + * Compose a TRS `Mat4` from translation, rotation quaternion, and scale + * (glTF `math/matCompose`). Uses core `mat4Compose` (column-major). + */ +export function fgMatrixCompose(pos: FgValue, quat: FgValue, scale: FgValue): Mat4 { + const p = isVec3(pos) ? pos : { x: 0, y: 0, z: 0 }; + const q = isVec4(quat) ? quat : { x: 0, y: 0, z: 0, w: 1 }; + const s = isVec3(scale) ? scale : { x: 1, y: 1, z: 1 }; + return mat4Compose(p.x, p.y, p.z, q.x, q.y, q.z, q.w, s.x, s.y, s.z); +} + +/** Result of `fgMatrixDecompose`. */ +export interface FgDecomposeResult { + position: Vec3; + rotationQuaternion: Quat; + scaling: Vec3; + isValid: boolean; +} + +/** + * Decompose a `Mat4` into translation, rotation (unit quaternion), and scale + * (glTF `math/matDecompose`). Uses core `mat4Decompose`. + * + * Validity pre-check: the bottom row of the column-major matrix (`m[3]`, `m[7]`, + * `m[11]`, `m[15]`) must round to `[0, 0, 0, 1]` at 4 decimal places; + * otherwise `isValid = false` and zero/identity defaults are returned. + */ +export function fgMatrixDecompose(m: FgValue): FgDecomposeResult { + const zero: Vec3 = { x: 0, y: 0, z: 0 }; + const identQ: Quat = { x: 0, y: 0, z: 0, w: 1 }; + const oneS: Vec3 = { x: 1, y: 1, z: 1 }; + if (!isMat4(m)) { + return { position: zero, rotationQuaternion: identQ, scaling: oneS, isValid: false }; + } + // Bottom row in column-major 4×4: indices m[3], m[7], m[11], m[15]. + const r0 = Math.round(m[3]! * 1e4) / 1e4; + const r1 = Math.round(m[7]! * 1e4) / 1e4; + const r2 = Math.round(m[11]! * 1e4) / 1e4; + const r3 = Math.round(m[15]! * 1e4) / 1e4; + if (r0 !== 0 || r1 !== 0 || r2 !== 0 || r3 !== 1) { + return { position: zero, rotationQuaternion: identQ, scaling: oneS, isValid: false }; + } + const { translation, rotation, scale } = mat4Decompose(m); + return { position: translation, rotationQuaternion: rotation, scaling: scale, isValid: true }; +} + +// ─── Quaternion ops (Phase 3f) ──────────────────────────────────────────────── + +/** + * Angle between two unit quaternions: `2 · acos(clamp(dot(a, b), −1, 1))` + * (glTF `math/quatAngleBetween`). Returns 0 for non-quaternion inputs. + */ +export function fgAngleBetween(a: FgValue, b: FgValue): number { + if (isVec4(a) && isVec4(b)) { + const d = Math.min(1, Math.max(-1, a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w)); + return 2 * Math.acos(d); + } + return 0; +} + +/** + * Quaternion from axis and angle (glTF `math/quatFromAxisAngle`). + * Does NOT pre-normalize the axis (replicates BJS `Quaternion.RotationAxis`). + * Result: `[sin(θ/2)·axis, cos(θ/2)]`. + */ +export function fgQuaternionFromAxisAngle(axis: FgValue, angle: FgValue): Quat { + const n = num(angle); + if (!isVec3(axis) || Number.isNaN(n)) { + return { x: 0, y: 0, z: 0, w: 1 }; + } + const half = n / 2; + const s = Math.sin(half); + return { x: axis.x * s, y: axis.y * s, z: axis.z * s, w: Math.cos(half) }; +} + +/** Result of `fgAxisAngleFromQuaternion`. */ +export interface FgAxisAngleResult { + axis: Vec3; + angle: number; + isValid: boolean; +} + +/** + * Extract axis and angle from a unit quaternion (glTF `math/quatToAxisAngle`). + * `angle = 2·acos(w)`. If `sin(angle/2)` is near zero the axis defaults to + * `(1, 0, 0)`. Always sets `isValid = true` for a valid quaternion input. + */ +export function fgAxisAngleFromQuaternion(q: FgValue): FgAxisAngleResult { + if (!isVec4(q)) { + return { axis: { x: 1, y: 0, z: 0 }, angle: 0, isValid: false }; + } + const w = Math.min(1, Math.max(-1, q.w)); + const angle = 2 * Math.acos(w); + const s = Math.sqrt(Math.max(0, 1 - w * w)); + if (s < 1e-7) { + return { axis: { x: 1, y: 0, z: 0 }, angle, isValid: true }; + } + return { axis: { x: q.x / s, y: q.y / s, z: q.z / s }, angle, isValid: true }; +} + +/** + * Quaternion that rotates direction `a` to direction `b` (glTF `math/quatFromDirections`). + * Assumes inputs are already unit vectors — does NOT pre-normalize. + * Computes `axis = cross(a, b)`, `angle = acos(clamp(dot(a,b), −1, 1))`, + * then `quatFromAxisAngle(axis, angle)`. + */ +export function fgQuaternionFromDirections(a: FgValue, b: FgValue): Quat { + if (!isVec3(a) || !isVec3(b)) { + return { x: 0, y: 0, z: 0, w: 1 }; + } + const axis = crossVec3(a, b); + const dot = Math.min(1, Math.max(-1, dotVec3(a, b))); + const angle = Math.acos(dot); + const half = angle / 2; + const s = Math.sin(half); + return { x: axis.x * s, y: axis.y * s, z: axis.z * s, w: Math.cos(half) }; +} diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index 9516eca1f4..e070269812 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -142,6 +142,88 @@ const NATIVE_OPS: Readonly> = { "math/rotate2D": { block: FgBlockType.Rotate2D, valueInputs: { a: "a", angle: "b" } }, "math/select": { block: FgBlockType.Conditional, valueInputs: { condition: "condition", a: "onTrue", b: "onFalse" } }, + // ─── Phase 3f (matrix + quaternion) ────────────────────────────────────── + "math/transform": { block: FgBlockType.TransformVector }, + "math/transpose": { block: FgBlockType.Transpose }, + "math/determinant": { block: FgBlockType.Determinant }, + "math/inverse": { block: FgBlockType.InvertMatrix }, + "math/matMul": { block: FgBlockType.MatrixMultiplication }, + "math/matCompose": { + block: FgBlockType.MatrixCompose, + valueInputs: { translation: "position", rotation: "rotationQuaternion", scale: "scaling" }, + }, + "math/matDecompose": { + block: FgBlockType.MatrixDecompose, + valueInputs: { a: "input" }, + outputValues: { translation: "position", rotation: "rotationQuaternion", scale: "scaling" }, + }, + "math/combine2x2": { + block: FgBlockType.CombineMatrix2D, + valueInputs: { a: "input_0", b: "input_1", c: "input_2", d: "input_3" }, + }, + "math/combine3x3": { + block: FgBlockType.CombineMatrix3D, + valueInputs: { a: "input_0", b: "input_1", c: "input_2", d: "input_3", e: "input_4", f: "input_5", g: "input_6", h: "input_7", i: "input_8" }, + }, + "math/combine4x4": { + block: FgBlockType.CombineMatrix, + valueInputs: { + a: "input_0", + b: "input_1", + c: "input_2", + d: "input_3", + e: "input_4", + f: "input_5", + g: "input_6", + h: "input_7", + i: "input_8", + j: "input_9", + k: "input_10", + l: "input_11", + m: "input_12", + n: "input_13", + o: "input_14", + p: "input_15", + }, + }, + "math/extract2x2": { + block: FgBlockType.ExtractMatrix2D, + valueInputs: { a: "input" }, + outputValues: { "0": "output_0", "1": "output_1", "2": "output_2", "3": "output_3" }, + }, + "math/extract3x3": { + block: FgBlockType.ExtractMatrix3D, + valueInputs: { a: "input" }, + outputValues: { "0": "output_0", "1": "output_1", "2": "output_2", "3": "output_3", "4": "output_4", "5": "output_5", "6": "output_6", "7": "output_7", "8": "output_8" }, + }, + "math/extract4x4": { + block: FgBlockType.ExtractMatrix, + valueInputs: { a: "input" }, + outputValues: { + "0": "output_0", + "1": "output_1", + "2": "output_2", + "3": "output_3", + "4": "output_4", + "5": "output_5", + "6": "output_6", + "7": "output_7", + "8": "output_8", + "9": "output_9", + "10": "output_10", + "11": "output_11", + "12": "output_12", + "13": "output_13", + "14": "output_14", + "15": "output_15", + }, + }, + "math/quatConjugate": { block: FgBlockType.Conjugate }, + "math/quatAngleBetween": { block: FgBlockType.AngleBetween }, + "math/quatFromAxisAngle": { block: FgBlockType.QuaternionFromAxisAngle, valueInputs: { axis: "a", angle: "b" } }, + "math/quatToAxisAngle": { block: FgBlockType.AxisAngleFromQuaternion }, + "math/quatFromDirections": { block: FgBlockType.QuaternionFromDirections }, + "variable/get": { block: FgBlockType.GetVariable, variableConfigKey: "variable" }, "variable/set": { block: FgBlockType.SetVariable, variableConfigKey: "variables", valueInputs: { value: "value" } }, diff --git a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts index bb462a9e89..e5c7da1f60 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts @@ -14,6 +14,8 @@ // KHR_interactivity asset can't silently render a broken interaction. import { fgInt } from "../custom-types/fg-integer.js"; +import { fgMatrix2D, fgMatrix3D } from "../custom-types/fg-matrix.js"; +import type { Mat4 } from "../../math/types.js"; import { getBlockDef } from "../block-registry.js"; import type { FgBlock, FgDataSocket, FgGraph, FgSignalSocket, FgValue } from "../types.js"; import { FgType } from "../types.js"; @@ -84,6 +86,18 @@ function arrayToFgValue(arr: number[] | undefined, type: FgType): FgValue { case FgType.Vector4: case FgType.Quaternion: return { x: a[0] ?? 0, y: a[1] ?? 0, z: a[2] ?? 0, w: a[3] ?? 0 }; + case FgType.Matrix2D: + // glTF matrix literals are column-major — stored directly (no transpose). + return fgMatrix2D(a); + case FgType.Matrix3D: + return fgMatrix3D(a); + case FgType.Matrix: { + const m = new Float32Array(16); + for (let i = 0; i < 16; i++) { + m[i] = a[i] ?? 0; + } + return m as unknown as Mat4; + } default: return a[0] ?? 0; } diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index fdfc374492..cda9256299 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -2,7 +2,21 @@ import { describe, expect, it, vi } from "vitest"; import type { AnimationGroup } from "../../../packages/babylon-lite/src/animation/animation-group"; import type { FgAccessor, FgBlock, FgBlockDef, FgGraph, FgValue, FgWiring } from "../../../packages/babylon-lite/src/flow-graph/index"; -import { createFgRuntime, fgInt, FgEventType, FgType, getBlockDef, getDataValue, pumpFgEvent, startFlowGraph, tickFlowGraph } from "../../../packages/babylon-lite/src/flow-graph/index"; +import { + createFgRuntime, + fgInt, + fgMatrix2D, + fgMatrix3D, + isFgMatrix2D, + isFgMatrix3D, + FgEventType, + FgType, + getBlockDef, + getDataValue, + pumpFgEvent, + startFlowGraph, + tickFlowGraph, +} from "../../../packages/babylon-lite/src/flow-graph/index"; // ─── graph + runtime builder driven by the REAL registry ──────────────────── @@ -363,11 +377,7 @@ describe("flow-graph blocks — math/data", () => { describe("flow-graph blocks — math Phase 3", () => { /** Build start→op→recorder, fire start, return the value pulled off `outSocket`. */ - async function evalOp( - type: string, - dataDefaults: Record, - opts: { config?: Record; outSocket?: string } = {} - ): Promise { + async function evalOp(type: string, dataDefaults: Record, opts: { config?: Record; outSocket?: string } = {}): Promise { const log: { label: string; value: FgValue }[] = []; const rt = await makeRuntime( [ @@ -481,10 +491,7 @@ describe("flow-graph blocks — math Phase 3", () => { expect((r as { value: number }).value).toBe(2); }); - it.each([ - ["Length", { x: 3, y: 4, z: 0 }, 5], - ["Dot", undefined, 32], - ] as const)("vector scalar op %s", async (type) => { + it.each(["Length", "Dot"] as const)("vector scalar op %s", async (type) => { if (type === "Length") { expect(await evalOp("Length", { a: { x: 3, y: 4, z: 0 } })).toBeCloseTo(5, 10); } else { @@ -568,7 +575,13 @@ describe("flow-graph blocks — math Phase 3", () => { /** True when a value is a FlowGraphInteger box (re-wrapped by bitwise/int ops). */ function isFgIntResult(v: FgValue): boolean { - return typeof v === "object" && v !== null && "value" in (v as Record) && typeof (v as { value: unknown }).value === "number" && !("x" in (v as Record)); + return ( + typeof v === "object" && + v !== null && + "value" in (v as unknown as Record) && + typeof (v as { value: unknown }).value === "number" && + !("x" in (v as unknown as Record)) + ); } describe("flow-graph blocks — property accessors", () => { @@ -716,3 +729,260 @@ describe("flow-graph blocks — animation", () => { expect(stop).toHaveBeenCalledWith(group); }); }); + +describe("flow-graph blocks — matrix/quaternion", () => { + /** Reuse the evalOp helper from Phase-3 tests. Same graph shape: + * start → op → recorder; returns the value at `outSocket`. */ + async function evalOp(type: string, dataDefaults: Record, opts: { config?: Record; outSocket?: string } = {}): Promise { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "op", type, config: opts.config, dataDefaults }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "op", socket: opts.outSocket ?? "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + return log[0]!.value; + } + + // ─── TransformVector ────────────────────────────────────────────────────── + + it("TransformVector: Vec2 × Matrix2D (M·v)", async () => { + // M (col-major) = [1,2,3,4] → [[1,3],[2,4]] + // v = (5,6); M·v = (1*5+3*6, 2*5+4*6) = (23, 34) + const m = fgMatrix2D([1, 2, 3, 4]); + const r = (await evalOp("TransformVector", { a: { x: 5, y: 6 }, b: m })) as { x: number; y: number }; + expect(r.x).toBeCloseTo(23, 8); + expect(r.y).toBeCloseTo(34, 8); + }); + + it("TransformVector: Vec3 × Matrix3D (M·v)", async () => { + // Identity 3x3 → result = input + const m = fgMatrix3D(); + const r = (await evalOp("TransformVector", { a: { x: 1, y: 2, z: 3 }, b: m })) as { x: number; y: number; z: number }; + expect(r.x).toBeCloseTo(1, 8); + expect(r.y).toBeCloseTo(2, 8); + expect(r.z).toBeCloseTo(3, 8); + }); + + // ─── MatrixMultiplication ───────────────────────────────────────────────── + + it("MatrixMultiplication: 2x2 col-major A×B", async () => { + // A=[1,2,3,4] = [[1,3],[2,4]], B=[5,6,7,8] = [[5,7],[6,8]] + // A×B[0][0] = 1*5+3*6=23, [1][0]=2*5+4*6=34, [0][1]=1*7+3*8=31, [1][1]=2*7+4*8=46 + const a = fgMatrix2D([1, 2, 3, 4]); + const b = fgMatrix2D([5, 6, 7, 8]); + const r = await evalOp("MatrixMultiplication", { a, b }); + expect(isFgMatrix2D(r)).toBe(true); + if (isFgMatrix2D(r)) { + expect(r.m[0]).toBeCloseTo(23, 8); // col0, row0 + expect(r.m[1]).toBeCloseTo(34, 8); // col0, row1 + expect(r.m[2]).toBeCloseTo(31, 8); // col1, row0 + expect(r.m[3]).toBeCloseTo(46, 8); // col1, row1 + } + }); + + it("MatrixMultiplication: identity × M = M (3x3)", async () => { + const identity = fgMatrix3D(); + const m = fgMatrix3D([1, 2, 3, 4, 5, 6, 7, 8, 9]); + const r = await evalOp("MatrixMultiplication", { a: identity, b: m }); + expect(isFgMatrix3D(r)).toBe(true); + if (isFgMatrix3D(r)) { + for (let i = 0; i < 9; i++) expect(r.m[i]).toBeCloseTo(m.m[i]!, 6); + } + }); + + // ─── Determinant ────────────────────────────────────────────────────────── + + it("Determinant: 2x2 [1,2,3,4] = 1*4 - 2*3 = -2", async () => { + const m = fgMatrix2D([1, 2, 3, 4]); + expect(await evalOp("Determinant", { a: m })).toBeCloseTo(-2, 8); + }); + + it("Determinant: 3x3 identity = 1", async () => { + expect(await evalOp("Determinant", { a: fgMatrix3D() })).toBeCloseTo(1, 8); + }); + + // ─── InvertMatrix ───────────────────────────────────────────────────────── + + it("InvertMatrix: M × inv(M) ≈ identity (2x2)", async () => { + const m = fgMatrix2D([1, 2, 3, 4]); + const inv = await evalOp("InvertMatrix", { a: m }); + expect(isFgMatrix2D(inv)).toBe(true); + if (isFgMatrix2D(inv)) { + // product M × inv should be identity + const am = m.m, + bm = inv.m; + const c00 = am[0]! * bm[0]! + am[2]! * bm[1]!; + const c11 = am[1]! * bm[2]! + am[3]! * bm[3]!; + expect(c00).toBeCloseTo(1, 6); + expect(c11).toBeCloseTo(1, 6); + } + }); + + it("InvertMatrix: identity inverse is identity (3x3)", async () => { + const inv = await evalOp("InvertMatrix", { a: fgMatrix3D() }); + expect(isFgMatrix3D(inv)).toBe(true); + if (isFgMatrix3D(inv)) { + expect(inv.m[0]).toBeCloseTo(1, 6); + expect(inv.m[4]).toBeCloseTo(1, 6); + expect(inv.m[8]).toBeCloseTo(1, 6); + } + }); + + // ─── Transpose ─────────────────────────────────────────────────────────── + + it("Transpose: 2x2 swaps off-diagonal", async () => { + const m = fgMatrix2D([1, 2, 3, 4]); // col-major: [[1,3],[2,4]] + const t = await evalOp("Transpose", { a: m }); + expect(isFgMatrix2D(t)).toBe(true); + if (isFgMatrix2D(t)) { + // transposed col-major = [1,3,2,4] + expect(t.m[0]).toBeCloseTo(1, 8); + expect(t.m[1]).toBeCloseTo(3, 8); + expect(t.m[2]).toBeCloseTo(2, 8); + expect(t.m[3]).toBeCloseTo(4, 8); + } + }); + + // ─── CombineMatrix / ExtractMatrix round-trips ──────────────────────────── + + it("CombineMatrix2D → ExtractMatrix2D round-trips 4 inputs", async () => { + const inputs = [1, 2, 3, 4]; + const dataDefaults: Record = {}; + inputs.forEach((v, i) => (dataDefaults[`input_${i}`] = v)); + const combined = await evalOp("CombineMatrix2D", dataDefaults); + expect(isFgMatrix2D(combined)).toBe(true); + if (isFgMatrix2D(combined)) { + for (let i = 0; i < 4; i++) { + const e = await evalOp("ExtractMatrix2D", { input: combined }, { outSocket: `output_${i}` }); + expect(e).toBeCloseTo(inputs[i]!, 8); + } + } + }); + + it("CombineMatrix3D → ExtractMatrix3D round-trips 9 inputs", async () => { + const inputs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; + const dataDefaults: Record = {}; + inputs.forEach((v, i) => (dataDefaults[`input_${i}`] = v)); + const combined = await evalOp("CombineMatrix3D", dataDefaults); + expect(isFgMatrix3D(combined)).toBe(true); + if (isFgMatrix3D(combined)) { + for (let i = 0; i < 9; i++) { + const e = await evalOp("ExtractMatrix3D", { input: combined }, { outSocket: `output_${i}` }); + expect(e).toBeCloseTo(inputs[i]!, 8); + } + } + }); + + it("CombineMatrix (4x4) → ExtractMatrix round-trips 16 inputs", async () => { + const inputs = Array.from({ length: 16 }, (_, i) => i + 1); + const dataDefaults: Record = {}; + inputs.forEach((v, i) => (dataDefaults[`input_${i}`] = v)); + const combined = await evalOp("CombineMatrix", dataDefaults); + expect(combined instanceof Float32Array).toBe(true); + for (let i = 0; i < 16; i++) { + const e = await evalOp("ExtractMatrix", { input: combined }, { outSocket: `output_${i}` }); + expect(e).toBeCloseTo(inputs[i]!, 8); + } + }); + + // ─── MatrixCompose / MatrixDecompose ────────────────────────────────────── + + it("MatrixCompose then MatrixDecompose round-trips TRS", async () => { + const pos = { x: 1, y: 2, z: 3 }; + const rot = { x: 0, y: 0, z: 0, w: 1 }; // identity quat + const scl = { x: 2, y: 3, z: 4 }; + const mat = await evalOp("MatrixCompose", { + position: pos, + rotationQuaternion: rot, + scaling: scl, + }); + + const posOut = (await evalOp("MatrixDecompose", { input: mat }, { outSocket: "position" })) as { x: number; y: number; z: number }; + const sclOut = (await evalOp("MatrixDecompose", { input: mat }, { outSocket: "scaling" })) as { x: number; y: number; z: number }; + const validOut = await evalOp("MatrixDecompose", { input: mat }, { outSocket: "isValid" }); + + expect(posOut.x).toBeCloseTo(1, 5); + expect(posOut.y).toBeCloseTo(2, 5); + expect(posOut.z).toBeCloseTo(3, 5); + expect(sclOut.x).toBeCloseTo(2, 5); + expect(sclOut.y).toBeCloseTo(3, 5); + expect(sclOut.z).toBeCloseTo(4, 5); + expect(validOut).toBe(true); + }); + + it("MatrixDecompose returns isValid=false for non-TRS matrix", async () => { + // A matrix with a bad bottom row ([1,0,0,1] instead of [0,0,0,1]). + // In column-major 4x4, bottom row is at indices 3,7,11,15. + const bad = new Float32Array(16); + bad[0] = 1; + bad[5] = 1; + bad[10] = 1; + bad[15] = 1; // identity base + bad[3] = 1; // break bottom row: m[3] should be 0 + const validOut = await evalOp("MatrixDecompose", { input: bad as unknown as FgValue }, { outSocket: "isValid" }); + expect(validOut).toBe(false); + }); + + // ─── Quaternion ops ─────────────────────────────────────────────────────── + + it("Conjugate: (-x,-y,-z,w)", async () => { + const r = (await evalOp("Conjugate", { a: { x: 1, y: 2, z: 3, w: 4 } })) as { x: number; y: number; z: number; w: number }; + expect(r.x).toBeCloseTo(-1, 8); + expect(r.y).toBeCloseTo(-2, 8); + expect(r.z).toBeCloseTo(-3, 8); + expect(r.w).toBeCloseTo(4, 8); + }); + + it("QuaternionFromAxisAngle: Y-axis 90° → known components", async () => { + // axis=(0,1,0), angle=PI/2 → quat=(0, sin(PI/4), 0, cos(PI/4)) + const r = (await evalOp("QuaternionFromAxisAngle", { + a: { x: 0, y: 1, z: 0 }, + b: Math.PI / 2, + })) as { x: number; y: number; z: number; w: number }; + expect(r.x).toBeCloseTo(0, 8); + expect(r.y).toBeCloseTo(Math.sin(Math.PI / 4), 8); + expect(r.z).toBeCloseTo(0, 8); + expect(r.w).toBeCloseTo(Math.cos(Math.PI / 4), 8); + }); + + it("AxisAngleFromQuaternion round-trips a known quaternion", async () => { + // quat from Y-axis 90° + const q = { x: 0, y: Math.sin(Math.PI / 4), z: 0, w: Math.cos(Math.PI / 4) }; + const axis = (await evalOp("AxisAngleFromQuaternion", { a: q }, { outSocket: "axis" })) as { x: number; y: number; z: number }; + const angle = (await evalOp("AxisAngleFromQuaternion", { a: q }, { outSocket: "angle" })) as number; + const valid = await evalOp("AxisAngleFromQuaternion", { a: q }, { outSocket: "isValid" }); + expect(axis.x).toBeCloseTo(0, 5); + expect(axis.y).toBeCloseTo(1, 5); + expect(axis.z).toBeCloseTo(0, 5); + expect(angle).toBeCloseTo(Math.PI / 2, 5); + expect(valid).toBe(true); + }); + + it("AngleBetween: same quaternion → 0", async () => { + const q = { x: 0, y: 0, z: 0, w: 1 }; + expect(await evalOp("AngleBetween", { a: q, b: q })).toBeCloseTo(0, 8); + }); + + it("AngleBetween: identity vs 180° rotation → PI", async () => { + // 180° rotation around any axis: quat = (0,1,0,0) (Y-axis 180°) + const q0 = { x: 0, y: 0, z: 0, w: 1 }; + const q180 = { x: 0, y: 1, z: 0, w: 0 }; + const result = await evalOp("AngleBetween", { a: q0, b: q180 }); + expect(result as number).toBeCloseTo(Math.PI, 5); + }); + + it("QuaternionFromDirections: (1,0,0) → (0,1,0) rotates 90° around Z", async () => { + const a = { x: 1, y: 0, z: 0 }; + const b = { x: 0, y: 1, z: 0 }; + const r = (await evalOp("QuaternionFromDirections", { a, b })) as { x: number; y: number; z: number; w: number }; + // cross(a,b) = (0,0,1); angle = PI/2 → quat = (0,0,sin(PI/4),cos(PI/4)) + expect(r.x).toBeCloseTo(0, 5); + expect(r.y).toBeCloseTo(0, 5); + expect(r.z).toBeCloseTo(Math.sin(Math.PI / 4), 5); + expect(r.w).toBeCloseTo(Math.cos(Math.PI / 4), 5); + }); +}); From cf5e03248059cefa93e736e87095abf500a03827 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 19:07:58 +0200 Subject: [PATCH 08/13] feat(flow-graph): add Phase 3h control-flow blocks Add the control-flow block surface (sync + async) on Lite's pure-data runtime: - blocks/control-flow/*: switch (flow), for-loop, while-loop, do-n, multi-gate, wait-all, throttle, set-delay, cancel-delay. - blocks/data/constant.ts: emits config.value (KHR_interactivity inlines value literals, so no glTF op). - Async blocks (throttle/set-delay) use the addPending/onTick countdown pattern; set-delay/cancel-delay coordinate via a per-context delay registry in ctx.executionVariables (no module-level state). - gltf/declaration-mapper.ts: added configKeys/configArrayKeys/switchOutputs to FgOpMapping; NATIVE_OPS entries for flow/{switch,for,while,doN,multiGate, waitAll,throttle,setDelay,cancelDelay} + the deferred math/switch (DataSwitch). - gltf/interactivity-parser.ts: generic config-copy mechanism (configKeys/ configArrayKeys) in pass 1, and switch flow-output naming. - tests: control-flow Phase 3h coverage (768 unit tests green). BJS semantics confirmed from source: ForLoop end-exclusive; DoN reset re-arms; MultiGate sequential round-robin with isLoop wrap; WaitAll fires after all inputs; Throttle/SetDelay durations in seconds. Throttle/SetDelay are tick-driven in Lite (vs BJS wall-clock) so they advance deterministically with tickFlowGraph. Note: bundle manifest regeneration deferred to the end of Phase 3. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../src/flow-graph/block-registry.ts | 20 + .../blocks/control-flow/cancel-delay.ts | 37 ++ .../flow-graph/blocks/control-flow/do-n.ts | 48 ++ .../blocks/control-flow/for-loop.ts | 63 ++ .../blocks/control-flow/multi-gate.ts | 77 +++ .../blocks/control-flow/set-delay.ts | 91 +++ .../flow-graph/blocks/control-flow/switch.ts | 33 + .../blocks/control-flow/throttle.ts | 71 +++ .../blocks/control-flow/wait-all.ts | 68 ++ .../blocks/control-flow/while-loop.ts | 42 ++ .../src/flow-graph/blocks/data/constant.ts | 21 + .../src/flow-graph/gltf/declaration-mapper.ts | 41 ++ .../flow-graph/gltf/interactivity-parser.ts | 24 +- tests/lite/unit/flow-graph-blocks.test.ts | 584 ++++++++++++++++++ 14 files changed, 1219 insertions(+), 1 deletion(-) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/cancel-delay.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/do-n.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/for-loop.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/multi-gate.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/set-delay.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/switch.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/throttle.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/wait-all.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/control-flow/while-loop.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/data/constant.ts diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index 5ba3ef65db..cb2640ef24 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -31,6 +31,24 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/control-flow/branch.js")).branchDef; case FgBlockType.Sequence: return async () => (await import("./blocks/control-flow/sequence.js")).sequenceDef; + case FgBlockType.Switch: + return async () => (await import("./blocks/control-flow/switch.js")).switchDef; + case FgBlockType.ForLoop: + return async () => (await import("./blocks/control-flow/for-loop.js")).forLoopDef; + case FgBlockType.WhileLoop: + return async () => (await import("./blocks/control-flow/while-loop.js")).whileLoopDef; + case FgBlockType.DoN: + return async () => (await import("./blocks/control-flow/do-n.js")).doNDef; + case FgBlockType.MultiGate: + return async () => (await import("./blocks/control-flow/multi-gate.js")).multiGateDef; + case FgBlockType.WaitAll: + return async () => (await import("./blocks/control-flow/wait-all.js")).waitAllDef; + case FgBlockType.Throttle: + return async () => (await import("./blocks/control-flow/throttle.js")).throttleDef; + case FgBlockType.SetDelay: + return async () => (await import("./blocks/control-flow/set-delay.js")).setDelayDef; + case FgBlockType.CancelDelay: + return async () => (await import("./blocks/control-flow/cancel-delay.js")).cancelDelayDef; // ─── Math ───────────────────────────────────────────────── case FgBlockType.Add: @@ -245,6 +263,8 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/data/get-variable.js")).getVariableDef; case FgBlockType.SetVariable: return async () => (await import("./blocks/data/set-variable.js")).setVariableDef; + case FgBlockType.Constant: + return async () => (await import("./blocks/data/constant.js")).constantDef; // ─── Animation ──────────────────────────────────────────── case FgBlockType.PlayAnimation: diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/cancel-delay.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/cancel-delay.ts new file mode 100644 index 0000000000..e9c6c6e857 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/cancel-delay.ts @@ -0,0 +1,37 @@ +// CancelDelay (BJS FlowGraphCancelDelayBlock, glTF op `flow/cancelDelay`). +// Cancels a previously scheduled delay by its index (from SetDelay's +// `lastDelayIndex` output). Looks up the task via the global registry +// (`ctx.executionVariables["__delay_"]`) populated by SetDelay. +// Fires `out` after cancellation (whether or not a matching delay was found). + +import type { FgBlockDef } from "../../block-def.js"; +import type { FgPendingTask } from "../../context.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; +import { isFgInt } from "../../custom-types/fg-integer.js"; + +export const cancelDelayDef: FgBlockDef = { + type: FgBlockType.CancelDelay, + build: () => ({ + dataIn: [sockIn("delayIndex", FgType.Integer)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out")], + }), + execute(block, ctx, env) { + const raw = getDataValue(ctx, env, block, "delayIndex"); + const idx: number = isFgInt(raw) ? raw.value : (raw as number) | 0; + if (isNaN(idx) || !isFinite(idx) || idx < 0) { + activateSignal(ctx, env, block, "out"); + return; + } + const key = `__delay_${idx}`; + const task = ctx.executionVariables[key] as FgPendingTask | undefined; + if (task) { + task.canceled = true; + delete ctx.executionVariables[key]; + } + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/do-n.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/do-n.ts new file mode 100644 index 0000000000..6a3e4092bd --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/do-n.ts @@ -0,0 +1,48 @@ +// DoN (BJS FlowGraphDoNBlock, glTF op `flow/doN`). +// Fires `out` for the first N activations (where N = `maxExecutions` data input). +// Tracks count in `executionCount` data output. The `reset` signal resets the +// counter to 0 (or config.startIndex, default 0). After N executions the block +// is silent until reset. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockIn, sockOut } from "../../sockets.js"; +import { fgInt, isFgInt } from "../../custom-types/fg-integer.js"; + +function toInt(v: unknown): number { + if (isFgInt(v)) { + return v.value; + } + return (v as number) | 0; +} + +export const doNDef: FgBlockDef = { + type: FgBlockType.DoN, + build: () => ({ + dataIn: [sockIn("maxExecutions", FgType.Integer, fgInt(0))], + dataOut: [sockOut("executionCount", FgType.Integer)], + signalIn: [sigIn("in"), sigIn("reset")], + signalOut: [sigOut("out")], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "executionCount", fgInt(getExecVar(ctx, block, "count", 0))); + }, + execute(block, ctx, env, incomingSignal) { + if (incomingSignal === "reset") { + const startIdx = toInt(block.config?.startIndex ?? 0); + setExecVar(ctx, block, "count", startIdx); + setDataValue(ctx, block, "executionCount", fgInt(startIdx)); + return; + } + const max = toInt(getDataValue(ctx, env, block, "maxExecutions")); + const count = getExecVar(ctx, block, "count", 0); + if (count < max) { + const next = count + 1; + setExecVar(ctx, block, "count", next); + setDataValue(ctx, block, "executionCount", fgInt(next)); + activateSignal(ctx, env, block, "out"); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/for-loop.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/for-loop.ts new file mode 100644 index 0000000000..b833cbadfb --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/for-loop.ts @@ -0,0 +1,63 @@ +// ForLoop (BJS FlowGraphForLoopBlock, glTF op `flow/for`). +// Synchronous loop: fires `executionFlow` for each integer from `startIndex` up +// to (but NOT including) `endIndex` with stride `step` (default 1). Fires +// `completed` when done. Caps at 1000 iterations to guard against infinite loops. +// BJS semantics: `for (i = startIndex; i < endIndex; i += step)`. +// `index` data output is updated each iteration (available to wired consumers). +// config.incrementIndexWhenLoopDone (default false): when true, `index` is +// advanced one extra step after the loop — this is always set by the glTF mapper. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockIn, sockOut } from "../../sockets.js"; +import { fgInt, isFgInt } from "../../custom-types/fg-integer.js"; + +const MAX_ITERATIONS = 1000; + +function toNum(v: unknown): number { + if (isFgInt(v)) { + return v.value; + } + return (v as number) ?? 0; +} + +export const forLoopDef: FgBlockDef = { + type: FgBlockType.ForLoop, + build: () => ({ + dataIn: [sockIn("startIndex", FgType.Any, 0), sockIn("endIndex", FgType.Any, 0), sockIn("step", FgType.Number, 1)], + dataOut: [sockOut("index", FgType.Integer)], + signalIn: [sigIn("in")], + signalOut: [sigOut("executionFlow"), sigOut("completed")], + }), + updateOutputs(block, ctx) { + // Expose the current index (kept in execVar between iterations). + const i = (ctx.executionVariables[`${block.id}:index`] as number) ?? 0; + setDataValue(ctx, block, "index", fgInt(i)); + }, + execute(block, ctx, env) { + const start = toNum(getDataValue(ctx, env, block, "startIndex")); + const step = toNum(getDataValue(ctx, env, block, "step")) || 1; + let end = toNum(getDataValue(ctx, env, block, "endIndex")); + + for (let i = start; i < end; i += step) { + setExecVar(ctx, block, "index", i); + setDataValue(ctx, block, "index", fgInt(i)); + activateSignal(ctx, env, block, "executionFlow"); + // Re-read endIndex each iteration (body may modify it). + end = toNum(getDataValue(ctx, env, block, "endIndex")); + if (i > MAX_ITERATIONS * step) { + break; + } + } + + if (block.config?.incrementIndexWhenLoopDone) { + const cur = toNum(getDataValue(ctx, env, block, "endIndex")); + setExecVar(ctx, block, "index", cur); + setDataValue(ctx, block, "index", fgInt(cur)); + } + + activateSignal(ctx, env, block, "completed"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/multi-gate.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/multi-gate.ts new file mode 100644 index 0000000000..f0167242de --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/multi-gate.ts @@ -0,0 +1,77 @@ +// MultiGate (BJS FlowGraphMultiGateBlock, glTF op `flow/multiGate`). +// Routes each activation to the NEXT unused output signal (`out_0`, `out_1`, …). +// config.isRandom (default false): pick a random unused output each time. +// config.isLoop (default false): wrap back to start when all outputs are used. +// config.outputSignalCount: number of output signals (required). +// `reset` signal clears state (all outputs unused, lastIndex = -1). +// `lastIndex` data output tracks the last activated output index. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockOut } from "../../sockets.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; + +function nextIndex(used: boolean[], isRandom: boolean, isLoop: boolean): number { + const allUsed = !used.includes(false); + if (allUsed) { + if (!isLoop) { + return -1; + } + used.fill(false); + } + if (!isRandom) { + return used.indexOf(false); + } + const unused = used.map((u, i) => (u ? -1 : i)).filter((i) => i >= 0); + if (!unused.length) { + return -1; + } + return unused[Math.floor(Math.random() * unused.length)]!; +} + +export const multiGateDef: FgBlockDef = { + type: FgBlockType.MultiGate, + build: (config) => { + const count = Math.max(1, (config?.outputSignalCount as number) ?? 1); + const signalOut: ReturnType[] = []; + for (let i = 0; i < count; i++) { + signalOut.push(sigOut(`out_${i}`)); + } + return { + dataOut: [sockOut("lastIndex", FgType.Integer)], + signalIn: [sigIn("in"), sigIn("reset")], + signalOut, + }; + }, + updateOutputs(block, ctx) { + setDataValue(ctx, block, "lastIndex", fgInt(getExecVar(ctx, block, "lastIndex", -1))); + }, + execute(block, ctx, env, incomingSignal) { + const count = block.signalOut.length; + const isRandom = !!(block.config?.isRandom as boolean | undefined); + const isLoop = !!(block.config?.isLoop as boolean | undefined); + + if (incomingSignal === "reset") { + setExecVar(ctx, block, "used", new Array(count).fill(false) as boolean[]); + setExecVar(ctx, block, "lastIndex", -1); + setDataValue(ctx, block, "lastIndex", fgInt(-1)); + return; + } + + let used = getExecVar(ctx, block, "used", undefined); + if (!used) { + used = new Array(count).fill(false) as boolean[]; + } + + const idx = nextIndex(used, isRandom, isLoop); + if (idx >= 0) { + used[idx] = true; + setExecVar(ctx, block, "used", used); + setExecVar(ctx, block, "lastIndex", idx); + setDataValue(ctx, block, "lastIndex", fgInt(idx)); + activateSignal(ctx, env, block, `out_${idx}`); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/set-delay.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/set-delay.ts new file mode 100644 index 0000000000..ec9c912df9 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/set-delay.ts @@ -0,0 +1,91 @@ +// SetDelay (BJS FlowGraphSetDelayBlock, glTF op `flow/setDelay`). +// Starts an async countdown of `duration` seconds, fires `out` immediately so +// sync flow continues, then fires `done` when the delay expires. Multiple +// concurrent delays are supported; each gets a unique index. +// `cancel` input cancels ALL pending delays on this block (matches BJS behaviour +// when called with its own `lastDelayIndex`). +// `lastDelayIndex` data output: the index of the most recently registered delay. +// +// CancelDelay coordination: each task's index is stored at +// `ctx.executionVariables["__delay_"] = task` so CancelDelay can find +// and cancel it by index without a direct block reference. + +import type { FgBlockDef } from "../../block-def.js"; +import type { FgPendingTask } from "../../context.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, addPending, cancelPendingForBlock, getDataValue, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockIn, sockOut } from "../../sockets.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; + +/** Global key for the monotonically-increasing delay sequence counter. */ +const DELAY_SEQ_KEY = "__delaySeq"; +/** Per-index key prefix where the live task object is stored. */ +const DELAY_KEY = (idx: number) => `__delay_${idx}`; + +export const setDelayDef: FgBlockDef = { + type: FgBlockType.SetDelay, + build: () => ({ + dataIn: [sockIn("duration", FgType.Number, 0)], + dataOut: [sockOut("lastDelayIndex", FgType.Integer)], + signalIn: [sigIn("in"), sigIn("cancel")], + signalOut: [sigOut("out"), sigOut("done"), sigOut("error")], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "lastDelayIndex", fgInt(getExecVar(ctx, block, "lastDelayIndex", -1))); + }, + execute(block, ctx, env, incomingSignal) { + if (incomingSignal === "cancel") { + // Cancel all pending delays for this block and clean up global registry. + for (const task of ctx.pending) { + if (task.blockId === block.id && !task.canceled && !task.done) { + const idx = task.state.delayIndex as number; + delete ctx.executionVariables[DELAY_KEY(idx)]; + } + } + cancelPendingForBlock(ctx, block); + return; + } + + const duration = getDataValue(ctx, env, block, "duration") as number; + if (!isFinite(duration) || isNaN(duration) || duration < 0) { + activateSignal(ctx, env, block, "error"); + return; + } + + // Allocate the next global delay index. + const seq = ((ctx.executionVariables[DELAY_SEQ_KEY] as number | undefined) ?? -1) + 1; + ctx.executionVariables[DELAY_SEQ_KEY] = seq; + + setExecVar(ctx, block, "lastDelayIndex", seq); + setDataValue(ctx, block, "lastDelayIndex", fgInt(seq)); + + const task: FgPendingTask = addPending(ctx, block, { remainingMs: duration * 1000, delayIndex: seq }); + // Register in the global registry so CancelDelay can look it up. + ctx.executionVariables[DELAY_KEY(seq)] = task; + + activateSignal(ctx, env, block, "out"); + }, + onTick(block, ctx, env, deltaMs, task) { + const remaining = (task.state.remainingMs as number) - deltaMs; + if (remaining <= 0) { + task.done = true; + const idx = task.state.delayIndex as number; + delete ctx.executionVariables[DELAY_KEY(idx)]; + activateSignal(ctx, env, block, "done"); + } else { + task.state.remainingMs = remaining; + } + }, + cancelPending(_block, ctx) { + // Clean up any leftover global registry entries for canceled tasks. + for (const key of Object.keys(ctx.executionVariables)) { + if (key.startsWith("__delay_")) { + const task = ctx.executionVariables[key] as FgPendingTask | undefined; + if (task?.canceled) { + delete ctx.executionVariables[key]; + } + } + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/switch.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/switch.ts new file mode 100644 index 0000000000..82daa3bee4 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/switch.ts @@ -0,0 +1,33 @@ +// Flow Switch (BJS FlowGraphSwitchBlock, glTF op `flow/switch`). +// Routes the incoming signal to `out_` if the numeric case value is in +// `config.cases`, or to `default` otherwise. Cases are integers. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; +import { isFgInt } from "../../custom-types/fg-integer.js"; + +export const switchDef: FgBlockDef = { + type: FgBlockType.Switch, + build: (config) => { + const cases = (config?.cases as number[] | undefined) ?? []; + const signalOut = [sigOut("default")]; + for (const c of cases) { + signalOut.push(sigOut(`out_${c | 0}`)); + } + return { + dataIn: [sockIn("case", FgType.Any)], + signalIn: [sigIn("in")], + signalOut, + }; + }, + execute(block, ctx, env) { + const cases = (block.config?.cases as number[] | undefined) ?? []; + const raw = getDataValue(ctx, env, block, "case"); + const key: number = isFgInt(raw) ? raw.value : (raw as number) | 0; + const matched = cases.some((c) => (c | 0) === key); + activateSignal(ctx, env, block, matched ? `out_${key}` : "default"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/throttle.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/throttle.ts new file mode 100644 index 0000000000..ce3259be28 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/throttle.ts @@ -0,0 +1,71 @@ +// Throttle (BJS FlowGraphThrottleBlock, glTF op `flow/throttle`). +// Passes the first activation through and suppresses further activations until +// `duration` seconds have elapsed since the last pass-through. `reset` clears +// the cooldown immediately. +// +// LITE DIVERGENCE: BJS uses wall-clock (`Date.now()`) for timing. Lite uses a +// tick-driven countdown via `addPending`/`onTick` so tests can drive it with +// `tickFlowGraph` instead of real-time. Semantics are identical for properly +// ticked scenes. +// +// `lastRemainingTime` data output: 0 when passing, remaining seconds when blocked. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, addPending, cancelPendingForBlock, getDataValue, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockIn, sockOut } from "../../sockets.js"; + +export const throttleDef: FgBlockDef = { + type: FgBlockType.Throttle, + build: () => ({ + dataIn: [sockIn("duration", FgType.Number, 0)], + dataOut: [sockOut("lastRemainingTime", FgType.Number)], + signalIn: [sigIn("in"), sigIn("reset")], + signalOut: [sigOut("out"), sigOut("error")], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "lastRemainingTime", getExecVar(ctx, block, "lastRemainingTime", NaN)); + }, + execute(block, ctx, env, incomingSignal) { + if (incomingSignal === "reset") { + cancelPendingForBlock(ctx, block); + setExecVar(ctx, block, "cooldownMs", 0); + setExecVar(ctx, block, "lastRemainingTime", NaN); + setDataValue(ctx, block, "lastRemainingTime", NaN); + return; + } + + const duration = getDataValue(ctx, env, block, "duration") as number; + if (!isFinite(duration) || isNaN(duration) || duration <= 0) { + activateSignal(ctx, env, block, "error"); + return; + } + + const cooldown = getExecVar(ctx, block, "cooldownMs", 0); + if (cooldown <= 0) { + // Ready to fire: reset cooldown and start countdown task. + setExecVar(ctx, block, "cooldownMs", duration * 1000); + setExecVar(ctx, block, "lastRemainingTime", 0); + setDataValue(ctx, block, "lastRemainingTime", 0); + addPending(ctx, block); + activateSignal(ctx, env, block, "out"); + } else { + // Still in cooldown: report remaining time but don't fire. + setExecVar(ctx, block, "lastRemainingTime", cooldown / 1000); + setDataValue(ctx, block, "lastRemainingTime", cooldown / 1000); + } + }, + onTick(block, ctx, _env, deltaMs, task) { + const remaining = getExecVar(ctx, block, "cooldownMs", 0) - deltaMs; + if (remaining <= 0) { + setExecVar(ctx, block, "cooldownMs", 0); + task.done = true; + } else { + setExecVar(ctx, block, "cooldownMs", remaining); + } + }, + cancelPending(block, ctx) { + setExecVar(ctx, block, "cooldownMs", 0); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/wait-all.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/wait-all.ts new file mode 100644 index 0000000000..7b1d20f390 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/wait-all.ts @@ -0,0 +1,68 @@ +// WaitAll (BJS FlowGraphWaitAllBlock, glTF op `flow/waitAll`). +// Waits for ALL N input signals (`in_0` … `in_{N-1}`) to fire before firing +// `completed`. Fires `out` for intermediate non-reset activations. `reset` +// clears all received flags. After `completed` fires the state resets so the +// block can be re-armed. `remainingInputs` data output counts unset slots. +// config.inputSignalCount: number of input flows (required, default 1). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getExecVar, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockOut } from "../../sockets.js"; +import { fgInt } from "../../custom-types/fg-integer.js"; + +export const waitAllDef: FgBlockDef = { + type: FgBlockType.WaitAll, + build: (config) => { + const n = Math.max(1, (config?.inputSignalCount as number) ?? 1); + const signalIn = [sigIn("reset")]; + for (let i = 0; i < n; i++) { + signalIn.push(sigIn(`in_${i}`)); + } + return { + dataOut: [sockOut("remainingInputs", FgType.Integer)], + signalIn, + signalOut: [sigOut("out"), sigOut("completed")], + }; + }, + updateOutputs(block, ctx) { + const state = getExecVar(ctx, block, "activationState", []); + const remaining = state.length ? state.filter((v) => !v).length : ((block.config?.inputSignalCount as number) ?? 1); + setDataValue(ctx, block, "remainingInputs", fgInt(remaining)); + }, + execute(block, ctx, env, incomingSignal) { + const n = (block.config?.inputSignalCount as number) ?? 1; + let state = getExecVar(ctx, block, "activationState", []); + if (!state.length) { + state = new Array(n).fill(false) as boolean[]; + } + + if (incomingSignal === "reset") { + state.fill(false); + setExecVar(ctx, block, "activationState", state.slice()); + setDataValue(ctx, block, "remainingInputs", fgInt(n)); + return; + } + + // Mark the corresponding slot received (socket name is "in_"). + const idxStr = incomingSignal.replace(/^in_/, ""); + const idx = parseInt(idxStr, 10); + if (!isNaN(idx) && idx >= 0 && idx < n) { + state[idx] = true; + } + + const remaining = state.filter((v) => !v).length; + setDataValue(ctx, block, "remainingInputs", fgInt(remaining)); + setExecVar(ctx, block, "activationState", state.slice()); + + if (remaining === 0) { + // All received — fire completed and reset for next round. + state.fill(false); + setExecVar(ctx, block, "activationState", state.slice()); + activateSignal(ctx, env, block, "completed"); + } else { + activateSignal(ctx, env, block, "out"); + } + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/control-flow/while-loop.ts b/packages/babylon-lite/src/flow-graph/blocks/control-flow/while-loop.ts new file mode 100644 index 0000000000..2d8bd50086 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/control-flow/while-loop.ts @@ -0,0 +1,42 @@ +// WhileLoop (BJS FlowGraphWhileLoopBlock, glTF op `flow/while`). +// Fires `executionFlow` repeatedly while `condition` is truthy. Fires +// `completed` after the condition becomes false. Caps at 1000 iterations. +// BJS config `doWhile` (default false): when true, the body runs once before +// the first condition check (not exposed via glTF). + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +const MAX_ITERATIONS = 1000; + +export const whileLoopDef: FgBlockDef = { + type: FgBlockType.WhileLoop, + build: () => ({ + dataIn: [sockIn("condition", FgType.Boolean, false)], + signalIn: [sigIn("in")], + signalOut: [sigOut("executionFlow"), sigOut("completed")], + }), + execute(block, ctx, env) { + const doWhile = !!(block.config?.doWhile as boolean | undefined); + let condition = !!getDataValue(ctx, env, block, "condition"); + + // do-while: run body once unconditionally before the first check. + if (doWhile && !condition) { + activateSignal(ctx, env, block, "executionFlow"); + } + + let i = 0; + while (condition) { + activateSignal(ctx, env, block, "executionFlow"); + if (++i >= MAX_ITERATIONS) { + break; + } + condition = !!getDataValue(ctx, env, block, "condition"); + } + + activateSignal(ctx, env, block, "completed"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/data/constant.ts b/packages/babylon-lite/src/flow-graph/blocks/data/constant.ts new file mode 100644 index 0000000000..da87a4942a --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/data/constant.ts @@ -0,0 +1,21 @@ +// Constant (BJS FlowGraphConstantBlock, no dedicated glTF op — constant values +// are represented as inline literals in KHR_interactivity assets). Used for +// internal-only graphs and unit tests. +// config.value: the constant value to emit. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import type { FgValue } from "../../types.js"; +import { setDataValue } from "../../runtime.js"; +import { sockOut } from "../../sockets.js"; + +export const constantDef: FgBlockDef = { + type: FgBlockType.Constant, + build: () => ({ + dataOut: [sockOut("value", FgType.Any)], + }), + updateOutputs(block, ctx) { + setDataValue(ctx, block, "value", (block.config?.value as FgValue) ?? undefined); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index e070269812..9734754a88 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -47,6 +47,26 @@ export interface FgOpMapping { /** Event op: copy a numeric glTF `configuration` value into `config[key]` * (e.g. `nodeIndex` for `event/onSelect`). */ readonly nodeConfigKey?: string; + /** + * glTF `configuration` keys to copy as SCALAR values into block config. + * Parser copies `node.configuration[gltfKey].value[0]` → `config[liteName]`. + * Use for booleans, numbers, counts, and other single-element values. + * ⚠️ SPEC-VOLATILE: quarantined here; re-sync against BJS PR #18455. + */ + readonly configKeys?: Readonly>; + /** + * glTF `configuration` keys to copy as ARRAY values into block config. + * Parser copies `node.configuration[gltfKey].value` (full array) → + * `config[liteName]`. Use for `cases` arrays and other multi-element lists. + * ⚠️ SPEC-VOLATILE: quarantined here; re-sync against BJS PR #18455. + */ + readonly configArrayKeys?: Readonly>; + /** + * Switch-style dynamic output renaming: glTF flow key `"N"` → Lite signal + * output `"out_N"` (except `"default"` which passes through unchanged). + * Mirrors BJS FlowGraphSwitchBlock's `extraProcessor` renaming logic. + */ + readonly switchOutputs?: boolean; } const FPS = (arr: number[]): number[] => [(arr[0] ?? 0) * ANIMATION_FPS]; @@ -59,6 +79,25 @@ const NATIVE_OPS: Readonly> = { "flow/branch": { block: FgBlockType.Branch, valueInputs: { condition: "condition" }, flowOutputs: { true: "onTrue", false: "onFalse" } }, "flow/sequence": { block: FgBlockType.Sequence, dynamicSequence: true }, + // ─── Phase 3h control-flow ops ──────────────────────────────────────────── + // flow/switch: glTF input `selection` → Lite `case`; flow keys are the raw + // case integers ("0","1",...) — `switchOutputs` prefixes them to `out_N`. + "flow/switch": { block: FgBlockType.Switch, valueInputs: { selection: "case" }, configArrayKeys: { cases: "cases" }, switchOutputs: true }, + // flow/for: `loopBody` → `executionFlow` (glTF name differs from BJS internal). + "flow/for": { block: FgBlockType.ForLoop, configKeys: { initialIndex: "initialIndex" }, flowOutputs: { loopBody: "executionFlow" } }, + // flow/while: same loopBody rename. + "flow/while": { block: FgBlockType.WhileLoop, flowOutputs: { loopBody: "executionFlow" } }, + // flow/doN: glTF `n` → `maxExecutions`; `currentCount` → `executionCount`. + "flow/doN": { block: FgBlockType.DoN, valueInputs: { n: "maxExecutions" }, outputValues: { currentCount: "executionCount" } }, + // flow/multiGate: output count from flow count (dynamicSequence); booleans from configKeys. + "flow/multiGate": { block: FgBlockType.MultiGate, dynamicSequence: true, configKeys: { isRandom: "isRandom", isLoop: "isLoop" } }, + // flow/waitAll: input count from glTF config key `inputFlows`. + "flow/waitAll": { block: FgBlockType.WaitAll, configKeys: { inputFlows: "inputSignalCount" } }, + // flow/throttle, flow/setDelay: `err` glTF output → `error` Lite signal. + "flow/throttle": { block: FgBlockType.Throttle, flowOutputs: { err: "error" } }, + "flow/setDelay": { block: FgBlockType.SetDelay, flowOutputs: { err: "error" } }, + "flow/cancelDelay": { block: FgBlockType.CancelDelay }, + "math/add": { block: FgBlockType.Add, valueInputs: { a: "a", b: "b" } }, "math/sub": { block: FgBlockType.Subtract, valueInputs: { a: "a", b: "b" } }, "math/mul": { block: FgBlockType.Multiply, valueInputs: { a: "a", b: "b" } }, @@ -141,6 +180,8 @@ const NATIVE_OPS: Readonly> = { "math/extract4": { block: FgBlockType.ExtractVector4, outputValues: { "0": "x", "1": "y", "2": "z", "3": "w" } }, "math/rotate2D": { block: FgBlockType.Rotate2D, valueInputs: { a: "a", angle: "b" } }, "math/select": { block: FgBlockType.Conditional, valueInputs: { condition: "condition", a: "onTrue", b: "onFalse" } }, + // math/switch: data switch; cases array from glTF configuration. + "math/switch": { block: FgBlockType.DataSwitch, configArrayKeys: { cases: "cases" } }, // ─── Phase 3f (matrix + quaternion) ────────────────────────────────────── "math/transform": { block: FgBlockType.TransformVector }, diff --git a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts index e5c7da1f60..6b0d1f3650 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/interactivity-parser.ts @@ -164,11 +164,16 @@ function resolvePointerTemplate(template: string, node: GltfNode): string | null } /** Compute a node's per-flow-key → Lite signal-output-name map (handles the - * dynamic sequence renaming). */ + * dynamic sequence renaming and switch-style integer-key prefixing). */ function flowOutputName(mapping: FgOpMapping, flowKeys: string[], key: string): string { if (mapping.dynamicSequence) { return `out_${flowKeys.indexOf(key)}`; } + // Switch-style: glTF flow keys are raw case integers; prefix with "out_" + // except for "default" which passes through unchanged. + if (mapping.switchOutputs && key !== "default") { + return `out_${key}`; + } return mapping.flowOutputs?.[key] ?? key; } @@ -221,6 +226,23 @@ export async function parseInteractivityGraph(json: GltfInteractivityGraph): Pro if (mapping.nodeConfigKey) { config[mapping.nodeConfigKey] = node.configuration?.[mapping.nodeConfigKey]?.value?.[0] as number; } + // ⚠️ SPEC-VOLATILE: configKeys/configArrayKeys — re-sync against BJS PR #18455. + if (mapping.configKeys) { + for (const [gltfKey, liteName] of Object.entries(mapping.configKeys)) { + const raw = node.configuration?.[gltfKey]?.value; + if (raw !== undefined) { + config[liteName] = raw[0]; // scalar: first element only + } + } + } + if (mapping.configArrayKeys) { + for (const [gltfKey, liteName] of Object.entries(mapping.configArrayKeys)) { + const raw = node.configuration?.[gltfKey]?.value; + if (raw !== undefined) { + config[liteName] = raw; // array: full value array + } + } + } if (mapping.pointer) { const template = node.configuration?.pointer?.value?.[0] as string | undefined; const resolved = template ? resolvePointerTemplate(template, node) : null; diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index cda9256299..74dd58f381 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -986,3 +986,587 @@ describe("flow-graph blocks — matrix/quaternion", () => { expect(r.w).toBeCloseTo(Math.cos(Math.PI / 4), 5); }); }); + +// ───────────────────────────────────────────────────────────────────────────── +// Phase 3h — control-flow blocks +// ───────────────────────────────────────────────────────────────────────────── + +describe("flow-graph blocks — control flow Phase 3h", () => { + // ── Switch ──────────────────────────────────────────────────────────────── + + it("Switch routes to matching out_ when case is known", async () => { + for (const [sel, expected] of [ + [0, "zero"], + [1, "one"], + [99, "default"], + ] as const) { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "sw", socket: "in" }] } }, + { + id: "sw", + type: "Switch", + config: { cases: [0, 1] }, + dataDefaults: { case: sel }, + signalTargets: { + out_0: [{ blockId: "r0", socket: "in" }], + out_1: [{ blockId: "r1", socket: "in" }], + default: [{ blockId: "rd", socket: "in" }], + }, + }, + { id: "r0", type: RECORD, config: { label: "zero" } }, + { id: "r1", type: RECORD, config: { label: "one" } }, + { id: "rd", type: RECORD, config: { label: "default" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual([expected]); + } + }); + + it("Switch routes to default when no case matches", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "sw", socket: "in" }] } }, + { + id: "sw", + type: "Switch", + config: { cases: [5, 10] }, + dataDefaults: { case: 42 }, + signalTargets: { default: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "hit" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["hit"]); + }); + + // ── ForLoop ─────────────────────────────────────────────────────────────── + + it("ForLoop fires executionFlow for indices [start, end) exclusively", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "fl", socket: "in" }] } }, + { + id: "fl", + type: "ForLoop", + dataDefaults: { startIndex: 2, endIndex: 5, step: 1 }, + signalTargets: { + executionFlow: [{ blockId: "rec", socket: "in" }], + completed: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "rec", type: RECORD, config: { label: "body" }, dataSources: { value: { blockId: "fl", socket: "index" } } }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // Indices 2, 3, 4 — end is EXCLUSIVE (BJS: i < endIndex); then "done" fires. + expect(log.filter((e) => e.label === "body").map((e) => e.value)).toEqual([fgInt(2), fgInt(3), fgInt(4)]); + expect(log.filter((e) => e.label === "done")).toHaveLength(1); + }); + + it("ForLoop fires completed immediately when startIndex >= endIndex", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "fl", socket: "in" }] } }, + { + id: "fl", + type: "ForLoop", + dataDefaults: { startIndex: 3, endIndex: 3 }, + signalTargets: { + executionFlow: [{ blockId: "body", socket: "in" }], + completed: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "body", type: RECORD, config: { label: "body" } }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["done"]); + }); + + // ── WhileLoop ───────────────────────────────────────────────────────────── + + it("WhileLoop fires body N times then completed when condition goes false", async () => { + const log: { label: string; value: FgValue }[] = []; + let condVal = true; + let callCount = 0; + + // Stateful recorder that flips the condition after 3 calls. + const flipDef: FgBlockDef = { + type: "test/flip", + build: () => ({ signalIn: [{ name: "in", targets: [] }], dataIn: [{ name: "value", type: FgType.Any }] }), + execute: (_block, _ctx, _env) => { + callCount++; + log.push({ label: "body", value: callCount as unknown as FgValue }); + if (callCount >= 3) condVal = false; + }, + }; + const condDef: FgBlockDef = { + type: "test/cond", + build: () => ({ dataOut: [{ name: "value", type: FgType.Boolean }] }), + updateOutputs: (_block, ctx, _env) => { + ctx.connectionValues["cond:value"] = condVal; + }, + }; + + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "wl", socket: "in" }] } }, + { + id: "wl", + type: "WhileLoop", + dataSources: { condition: { blockId: "cond", socket: "value" } }, + signalTargets: { + executionFlow: [{ blockId: "flip", socket: "in" }], + completed: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "cond", type: "test/cond" }, + { id: "flip", type: "test/flip" }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log), "test/flip": flipDef, "test/cond": condDef } } + ); + startFlowGraph(rt); + expect(log.filter((e) => e.label === "body")).toHaveLength(3); + expect(log[log.length - 1]!.label).toBe("done"); + }); + + // ── DoN ─────────────────────────────────────────────────────────────────── + + it("DoN fires out only for the first N activations", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "don", socket: "in" }, + { blockId: "don", socket: "in" }, + { blockId: "don", socket: "in" }, + { blockId: "don", socket: "in" }, + ], + }, + }, + { + id: "don", + type: "DoN", + dataDefaults: { maxExecutions: fgInt(3) }, + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "fired" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // 4 activations but max is 3 → only 3 should fire. + expect(log.filter((e) => e.label === "fired")).toHaveLength(3); + }); + + it("DoN reset re-arms the block", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "don", socket: "in" }, + { blockId: "don", socket: "in" }, + { blockId: "don", socket: "in" }, // exhausts N=2 + { blockId: "don", socket: "reset" }, // resets + { blockId: "don", socket: "in" }, // fires again + ], + }, + }, + { + id: "don", + type: "DoN", + dataDefaults: { maxExecutions: fgInt(2) }, + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "fired" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // 3 activate before exhaustion (N=2 → 2 pass), then reset, then 1 more. + expect(log.filter((e) => e.label === "fired")).toHaveLength(3); + }); + + // ── MultiGate ───────────────────────────────────────────────────────────── + + it("MultiGate cycles through outputs sequentially", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, + ], + }, + }, + { + id: "mg", + type: "MultiGate", + config: { outputSignalCount: 3, isRandom: false, isLoop: false }, + signalTargets: { + out_0: [{ blockId: "r0", socket: "in" }], + out_1: [{ blockId: "r1", socket: "in" }], + out_2: [{ blockId: "r2", socket: "in" }], + }, + }, + { id: "r0", type: RECORD, config: { label: "0" } }, + { id: "r1", type: RECORD, config: { label: "1" } }, + { id: "r2", type: RECORD, config: { label: "2" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["0", "1", "2"]); + }); + + it("MultiGate with isLoop wraps around", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, // wraps + ], + }, + }, + { + id: "mg", + type: "MultiGate", + config: { outputSignalCount: 2, isRandom: false, isLoop: true }, + signalTargets: { + out_0: [{ blockId: "r0", socket: "in" }], + out_1: [{ blockId: "r1", socket: "in" }], + }, + }, + { id: "r0", type: RECORD, config: { label: "A" } }, + { id: "r1", type: RECORD, config: { label: "B" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["A", "B", "A", "B"]); + }); + + it("MultiGate reset clears state", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "mg", socket: "in" }, + { blockId: "mg", socket: "in" }, // exhausts 2 + { blockId: "mg", socket: "reset" }, + { blockId: "mg", socket: "in" }, // starts over + ], + }, + }, + { + id: "mg", + type: "MultiGate", + config: { outputSignalCount: 2, isRandom: false, isLoop: false }, + signalTargets: { + out_0: [{ blockId: "r0", socket: "in" }], + out_1: [{ blockId: "r1", socket: "in" }], + }, + }, + { id: "r0", type: RECORD, config: { label: "A" } }, + { id: "r1", type: RECORD, config: { label: "B" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // First 2 activations → A, B (exhausted). After reset → A again. + expect(log.map((e) => e.label)).toEqual(["A", "B", "A"]); + }); + + // ── WaitAll ─────────────────────────────────────────────────────────────── + + it("WaitAll fires completed only after all inputs received", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "wa", socket: "in_0" }, + { blockId: "wa", socket: "in_1" }, // completes + ], + }, + }, + { + id: "wa", + type: "WaitAll", + config: { inputSignalCount: 2 }, + signalTargets: { + out: [{ blockId: "partial", socket: "in" }], + completed: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "partial", type: RECORD, config: { label: "partial" } }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // in_0 → "partial"; in_1 completes → "done" + expect(log.map((e) => e.label)).toEqual(["partial", "done"]); + }); + + it("WaitAll reset clears received flags", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "wa", socket: "in_0" }, // partial + { blockId: "wa", socket: "reset" }, // resets + { blockId: "wa", socket: "in_0" }, // partial again + { blockId: "wa", socket: "in_1" }, // now completes + ], + }, + }, + { + id: "wa", + type: "WaitAll", + config: { inputSignalCount: 2 }, + signalTargets: { + out: [{ blockId: "partial", socket: "in" }], + completed: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "partial", type: RECORD, config: { label: "partial" } }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // in_0 → partial; reset; in_0 → partial; in_1 → done + expect(log.map((e) => e.label)).toEqual(["partial", "partial", "done"]); + }); + + // ── Throttle ────────────────────────────────────────────────────────────── + + it("Throttle passes first activation then suppresses until duration elapses", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "th", socket: "in" }] } }, + { + id: "th", + type: "Throttle", + dataDefaults: { duration: 1 }, // 1 second + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "pass" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // First activation should pass through. + expect(log).toHaveLength(1); + expect(log[0]!.label).toBe("pass"); + }); + + it("Throttle suppresses re-activations during cooldown", async () => { + const log: { label: string; value: FgValue }[] = []; + + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "th", socket: "in" }] } }, + { + id: "th", + type: "Throttle", + dataDefaults: { duration: 1 }, // 1 second + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "pass" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // First activation passes. + expect(log).toHaveLength(1); + + // Re-fire during cooldown (500 ms elapsed, need 1000 ms). + const thBlock = rt.env.graph.blocks.find((b) => b.type === "Throttle")!; + rt.env.defs[thBlock.type]!.execute!(thBlock, rt.context, rt.env, "in"); + expect(log).toHaveLength(1); // still suppressed + + // Tick past the duration. + tickFlowGraph(rt, 600); + tickFlowGraph(rt, 600); // total 1200 ms > 1000 ms → cooldown done + + // Activate again — should pass. + rt.env.defs[thBlock.type]!.execute!(thBlock, rt.context, rt.env, "in"); + expect(log).toHaveLength(2); + }); + + // ── SetDelay / CancelDelay ──────────────────────────────────────────────── + + it("SetDelay fires done after duration via tickFlowGraph", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "sd", socket: "in" }] } }, + { + id: "sd", + type: "SetDelay", + dataDefaults: { duration: 1 }, // 1 second + signalTargets: { + out: [{ blockId: "out", socket: "in" }], + done: [{ blockId: "done", socket: "in" }], + }, + }, + { id: "out", type: RECORD, config: { label: "out" } }, + { id: "done", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log.map((e) => e.label)).toEqual(["out"]); // immediate + + tickFlowGraph(rt, 500); // 500 ms — not done yet + expect(log.map((e) => e.label)).toEqual(["out"]); + + tickFlowGraph(rt, 600); // total 1100 ms > 1000 ms → done fires + expect(log.map((e) => e.label)).toEqual(["out", "done"]); + }); + + it("CancelDelay prevents done from firing", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { + out: [ + { blockId: "sd", socket: "in" }, // schedule delay + { blockId: "cd", socket: "in" }, // immediately cancel it + ], + }, + }, + { + id: "sd", + type: "SetDelay", + dataDefaults: { duration: 1 }, + signalTargets: { done: [{ blockId: "done", socket: "in" }] }, + }, + { + id: "cd", + type: "CancelDelay", + // Wire the lastDelayIndex output of sd into delayIndex input of cd. + dataSources: { delayIndex: { blockId: "sd", socket: "lastDelayIndex" } }, + signalTargets: { out: [{ blockId: "cancelled", socket: "in" }] }, + }, + { id: "done", type: RECORD, config: { label: "done" } }, + { id: "cancelled", type: RECORD, config: { label: "cancelled" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + tickFlowGraph(rt, 2000); // well past duration + // done must NOT fire; cancelled must fire once. + expect(log.filter((e) => e.label === "done")).toHaveLength(0); + expect(log.filter((e) => e.label === "cancelled")).toHaveLength(1); + }); + + // ── Constant ────────────────────────────────────────────────────────────── + + it("Constant emits its configured value", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "const", type: "Constant", config: { value: 42 } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "const", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(42); + }); + + it("Constant emits a vector value", async () => { + const log: { label: string; value: FgValue }[] = []; + const v = { x: 1, y: 2, z: 3 }; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { id: "const", type: "Constant", config: { value: v } }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "const", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toEqual(v); + }); + + // ── DataSwitch (math/switch cases config) ──────────────────────────────── + + it("DataSwitch selects in_ by selector value", async () => { + for (const [sel, expected] of [ + [0, 100], + [1, 200], + [2, 999], // default + ] as const) { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "rec", socket: "in" }] } }, + { + id: "ds", + type: "DataSwitch", + config: { cases: [0, 1] }, + dataDefaults: { case: sel, default: 999, in_0: 100, in_1: 200 }, + }, + { id: "rec", type: RECORD, dataSources: { value: { blockId: "ds", socket: "value" } } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + expect(log[0]!.value).toBe(expected); + } + }); +}); From e0bd4c022f2cdd10bb956adabd39d10bd03c9067 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 19:22:34 +0200 Subject: [PATCH 09/13] feat(flow-graph): add Phase 3i custom events + value interpolation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - blocks/events/send-custom-event.ts: pumps a CustomEvent on the shared bus (eventName + named values) and fires out. - blocks/events/receive-custom-event.ts: event block subscribed to the CustomEvent channel; filters by config.eventId, writes named values to data outputs, fires out/done. Non-matching events are ignored. - blocks/animation/value-interpolation.ts: self-contained async block (addPending/onTick); type-aware lerp (scalar, Vec2/3/4, Color3/4) with quaternion slerp; duration in seconds; a new in cancels the prior run. - block-registry.ts + gltf/declaration-mapper.ts: lazy cases + NATIVE_OPS (event/send, event/receive, variable/interpolate, pointer/interpolate) using the configKeys mechanism for eventId. - tests: send→receive round-trip (incl. non-match rejection) + numeric/vector interpolation over ticks (777 unit tests green). No runtime.ts/parser changes needed: startFlowGraph already subscribes CustomEvent receivers before Start fires. Deferred (documented): parsing the glTF events table for per-event value sockets, bezier easing control points, and pointer/interpolate accessor write-back — follow-ups aligned with BJS PR #18455 re-sync. Note: bundle manifest regeneration deferred to the end of Phase 3. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../src/flow-graph/block-registry.ts | 6 + .../blocks/animation/value-interpolation.ts | 219 +++++++++++ .../blocks/events/receive-custom-event.ts | 60 +++ .../blocks/events/send-custom-event.ts | 46 +++ .../src/flow-graph/gltf/declaration-mapper.ts | 31 ++ tests/lite/unit/flow-graph-blocks.test.ts | 366 ++++++++++++++++++ 6 files changed, 728 insertions(+) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/animation/value-interpolation.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/events/receive-custom-event.ts create mode 100644 packages/babylon-lite/src/flow-graph/blocks/events/send-custom-event.ts diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index cb2640ef24..e3f53f31d2 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -25,6 +25,10 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/events/scene-tick.js")).sceneTickDef; case FgBlockType.OnSelect: return async () => (await import("./blocks/events/on-select.js")).onSelectDef; + case FgBlockType.SendCustomEvent: + return async () => (await import("./blocks/events/send-custom-event.js")).sendCustomEventDef; + case FgBlockType.ReceiveCustomEvent: + return async () => (await import("./blocks/events/receive-custom-event.js")).receiveCustomEventDef; // ─── Control flow ───────────────────────────────────────── case FgBlockType.Branch: @@ -271,6 +275,8 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/animation/play-animation.js")).playAnimationDef; case FgBlockType.StopAnimation: return async () => (await import("./blocks/animation/stop-animation.js")).stopAnimationDef; + case FgBlockType.ValueInterpolation: + return async () => (await import("./blocks/animation/value-interpolation.js")).valueInterpolationDef; // ─── Debug ──────────────────────────────────────────────── case FgBlockType.ConsoleLog: diff --git a/packages/babylon-lite/src/flow-graph/blocks/animation/value-interpolation.ts b/packages/babylon-lite/src/flow-graph/blocks/animation/value-interpolation.ts new file mode 100644 index 0000000000..adf18d6dd1 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/animation/value-interpolation.ts @@ -0,0 +1,219 @@ +// ValueInterpolation (BJS FlowGraphInterpolationBlock + PlayAnimation chain, +// glTF ops `variable/interpolate` / `pointer/interpolate`). +// +// Self-contained async execution block: when `in` fires, it snapshots the +// start and end values, fires `out` immediately, then interpolates the value +// over `duration` seconds via `onTick`, writing the current result to the +// `value` data output. Fires `done` once when elapsed time reaches the duration. +// A new `in` signal cancels any in-progress interpolation on this block. +// +// Supported interpolation per animation type: +// Float / Integer: scalar linear lerp. +// Vector2/3/4, Color3/4: component-wise linear lerp. +// Quaternion: spherical linear interpolation (slerp), matching BJS `useSlerp`. +// Matrix: instant snap to endValue (no interpolation defined in BJS). +// +// Config: +// `type` — optional FgType string (e.g. "Vector3") for type-aware lerp. +// If omitted the type is inferred from the startValue at runtime. +// `useSlerp` — optional boolean; when true, treats values as quaternions and +// uses slerp regardless of the `type` field. +// +// glTF: `variable/interpolate` maps `value` → `endValue`, `duration` → +// `duration`. `pointer/interpolate` adds an accessor config. Easing control +// points (`p1`/`p2`) and bezier curves are deferred (linear only for now). + +import type { FgBlockDef } from "../../block-def.js"; +import type { FgPendingTask } from "../../context.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import type { FgValue, Vec2 } from "../../types.js"; +import type { Color3, Color4, Quat, Vec3, Vec4 } from "../../../math/types.js"; +import { FgAnimationValueType, animationTypeForFgType } from "../../rich-type.js"; +import { activateSignal, addPending, cancelPendingForBlock, getDataValue, setDataValue, setExecVar } from "../../runtime.js"; +import { sigIn, sigOut, sockIn, sockOut } from "../../sockets.js"; + +// ─── Interpolation math ─────────────────────────────────────────────────────── + +/** Spherical linear interpolation for quaternions (BJS-compatible). */ +function slerpQuat(a: Quat, b: Quat, t: number): Quat { + let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + let bx = b.x, + by = b.y, + bz = b.z, + bw = b.w; + // Take the shortest arc — negate b if dot is negative. + if (dot < 0) { + dot = -dot; + bx = -bx; + by = -by; + bz = -bz; + bw = -bw; + } + let s0: number; + let s1: number; + if (dot > 0.9995) { + // Numerically safe fallback: normalised linear interpolation. + s0 = 1 - t; + s1 = t; + } else { + const theta = Math.acos(dot); + const sinTheta = Math.sin(theta); + s0 = Math.sin((1 - t) * theta) / sinTheta; + s1 = Math.sin(t * theta) / sinTheta; + } + return { x: s0 * a.x + s1 * bx, y: s0 * a.y + s1 * by, z: s0 * a.z + s1 * bz, w: s0 * a.w + s1 * bw }; +} + +/** Type-aware linear/spherical interpolation between two FgValues. */ +function lerpFgValue(a: FgValue, b: FgValue, t: number, animType: FgAnimationValueType): FgValue { + switch (animType) { + case FgAnimationValueType.Float: { + const na = typeof a === "number" ? a : 0; + const nb = typeof b === "number" ? b : 0; + return na + t * (nb - na); + } + case FgAnimationValueType.Vector2: { + const va = a as Vec2; + const vb = b as Vec2; + return { x: va.x + t * (vb.x - va.x), y: va.y + t * (vb.y - va.y) }; + } + case FgAnimationValueType.Vector3: { + const va = a as Vec3; + const vb = b as Vec3; + return { x: va.x + t * (vb.x - va.x), y: va.y + t * (vb.y - va.y), z: va.z + t * (vb.z - va.z) }; + } + case FgAnimationValueType.Vector4: { + const va = a as Vec4; + const vb = b as Vec4; + return { x: va.x + t * (vb.x - va.x), y: va.y + t * (vb.y - va.y), z: va.z + t * (vb.z - va.z), w: va.w + t * (vb.w - va.w) }; + } + case FgAnimationValueType.Quaternion: + return slerpQuat(a as Quat, b as Quat, t); + case FgAnimationValueType.Color3: { + const ca = a as Color3; + const cb = b as Color3; + return { r: ca.r + t * (cb.r - ca.r), g: ca.g + t * (cb.g - ca.g), b: ca.b + t * (cb.b - ca.b) }; + } + case FgAnimationValueType.Color4: { + const ca = a as Color4; + const cb = b as Color4; + return { r: ca.r + t * (cb.r - ca.r), g: ca.g + t * (cb.g - ca.g), b: ca.b + t * (cb.b - ca.b), a: ca.a + t * (cb.a - ca.a) }; + } + default: + // Matrix types: snap to end (no interpolation defined in BJS for matrices). + return b; + } +} + +/** Derive the `FgAnimationValueType` from config and/or the runtime start value. */ +function resolveAnimType(startValue: FgValue, config: Readonly> | undefined): FgAnimationValueType { + if (config?.useSlerp) { + return FgAnimationValueType.Quaternion; + } + const configType = config?.type as string | undefined; + if (configType) { + return animationTypeForFgType(configType as FgType); + } + // Infer from value shape — covers the common test/unit cases. + if (typeof startValue === "number" || startValue === null || startValue === undefined) { + return FgAnimationValueType.Float; + } + if (typeof startValue === "object") { + if ("r" in startValue && "a" in startValue) { + return FgAnimationValueType.Color4; + } + if ("r" in startValue) { + return FgAnimationValueType.Color3; + } + // Vec4 and Quat both carry `w`; without an explicit `type`/`useSlerp` in + // config, prefer Vec4 (linear). Set `config.useSlerp` or `config.type = + // "Quaternion"` to force slerp. + if ("w" in startValue) { + return FgAnimationValueType.Vector4; + } + if ("z" in startValue) { + return FgAnimationValueType.Vector3; + } + if ("y" in startValue) { + return FgAnimationValueType.Vector2; + } + } + return FgAnimationValueType.Float; +} + +// ─── Block definition ───────────────────────────────────────────────────────── + +export const valueInterpolationDef: FgBlockDef = { + type: FgBlockType.ValueInterpolation, + build: () => ({ + dataIn: [sockIn("startValue", FgType.Any), sockIn("endValue", FgType.Any), sockIn("duration", FgType.Number, 0)], + dataOut: [sockOut("value", FgType.Any)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out"), sigOut("done"), sigOut("error")], + }), + updateOutputs(block, ctx) { + // Expose whatever the most recent onTick (or execute) wrote. + const cv = ctx.executionVariables[`${block.id}:currentValue`]; + if (cv !== undefined) { + setDataValue(ctx, block, "value", cv as FgValue); + } + }, + execute(block, ctx, env, incomingSignal) { + if (incomingSignal !== "in" && incomingSignal !== undefined) { + return; + } + + const duration = getDataValue(ctx, env, block, "duration") as number; + if (!isFinite(duration) || isNaN(duration) || duration < 0) { + activateSignal(ctx, env, block, "error"); + return; + } + + // Cancel any prior interpolation on this block. + cancelPendingForBlock(ctx, block); + + const startValue = getDataValue(ctx, env, block, "startValue"); + const endValue = getDataValue(ctx, env, block, "endValue"); + const animType = resolveAnimType(startValue, block.config); + + // Seed the data output with the start value immediately. + setExecVar(ctx, block, "currentValue", startValue); + setDataValue(ctx, block, "value", startValue); + + if (duration <= 0) { + // Zero-duration: snap straight to end, fire done synchronously. + setExecVar(ctx, block, "currentValue", endValue); + setDataValue(ctx, block, "value", endValue); + activateSignal(ctx, env, block, "out"); + activateSignal(ctx, env, block, "done"); + return; + } + + addPending(ctx, block, { startValue, endValue, duration, elapsed: 0, animType }); + activateSignal(ctx, env, block, "out"); + }, + onTick(block, ctx, env, deltaMs, task: FgPendingTask) { + const elapsed = (task.state.elapsed as number) + deltaMs / 1000; + const duration = task.state.duration as number; + const startValue = task.state.startValue as FgValue; + const endValue = task.state.endValue as FgValue; + const animType = task.state.animType as FgAnimationValueType; + + if (elapsed >= duration) { + task.done = true; + setExecVar(ctx, block, "currentValue", endValue); + setDataValue(ctx, block, "value", endValue); + activateSignal(ctx, env, block, "done"); + } else { + task.state.elapsed = elapsed; + const t = elapsed / duration; + const current = lerpFgValue(startValue, endValue, t, animType); + setExecVar(ctx, block, "currentValue", current); + setDataValue(ctx, block, "value", current); + } + }, + cancelPending(_block, _ctx, _env) { + // No external resources (file handles, subscriptions) to release. + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/events/receive-custom-event.ts b/packages/babylon-lite/src/flow-graph/blocks/events/receive-custom-event.ts new file mode 100644 index 0000000000..d2621a2591 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/events/receive-custom-event.ts @@ -0,0 +1,60 @@ +// ReceiveCustomEvent (BJS FlowGraphReceiveCustomEventBlock, glTF op `event/receive`). +// Event block: subscribes to `FgEventType.CustomEvent` on the shared bus. +// The runtime's `startFlowGraph` subscribes it BEFORE Start blocks fire, so a +// Send triggered by SceneStart is guaranteed to reach this receiver. +// +// When the bus fires, `execute` reads the stashed payload, checks that +// `payload.eventName` matches `config.eventId`, writes named data outputs from +// `payload.values`, then fires `out` (and the BJS-compatible `done`). +// Events whose name does not match are silently ignored. +// +// Config: +// `eventId` — string identifier that must match the sender's (required). +// `valueNames` — optional string[] of data-output socket names populated from +// `payload.values`. Derived from the glTF events table (deferred +// wiring — see report). +// +// glTF: `event/receive`. `configuration["event"]` index → `config.eventId` +// (configKeys). Value outputs from the events table are a deferred Phase 3i+ item. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgEventType } from "../../event-bus.js"; +import { FgType } from "../../types.js"; +import type { FgValue } from "../../types.js"; +import { activateSignal, getExecVar, setDataValue } from "../../runtime.js"; +import { sigOut, sockOut } from "../../sockets.js"; + +export const receiveCustomEventDef: FgBlockDef = { + type: FgBlockType.ReceiveCustomEvent, + build(config) { + const valueNames = (config?.valueNames as string[] | undefined) ?? []; + return { + dataOut: valueNames.map((name) => sockOut(name, FgType.Any)), + signalOut: [sigOut("out"), sigOut("done")], + event: FgEventType.CustomEvent, + }; + }, + execute(block, ctx, env) { + const eventId = (block.config?.eventId as string | undefined) ?? ""; + const valueNames = (block.config?.valueNames as string[] | undefined) ?? []; + + const payload = getExecVar<{ eventName?: string; values?: Record } | undefined>(ctx, block, "lastEvent", undefined); + + // Filter: only react to events that match this block's eventId. + if (!payload || payload.eventName !== eventId) { + return; + } + + // Write named values from the payload into data outputs. + for (const name of valueNames) { + const v = payload.values?.[name]; + if (v !== undefined) { + setDataValue(ctx, block, name, v); + } + } + + activateSignal(ctx, env, block, "done"); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/blocks/events/send-custom-event.ts b/packages/babylon-lite/src/flow-graph/blocks/events/send-custom-event.ts new file mode 100644 index 0000000000..f582a9ed22 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/events/send-custom-event.ts @@ -0,0 +1,46 @@ +// SendCustomEvent (BJS FlowGraphSendCustomEventBlock, glTF op `event/send`). +// Execution block: gathers named data inputs and pumps a custom event on the +// shared bus so any ReceiveCustomEvent block in any graph can consume it. +// +// Config: +// `eventId` — string identifier for the event channel (required). +// `valueNames` — optional string[] of data-input socket names whose values +// are bundled into `payload.values`. Derived from the glTF +// events table (deferred wiring — see report). +// +// glTF: `event/send`. The `configuration["event"]` integer index is mapped to +// `config.eventId` by declaration-mapper (configKeys). Full value-parameter +// sockets from the glTF events table are a deferred Phase 3i+ item. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgEventType } from "../../event-bus.js"; +import { FgType } from "../../types.js"; +import type { FgValue } from "../../types.js"; +import { activateSignal, getDataValue } from "../../runtime.js"; +import { pumpFgEvent } from "../../event-bus.js"; +import { sigIn, sigOut, sockIn } from "../../sockets.js"; + +export const sendCustomEventDef: FgBlockDef = { + type: FgBlockType.SendCustomEvent, + build(config) { + const valueNames = (config?.valueNames as string[] | undefined) ?? []; + return { + dataIn: valueNames.map((name) => sockIn(name, FgType.Any)), + signalIn: [sigIn("in")], + signalOut: [sigOut("out")], + }; + }, + execute(block, ctx, env) { + const eventId = (block.config?.eventId as string | undefined) ?? ""; + const valueNames = (block.config?.valueNames as string[] | undefined) ?? []; + + const values: Record = {}; + for (const name of valueNames) { + values[name] = getDataValue(ctx, env, block, name); + } + + pumpFgEvent(env.events, FgEventType.CustomEvent, { eventName: eventId, values }); + activateSignal(ctx, env, block, "out"); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index 9734754a88..2ab479879f 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -278,6 +278,37 @@ const NATIVE_OPS: Readonly> = { flowOutputs: { err: "error" }, }, "animation/stop": { block: FgBlockType.StopAnimation, valueInputs: { animation: "animation" }, flowOutputs: { err: "error" } }, + + // ─── Phase 3i event ops ──────────────────────────────────────────────────── + // event/send: `configuration["event"]` holds the integer event-table index, + // copied into `config.eventId` as a scalar. Value parameters from the glTF + // events table are a deferred Phase 3i+ item (parser doesn't yet read + // `json.events`, so sockets beyond the eventId are not wired from glTF). + "event/send": { block: FgBlockType.SendCustomEvent, configKeys: { event: "eventId" } }, + // event/receive: same index → eventId mapping; glTF flow key `out` maps to + // the Lite `done` signal (BJS convention for event blocks). + "event/receive": { block: FgBlockType.ReceiveCustomEvent, configKeys: { event: "eventId" }, flowOutputs: { out: "done" } }, + + // ─── Phase 3i interpolation ops ─────────────────────────────────────────── + // variable/interpolate: glTF `value` input → Lite `endValue`; `duration` + // passes through. `useSlerp` config → `config.useSlerp` (boolean). + // Easing control points `p1`/`p2` (BezierCurveEasing) are deferred. + // Pointer/variable target wiring (SetProperty after done) is also deferred. + "variable/interpolate": { + block: FgBlockType.ValueInterpolation, + valueInputs: { value: "endValue", duration: "duration" }, + configKeys: { useSlerp: "useSlerp" }, + flowOutputs: { err: "error" }, + }, + // pointer/interpolate: same inputs; adds accessor resolution from the pointer + // configuration so the block can eventually write its `value` to a property. + "pointer/interpolate": { + block: FgBlockType.ValueInterpolation, + pointer: true, + valueInputs: { value: "endValue", duration: "duration" }, + configKeys: { useSlerp: "useSlerp" }, + flowOutputs: { err: "error" }, + }, }; /** Babylon-extension ops (`declaration.extension === "BABYLON"`). */ diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index 74dd58f381..582aecdf6f 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -1570,3 +1570,369 @@ describe("flow-graph blocks — control flow Phase 3h", () => { } }); }); + +// ─── Phase 3i: custom events + value interpolation ──────────────────────────── + +describe("flow-graph blocks — events + interpolation Phase 3i", () => { + // ── SendCustomEvent / ReceiveCustomEvent ───────────────────────────────── + + it("Send→Receive round-trip: matching eventId delivers named values", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + // SceneStart fires SendCustomEvent with {score: 42} + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "send", socket: "in" }] }, + }, + { + id: "send", + type: "SendCustomEvent", + config: { eventId: "myEvent", valueNames: ["score"] }, + dataDefaults: { score: 42 }, + signalTargets: { out: [{ blockId: "recSent", socket: "in" }] }, + }, + // ReceiveCustomEvent (same eventId) wires to recorder + { + id: "recv", + type: "ReceiveCustomEvent", + config: { eventId: "myEvent", valueNames: ["score"] }, + signalTargets: { out: [{ blockId: "recRecv", socket: "in" }] }, + }, + { id: "recSent", type: RECORD, config: { label: "sent" } }, + { + id: "recRecv", + type: RECORD, + config: { label: "recv" }, + dataSources: { value: { blockId: "recv", socket: "score" } }, + }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + + // send fired "sent" + receive triggered "recv" + expect(log.map((e) => e.label)).toContain("sent"); + expect(log.map((e) => e.label)).toContain("recv"); + + const recvEntry = log.find((e) => e.label === "recv"); + expect(recvEntry?.value).toBe(42); + }); + + it("Send→Receive: non-matching eventId does NOT trigger receiver", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "send", socket: "in" }] }, + }, + { + id: "send", + type: "SendCustomEvent", + config: { eventId: "eventA", valueNames: ["x"] }, + dataDefaults: { x: 7 }, + }, + // Receiver listens on a DIFFERENT eventId — must NOT fire. + { + id: "recv", + type: "ReceiveCustomEvent", + config: { eventId: "eventB", valueNames: ["x"] }, + signalTargets: { out: [{ blockId: "rec", socket: "in" }] }, + }, + { id: "rec", type: RECORD, config: { label: "fired" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + // No record should appear — mismatched eventId is filtered out. + expect(log.filter((e) => e.label === "fired")).toHaveLength(0); + }); + + it("Send→Receive: matching receiver fires, mismatched receiver is silent", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "send", socket: "in" }] }, + }, + { + id: "send", + type: "SendCustomEvent", + config: { eventId: "ping", valueNames: [] }, + }, + { + id: "recvOk", + type: "ReceiveCustomEvent", + config: { eventId: "ping" }, + signalTargets: { out: [{ blockId: "recOk", socket: "in" }] }, + }, + { + id: "recvNo", + type: "ReceiveCustomEvent", + config: { eventId: "pong" }, + signalTargets: { out: [{ blockId: "recNo", socket: "in" }] }, + }, + { id: "recOk", type: RECORD, config: { label: "ok" } }, + { id: "recNo", type: RECORD, config: { label: "no" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + expect(log.filter((e) => e.label === "ok")).toHaveLength(1); + expect(log.filter((e) => e.label === "no")).toHaveLength(0); + }); + + it("ReceiveCustomEvent fires both out and done signals", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "send", socket: "in" }] }, + }, + { id: "send", type: "SendCustomEvent", config: { eventId: "ev" } }, + { + id: "recv", + type: "ReceiveCustomEvent", + config: { eventId: "ev" }, + signalTargets: { + out: [{ blockId: "recOut", socket: "in" }], + done: [{ blockId: "recDone", socket: "in" }], + }, + }, + { id: "recOut", type: RECORD, config: { label: "out" } }, + { id: "recDone", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + expect(log.map((e) => e.label)).toContain("out"); + expect(log.map((e) => e.label)).toContain("done"); + }); + + // ── ValueInterpolation ──────────────────────────────────────────────────── + + it("ValueInterpolation: numeric lerp moves value toward target over ticks", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "interp", socket: "in" }] }, + }, + { + id: "interp", + type: "ValueInterpolation", + config: { type: "number" }, + dataDefaults: { startValue: 0, endValue: 10, duration: 1 }, // 1 second + signalTargets: { + out: [{ blockId: "recOut", socket: "in" }], + done: [{ blockId: "recDone", socket: "in" }], + }, + }, + { + id: "recOut", + type: RECORD, + config: { label: "out" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + { + id: "recDone", + type: RECORD, + config: { label: "done" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + // out fires immediately — value should be at startValue (0) + const outEntry = log.find((e) => e.label === "out"); + expect(outEntry).toBeDefined(); + expect(outEntry!.value).toBe(0); + expect(log.find((e) => e.label === "done")).toBeUndefined(); + + // Tick to 50% progress (500 ms of 1000 ms) → value ≈ 5 + tickFlowGraph(rt, 500); + const interpBlock = rt.env.graph.blocks.find((b) => b.type === "ValueInterpolation")!; + const midValue = rt.context.connectionValues[`${interpBlock.id}:value`] as number; + expect(midValue).toBeGreaterThan(0); + expect(midValue).toBeLessThan(10); + expect(midValue).toBeCloseTo(5, 5); + + // Tick past duration → done fires, value snaps to 10 + tickFlowGraph(rt, 600); // total ~1100 ms exceeds the 1 s duration + expect(log.find((e) => e.label === "done")).toBeDefined(); + expect(log.find((e) => e.label === "done")!.value).toBe(10); + }); + + it("ValueInterpolation: done fires exactly once even with extra ticks", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "interp", socket: "in" }] }, + }, + { + id: "interp", + type: "ValueInterpolation", + config: { type: "number" }, + dataDefaults: { startValue: 0, endValue: 1, duration: 0.5 }, + signalTargets: { done: [{ blockId: "recDone", socket: "in" }] }, + }, + { id: "recDone", type: RECORD, config: { label: "done" } }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + tickFlowGraph(rt, 1000); // well past 500 ms + tickFlowGraph(rt, 1000); + expect(log.filter((e) => e.label === "done")).toHaveLength(1); + }); + + it("ValueInterpolation: Vec3 lerp produces correct intermediate and final components", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "interp", socket: "in" }] }, + }, + { + id: "interp", + type: "ValueInterpolation", + config: { type: "Vector3" }, + dataDefaults: { + startValue: { x: 0, y: 0, z: 0 }, + endValue: { x: 10, y: 20, z: 30 }, + duration: 1, + }, + signalTargets: { done: [{ blockId: "recDone", socket: "in" }] }, + }, + { + id: "recDone", + type: RECORD, + config: { label: "done" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + // Advance to halfway point (500 ms of 1 s). + tickFlowGraph(rt, 500); + const interpBlock = rt.env.graph.blocks.find((b) => b.type === "ValueInterpolation")!; + const mid = rt.context.connectionValues[`${interpBlock.id}:value`] as { x: number; y: number; z: number }; + expect(mid.x).toBeCloseTo(5, 5); + expect(mid.y).toBeCloseTo(10, 5); + expect(mid.z).toBeCloseTo(15, 5); + + // Tick past the end. + tickFlowGraph(rt, 600); + const done = log.find((e) => e.label === "done"); + expect(done?.value).toEqual({ x: 10, y: 20, z: 30 }); + }); + + it("ValueInterpolation: zero duration snaps to endValue synchronously", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "interp", socket: "in" }] }, + }, + { + id: "interp", + type: "ValueInterpolation", + config: { type: "number" }, + dataDefaults: { startValue: 0, endValue: 99, duration: 0 }, + signalTargets: { + out: [{ blockId: "recOut", socket: "in" }], + done: [{ blockId: "recDone", socket: "in" }], + }, + }, + { + id: "recOut", + type: RECORD, + config: { label: "out" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + { + id: "recDone", + type: RECORD, + config: { label: "done" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + // Both out and done fire synchronously; value is already endValue. + expect(log.map((e) => e.label)).toContain("out"); + expect(log.map((e) => e.label)).toContain("done"); + expect(log.find((e) => e.label === "done")?.value).toBe(99); + }); + + it("ValueInterpolation: re-triggering in cancels the previous run", async () => { + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { + id: "start", + type: "SceneReadyEvent", + signalTargets: { out: [{ blockId: "interp", socket: "in" }] }, + }, + { + id: "interp", + type: "ValueInterpolation", + config: { type: "number" }, + dataDefaults: { startValue: 0, endValue: 100, duration: 2 }, + signalTargets: { done: [{ blockId: "recDone", socket: "in" }] }, + }, + { + id: "recDone", + type: RECORD, + config: { label: "done" }, + dataSources: { value: { blockId: "interp", socket: "value" } }, + }, + ], + { defs: { [RECORD]: recorderDef(log) } } + ); + + startFlowGraph(rt); + tickFlowGraph(rt, 500); // half-way through first run + + // Re-trigger with different endValue / duration via direct mutation of the + // socket defaults (the same technique used in the SetDelay cancel test). + const interpBlock = rt.env.graph.blocks.find((b) => b.type === "ValueInterpolation")!; + const endSock = interpBlock.dataIn.find((s) => s.name === "endValue")!; + (endSock as { defaultValue?: FgValue }).defaultValue = 200; + const durSock = interpBlock.dataIn.find((s) => s.name === "duration")!; + (durSock as { defaultValue?: FgValue }).defaultValue = 0.5; + rt.env.defs[interpBlock.type]!.execute!(interpBlock, rt.context, rt.env, "in"); + + tickFlowGraph(rt, 600); // past the new 500 ms duration + // done fires once for the second interpolation (first was canceled) + expect(log.filter((e) => e.label === "done")).toHaveLength(1); + expect(log.find((e) => e.label === "done")?.value).toBe(200); + }); +}); From af9046ebe6ed0476945256ea1bfca8112d1aaed3 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 19:36:38 +0200 Subject: [PATCH 10/13] build(flow-graph): regenerate bundle manifest for Phase 3 Single manifest regeneration covering all Phase 3 src changes (3a-3i). Most interactivity-eligible scenes show hash-only gltf-feature-registry chunk renames. Animation/skeleton scenes (scene5/7/34/35/39, etc.) gain shared mat4-invert / mat4-multiply chunks: Phase 3f's matrix blocks reuse core mat4Invert/mat4Multiply, so Rollup's global chunk analysis hoists those core functions into shared chunks rather than duplicating them. Net effect is code sharing (no duplication); per-scene deltas are sub-KB chunk-boundary overhead and stay within size ceilings. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- lab/public/bundle/manifest.json | 541 +++++++++++++++++--------------- 1 file changed, 283 insertions(+), 258 deletions(-) diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index e11b9a3adf..117e411a3d 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -10,7 +10,7 @@ "scene1-generate-mipmaps-DfKYIHYG.js", "scene1-gltf-glb-parser-BL74Wcec.js", "scene1-ibl-fragment-CeRrvT96.js", - "scene1-pbr-renderable-BgW6YoeF.js", + "scene1-pbr-renderable-DpADIW0T.js", "scene1-rgbd-decode-JSHbS7uW.js", "scene1-scene-uniforms-FTYH6Ct0.js", "scene1-singlelight-hemispheric-wgsl-dhCCcXC9.js", @@ -57,25 +57,26 @@ ] }, "scene5": { - "rawKB": 90, - "gzipKB": 38.1, + "rawKB": 90.2, + "gzipKB": 38.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene5-create-morph-targets-CxWjyKmd.js", "scene5-create-skeleton-Bi7nAPH9.js", "scene5-generate-mipmaps-DjmtEap1.js", - "scene5-gltf-animation-qzi1HRZg.js", + "scene5-gltf-animation-Db000-8t.js", "scene5-gltf-color-normalize-BtnJk1yq.js", - "scene5-gltf-feature-animations-CQrRowr9.js", + "scene5-gltf-feature-animations-BTJfdC_m.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry--nXe1DF5.js", - "scene5-gltf-feature-skeleton-Siixi_P0.js", + "scene5-gltf-feature-registry-BM89Nuq3.js", + "scene5-gltf-feature-skeleton-DPTrgiUu.js", "scene5-gltf-json-asset-DS0i23k1.js", - "scene5-morph-fragment-BhcJT1xs.js", - "scene5-pbr-renderable-205Mi-TV.js", + "scene5-mat4-invert-DlwG0Ui-.js", + "scene5-morph-fragment-SUVkfdAM.js", + "scene5-pbr-renderable-DGLP44TZ.js", "scene5-pbr-template-ext-BoJ8SFLM.js", "scene5-singlelight-hemispheric-wgsl-DYn0thCO.js", - "scene5-skeleton-fragment-BNjKEYjD.js", + "scene5-skeleton-fragment-DOzbHYJb.js", "scene5.js" ] }, @@ -96,26 +97,27 @@ ] }, "scene7": { - "rawKB": 104.4, - "gzipKB": 44.1, + "rawKB": 104.5, + "gzipKB": 44.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene7-background-ground-SAvSHzNE.js", "scene7-background-solid-skybox-gCmyuEIn.js", "scene7-create-skeleton-xdZ7V4Ou.js", "scene7-generate-mipmaps-BNxg8boc.js", - "scene7-gltf-animation-B7Xr33me.js", - "scene7-gltf-feature-animations-CG5FpT6C.js", + "scene7-gltf-animation-CH0_e4oq.js", + "scene7-gltf-feature-animations-Bgob9WEn.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-CB2PmYGi.js", - "scene7-gltf-feature-skeleton-BCWZyzWC.js", + "scene7-gltf-feature-registry-Wc2uroCJ.js", + "scene7-gltf-feature-skeleton-B9G0EPQT.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", - "scene7-pbr-renderable-Cs3YgpsU.js", + "scene7-mat4-invert-qkYx19NH.js", + "scene7-pbr-renderable-CseWBxfZ.js", "scene7-rgbd-decode-C9OJGqTP.js", "scene7-scene-uniforms-FTYH6Ct0.js", "scene7-singlelight-hemispheric-wgsl-DbXoSTyY.js", - "scene7-skeleton-fragment-B2mbr3JT.js", + "scene7-skeleton-fragment-Cz2KW3d3.js", "scene7-skybox.vertex-Ban7q6IM-D1KSfOUq.js", "scene7-wgsl-helpers-CkUi9P9Q.js", "scene7.js" @@ -163,39 +165,41 @@ ] }, "scene11": { - "rawKB": 87.6, - "gzipKB": 36.8, + "rawKB": 87.7, + "gzipKB": 36.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene11-create-skeleton-D7GjlnE9.js", "scene11-generate-mipmaps-YGxDoUB2.js", - "scene11-gltf-animation-CQ75q6KC.js", + "scene11-gltf-animation-CcJYg0ZT.js", "scene11-gltf-ext-spec-gloss-D60sFZYX.js", - "scene11-gltf-feature-animations-Bmg0PBR4.js", + "scene11-gltf-feature-animations-BIZ-N9xV.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-C7hwLHSw.js", - "scene11-gltf-feature-skeleton-CrXfHDG6.js", + "scene11-gltf-feature-registry-MWFUiHlf.js", + "scene11-gltf-feature-skeleton-Dd-D_2bN.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", - "scene11-pbr-renderable-CGkvaNwT.js", + "scene11-mat4-invert-CVQ5maV0.js", + "scene11-pbr-renderable-eg_x6Za2.js", "scene11-singlelight-hemispheric-wgsl-C40tQGmo.js", - "scene11-skeleton-fragment-CNcDYl5q.js", + "scene11-skeleton-fragment-CzpG9JGH.js", "scene11.js" ] }, "scene12": { - "rawKB": 102, - "gzipKB": 41.6, + "rawKB": 102.1, + "gzipKB": 41.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene12-create-skeleton-Cjf80v3R.js", "scene12-generate-mipmaps-Bsp4UQ3D.js", - "scene12-gltf-animation-BDKbEYQd.js", - "scene12-gltf-feature-animations-Bfc5iW7L.js", - "scene12-gltf-feature-registry-B3m6qlCk.js", - "scene12-gltf-feature-skeleton-CN1CorcX.js", + "scene12-gltf-animation-CDCBlIUe.js", + "scene12-gltf-feature-animations-CxVsuL-g.js", + "scene12-gltf-feature-registry-BemD_Rua.js", + "scene12-gltf-feature-skeleton-BBrB-2Pq.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", + "scene12-mat4-invert-DAsxoqbB.js", "scene12-pbr-renderable-Bo7mvJtD.js", "scene12-reflectance-fragment-Kimqnape.js", "scene12-rgbd-decode-BLiTLohS.js", @@ -206,7 +210,7 @@ ] }, "scene13": { - "rawKB": 83.9, + "rawKB": 84, "gzipKB": 34.6, "ignoredRawKB": 0, "runtimeChunks": [ @@ -214,7 +218,7 @@ "scene13-generate-mipmaps-BYu5QYgJ.js", "scene13-gltf-glb-parser-HP2v-3hE.js", "scene13-ibl-fragment-CeRrvT96.js", - "scene13-pbr-renderable-Jx_XgvTU.js", + "scene13-pbr-renderable-DIkUPn0q.js", "scene13-rgbd-decode-CmtmNnLb.js", "scene13-scene-uniforms-FTYH6Ct0.js", "scene13-singlelight-hemispheric-wgsl-D1uhnT_s.js", @@ -233,7 +237,7 @@ "scene14-generate-mipmaps-Drlt5FNB.js", "scene14-gltf-glb-parser-B--vN_CU.js", "scene14-ibl-fragment-CeRrvT96.js", - "scene14-pbr-renderable-BPFgC4Sv.js", + "scene14-pbr-renderable-Btml529S.js", "scene14-rgbd-decode-BdaP5z1T.js", "scene14-scene-uniforms-FTYH6Ct0.js", "scene14-singlelight-hemispheric-wgsl-Q-eHTfjt.js", @@ -411,7 +415,7 @@ ] }, "scene26": { - "rawKB": 89.4, + "rawKB": 89.5, "gzipKB": 36.4, "ignoredRawKB": 0, "runtimeChunks": [ @@ -435,12 +439,12 @@ "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-BgpF1m7m.js", + "scene27-gltf-feature-registry-ei9UqmOm.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", "scene27-gltf-variants-CqSlvDBE.js", - "scene27-pbr-renderable-DP1MITnP.js", + "scene27-pbr-renderable-CYcDjssQ.js", "scene27-reflectance-fragment-CvRmBvQ0.js", "scene27-singlelight-hemispheric-wgsl-B8SoT1MB.js", "scene27-texture-2d-DQo3n8D6.js", @@ -455,10 +459,10 @@ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry-ZTlsFOBl.js", + "scene28-gltf-feature-registry--MjnqBQp.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", - "scene28-pbr-renderable-BYSlPUr5.js", + "scene28-pbr-renderable-eX7eFIi2.js", "scene28-rgbd-decode-wUvHpHPX.js", "scene28-scene-uniforms-FTYH6Ct0.js", "scene28.js" @@ -472,11 +476,11 @@ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-CHIA8ktl.js", + "scene29-gltf-feature-registry-D_9kBHw8.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", - "scene29-pbr-renderable-CYFwIG7G.js", + "scene29-pbr-renderable-CcNfOY06.js", "scene29-pbr-template-ext-BoJ8SFLM.js", "scene29-rgbd-decode-DZaCQfRj.js", "scene29-scene-uniforms-FTYH6Ct0.js", @@ -496,14 +500,14 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-BTz1SdJl.js", + "scene30-gltf-feature-registry-CaT3ij9r.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", - "scene30-pbr-refraction-BR-OcPmw.js", - "scene30-pbr-renderable-CoSAyXaL.js", + "scene30-pbr-refraction-BhGoeTX9.js", + "scene30-pbr-renderable-7H5c0RKe.js", "scene30-pbr-template-ext-BoJ8SFLM.js", - "scene30-pbr-transmission-ext-CGs28NrW.js", + "scene30-pbr-transmission-ext-D_j4aSe7.js", "scene30-rgbd-decode-RQYTGqhL.js", "scene30-scene-uniforms-FTYH6Ct0.js", "scene30-texture-2d-DQo3n8D6.js", @@ -512,17 +516,17 @@ ] }, "scene31": { - "rawKB": 79, + "rawKB": 79.1, "gzipKB": 32.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-DHWtFb0K.js", + "scene31-gltf-feature-registry-DeKOspJg.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", - "scene31-pbr-renderable-Bg8O1LwN.js", + "scene31-pbr-renderable-DBEVLcPa.js", "scene31-rgbd-decode-C5kd6U3R.js", "scene31-scene-uniforms-FTYH6Ct0.js", "scene31.js" @@ -530,15 +534,15 @@ }, "scene32": { "rawKB": 78.9, - "gzipKB": 32.4, + "gzipKB": 32.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-DJXe2woQ.js", + "scene32-gltf-feature-registry-Dq-fTLv5.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", - "scene32-pbr-renderable-CUtjMSAl.js", + "scene32-pbr-renderable-UXm0NIAX.js", "scene32-rgbd-decode-3FngBUdB.js", "scene32-scene-uniforms-FTYH6Ct0.js", "scene32-unlit-fragment-DYNWudHP.js", @@ -553,16 +557,16 @@ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-xCrbrsGP.js", + "scene33-gltf-feature-registry-DboRc1lb.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", "scene33-ibl-fragment-CeRrvT96.js", "scene33-light-base-SJy-sLMD.js", "scene33-multilight-wgsl-D3rF1wIQ.js", - "scene33-pbr-refraction-D471wMEc.js", - "scene33-pbr-renderable-DJawGTOL.js", - "scene33-pbr-transmission-ext-BYr3YXsr.js", + "scene33-pbr-refraction-DRBX9DRu.js", + "scene33-pbr-renderable-kYGvDAQa.js", + "scene33-pbr-transmission-ext-DNvne2d4.js", "scene33-point-light-CcVWqAnQ.js", "scene33-rgbd-decode-3bEbw5la.js", "scene33-scene-uniforms-FTYH6Ct0.js", @@ -570,20 +574,21 @@ ] }, "scene34": { - "rawKB": 95.7, - "gzipKB": 39.5, + "rawKB": 95.9, + "gzipKB": 39.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene34-animation-pointer-Ddy-YJnh.js", "scene34-generate-mipmaps-C244DQVV.js", - "scene34-gltf-animation-Cz7h58Nc.js", + "scene34-gltf-animation-DPV8cS8y.js", "scene34-gltf-ext-node-visibility-CyR_MQR5.js", - "scene34-gltf-feature-animation-pointer-rAfd1hLG.js", - "scene34-gltf-feature-animations-BQSrKgM_.js", - "scene34-gltf-feature-registry-CRyMahIV.js", + "scene34-gltf-feature-animation-pointer-Dwl9YL57.js", + "scene34-gltf-feature-animations-CdtaC2qb.js", + "scene34-gltf-feature-registry-BsUHr3YM.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", - "scene34-pbr-renderable-BelxTmu1.js", + "scene34-mat4-invert-BeOKSoLh.js", + "scene34-pbr-renderable-BmEHhHi_.js", "scene34-rgbd-decode-ByPAsdES.js", "scene34-scene-uniforms-FTYH6Ct0.js", "scene34-visibility-fb8svtso.js", @@ -591,16 +596,17 @@ ] }, "scene35": { - "rawKB": 82.2, - "gzipKB": 33.8, + "rawKB": 82.3, + "gzipKB": 34, "ignoredRawKB": 0, "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", - "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", - "scene35-gltf-feature-registry-CYDnesiH.js", + "scene35-gltf-feature-gpu-instancing-B4GHj5Jg.js", + "scene35-gltf-feature-registry-DDJrohjx.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", - "scene35-pbr-renderable-B_cgTnJN.js", + "scene35-mat4-multiply-CZ8Su_a2.js", + "scene35-pbr-renderable-CM5qYb7h.js", "scene35-rgbd-decode-U56TFVGU.js", "scene35-scene-uniforms-FTYH6Ct0.js", "scene35-thin-instance-fragment-CBn2miAC.js", @@ -620,7 +626,7 @@ ] }, "scene37": { - "rawKB": 95.8, + "rawKB": 95.9, "gzipKB": 39.2, "ignoredRawKB": 0, "runtimeChunks": [ @@ -629,11 +635,11 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-BVOrVtrK.js", + "scene37-gltf-feature-registry-DXpcYFv_.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", - "scene37-pbr-renderable-DKwsq1aF.js", + "scene37-pbr-renderable-CUE3gxbO.js", "scene37-pbr-template-ext-BoJ8SFLM.js", "scene37-reflectance-fragment-QHrzuq3H.js", "scene37-rgbd-decode-D3VLnI-E.js", @@ -655,8 +661,8 @@ ] }, "scene39": { - "rawKB": 107.8, - "gzipKB": 45.8, + "rawKB": 108, + "gzipKB": 45.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene39-alpha-test-fragment-C7zCAOOO.js", @@ -664,12 +670,12 @@ "scene39-animation-pointer-lights-CYbYE0zn.js", "scene39-emissive-fragment-q97NxqgU.js", "scene39-generate-mipmaps-DHGFn5-s.js", - "scene39-gltf-animation-h1jXkBbl.js", + "scene39-gltf-animation-Dh4We0oU.js", "scene39-gltf-ext-uv-transform-DhfZ3GtK.js", - "scene39-gltf-feature-animation-pointer-BOWPlTMd.js", - "scene39-gltf-feature-animations-BqoIrLnC.js", + "scene39-gltf-feature-animation-pointer-DjcUP1WK.js", + "scene39-gltf-feature-animations-CsxstZl5.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-BQ_RvOvp.js", + "scene39-gltf-feature-registry-_8ydQlvj.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -677,7 +683,8 @@ "scene39-ibl-fragment-CeRrvT96.js", "scene39-light-base-kuMtkINt.js", "scene39-light-matrix-CBTBdGsb.js", - "scene39-pbr-renderable-DqM2bVmy.js", + "scene39-mat4-invert-CQB3hEce.js", + "scene39-pbr-renderable-B3XArPet.js", "scene39-pbr-template-ext-BoJ8SFLM.js", "scene39-rgbd-decode-YUi8rAlU.js", "scene39-scene-uniforms-FTYH6Ct0.js", @@ -698,12 +705,12 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-BPEPrqN6.js", + "scene99-gltf-feature-registry-Ans5pQCS.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", - "scene99-pbr-renderable-BE9CqTHC.js", - "scene99-skeleton-fragment-CaEr1tK3.js", + "scene99-pbr-renderable-CGYUNdsR.js", + "scene99-skeleton-fragment-BqKLod3Y.js", "scene99-types-DuyfkTc1.js", "scene99.js" ] @@ -719,13 +726,13 @@ ] }, "scene41": { - "rawKB": 91.9, - "gzipKB": 36.6, + "rawKB": 92, + "gzipKB": 36.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-DtnAz1y3.js", + "scene41-gltf-feature-registry-D1mzg7cw.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -794,7 +801,7 @@ "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-PYkTux97.js", + "scene47-gltf-feature-registry-BOJJVwzL.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1223,14 +1230,14 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-nEutQpi_.js", + "scene73-gltf-feature-registry-ClLzoaDW.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", "scene73-node-env-2j3ozSNZ.js", "scene73-node-renderable-Ik7zhWQu.js", "scene73-pbr-metallic-roughness-block-full-CgKHgEzu.js", - "scene73-pbr-renderable-Ccb3OJuh.js", + "scene73-pbr-renderable-C72iDITq.js", "scene73-perturb-normal-Bqx-TYaB.js", "scene73-reflection-block-CIXuH-z0.js", "scene73-rgbd-decode-Bpa-sBKE.js", @@ -1743,7 +1750,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-B5rSINEH.js", + "scene104-gltf-feature-registry-DITkHkyd.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1758,7 +1765,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-Bsidhh9s.js", + "scene105-gltf-feature-registry-OsDvdNSC.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1822,7 +1829,7 @@ }, "scene112": { "rawKB": 119, - "gzipKB": 48.2, + "gzipKB": 48.3, "ignoredRawKB": 0, "runtimeChunks": [ "scene112-background-dds-skybox-CBVfRJkx.js", @@ -1831,12 +1838,12 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-hw2KrODl.js", + "scene112-gltf-feature-registry-DdHkkqV1.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", - "scene112-pbr-refraction-DZYuYfJR.js", - "scene112-pbr-renderable-CU6jvotk.js", - "scene112-pbr-transmission-ext-C5pDjKKB.js", + "scene112-pbr-refraction-gMVc2VQg.js", + "scene112-pbr-renderable-BWN4drN-.js", + "scene112-pbr-transmission-ext-CxPp7oKx.js", "scene112-rgbd-decode-CCG7-bTA.js", "scene112-scene-uniforms-FTYH6Ct0.js", "scene112-singlelight-hemispheric-wgsl-CKrwpx3D.js", @@ -1878,14 +1885,14 @@ "scene115-generate-mipmaps-3gj5PaV4.js", "scene115-gltf-animation-u6_6VYrC.js", "scene115-gltf-color-normalize-BtnJk1yq.js", - "scene115-gltf-feature-animations-eusiMJnc.js", + "scene115-gltf-feature-animations-Do6kXVEc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-CL3PlpTx.js", + "scene115-gltf-feature-registry-D4lxPj6n.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", "scene115-morph-fragment-core-BW8kE7zi.js", - "scene115-pbr-renderable-9KLrN-yl.js", + "scene115-pbr-renderable-CN_CDZ1B.js", "scene115-pbr-template-ext-BoJ8SFLM.js", "scene115-shader-composer-CgJmQyJj.js", "scene115-singlelight-hemispheric-wgsl-D4qRhfo5.js", @@ -2101,25 +2108,26 @@ ] }, "scene144": { - "rawKB": 109.1, - "gzipKB": 44.1, + "rawKB": 109.2, + "gzipKB": 44.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene144-create-skeleton-pj3iqxnA.js", "scene144-generate-mipmaps-DW-CgxSa.js", - "scene144-gltf-animation-CAQsjrcS.js", + "scene144-gltf-animation-D97bjMKJ.js", "scene144-gltf-ext-spec-gloss-D60sFZYX.js", - "scene144-gltf-feature-animations-DOSVTx1Z.js", + "scene144-gltf-feature-animations-DLHxMWua.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-dnInYLDI.js", - "scene144-gltf-feature-skeleton-Dq3GN8sP.js", + "scene144-gltf-feature-registry-B-nT5EIV.js", + "scene144-gltf-feature-skeleton-DZpXOkpb.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", "scene144-ibl-fragment-CeRrvT96.js", - "scene144-pbr-renderable-CJnGSI74.js", + "scene144-mat4-invert-dTg58Twl.js", + "scene144-pbr-renderable-DP_xpfDU.js", "scene144-rgbd-decode-DNSQ_egC.js", "scene144-scene-uniforms-FTYH6Ct0.js", - "scene144-skeleton-fragment-Boc4qWJv.js", + "scene144-skeleton-fragment-BEG1WT5V.js", "scene144-texture-2d-DQo3n8D6.js", "scene144.js" ] @@ -2182,7 +2190,7 @@ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-vuAjDSxD.js", + "scene147-gltf-feature-registry-C6baKi51.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2201,7 +2209,7 @@ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-hZMMcMJn.js", + "scene148-gltf-feature-registry-DSQ21wwc.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2223,7 +2231,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry-CVYLM4Lj.js", + "scene149-gltf-feature-registry-CpwxxRj2.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2258,23 +2266,24 @@ ] }, "scene152": { - "rawKB": 92.7, - "gzipKB": 38.5, + "rawKB": 92.9, + "gzipKB": 38.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene152-create-skeleton-DOtZWQXa.js", "scene152-generate-mipmaps-COVZomJQ.js", - "scene152-gltf-animation-Cam0al-J.js", + "scene152-gltf-animation-CUv7VhcY.js", "scene152-gltf-ext-spec-gloss-D60sFZYX.js", - "scene152-gltf-feature-animations-z0zN7iq2.js", + "scene152-gltf-feature-animations-C3wnhmJA.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-Dwi5plrR.js", - "scene152-gltf-feature-skeleton-DdNk7nTu.js", + "scene152-gltf-feature-registry-CpT-ckEe.js", + "scene152-gltf-feature-skeleton-ChlHOows.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", - "scene152-pbr-renderable-D_0M3XBI.js", + "scene152-mat4-invert-CR5eyDCu.js", + "scene152-pbr-renderable-B-fzwrDm.js", "scene152-singlelight-hemispheric-wgsl-DT7gfcww.js", - "scene152-skeleton-fragment-DtrinbOb.js", + "scene152-skeleton-fragment-KWg36pou.js", "scene152.js" ] }, @@ -2317,38 +2326,40 @@ ] }, "scene157": { - "rawKB": 94.1, - "gzipKB": 38.2, + "rawKB": 94.3, + "gzipKB": 38.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene157-create-skeleton-CkTxS2Cs.js", "scene157-generate-mipmaps-CSgsFZsy.js", - "scene157-gltf-animation-97jnT3rB.js", - "scene157-gltf-feature-animations-C4GEf0C-.js", - "scene157-gltf-feature-registry-BbddfnfE.js", - "scene157-gltf-feature-skeleton-sqEIM232.js", + "scene157-gltf-animation-9r1IBBbg.js", + "scene157-gltf-feature-animations-CtL56Jy6.js", + "scene157-gltf-feature-registry-DMx0U-Q_.js", + "scene157-gltf-feature-skeleton-C-dHjMtj.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", + "scene157-mat4-invert-DryVXUGl.js", "scene157-multilight-wgsl-DMQZ6dS_.js", - "scene157-pbr-renderable-DBjQB5n8.js", - "scene157-skeleton-fragment-CSyOaqLV.js", + "scene157-pbr-renderable-B6Hjf0IX.js", + "scene157-skeleton-fragment-DfhFipOY.js", "scene157.js" ] }, "scene158": { - "rawKB": 94.6, - "gzipKB": 38.4, + "rawKB": 94.7, + "gzipKB": 38.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene158-create-skeleton-B0S37Ruf.js", "scene158-generate-mipmaps-ONVnFwM1.js", - "scene158-gltf-animation-D36FWf_9.js", - "scene158-gltf-feature-animations-_BY8aVDC.js", - "scene158-gltf-feature-registry-DkceuqWi.js", - "scene158-gltf-feature-skeleton-BQO9mRtS.js", + "scene158-gltf-animation-Bgc3w_cb.js", + "scene158-gltf-feature-animations-BqESfQQp.js", + "scene158-gltf-feature-registry-B526ppYL.js", + "scene158-gltf-feature-skeleton-CSz1WHAe.js", "scene158-gltf-glb-parser-BhqojsL9.js", + "scene158-mat4-invert-Cbm0rKFX.js", "scene158-multilight-wgsl-DhVJV_xa.js", - "scene158-pbr-renderable-DudI2994.js", - "scene158-skeleton-fragment-BEyhBIMl.js", + "scene158-pbr-renderable-BOKf235n.js", + "scene158-skeleton-fragment-DxHsHGzx.js", "scene158.js" ] }, @@ -2398,25 +2409,26 @@ ] }, "scene164": { - "rawKB": 97, - "gzipKB": 40.1, + "rawKB": 97.1, + "gzipKB": 40.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene164-create-morph-targets-DRqKS4bi.js", "scene164-create-skeleton-CBLyRVMO.js", "scene164-generate-mipmaps-BxA9-hzJ.js", - "scene164-gltf-animation-Lkey7rHQ.js", + "scene164-gltf-animation-TVBXeorm.js", "scene164-gltf-color-normalize-BtnJk1yq.js", - "scene164-gltf-feature-animations-CkuodxMl.js", + "scene164-gltf-feature-animations-CIWhsE1b.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-D8b0tlwu.js", - "scene164-gltf-feature-skeleton-DOpy65Ao.js", + "scene164-gltf-feature-registry-Ct_-nYZr.js", + "scene164-gltf-feature-skeleton-CF4C5MkN.js", "scene164-gltf-json-asset-BCxbuHbB.js", - "scene164-morph-fragment-29qCql2q.js", - "scene164-pbr-renderable-CtmbMPPp.js", + "scene164-mat4-invert-DXlmp5es.js", + "scene164-morph-fragment-BrDXuWr6.js", + "scene164-pbr-renderable-XUsRNJ8A.js", "scene164-pbr-template-ext-BoJ8SFLM.js", "scene164-singlelight-hemispheric-wgsl-L03Bnk5I.js", - "scene164-skeleton-fragment-BNgGN4I9.js", + "scene164-skeleton-fragment-DC_UaM8a.js", "scene164.js" ] }, @@ -2449,7 +2461,7 @@ "runtimeChunks": [ "scene171-generate-mipmaps-DXPozdXM.js", "scene171-gltf-glb-parser-COBAbifQ.js", - "scene171-pbr-renderable-Y_ydn5yE.js", + "scene171-pbr-renderable-8UCWJclt.js", "scene171-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene171-shader-composer-CgJmQyJj.js", "scene171-singlelight-hemispheric-wgsl-CeuKqi92.js", @@ -2481,13 +2493,13 @@ ] }, "scene174": { - "rawKB": 96.4, + "rawKB": 96.5, "gzipKB": 39.4, "ignoredRawKB": 1485.2, "runtimeChunks": [ "scene174-generate-mipmaps-oyz7Zcb3.js", "scene174-gltf-glb-parser-V10AO6Mf.js", - "scene174-pbr-renderable-B8C0TAcA.js", + "scene174-pbr-renderable-CrwMaE3h.js", "scene174-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene174-shader-composer-CgJmQyJj.js", "scene174-singlelight-hemispheric-wgsl-STW_78f5.js", @@ -2503,7 +2515,7 @@ "runtimeChunks": [ "scene175-generate-mipmaps-B-d91NI_.js", "scene175-gltf-glb-parser-BmlEZ507.js", - "scene175-pbr-renderable-BLomY6Qz.js", + "scene175-pbr-renderable-WNTvF3-Y.js", "scene175-recast-navigation-CYBQI-zY-Dry_z7x_.js", "scene175-shader-composer-CgJmQyJj.js", "scene175-singlelight-hemispheric-wgsl-D-nS_1oq.js", @@ -2513,14 +2525,14 @@ ] }, "scene176": { - "rawKB": 102.3, - "gzipKB": 41.1, + "rawKB": 102.4, + "gzipKB": 41.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-D8npAK5m.js", + "scene176-gltf-feature-registry-Dg0RLYSE.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2554,7 +2566,7 @@ "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-DlG94CAQ.js", + "scene178-gltf-feature-registry-DhdCMeCg.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2567,13 +2579,13 @@ }, "scene179": { "rawKB": 72.3, - "gzipKB": 29.5, + "gzipKB": 29.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene179-alpha-test-fragment-BaX_J1Vy.js", "scene179-generate-mipmaps-BxrZVeh_.js", "scene179-gltf-json-asset-8LBNnI1r.js", - "scene179-pbr-renderable-DiBBath3.js", + "scene179-pbr-renderable-BiGfT8Np.js", "scene179.js" ] }, @@ -2726,34 +2738,35 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-B8xs8jyW.js", + "scene210-gltf-feature-registry-BCcHOZSI.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", "scene210-gltf-normals-DYhLwXNX.js", - "scene210-pbr-renderable-D5dHBfLG.js", + "scene210-pbr-renderable-EUUhAPi0.js", "scene210-singlelight-hemispheric-wgsl-CDyba_3g.js", "scene210.js" ] }, "scene211": { - "rawKB": 88.4, - "gzipKB": 37.1, + "rawKB": 88.6, + "gzipKB": 37.3, "ignoredRawKB": 0, "runtimeChunks": [ "scene211-create-skeleton-CNw6l2jY.js", "scene211-generate-mipmaps-CJi4kk1V.js", - "scene211-gltf-animation-D93nwuGW.js", + "scene211-gltf-animation-Vdwe86C8.js", "scene211-gltf-ext-quantization-Do-ofjB-.js", - "scene211-gltf-feature-animations-C0rPaLwN.js", + "scene211-gltf-feature-animations-kGDiptSR.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-CGBWVHjZ.js", - "scene211-gltf-feature-skeleton-C5YXdC68.js", + "scene211-gltf-feature-registry-C0_YelTQ.js", + "scene211-gltf-feature-skeleton-DFzTK7Gw.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", - "scene211-pbr-renderable-BfE5pOIl.js", + "scene211-mat4-invert-DjnqZieS.js", + "scene211-pbr-renderable-D0Yq81ts.js", "scene211-singlelight-hemispheric-wgsl-DSkghTRP.js", - "scene211-skeleton-fragment-DIgH_ecl.js", + "scene211-skeleton-fragment-j8M2FAgZ.js", "scene211.js" ] }, @@ -2764,7 +2777,7 @@ "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-C2eFgAy6.js", + "scene212-gltf-feature-registry-CKiJQpKT.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2841,41 +2854,43 @@ ] }, "scene218": { - "rawKB": 91.1, - "gzipKB": 37.9, + "rawKB": 91.2, + "gzipKB": 38, "ignoredRawKB": 0, "runtimeChunks": [ "scene218-create-skeleton-Dzggqla-.js", "scene218-generate-mipmaps-OT2YZZyD.js", - "scene218-gltf-animation-BXVexdPI.js", + "scene218-gltf-animation-BI8XOIBz.js", "scene218-gltf-ext-spec-gloss-D60sFZYX.js", - "scene218-gltf-feature-animations-Xir-5MtM.js", + "scene218-gltf-feature-animations-ClxFBFMu.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-z1m5ttRm.js", - "scene218-gltf-feature-skeleton-CuQWo93o.js", + "scene218-gltf-feature-registry-6UjyxPeO.js", + "scene218-gltf-feature-skeleton-BfgGiYUm.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", - "scene218-pbr-renderable-Uyit_WAZ.js", + "scene218-mat4-invert-Drlya-l-.js", + "scene218-pbr-renderable-Bh2l4hxd.js", "scene218-singlelight-hemispheric-wgsl-CYhHmrGt.js", "scene218.js" ] }, "scene219": { - "rawKB": 93.6, - "gzipKB": 39.1, + "rawKB": 93.7, + "gzipKB": 39.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene219-create-skeleton-DNC_UZif.js", "scene219-generate-mipmaps-0aNHbogu.js", - "scene219-gltf-animation-BrzaWRaE.js", + "scene219-gltf-animation-2jNHm_e8.js", "scene219-gltf-ext-spec-gloss-D60sFZYX.js", - "scene219-gltf-feature-animations-Cr5Rjgc6.js", + "scene219-gltf-feature-animations-tPyZdXPg.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-33kxOhgb.js", - "scene219-gltf-feature-skeleton-QiTS1ubb.js", + "scene219-gltf-feature-registry-D2P1Bigz.js", + "scene219-gltf-feature-skeleton-8rF657UP.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", - "scene219-pbr-renderable-BwDj7GKa.js", + "scene219-mat4-invert-JBPuFPBh.js", + "scene219-pbr-renderable-CqDmN0xY.js", "scene219-singlelight-hemispheric-wgsl-tmGAbfLP.js", "scene219-thin-instance-fragment-CBn2miAC.js", "scene219-thin-instance-gpu-DFISRtwj.js", @@ -2970,34 +2985,35 @@ "scene229-generate-mipmaps-qvmJKzcy.js", "scene229-gltf-json-asset-aHzaWMo_.js", "scene229-gltf-normals-DYhLwXNX.js", - "scene229-pbr-renderable-l08Tk5Mv.js", + "scene229-pbr-renderable-BXEnKaMn.js", "scene229-unlit-fragment-DjsTCAku.js", "scene229.js" ] }, "scene240": { - "rawKB": 89.6, - "gzipKB": 37.5, + "rawKB": 89.7, + "gzipKB": 37.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene240-flat-normal-wgsl-Cm9mM4tC.js", "scene240-generate-mipmaps-BQZ9ivTX.js", - "scene240-gltf-animation-BKjmZpR3.js", - "scene240-gltf-feature-animations-Deh9CXYc.js", - "scene240-gltf-feature-registry-BvKGUGT8.js", + "scene240-gltf-animation-BkvY3NRC.js", + "scene240-gltf-feature-animations-CR4mX4H5.js", + "scene240-gltf-feature-registry-CVXje8Wp.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", "scene240-ibl-fragment-CeRrvT96.js", - "scene240-pbr-renderable-CMPWVjP9.js", + "scene240-mat4-invert-7qtKxwyO.js", + "scene240-pbr-renderable-u8wK6BUo.js", "scene240-rgbd-decode-2FzzQzZ2.js", "scene240-scene-uniforms-FTYH6Ct0.js", "scene240.js" ] }, "scene241": { - "rawKB": 160.3, - "gzipKB": 65.7, + "rawKB": 160.5, + "gzipKB": 65.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene241-alpha-test-fragment-BpzeKSEk.js", @@ -3007,7 +3023,7 @@ "scene241-clearcoat-fragment-Bi0N7tnR.js", "scene241-directional-light-BIPgtvfI.js", "scene241-generate-mipmaps-D3XHgpCy.js", - "scene241-gltf-animation-OqMytGgN.js", + "scene241-gltf-animation-e7B6DiHl.js", "scene241-gltf-ext-anisotropy-CcRaZh9b.js", "scene241-gltf-ext-clearcoat-BgaLgSgD.js", "scene241-gltf-ext-dielectric-C6hvXXiF.js", @@ -3016,10 +3032,10 @@ "scene241-gltf-ext-sheen-Dv23b_3T.js", "scene241-gltf-ext-unlit-1vUYfF7v.js", "scene241-gltf-ext-uv-transform-CXwEpHUI.js", - "scene241-gltf-feature-animation-pointer-CepPGaOM.js", - "scene241-gltf-feature-animations-CSjZ3yRx.js", + "scene241-gltf-feature-animation-pointer-DI3Ian1U.js", + "scene241-gltf-feature-animations-CJjpf6fv.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-DOTWrkKX.js", + "scene241-gltf-feature-registry-BX2mqWA8.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3027,10 +3043,11 @@ "scene241-iridescence-fragment-2b1zlUa_.js", "scene241-light-base-Dop4VNA_.js", "scene241-light-matrix-CtsX4GmG.js", - "scene241-pbr-refraction-DAa5tFok.js", - "scene241-pbr-renderable-cZo5h4ql.js", + "scene241-mat4-invert-Cl1WlbJo.js", + "scene241-pbr-refraction-elsNtP3V.js", + "scene241-pbr-renderable-D58MtW_2.js", "scene241-pbr-template-ext-BoJ8SFLM.js", - "scene241-pbr-transmission-ext-DJnGQUbV.js", + "scene241-pbr-transmission-ext-DqBIqk4s.js", "scene241-reflectance-fragment-btSdECMQ.js", "scene241-rgbd-decode-Bil1WUEk.js", "scene241-scene-uniforms-FTYH6Ct0.js", @@ -3045,22 +3062,23 @@ ] }, "scene242": { - "rawKB": 96.3, - "gzipKB": 40, + "rawKB": 96.5, + "gzipKB": 40.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene242-animation-pointer-CtucZ4IY.js", "scene242-animation-pointer-basecolor-C0cq9A_I.js", "scene242-emissive-fragment-BjnF3duS.js", "scene242-generate-mipmaps-BCxjeJMR.js", - "scene242-gltf-animation-Dm97A3mz.js", + "scene242-gltf-animation-D7ekVJUH.js", "scene242-gltf-ext-emissive-strength-CButLZnK.js", - "scene242-gltf-feature-animation-pointer-DuUn5-xJ.js", - "scene242-gltf-feature-animations-B_VnRwPM.js", - "scene242-gltf-feature-registry-CiUAlMx2.js", + "scene242-gltf-feature-animation-pointer-CqjUmXa4.js", + "scene242-gltf-feature-animations-WlV0WKZJ.js", + "scene242-gltf-feature-registry-C843LdZm.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", - "scene242-pbr-renderable-DQEk4f7o.js", + "scene242-mat4-invert-DZR4hiws.js", + "scene242-pbr-renderable-CmvfRP8M.js", "scene242-rgbd-decode-DapdOyyV.js", "scene242-scene-uniforms-FTYH6Ct0.js", "scene242-visibility-CNBVZaJ8.js", @@ -3068,22 +3086,23 @@ ] }, "scene243": { - "rawKB": 96, - "gzipKB": 40.5, + "rawKB": 96.2, + "gzipKB": 40.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene243-create-morph-targets-C_lcfVOA.js", "scene243-generate-mipmaps-C4S5NcQC.js", - "scene243-gltf-animation-B51SBoH8.js", - "scene243-gltf-feature-animations-DEeCXW1Z.js", + "scene243-gltf-animation-TbeJGwSx.js", + "scene243-gltf-feature-animations-BZw9sEIf.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-CWLdf1b8.js", + "scene243-gltf-feature-registry-BMvZpp0X.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", - "scene243-morph-fragment-DpvPLMUz.js", - "scene243-pbr-renderable-Cm34unHt.js", + "scene243-mat4-invert-k38u0vRD.js", + "scene243-morph-fragment-DTmLRHdp.js", + "scene243-pbr-renderable-CShH3BMl.js", "scene243-pbr-template-ext-BoJ8SFLM.js", "scene243-rgbd-decode-CtyuiJdH.js", "scene243-scene-uniforms-FTYH6Ct0.js", @@ -3092,28 +3111,29 @@ ] }, "scene244": { - "rawKB": 132.2, - "gzipKB": 53.6, + "rawKB": 132.4, + "gzipKB": 53.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene244-animation-pointer-ext-CoOxzYYy.js", "scene244-animation-pointer-jEniq5im.js", "scene244-clearcoat-fragment-fqLK-qje.js", "scene244-generate-mipmaps-BY39y9hS.js", - "scene244-gltf-animation-BkhOo1GS.js", + "scene244-gltf-animation-fivOCnLe.js", "scene244-gltf-ext-clearcoat-BgaLgSgD.js", "scene244-gltf-ext-dielectric-C6hvXXiF.js", "scene244-gltf-ext-uv-transform-YGWG8v_J.js", - "scene244-gltf-feature-animation-pointer-Cv2YzJgj.js", - "scene244-gltf-feature-animations-CTlvB6vN.js", - "scene244-gltf-feature-registry-BXNc8oEO.js", + "scene244-gltf-feature-animation-pointer-Cw-JSEoG.js", + "scene244-gltf-feature-animations-B4zBW5hu.js", + "scene244-gltf-feature-registry-CiZh4-Qb.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", - "scene244-pbr-refraction-CXnidF1h.js", - "scene244-pbr-renderable-CLORI0l-.js", + "scene244-mat4-invert-B4l_4Xp7.js", + "scene244-pbr-refraction-1mYxyyrr.js", + "scene244-pbr-renderable-CjRk8WAR.js", "scene244-pbr-template-ext-BoJ8SFLM.js", - "scene244-pbr-transmission-ext-CWsRTR8g.js", + "scene244-pbr-transmission-ext-D5dYChu4.js", "scene244-reflectance-fragment-COQ8Gwb2.js", "scene244-rgbd-decode-DC93u83f.js", "scene244-scene-uniforms-FTYH6Ct0.js", @@ -3124,68 +3144,71 @@ ] }, "scene245": { - "rawKB": 98.7, - "gzipKB": 41.8, + "rawKB": 98.8, + "gzipKB": 41.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene245-create-skeleton-nuOFOS6J.js", "scene245-flat-normal-wgsl-Cm9mM4tC.js", "scene245-generate-mipmaps-WM6bVf2v.js", - "scene245-gltf-animation-Dvm46y_g.js", - "scene245-gltf-feature-animations-BV66HV-9.js", - "scene245-gltf-feature-registry-BgWXssIv.js", - "scene245-gltf-feature-skeleton-IRWJQHYY.js", + "scene245-gltf-animation-CH-NCr-C.js", + "scene245-gltf-feature-animations-BqSXwBPk.js", + "scene245-gltf-feature-registry-D0j79zuB.js", + "scene245-gltf-feature-skeleton-tGggxvpO.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", "scene245-gltf-normals-DYhLwXNX.js", "scene245-gltf-strided-attribute-CGKc0Sx6.js", "scene245-ibl-fragment-CeRrvT96.js", - "scene245-pbr-renderable-DJtd1wk2.js", + "scene245-mat4-invert-CN3HReau.js", + "scene245-pbr-renderable-CUmy8A52.js", "scene245-pbr-template-ext-BoJ8SFLM.js", "scene245-rgbd-decode-CKe7_W5g.js", "scene245-scene-uniforms-FTYH6Ct0.js", - "scene245-skeleton-fragment-DCOcURyb.js", + "scene245-skeleton-fragment-DkIdFFDD.js", "scene245.js" ] }, "scene246": { - "rawKB": 97.6, - "gzipKB": 41.4, + "rawKB": 97.7, + "gzipKB": 41.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene246-create-skeleton-COkERfCM.js", "scene246-flat-normal-wgsl-Cm9mM4tC.js", "scene246-generate-mipmaps-DzKvtUax.js", - "scene246-gltf-animation-DGsaicDt.js", - "scene246-gltf-feature-animations-DimU6cfM.js", - "scene246-gltf-feature-registry-DsY2cQH8.js", - "scene246-gltf-feature-skeleton-Bf1KbRoN.js", + "scene246-gltf-animation-5d--qD22.js", + "scene246-gltf-feature-animations-BVShSXS8.js", + "scene246-gltf-feature-registry-DxJla7FB.js", + "scene246-gltf-feature-skeleton-yfeKWm3c.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", "scene246-gltf-multi-buffer-Cwm5u1Qq.js", "scene246-gltf-normals-DYhLwXNX.js", "scene246-gltf-strided-attribute-R3NdoKEL.js", "scene246-ibl-fragment-CeRrvT96.js", - "scene246-pbr-renderable-CIdpqET2.js", + "scene246-mat4-invert-DBC-i-zv.js", + "scene246-pbr-renderable-gTWSGiFj.js", "scene246-rgbd-decode-DQhLUjb0.js", "scene246-scene-uniforms-FTYH6Ct0.js", - "scene246-skeleton-fragment-vnGyEpBe.js", + "scene246-skeleton-fragment-DeOaTzo7.js", "scene246.js" ] }, "scene247": { - "rawKB": 82.9, - "gzipKB": 34.4, + "rawKB": 83, + "gzipKB": 34.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", - "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", - "scene247-gltf-feature-registry-DcRcf-aT.js", + "scene247-gltf-feature-gpu-instancing-DvUcvoJl.js", + "scene247-gltf-feature-registry-DRYMtS8a.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", - "scene247-pbr-renderable-CqPnXLX7.js", + "scene247-mat4-multiply-BjOi0MOL.js", + "scene247-pbr-renderable-D7Uak2DC.js", "scene247-rgbd-decode-ClWWmAM6.js", "scene247-scene-uniforms-FTYH6Ct0.js", "scene247-thin-instance-fragment-CBn2miAC.js", @@ -3202,7 +3225,7 @@ "scene248-gltf-json-asset-Ctllxvz4.js", "scene248-gltf-sampler-desc-CdC-ieMf.js", "scene248-ibl-fragment-CeRrvT96.js", - "scene248-pbr-renderable-JPiljkua.js", + "scene248-pbr-renderable-D_KxVP9v.js", "scene248-rgbd-decode-CLeq7oRj.js", "scene248-scene-uniforms-FTYH6Ct0.js", "scene248.js" @@ -3218,7 +3241,7 @@ "scene249-gltf-color-normalize-BtnJk1yq.js", "scene249-gltf-json-asset-CB71ibXk.js", "scene249-ibl-fragment-CeRrvT96.js", - "scene249-pbr-renderable-Dq7mqANN.js", + "scene249-pbr-renderable-DxCf_gK2.js", "scene249-pbr-template-ext-BoJ8SFLM.js", "scene249-rgbd-decode-BRTm0Szn.js", "scene249-scene-uniforms-FTYH6Ct0.js", @@ -3226,20 +3249,21 @@ ] }, "scene251": { - "rawKB": 88.2, - "gzipKB": 36.5, + "rawKB": 88.3, + "gzipKB": 36.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene251-create-skeleton-QaTYEW_C.js", "scene251-generate-mipmaps-ojYQxP8q.js", - "scene251-gltf-animation-BJ2pOO_r.js", - "scene251-gltf-feature-animations-Do8ooupS.js", - "scene251-gltf-feature-registry-Dc_R0Y-b.js", - "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", + "scene251-gltf-animation-B4iYdDHq.js", + "scene251-gltf-feature-animations-BoUtEts6.js", + "scene251-gltf-feature-registry-fUo90dpV.js", + "scene251-gltf-feature-skeleton-zwplEGNL.js", "scene251-gltf-glb-parser-8AD91ACR.js", + "scene251-mat4-invert-DxOzu6n0.js", "scene251-multilight-wgsl-Cxg2lDtv.js", - "scene251-pbr-renderable-DIJLkuwp.js", - "scene251-skeleton-fragment-CylZgMZD.js", + "scene251-pbr-renderable-rJR7cw2X.js", + "scene251-skeleton-fragment-BbV5HG1g.js", "scene251.js" ] }, @@ -3255,8 +3279,8 @@ ] }, "scene253": { - "rawKB": 151, - "gzipKB": 63.9, + "rawKB": 151.2, + "gzipKB": 64, "ignoredRawKB": 0, "runtimeChunks": [ "scene253-alpha-test-fragment-CBuxkQtx.js", @@ -3269,20 +3293,20 @@ "scene253-directional-light-C7HjjUeW.js", "scene253-emissive-fragment-CWAgCBrm.js", "scene253-generate-mipmaps-BHuGZ0l5.js", - "scene253-gltf-animation-BKiWufrU.js", + "scene253-gltf-animation-B2okpalN.js", "scene253-gltf-color-normalize-BtnJk1yq.js", "scene253-gltf-ext-dielectric-C6hvXXiF.js", "scene253-gltf-ext-emissive-strength-CButLZnK.js", "scene253-gltf-ext-iridescence-b4LVniAM.js", "scene253-gltf-ext-unlit-1vUYfF7v.js", "scene253-gltf-ext-uv-transform-DixkPR9o.js", - "scene253-gltf-feature-animation-pointer-B4es0u03.js", - "scene253-gltf-feature-animations-DQAfdhkC.js", + "scene253-gltf-feature-animation-pointer-l7f0I44Q.js", + "scene253-gltf-feature-animations-D5QgCDV9.js", "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-B09JNhRe.js", - "scene253-gltf-feature-skeleton-Bjigd6Ok.js", + "scene253-gltf-feature-registry-Bkcz8zPQ.js", + "scene253-gltf-feature-skeleton-mdE9XqYt.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js", "scene253-gltf-pbr-builder-ext-BzZBX-YN.js", @@ -3291,16 +3315,17 @@ "scene253-iridescence-fragment-BIm-2okC.js", "scene253-light-base-eE8_4fU8.js", "scene253-light-matrix-BpE3lP6k.js", - "scene253-morph-fragment-ClEpS6EZ.js", + "scene253-mat4-invert-zKjU83zn.js", + "scene253-morph-fragment-CEhGS5lc.js", "scene253-multilight-wgsl-D9gPIJS-.js", - "scene253-pbr-refraction-CjdGzkAP.js", - "scene253-pbr-renderable-Bno43uQO.js", + "scene253-pbr-refraction-Cnk6VDE7.js", + "scene253-pbr-renderable-BmtMluPY.js", "scene253-pbr-template-ext-BoJ8SFLM.js", - "scene253-pbr-transmission-ext-D9xCLdT8.js", + "scene253-pbr-transmission-ext-Cd9Bx90s.js", "scene253-reflectance-fragment-ua5TUzB_.js", "scene253-rgbd-decode-Cz9OR-T-.js", "scene253-scene-uniforms-FTYH6Ct0.js", - "scene253-skeleton-fragment-D5DeYQNO.js", + "scene253-skeleton-fragment-1vKJHRqi.js", "scene253-spot-light-D97XdhJC.js", "scene253-texture-2d-DQo3n8D6.js", "scene253-unlit-fragment-BCZQRNLX.js", From 3211847fb10df98273d4c5abe7a5f27196e04b90 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 20:10:08 +0200 Subject: [PATCH 11/13] fix(flow-graph): localize Mat4 invert/multiply to protect bundle ceilings fg-math previously imported core mat4Invert/mat4Multiply for the Mat4 matrix dispatchers. Those core modules are also used by the skeleton/animation runtime, and flow-graph block chunks are emitted into every glTF scene's bundle via the lazy gltf-feature-interactivity -> getBlockDef dynamic-chunk graph (even when the asset declares no interactivity). Rollup therefore hoisted mat4-invert/ mat4-multiply into shared chunks that the live skeleton chunk loads at runtime, pushing scene7 (ChibiRex) and scene247 (TeapotsGalore) over their raw-size ceilings. Give fg-math fully self-contained column-major invert/multiply (math identical to core, verified by the existing matrix unit tests) so those bytes stay inside the lazily-loaded flow-graph block chunks only. Existing scenes return to their master chunk layout; all 198 bundle-size ceilings pass. mat4Compose/mat4Decompose stay on core (they are not shared with any live scene chunk, so no extraction). Also regenerates the bundle manifest to match. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- lab/public/bundle/manifest.json | 361 ++++++++---------- .../babylon-lite/src/flow-graph/fg-math.ts | 146 ++++++- 2 files changed, 307 insertions(+), 200 deletions(-) diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index 117e411a3d..6d6befb70e 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -57,21 +57,20 @@ ] }, "scene5": { - "rawKB": 90.2, - "gzipKB": 38.2, + "rawKB": 90.1, + "gzipKB": 38.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene5-create-morph-targets-CxWjyKmd.js", "scene5-create-skeleton-Bi7nAPH9.js", "scene5-generate-mipmaps-DjmtEap1.js", - "scene5-gltf-animation-Db000-8t.js", + "scene5-gltf-animation-qzi1HRZg.js", "scene5-gltf-color-normalize-BtnJk1yq.js", - "scene5-gltf-feature-animations-BTJfdC_m.js", + "scene5-gltf-feature-animations-NJC85MBJ.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry-BM89Nuq3.js", - "scene5-gltf-feature-skeleton-DPTrgiUu.js", + "scene5-gltf-feature-registry-_5DT5FoO.js", + "scene5-gltf-feature-skeleton-Siixi_P0.js", "scene5-gltf-json-asset-DS0i23k1.js", - "scene5-mat4-invert-DlwG0Ui-.js", "scene5-morph-fragment-SUVkfdAM.js", "scene5-pbr-renderable-DGLP44TZ.js", "scene5-pbr-template-ext-BoJ8SFLM.js", @@ -97,22 +96,21 @@ ] }, "scene7": { - "rawKB": 104.5, - "gzipKB": 44.2, + "rawKB": 104.4, + "gzipKB": 44.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene7-background-ground-SAvSHzNE.js", "scene7-background-solid-skybox-gCmyuEIn.js", "scene7-create-skeleton-xdZ7V4Ou.js", "scene7-generate-mipmaps-BNxg8boc.js", - "scene7-gltf-animation-CH0_e4oq.js", - "scene7-gltf-feature-animations-Bgob9WEn.js", + "scene7-gltf-animation-B7Xr33me.js", + "scene7-gltf-feature-animations-DNqmTY-c.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-Wc2uroCJ.js", - "scene7-gltf-feature-skeleton-B9G0EPQT.js", + "scene7-gltf-feature-registry-BvQc5lz0.js", + "scene7-gltf-feature-skeleton-BCWZyzWC.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", - "scene7-mat4-invert-qkYx19NH.js", "scene7-pbr-renderable-CseWBxfZ.js", "scene7-rgbd-decode-C9OJGqTP.js", "scene7-scene-uniforms-FTYH6Ct0.js", @@ -165,21 +163,20 @@ ] }, "scene11": { - "rawKB": 87.7, - "gzipKB": 36.9, + "rawKB": 87.6, + "gzipKB": 36.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene11-create-skeleton-D7GjlnE9.js", "scene11-generate-mipmaps-YGxDoUB2.js", - "scene11-gltf-animation-CcJYg0ZT.js", + "scene11-gltf-animation-CQ75q6KC.js", "scene11-gltf-ext-spec-gloss-D60sFZYX.js", - "scene11-gltf-feature-animations-BIZ-N9xV.js", + "scene11-gltf-feature-animations-CmHJNYiV.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-MWFUiHlf.js", - "scene11-gltf-feature-skeleton-Dd-D_2bN.js", + "scene11-gltf-feature-registry-BK2fq-aN.js", + "scene11-gltf-feature-skeleton-CrXfHDG6.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", - "scene11-mat4-invert-CVQ5maV0.js", "scene11-pbr-renderable-eg_x6Za2.js", "scene11-singlelight-hemispheric-wgsl-C40tQGmo.js", "scene11-skeleton-fragment-CzpG9JGH.js", @@ -187,19 +184,18 @@ ] }, "scene12": { - "rawKB": 102.1, - "gzipKB": 41.7, + "rawKB": 102, + "gzipKB": 41.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene12-create-skeleton-Cjf80v3R.js", "scene12-generate-mipmaps-Bsp4UQ3D.js", - "scene12-gltf-animation-CDCBlIUe.js", - "scene12-gltf-feature-animations-CxVsuL-g.js", - "scene12-gltf-feature-registry-BemD_Rua.js", - "scene12-gltf-feature-skeleton-BBrB-2Pq.js", + "scene12-gltf-animation-BDKbEYQd.js", + "scene12-gltf-feature-animations-BFGZaHvm.js", + "scene12-gltf-feature-registry-B5462gW5.js", + "scene12-gltf-feature-skeleton-CN1CorcX.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", - "scene12-mat4-invert-DAsxoqbB.js", "scene12-pbr-renderable-Bo7mvJtD.js", "scene12-reflectance-fragment-Kimqnape.js", "scene12-rgbd-decode-BLiTLohS.js", @@ -439,7 +435,7 @@ "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-ei9UqmOm.js", + "scene27-gltf-feature-registry-jUkTs8TS.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", @@ -459,7 +455,7 @@ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry--MjnqBQp.js", + "scene28-gltf-feature-registry-vfc93Ul-.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", "scene28-pbr-renderable-eX7eFIi2.js", @@ -476,7 +472,7 @@ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-D_9kBHw8.js", + "scene29-gltf-feature-registry-hOmU7_Sw.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", @@ -500,7 +496,7 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-CaT3ij9r.js", + "scene30-gltf-feature-registry-C27hv4YD.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", @@ -523,7 +519,7 @@ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-DeKOspJg.js", + "scene31-gltf-feature-registry-9VDR-B_R.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", "scene31-pbr-renderable-DBEVLcPa.js", @@ -539,7 +535,7 @@ "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-Dq-fTLv5.js", + "scene32-gltf-feature-registry-OzSd1WXD.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", "scene32-pbr-renderable-UXm0NIAX.js", @@ -557,7 +553,7 @@ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-DboRc1lb.js", + "scene33-gltf-feature-registry-D4s0gD8X.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", @@ -574,20 +570,19 @@ ] }, "scene34": { - "rawKB": 95.9, - "gzipKB": 39.7, + "rawKB": 95.7, + "gzipKB": 39.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene34-animation-pointer-Ddy-YJnh.js", "scene34-generate-mipmaps-C244DQVV.js", - "scene34-gltf-animation-DPV8cS8y.js", + "scene34-gltf-animation-Cz7h58Nc.js", "scene34-gltf-ext-node-visibility-CyR_MQR5.js", - "scene34-gltf-feature-animation-pointer-Dwl9YL57.js", - "scene34-gltf-feature-animations-CdtaC2qb.js", - "scene34-gltf-feature-registry-BsUHr3YM.js", + "scene34-gltf-feature-animation-pointer-rAfd1hLG.js", + "scene34-gltf-feature-animations-Bl_MxMv-.js", + "scene34-gltf-feature-registry-D62J6fVc.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", - "scene34-mat4-invert-BeOKSoLh.js", "scene34-pbr-renderable-BmEHhHi_.js", "scene34-rgbd-decode-ByPAsdES.js", "scene34-scene-uniforms-FTYH6Ct0.js", @@ -596,16 +591,15 @@ ] }, "scene35": { - "rawKB": 82.3, - "gzipKB": 34, + "rawKB": 82.2, + "gzipKB": 33.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", - "scene35-gltf-feature-gpu-instancing-B4GHj5Jg.js", - "scene35-gltf-feature-registry-DDJrohjx.js", + "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", + "scene35-gltf-feature-registry-CzHQY-Hc.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", - "scene35-mat4-multiply-CZ8Su_a2.js", "scene35-pbr-renderable-CM5qYb7h.js", "scene35-rgbd-decode-U56TFVGU.js", "scene35-scene-uniforms-FTYH6Ct0.js", @@ -635,7 +629,7 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-DXpcYFv_.js", + "scene37-gltf-feature-registry-Dlwg9yLI.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", @@ -661,8 +655,8 @@ ] }, "scene39": { - "rawKB": 108, - "gzipKB": 45.9, + "rawKB": 107.8, + "gzipKB": 45.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene39-alpha-test-fragment-C7zCAOOO.js", @@ -670,12 +664,12 @@ "scene39-animation-pointer-lights-CYbYE0zn.js", "scene39-emissive-fragment-q97NxqgU.js", "scene39-generate-mipmaps-DHGFn5-s.js", - "scene39-gltf-animation-Dh4We0oU.js", + "scene39-gltf-animation-h1jXkBbl.js", "scene39-gltf-ext-uv-transform-DhfZ3GtK.js", - "scene39-gltf-feature-animation-pointer-DjcUP1WK.js", - "scene39-gltf-feature-animations-CsxstZl5.js", + "scene39-gltf-feature-animation-pointer-BOWPlTMd.js", + "scene39-gltf-feature-animations-BdsovlyG.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-_8ydQlvj.js", + "scene39-gltf-feature-registry-BIGqGo9B.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -683,7 +677,6 @@ "scene39-ibl-fragment-CeRrvT96.js", "scene39-light-base-kuMtkINt.js", "scene39-light-matrix-CBTBdGsb.js", - "scene39-mat4-invert-CQB3hEce.js", "scene39-pbr-renderable-B3XArPet.js", "scene39-pbr-template-ext-BoJ8SFLM.js", "scene39-rgbd-decode-YUi8rAlU.js", @@ -705,7 +698,7 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-Ans5pQCS.js", + "scene99-gltf-feature-registry-B7Nk4ze3.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", @@ -732,7 +725,7 @@ "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-D1mzg7cw.js", + "scene41-gltf-feature-registry-BOAnuBc1.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -801,7 +794,7 @@ "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-BOJJVwzL.js", + "scene47-gltf-feature-registry-CHSNRxvG.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1230,7 +1223,7 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-ClLzoaDW.js", + "scene73-gltf-feature-registry-6SgsE2Gt.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", @@ -1750,7 +1743,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-DITkHkyd.js", + "scene104-gltf-feature-registry-CcotYfmb.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1765,7 +1758,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-OsDvdNSC.js", + "scene105-gltf-feature-registry-Bsnwpi1i.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1838,7 +1831,7 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-DdHkkqV1.js", + "scene112-gltf-feature-registry-DfGapbqE.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", "scene112-pbr-refraction-gMVc2VQg.js", @@ -1887,7 +1880,7 @@ "scene115-gltf-color-normalize-BtnJk1yq.js", "scene115-gltf-feature-animations-Do6kXVEc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-D4lxPj6n.js", + "scene115-gltf-feature-registry-DOSw4opn.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", @@ -2108,22 +2101,21 @@ ] }, "scene144": { - "rawKB": 109.2, - "gzipKB": 44.2, + "rawKB": 109.1, + "gzipKB": 44.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene144-create-skeleton-pj3iqxnA.js", "scene144-generate-mipmaps-DW-CgxSa.js", - "scene144-gltf-animation-D97bjMKJ.js", + "scene144-gltf-animation-CAQsjrcS.js", "scene144-gltf-ext-spec-gloss-D60sFZYX.js", - "scene144-gltf-feature-animations-DLHxMWua.js", + "scene144-gltf-feature-animations-Bud5JgI9.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-B-nT5EIV.js", - "scene144-gltf-feature-skeleton-DZpXOkpb.js", + "scene144-gltf-feature-registry-bhfEPzHG.js", + "scene144-gltf-feature-skeleton-Dq3GN8sP.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", "scene144-ibl-fragment-CeRrvT96.js", - "scene144-mat4-invert-dTg58Twl.js", "scene144-pbr-renderable-DP_xpfDU.js", "scene144-rgbd-decode-DNSQ_egC.js", "scene144-scene-uniforms-FTYH6Ct0.js", @@ -2190,7 +2182,7 @@ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-C6baKi51.js", + "scene147-gltf-feature-registry-a5-CPjZi.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2209,7 +2201,7 @@ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-DSQ21wwc.js", + "scene148-gltf-feature-registry-pRGBNIs2.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2231,7 +2223,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry-CpwxxRj2.js", + "scene149-gltf-feature-registry-srFjBMzZ.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2266,21 +2258,20 @@ ] }, "scene152": { - "rawKB": 92.9, - "gzipKB": 38.6, + "rawKB": 92.7, + "gzipKB": 38.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene152-create-skeleton-DOtZWQXa.js", "scene152-generate-mipmaps-COVZomJQ.js", - "scene152-gltf-animation-CUv7VhcY.js", + "scene152-gltf-animation-Cam0al-J.js", "scene152-gltf-ext-spec-gloss-D60sFZYX.js", - "scene152-gltf-feature-animations-C3wnhmJA.js", + "scene152-gltf-feature-animations-DtfqqyNl.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-CpT-ckEe.js", - "scene152-gltf-feature-skeleton-ChlHOows.js", + "scene152-gltf-feature-registry-B-6ccq2s.js", + "scene152-gltf-feature-skeleton-DdNk7nTu.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", - "scene152-mat4-invert-CR5eyDCu.js", "scene152-pbr-renderable-B-fzwrDm.js", "scene152-singlelight-hemispheric-wgsl-DT7gfcww.js", "scene152-skeleton-fragment-KWg36pou.js", @@ -2326,18 +2317,17 @@ ] }, "scene157": { - "rawKB": 94.3, - "gzipKB": 38.4, + "rawKB": 94.1, + "gzipKB": 38.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene157-create-skeleton-CkTxS2Cs.js", "scene157-generate-mipmaps-CSgsFZsy.js", - "scene157-gltf-animation-9r1IBBbg.js", - "scene157-gltf-feature-animations-CtL56Jy6.js", - "scene157-gltf-feature-registry-DMx0U-Q_.js", - "scene157-gltf-feature-skeleton-C-dHjMtj.js", + "scene157-gltf-animation-97jnT3rB.js", + "scene157-gltf-feature-animations-3TPbmuLQ.js", + "scene157-gltf-feature-registry-CE_Ovhf9.js", + "scene157-gltf-feature-skeleton-sqEIM232.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", - "scene157-mat4-invert-DryVXUGl.js", "scene157-multilight-wgsl-DMQZ6dS_.js", "scene157-pbr-renderable-B6Hjf0IX.js", "scene157-skeleton-fragment-DfhFipOY.js", @@ -2345,18 +2335,17 @@ ] }, "scene158": { - "rawKB": 94.7, - "gzipKB": 38.5, + "rawKB": 94.6, + "gzipKB": 38.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene158-create-skeleton-B0S37Ruf.js", "scene158-generate-mipmaps-ONVnFwM1.js", - "scene158-gltf-animation-Bgc3w_cb.js", - "scene158-gltf-feature-animations-BqESfQQp.js", - "scene158-gltf-feature-registry-B526ppYL.js", - "scene158-gltf-feature-skeleton-CSz1WHAe.js", + "scene158-gltf-animation-D36FWf_9.js", + "scene158-gltf-feature-animations-DfL_qlI0.js", + "scene158-gltf-feature-registry-D0z4K601.js", + "scene158-gltf-feature-skeleton-BQO9mRtS.js", "scene158-gltf-glb-parser-BhqojsL9.js", - "scene158-mat4-invert-Cbm0rKFX.js", "scene158-multilight-wgsl-DhVJV_xa.js", "scene158-pbr-renderable-BOKf235n.js", "scene158-skeleton-fragment-DxHsHGzx.js", @@ -2409,21 +2398,20 @@ ] }, "scene164": { - "rawKB": 97.1, - "gzipKB": 40.2, + "rawKB": 97, + "gzipKB": 40.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene164-create-morph-targets-DRqKS4bi.js", "scene164-create-skeleton-CBLyRVMO.js", "scene164-generate-mipmaps-BxA9-hzJ.js", - "scene164-gltf-animation-TVBXeorm.js", + "scene164-gltf-animation-Lkey7rHQ.js", "scene164-gltf-color-normalize-BtnJk1yq.js", - "scene164-gltf-feature-animations-CIWhsE1b.js", + "scene164-gltf-feature-animations-DDqOp9Eq.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-Ct_-nYZr.js", - "scene164-gltf-feature-skeleton-CF4C5MkN.js", + "scene164-gltf-feature-registry-rcHjt908.js", + "scene164-gltf-feature-skeleton-DOpy65Ao.js", "scene164-gltf-json-asset-BCxbuHbB.js", - "scene164-mat4-invert-DXlmp5es.js", "scene164-morph-fragment-BrDXuWr6.js", "scene164-pbr-renderable-XUsRNJ8A.js", "scene164-pbr-template-ext-BoJ8SFLM.js", @@ -2532,7 +2520,7 @@ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-Dg0RLYSE.js", + "scene176-gltf-feature-registry-BHxB0k8Y.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2566,7 +2554,7 @@ "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-DhdCMeCg.js", + "scene178-gltf-feature-registry-YJ5vGCnH.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2738,7 +2726,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-BCcHOZSI.js", + "scene210-gltf-feature-registry-Dr6wU7WQ.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", @@ -2749,21 +2737,20 @@ ] }, "scene211": { - "rawKB": 88.6, - "gzipKB": 37.3, + "rawKB": 88.4, + "gzipKB": 37.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene211-create-skeleton-CNw6l2jY.js", "scene211-generate-mipmaps-CJi4kk1V.js", - "scene211-gltf-animation-Vdwe86C8.js", + "scene211-gltf-animation-D93nwuGW.js", "scene211-gltf-ext-quantization-Do-ofjB-.js", - "scene211-gltf-feature-animations-kGDiptSR.js", + "scene211-gltf-feature-animations-CTZOLIzx.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-C0_YelTQ.js", - "scene211-gltf-feature-skeleton-DFzTK7Gw.js", + "scene211-gltf-feature-registry-KnmTT4TG.js", + "scene211-gltf-feature-skeleton-C5YXdC68.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", - "scene211-mat4-invert-DjnqZieS.js", "scene211-pbr-renderable-D0Yq81ts.js", "scene211-singlelight-hemispheric-wgsl-DSkghTRP.js", "scene211-skeleton-fragment-j8M2FAgZ.js", @@ -2777,7 +2764,7 @@ "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-CKiJQpKT.js", + "scene212-gltf-feature-registry-BBvG5RdZ.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2854,42 +2841,40 @@ ] }, "scene218": { - "rawKB": 91.2, - "gzipKB": 38, + "rawKB": 91.1, + "gzipKB": 37.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene218-create-skeleton-Dzggqla-.js", "scene218-generate-mipmaps-OT2YZZyD.js", - "scene218-gltf-animation-BI8XOIBz.js", + "scene218-gltf-animation-BXVexdPI.js", "scene218-gltf-ext-spec-gloss-D60sFZYX.js", - "scene218-gltf-feature-animations-ClxFBFMu.js", + "scene218-gltf-feature-animations-BhunLZUh.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-6UjyxPeO.js", - "scene218-gltf-feature-skeleton-BfgGiYUm.js", + "scene218-gltf-feature-registry-BcNKTtcL.js", + "scene218-gltf-feature-skeleton-CuQWo93o.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", - "scene218-mat4-invert-Drlya-l-.js", "scene218-pbr-renderable-Bh2l4hxd.js", "scene218-singlelight-hemispheric-wgsl-CYhHmrGt.js", "scene218.js" ] }, "scene219": { - "rawKB": 93.7, - "gzipKB": 39.2, + "rawKB": 93.6, + "gzipKB": 39.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene219-create-skeleton-DNC_UZif.js", "scene219-generate-mipmaps-0aNHbogu.js", - "scene219-gltf-animation-2jNHm_e8.js", + "scene219-gltf-animation-BrzaWRaE.js", "scene219-gltf-ext-spec-gloss-D60sFZYX.js", - "scene219-gltf-feature-animations-tPyZdXPg.js", + "scene219-gltf-feature-animations-7TJPdKpt.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-D2P1Bigz.js", - "scene219-gltf-feature-skeleton-8rF657UP.js", + "scene219-gltf-feature-registry-BpdMkjop.js", + "scene219-gltf-feature-skeleton-QiTS1ubb.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", - "scene219-mat4-invert-JBPuFPBh.js", "scene219-pbr-renderable-CqDmN0xY.js", "scene219-singlelight-hemispheric-wgsl-tmGAbfLP.js", "scene219-thin-instance-fragment-CBn2miAC.js", @@ -2991,20 +2976,19 @@ ] }, "scene240": { - "rawKB": 89.7, - "gzipKB": 37.6, + "rawKB": 89.6, + "gzipKB": 37.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene240-flat-normal-wgsl-Cm9mM4tC.js", "scene240-generate-mipmaps-BQZ9ivTX.js", - "scene240-gltf-animation-BkvY3NRC.js", - "scene240-gltf-feature-animations-CR4mX4H5.js", - "scene240-gltf-feature-registry-CVXje8Wp.js", + "scene240-gltf-animation-BKjmZpR3.js", + "scene240-gltf-feature-animations-hHnIQ4Bv.js", + "scene240-gltf-feature-registry-K1plHaQL.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", "scene240-ibl-fragment-CeRrvT96.js", - "scene240-mat4-invert-7qtKxwyO.js", "scene240-pbr-renderable-u8wK6BUo.js", "scene240-rgbd-decode-2FzzQzZ2.js", "scene240-scene-uniforms-FTYH6Ct0.js", @@ -3012,8 +2996,8 @@ ] }, "scene241": { - "rawKB": 160.5, - "gzipKB": 65.9, + "rawKB": 160.4, + "gzipKB": 65.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene241-alpha-test-fragment-BpzeKSEk.js", @@ -3023,7 +3007,7 @@ "scene241-clearcoat-fragment-Bi0N7tnR.js", "scene241-directional-light-BIPgtvfI.js", "scene241-generate-mipmaps-D3XHgpCy.js", - "scene241-gltf-animation-e7B6DiHl.js", + "scene241-gltf-animation-OqMytGgN.js", "scene241-gltf-ext-anisotropy-CcRaZh9b.js", "scene241-gltf-ext-clearcoat-BgaLgSgD.js", "scene241-gltf-ext-dielectric-C6hvXXiF.js", @@ -3032,10 +3016,10 @@ "scene241-gltf-ext-sheen-Dv23b_3T.js", "scene241-gltf-ext-unlit-1vUYfF7v.js", "scene241-gltf-ext-uv-transform-CXwEpHUI.js", - "scene241-gltf-feature-animation-pointer-DI3Ian1U.js", - "scene241-gltf-feature-animations-CJjpf6fv.js", + "scene241-gltf-feature-animation-pointer-CepPGaOM.js", + "scene241-gltf-feature-animations-CJigVEWA.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-BX2mqWA8.js", + "scene241-gltf-feature-registry-CkN9RmeI.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3043,7 +3027,6 @@ "scene241-iridescence-fragment-2b1zlUa_.js", "scene241-light-base-Dop4VNA_.js", "scene241-light-matrix-CtsX4GmG.js", - "scene241-mat4-invert-Cl1WlbJo.js", "scene241-pbr-refraction-elsNtP3V.js", "scene241-pbr-renderable-D58MtW_2.js", "scene241-pbr-template-ext-BoJ8SFLM.js", @@ -3062,22 +3045,21 @@ ] }, "scene242": { - "rawKB": 96.5, - "gzipKB": 40.2, + "rawKB": 96.3, + "gzipKB": 40, "ignoredRawKB": 0, "runtimeChunks": [ "scene242-animation-pointer-CtucZ4IY.js", "scene242-animation-pointer-basecolor-C0cq9A_I.js", "scene242-emissive-fragment-BjnF3duS.js", "scene242-generate-mipmaps-BCxjeJMR.js", - "scene242-gltf-animation-D7ekVJUH.js", + "scene242-gltf-animation-Dm97A3mz.js", "scene242-gltf-ext-emissive-strength-CButLZnK.js", - "scene242-gltf-feature-animation-pointer-CqjUmXa4.js", - "scene242-gltf-feature-animations-WlV0WKZJ.js", - "scene242-gltf-feature-registry-C843LdZm.js", + "scene242-gltf-feature-animation-pointer-DuUn5-xJ.js", + "scene242-gltf-feature-animations-BvTxdDNR.js", + "scene242-gltf-feature-registry-BoIeBdL4.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", - "scene242-mat4-invert-DZR4hiws.js", "scene242-pbr-renderable-CmvfRP8M.js", "scene242-rgbd-decode-DapdOyyV.js", "scene242-scene-uniforms-FTYH6Ct0.js", @@ -3086,21 +3068,20 @@ ] }, "scene243": { - "rawKB": 96.2, - "gzipKB": 40.6, + "rawKB": 96, + "gzipKB": 40.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene243-create-morph-targets-C_lcfVOA.js", "scene243-generate-mipmaps-C4S5NcQC.js", - "scene243-gltf-animation-TbeJGwSx.js", - "scene243-gltf-feature-animations-BZw9sEIf.js", + "scene243-gltf-animation-B51SBoH8.js", + "scene243-gltf-feature-animations-C5TP9MXt.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-BMvZpp0X.js", + "scene243-gltf-feature-registry-22kVPIi6.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", - "scene243-mat4-invert-k38u0vRD.js", "scene243-morph-fragment-DTmLRHdp.js", "scene243-pbr-renderable-CShH3BMl.js", "scene243-pbr-template-ext-BoJ8SFLM.js", @@ -3111,25 +3092,24 @@ ] }, "scene244": { - "rawKB": 132.4, - "gzipKB": 53.8, + "rawKB": 132.2, + "gzipKB": 53.7, "ignoredRawKB": 0, "runtimeChunks": [ "scene244-animation-pointer-ext-CoOxzYYy.js", "scene244-animation-pointer-jEniq5im.js", "scene244-clearcoat-fragment-fqLK-qje.js", "scene244-generate-mipmaps-BY39y9hS.js", - "scene244-gltf-animation-fivOCnLe.js", + "scene244-gltf-animation-BkhOo1GS.js", "scene244-gltf-ext-clearcoat-BgaLgSgD.js", "scene244-gltf-ext-dielectric-C6hvXXiF.js", "scene244-gltf-ext-uv-transform-YGWG8v_J.js", - "scene244-gltf-feature-animation-pointer-Cw-JSEoG.js", - "scene244-gltf-feature-animations-B4zBW5hu.js", - "scene244-gltf-feature-registry-CiZh4-Qb.js", + "scene244-gltf-feature-animation-pointer-Cv2YzJgj.js", + "scene244-gltf-feature-animations-DmXCvx5H.js", + "scene244-gltf-feature-registry-BhL6FR73.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", - "scene244-mat4-invert-B4l_4Xp7.js", "scene244-pbr-refraction-1mYxyyrr.js", "scene244-pbr-renderable-CjRk8WAR.js", "scene244-pbr-template-ext-BoJ8SFLM.js", @@ -3144,23 +3124,22 @@ ] }, "scene245": { - "rawKB": 98.8, - "gzipKB": 41.9, + "rawKB": 98.7, + "gzipKB": 41.8, "ignoredRawKB": 0, "runtimeChunks": [ "scene245-create-skeleton-nuOFOS6J.js", "scene245-flat-normal-wgsl-Cm9mM4tC.js", "scene245-generate-mipmaps-WM6bVf2v.js", - "scene245-gltf-animation-CH-NCr-C.js", - "scene245-gltf-feature-animations-BqSXwBPk.js", - "scene245-gltf-feature-registry-D0j79zuB.js", - "scene245-gltf-feature-skeleton-tGggxvpO.js", + "scene245-gltf-animation-Dvm46y_g.js", + "scene245-gltf-feature-animations-B19wAXO_.js", + "scene245-gltf-feature-registry-D6WbLPzH.js", + "scene245-gltf-feature-skeleton-IRWJQHYY.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", "scene245-gltf-normals-DYhLwXNX.js", "scene245-gltf-strided-attribute-CGKc0Sx6.js", "scene245-ibl-fragment-CeRrvT96.js", - "scene245-mat4-invert-CN3HReau.js", "scene245-pbr-renderable-CUmy8A52.js", "scene245-pbr-template-ext-BoJ8SFLM.js", "scene245-rgbd-decode-CKe7_W5g.js", @@ -3170,24 +3149,23 @@ ] }, "scene246": { - "rawKB": 97.7, - "gzipKB": 41.5, + "rawKB": 97.6, + "gzipKB": 41.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene246-create-skeleton-COkERfCM.js", "scene246-flat-normal-wgsl-Cm9mM4tC.js", "scene246-generate-mipmaps-DzKvtUax.js", - "scene246-gltf-animation-5d--qD22.js", - "scene246-gltf-feature-animations-BVShSXS8.js", - "scene246-gltf-feature-registry-DxJla7FB.js", - "scene246-gltf-feature-skeleton-yfeKWm3c.js", + "scene246-gltf-animation-DGsaicDt.js", + "scene246-gltf-feature-animations-CPl_ISPs.js", + "scene246-gltf-feature-registry-C0jyX5bF.js", + "scene246-gltf-feature-skeleton-Bf1KbRoN.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", "scene246-gltf-multi-buffer-Cwm5u1Qq.js", "scene246-gltf-normals-DYhLwXNX.js", "scene246-gltf-strided-attribute-R3NdoKEL.js", "scene246-ibl-fragment-CeRrvT96.js", - "scene246-mat4-invert-DBC-i-zv.js", "scene246-pbr-renderable-gTWSGiFj.js", "scene246-rgbd-decode-DQhLUjb0.js", "scene246-scene-uniforms-FTYH6Ct0.js", @@ -3196,18 +3174,17 @@ ] }, "scene247": { - "rawKB": 83, - "gzipKB": 34.6, + "rawKB": 82.9, + "gzipKB": 34.4, "ignoredRawKB": 0, "runtimeChunks": [ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", - "scene247-gltf-feature-gpu-instancing-DvUcvoJl.js", - "scene247-gltf-feature-registry-DRYMtS8a.js", + "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", + "scene247-gltf-feature-registry-7cX4fW5H.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", - "scene247-mat4-multiply-BjOi0MOL.js", "scene247-pbr-renderable-D7Uak2DC.js", "scene247-rgbd-decode-ClWWmAM6.js", "scene247-scene-uniforms-FTYH6Ct0.js", @@ -3249,18 +3226,17 @@ ] }, "scene251": { - "rawKB": 88.3, - "gzipKB": 36.6, + "rawKB": 88.2, + "gzipKB": 36.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene251-create-skeleton-QaTYEW_C.js", "scene251-generate-mipmaps-ojYQxP8q.js", - "scene251-gltf-animation-B4iYdDHq.js", - "scene251-gltf-feature-animations-BoUtEts6.js", - "scene251-gltf-feature-registry-fUo90dpV.js", - "scene251-gltf-feature-skeleton-zwplEGNL.js", + "scene251-gltf-animation-BJ2pOO_r.js", + "scene251-gltf-feature-animations-Cj7oKyXf.js", + "scene251-gltf-feature-registry-DfsBNKUg.js", + "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", "scene251-gltf-glb-parser-8AD91ACR.js", - "scene251-mat4-invert-DxOzu6n0.js", "scene251-multilight-wgsl-Cxg2lDtv.js", "scene251-pbr-renderable-rJR7cw2X.js", "scene251-skeleton-fragment-BbV5HG1g.js", @@ -3279,8 +3255,8 @@ ] }, "scene253": { - "rawKB": 151.2, - "gzipKB": 64, + "rawKB": 151, + "gzipKB": 63.9, "ignoredRawKB": 0, "runtimeChunks": [ "scene253-alpha-test-fragment-CBuxkQtx.js", @@ -3293,20 +3269,20 @@ "scene253-directional-light-C7HjjUeW.js", "scene253-emissive-fragment-CWAgCBrm.js", "scene253-generate-mipmaps-BHuGZ0l5.js", - "scene253-gltf-animation-B2okpalN.js", + "scene253-gltf-animation-BKiWufrU.js", "scene253-gltf-color-normalize-BtnJk1yq.js", "scene253-gltf-ext-dielectric-C6hvXXiF.js", "scene253-gltf-ext-emissive-strength-CButLZnK.js", "scene253-gltf-ext-iridescence-b4LVniAM.js", "scene253-gltf-ext-unlit-1vUYfF7v.js", "scene253-gltf-ext-uv-transform-DixkPR9o.js", - "scene253-gltf-feature-animation-pointer-l7f0I44Q.js", - "scene253-gltf-feature-animations-D5QgCDV9.js", + "scene253-gltf-feature-animation-pointer-B4es0u03.js", + "scene253-gltf-feature-animations-BfsMkPNo.js", "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-Bkcz8zPQ.js", - "scene253-gltf-feature-skeleton-mdE9XqYt.js", + "scene253-gltf-feature-registry-Q0Dxo0gu.js", + "scene253-gltf-feature-skeleton-Bjigd6Ok.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js", "scene253-gltf-pbr-builder-ext-BzZBX-YN.js", @@ -3315,7 +3291,6 @@ "scene253-iridescence-fragment-BIm-2okC.js", "scene253-light-base-eE8_4fU8.js", "scene253-light-matrix-BpE3lP6k.js", - "scene253-mat4-invert-zKjU83zn.js", "scene253-morph-fragment-CEhGS5lc.js", "scene253-multilight-wgsl-D9gPIJS-.js", "scene253-pbr-refraction-Cnk6VDE7.js", diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts index 69beba1e1d..45c7c5b987 100644 --- a/packages/babylon-lite/src/flow-graph/fg-math.ts +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -14,11 +14,8 @@ import type { FgValue, Vec2 } from "./types.js"; import type { Mat4, Quat, Vec3, Vec4 } from "../math/types.js"; import { crossVec3 } from "../math/cross-vec3.js"; import { dotVec3 } from "../math/dot-vec3.js"; -import { mat4Multiply } from "../math/mat4-multiply.js"; -import { mat4Invert } from "../math/mat4-invert.js"; import { mat4Compose } from "../math/mat4-compose.js"; import { mat4Decompose } from "../math/mat4-decompose.js"; -import { mat4Identity } from "../math/mat4-identity.js"; function isVec2(v: unknown): v is Vec2 { return typeof v === "object" && v !== null && "x" in v && "y" in v && !("z" in v); @@ -759,9 +756,144 @@ export function fgDeterminant(m: FgValue): number { return 0; } +// ─── Local Mat4 invert/multiply ─────────────────────────────────────────────── +// fg-math keeps its own column-major Mat4 invert/multiply instead of importing +// the core `mat4Invert`/`mat4Multiply`. Those core modules are also used by the +// skeleton/animation runtime, and the flow-graph block chunks are emitted into +// EVERY glTF scene's bundle (via the lazy gltf-feature-interactivity → getBlockDef +// chunk graph). Sharing the core modules would make Rollup hoist them into shared +// chunks that the live skeleton chunk then loads at runtime, perturbing existing +// scenes' bundles and breaking their size ceilings. Local copies keep those bytes +// inside the lazily-loaded flow-graph block chunks only. Math is identical to core. + +/** Inverse of a column-major Mat4. Returns null when singular. */ +function fgMat4Invert(input: Mat4): Mat4 | null { + const m = input as unknown as Float32Array; + const a00 = m[0]!, + a01 = m[1]!, + a02 = m[2]!, + a03 = m[3]!; + const a10 = m[4]!, + a11 = m[5]!, + a12 = m[6]!, + a13 = m[7]!; + const a20 = m[8]!, + a21 = m[9]!, + a22 = m[10]!, + a23 = m[11]!; + const a30 = m[12]!, + a31 = m[13]!, + a32 = m[14]!, + a33 = m[15]!; + + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + + let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (Math.abs(det) < 1e-10) { + return null; + } + det = 1 / det; + + const out = new Float32Array(16); + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out as unknown as Mat4; +} + +/** Column-major Mat4 product: `out = a * b`. */ +function fgMat4Multiply(a: Mat4, b: Mat4): Mat4 { + const x = a as unknown as Float32Array; + const y = b as unknown as Float32Array; + const a0 = x[0]!, + a1 = x[1]!, + a2 = x[2]!, + a3 = x[3]!; + const a4 = x[4]!, + a5 = x[5]!, + a6 = x[6]!, + a7 = x[7]!; + const a8 = x[8]!, + a9 = x[9]!, + a10 = x[10]!, + a11 = x[11]!; + const a12 = x[12]!, + a13 = x[13]!, + a14 = x[14]!, + a15 = x[15]!; + const out = new Float32Array(16); + let b0 = y[0]!, + b1 = y[1]!, + b2 = y[2]!, + b3 = y[3]!; + out[0] = a0 * b0 + a4 * b1 + a8 * b2 + a12 * b3; + out[1] = a1 * b0 + a5 * b1 + a9 * b2 + a13 * b3; + out[2] = a2 * b0 + a6 * b1 + a10 * b2 + a14 * b3; + out[3] = a3 * b0 + a7 * b1 + a11 * b2 + a15 * b3; + b0 = y[4]!; + b1 = y[5]!; + b2 = y[6]!; + b3 = y[7]!; + out[4] = a0 * b0 + a4 * b1 + a8 * b2 + a12 * b3; + out[5] = a1 * b0 + a5 * b1 + a9 * b2 + a13 * b3; + out[6] = a2 * b0 + a6 * b1 + a10 * b2 + a14 * b3; + out[7] = a3 * b0 + a7 * b1 + a11 * b2 + a15 * b3; + b0 = y[8]!; + b1 = y[9]!; + b2 = y[10]!; + b3 = y[11]!; + out[8] = a0 * b0 + a4 * b1 + a8 * b2 + a12 * b3; + out[9] = a1 * b0 + a5 * b1 + a9 * b2 + a13 * b3; + out[10] = a2 * b0 + a6 * b1 + a10 * b2 + a14 * b3; + out[11] = a3 * b0 + a7 * b1 + a11 * b2 + a15 * b3; + b0 = y[12]!; + b1 = y[13]!; + b2 = y[14]!; + b3 = y[15]!; + out[12] = a0 * b0 + a4 * b1 + a8 * b2 + a12 * b3; + out[13] = a1 * b0 + a5 * b1 + a9 * b2 + a13 * b3; + out[14] = a2 * b0 + a6 * b1 + a10 * b2 + a14 * b3; + out[15] = a3 * b0 + a7 * b1 + a11 * b2 + a15 * b3; + return out as unknown as Mat4; +} + +/** 4x4 column-major identity. */ +function fgMat4Identity(): Mat4 { + const out = new Float32Array(16); + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out as unknown as Mat4; +} + /** * Invert a matrix (glTF `math/inverse`). Returns the identity when singular. - * Supports `FgMatrix2D`, `FgMatrix3D`, and `Mat4` (via core `mat4Invert`). + * Supports `FgMatrix2D`, `FgMatrix3D`, and `Mat4` (local column-major invert). */ export function fgInvertMatrix(m: FgValue): FgValue { if (isFgMatrix2D(m)) { @@ -793,7 +925,7 @@ export function fgInvertMatrix(m: FgValue): FgValue { ]); } if (isMat4(m)) { - return mat4Invert(m) ?? mat4Identity(); + return fgMat4Invert(m) ?? fgMat4Identity(); } return m; } @@ -801,7 +933,7 @@ export function fgInvertMatrix(m: FgValue): FgValue { /** * Multiply two same-size matrices: `out = A × B` (standard matrix product). * Supports `FgMatrix2D × FgMatrix2D`, `FgMatrix3D × FgMatrix3D`, and - * `Mat4 × Mat4` (via core `mat4Multiply`). (glTF `math/matMul`) + * `Mat4 × Mat4` (local column-major multiply). (glTF `math/matMul`) */ export function fgMatrixMultiplication(a: FgValue, b: FgValue): FgValue { if (isFgMatrix2D(a) && isFgMatrix2D(b)) { @@ -825,7 +957,7 @@ export function fgMatrixMultiplication(a: FgValue, b: FgValue): FgValue { ]); } if (isMat4(a) && isMat4(b)) { - return mat4Multiply(a, b); + return fgMat4Multiply(a, b); } return a; } From d7900c4bc75eeafaadd7a0b43ac2a97a344b2f39 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 21:24:06 +0200 Subject: [PATCH 12/13] feat(flow-graph): complete glTF op mapper with quatMul, stopAt, debug/log Phase 4a closes the declaration-mapper gap against BJS commit 8f728b23ea: - math/quatMul: dedicated QuaternionMultiplication block (Hamilton product via self-contained fgQuatMul); Lite's generic Multiply is component-wise. - animation/stopAt: StopAnimation gains an optional stopAtFrame input that defers the stop via an onTick monitor + new stopAnimationAt capability (poses the target at the frame instead of resetting to 0). - debug/log: ConsoleLog now expands {name} placeholders from a messageTemplate config (faithful to BJS), reading named inputs or message-object keys. Adds an allMappedBlockTypes() coverage guard test asserting every mapped op resolves to a registered, type-matching block def. 784 unit tests green; lint + typecheck clean. Manifest regen follows. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../src/flow-graph/block-registry.ts | 2 + .../babylon-lite/src/flow-graph/block-type.ts | 1 + .../blocks/animation/stop-animation.ts | 60 +++++++-- .../flow-graph/blocks/debug/console-log.ts | 81 ++++++++++-- .../blocks/math/quaternion-multiplication.ts | 28 +++++ .../babylon-lite/src/flow-graph/context.ts | 2 + .../babylon-lite/src/flow-graph/fg-math.ts | 17 +++ .../src/flow-graph/gltf/declaration-mapper.ts | 32 +++++ .../src/flow-graph/scene-flow-graph.ts | 5 +- tests/lite/unit/flow-graph-blocks.test.ts | 116 ++++++++++++++++++ .../lite/unit/flow-graph-gltf-parser.test.ts | 18 +++ 11 files changed, 344 insertions(+), 18 deletions(-) create mode 100644 packages/babylon-lite/src/flow-graph/blocks/math/quaternion-multiplication.ts diff --git a/packages/babylon-lite/src/flow-graph/block-registry.ts b/packages/babylon-lite/src/flow-graph/block-registry.ts index e3f53f31d2..07dd560a56 100644 --- a/packages/babylon-lite/src/flow-graph/block-registry.ts +++ b/packages/babylon-lite/src/flow-graph/block-registry.ts @@ -245,6 +245,8 @@ export function getBlockDef(type: string): (() => Promise) | null { return async () => (await import("./blocks/math/axis-angle-from-quaternion.js")).axisAngleFromQuaternionDef; case FgBlockType.QuaternionFromDirections: return async () => (await import("./blocks/math/quaternion-from-directions.js")).quaternionFromDirectionsDef; + case FgBlockType.QuaternionMultiplication: + return async () => (await import("./blocks/math/quaternion-multiplication.js")).quaternionMultiplicationDef; case FgBlockType.BooleanToFloat: return async () => (await import("./blocks/conversion/boolean-to-float.js")).booleanToFloatDef; case FgBlockType.BooleanToInt: diff --git a/packages/babylon-lite/src/flow-graph/block-type.ts b/packages/babylon-lite/src/flow-graph/block-type.ts index 2dd64f98c1..96e615e752 100644 --- a/packages/babylon-lite/src/flow-graph/block-type.ts +++ b/packages/babylon-lite/src/flow-graph/block-type.ts @@ -142,6 +142,7 @@ export const enum FgBlockType { QuaternionFromAxisAngle = "QuaternionFromAxisAngle", AxisAngleFromQuaternion = "AxisAngleFromQuaternion", QuaternionFromDirections = "QuaternionFromDirections", + QuaternionMultiplication = "QuaternionMultiplication", // ─── Data / type conversion ─────────────────────────────── BooleanToFloat = "BooleanToFloat", diff --git a/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts b/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts index 7e865f5aea..7dee13ed51 100644 --- a/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts +++ b/packages/babylon-lite/src/flow-graph/blocks/animation/stop-animation.ts @@ -1,28 +1,72 @@ -// StopAnimation (BJS FlowGraphStopAnimationBlock, glTF op `animation/stop`). -// Execution block: stops an AnimationGroup resolved by glTF animation index, -// then fires `out` (or `error` when the index/capability is missing). +// StopAnimation (BJS FlowGraphStopAnimationBlock, glTF ops `animation/stop` and +// `animation/stopAt`). Execution block: stops an AnimationGroup resolved by glTF +// animation index, then fires `out` (or `error` when the index/capability is +// missing). +// +// - `animation/stop`: stops immediately (resets to frame 0 via `stopAnimation`). +// - `animation/stopAt`: an optional `stopAtFrame` input defers the stop — the +// block fires `out` at once, then polls each tick and halts the group at the +// requested frame (`stopAnimationAt`, which poses the target at that frame). +// +// LITE DIVERGENCE: BJS expands `animation/stopAt` to [StopAnimation, ArrayIndex, +// GLTFDataProvider]; Lite pre-resolves the animation array in the loader and +// drives playback through scene-owned `env.caps`. The deferred monitor handles +// forward playback (the common case) and also completes if the group stops on +// its own. import type { FgBlockDef } from "../../block-def.js"; import { FgBlockType } from "../../block-type.js"; import { FgType } from "../../types.js"; -import { activateSignal, getDataValue } from "../../runtime.js"; +import type { AnimationGroup } from "../../../animation/animation-group.js"; +import { activateSignal, addPending, getDataValue } from "../../runtime.js"; import { sigIn, sigOut, sockIn } from "../../sockets.js"; +const DEFAULT_FRAME_RATE = 60; + export const stopAnimationDef: FgBlockDef = { type: FgBlockType.StopAnimation, build: () => ({ - dataIn: [sockIn("animation", FgType.Integer)], + dataIn: [sockIn("animation", FgType.Integer), sockIn("stopAtFrame", FgType.Number)], signalIn: [sigIn("in")], signalOut: [sigOut("out"), sigOut("error")], }), execute(block, ctx, env) { const index = toIndex(getDataValue(ctx, env, block, "animation")); const group = index === undefined ? undefined : env.animations[index]; - if (group && env.caps.stopAnimation) { + if (!group || !env.caps.stopAnimation) { + activateSignal(ctx, env, block, "error"); + return; + } + + // Deferred stop only when a `stopAtFrame` input is actually wired/provided + // (an unwired socket reads as 0, which must NOT be treated as "stop at 0"). + const frameSocket = block.dataIn.find((s) => s.name === "stopAtFrame"); + const hasStopAt = !!(frameSocket && (frameSocket.source || frameSocket.defaultValue !== undefined)) && !!env.caps.stopAnimationAt; + + if (!hasStopAt) { env.caps.stopAnimation(group); activateSignal(ctx, env, block, "out"); - } else { - activateSignal(ctx, env, block, "error"); + return; + } + + const stopAtFrame = getDataValue(ctx, env, block, "stopAtFrame") as number; + activateSignal(ctx, env, block, "out"); + addPending(ctx, block, { group, stopAtFrame }); + }, + onTick(_block, _ctx, env, _deltaMs, task) { + const group = task.state.group as AnimationGroup | undefined; + if (!group) { + task.done = true; + return; + } + const stopAtFrame = task.state.stopAtFrame as number; + const currentFrame = group.currentTime * (group.frameRate || DEFAULT_FRAME_RATE); + if (currentFrame >= stopAtFrame) { + env.caps.stopAnimationAt?.(group, stopAtFrame); + task.done = true; + } else if (!group.isPlaying) { + // Group ended before reaching the target frame — nothing left to stop. + task.done = true; } }, }; diff --git a/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts b/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts index 1de12bace5..be9f5d9d71 100644 --- a/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts +++ b/packages/babylon-lite/src/flow-graph/blocks/debug/console-log.ts @@ -1,22 +1,85 @@ -// ConsoleLog (BJS FlowGraphConsoleLogBlock, glTF op `flow/log` in the BABYLON -// extension). Execution block: logs `message` to the console, then fires `out`. +// ConsoleLog (BJS FlowGraphConsoleLogBlock, glTF ops `flow/log` in the BABYLON +// extension and `debug/log` in core). Execution block: logs a value to the +// console, then fires `out`. +// +// Two modes (mirrors BJS): +// - `flow/log`: logs the `message` data input directly (raw value). +// - `debug/log`: `config.messageTemplate` is a string with `{name}` +// placeholders. Each placeholder becomes its own data input; at execution the +// template is rendered by substituting each `{name}` with the serialized value +// of the matching input (or, when `message` is an object, its same-named key). -import type { FgBlockDef } from "../../block-def.js"; +import type { FgBlockDef, FgBlockShape } from "../../block-def.js"; import { FgBlockType } from "../../block-type.js"; import { FgType } from "../../types.js"; +import type { FgValue } from "../../types.js"; import { activateSignal, getDataValue } from "../../runtime.js"; import { sigIn, sigOut, sockIn } from "../../sockets.js"; +const PLACEHOLDER = /\{([^}]+)\}/g; + +function templateMatches(template: string): string[] { + const matches: string[] = []; + let m: RegExpExecArray | null; + PLACEHOLDER.lastIndex = 0; + while ((m = PLACEHOLDER.exec(template)) !== null) { + matches.push(m[1]!); + } + return matches; +} + +function serializeValue(value: FgValue): string { + if (value === null || value === undefined) { + return String(value); + } + if (typeof value === "object") { + try { + return JSON.stringify(value); + } catch { + return String(value); + } + } + return String(value); +} + export const consoleLogDef: FgBlockDef = { type: FgBlockType.ConsoleLog, - build: () => ({ - dataIn: [sockIn("message", FgType.Any)], - signalIn: [sigIn("in")], - signalOut: [sigOut("out")], - }), + build: (config) => { + const template = config?.messageTemplate as string | undefined; + const shape: FgBlockShape = { + dataIn: [sockIn("message", FgType.Any)], + signalIn: [sigIn("in")], + signalOut: [sigOut("out")], + }; + if (template) { + for (const name of templateMatches(template)) { + if (name !== "message" && !shape.dataIn!.some((s) => s.name === name)) { + shape.dataIn!.push(sockIn(name, FgType.Any)); + } + } + } + return shape; + }, execute(block, ctx, env) { + const template = block.config?.messageTemplate as string | undefined; + let message: FgValue; + if (template) { + const messageVal = getDataValue(ctx, env, block, "message"); + const messageObj = messageVal !== null && typeof messageVal === "object" ? (messageVal as unknown as Record) : null; + let rendered = template; + for (const name of templateMatches(template)) { + const value = messageObj && name in messageObj ? messageObj[name] : getDataValue(ctx, env, block, name); + if (value !== undefined) { + const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + rendered = rendered.replace(new RegExp(`\\{${escaped}\\}`, "g"), serializeValue(value)); + } + } + message = rendered; + } else { + message = getDataValue(ctx, env, block, "message"); + } // eslint-disable-next-line no-console - console.log(getDataValue(ctx, env, block, "message")); + console.log(message); activateSignal(ctx, env, block, "out"); }, }; diff --git a/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-multiplication.ts b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-multiplication.ts new file mode 100644 index 0000000000..21e04affd8 --- /dev/null +++ b/packages/babylon-lite/src/flow-graph/blocks/math/quaternion-multiplication.ts @@ -0,0 +1,28 @@ +// QuaternionMultiplication (BJS FlowGraphMultiply with `config.type = +// Quaternion`, glTF op `math/quatMul`). Data block (PULL): emits the Hamilton +// product `a ⊗ b` via fg-math's `fgQuatMul`. +// +// LITE DIVERGENCE: BJS reuses the generic Multiply block and switches it to the +// Quaternion path via config. Lite's generic Multiply is component-wise (Vec4 +// and Quat are shape-identical `{x,y,z,w}` at runtime), so quaternion +// multiplication needs its own dedicated block to avoid mangling Vec4 math. + +import type { FgBlockDef } from "../../block-def.js"; +import { FgBlockType } from "../../block-type.js"; +import { FgType } from "../../types.js"; +import { getDataValue, setDataValue } from "../../runtime.js"; +import { sockIn, sockOut } from "../../sockets.js"; +import { fgQuatMul } from "../../fg-math.js"; + +export const quaternionMultiplicationDef: FgBlockDef = { + type: FgBlockType.QuaternionMultiplication, + build: () => ({ + dataIn: [sockIn("a", FgType.Any), sockIn("b", FgType.Any)], + dataOut: [sockOut("value", FgType.Quaternion)], + }), + updateOutputs(block, ctx, env) { + const a = getDataValue(ctx, env, block, "a"); + const b = getDataValue(ctx, env, block, "b"); + setDataValue(ctx, block, "value", fgQuatMul(a, b)); + }, +}; diff --git a/packages/babylon-lite/src/flow-graph/context.ts b/packages/babylon-lite/src/flow-graph/context.ts index b578c5080e..887707355d 100644 --- a/packages/babylon-lite/src/flow-graph/context.ts +++ b/packages/babylon-lite/src/flow-graph/context.ts @@ -48,6 +48,8 @@ export interface FgCapabilities { readonly playAnimation?: (group: AnimationGroup, opts?: { speed?: number; loop?: boolean; from?: number; to?: number }) => void; /** Stop a playing animation group. */ readonly stopAnimation?: (group: AnimationGroup) => void; + /** Halt a playing animation group at a specific frame (glTF `animation/stopAt`). */ + readonly stopAnimationAt?: (group: AnimationGroup, frame: number) => void; /** Subscribe to an animation group's end; returns an unsubscribe fn. */ readonly onAnimationEnd?: (group: AnimationGroup, cb: () => void) => () => void; } diff --git a/packages/babylon-lite/src/flow-graph/fg-math.ts b/packages/babylon-lite/src/flow-graph/fg-math.ts index 45c7c5b987..8fcc50fe82 100644 --- a/packages/babylon-lite/src/flow-graph/fg-math.ts +++ b/packages/babylon-lite/src/flow-graph/fg-math.ts @@ -584,6 +584,23 @@ export function fgConjugate(a: FgValue): FgValue { return a; } +/** + * Hamilton product of two quaternions, `a ⊗ b` (glTF `math/quatMul`). Self- + * contained (no core import) so the block chunk never shares a core module with + * non-flow-graph scene chunks. Convention matches BJS `Quaternion.multiply` + * (`a.multiply(b)`). Non-quaternion inputs return `a` unchanged. */ +export function fgQuatMul(a: FgValue, b: FgValue): FgValue { + if (isVec4(a) && isVec4(b)) { + return { + x: a.x * b.w + a.w * b.x + a.y * b.z - a.z * b.y, + y: a.y * b.w + a.w * b.y + a.z * b.x - a.x * b.z, + z: a.z * b.w + a.w * b.z + a.x * b.y - a.y * b.x, + w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z, + } as Quat; + } + return a; +} + // ─── Matrix ops (Phase 3f) ──────────────────────────────────────────────────── /** diff --git a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts index 2ab479879f..39abdf05b0 100644 --- a/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts +++ b/packages/babylon-lite/src/flow-graph/gltf/declaration-mapper.ts @@ -264,6 +264,10 @@ const NATIVE_OPS: Readonly> = { "math/quatFromAxisAngle": { block: FgBlockType.QuaternionFromAxisAngle, valueInputs: { axis: "a", angle: "b" } }, "math/quatToAxisAngle": { block: FgBlockType.AxisAngleFromQuaternion }, "math/quatFromDirections": { block: FgBlockType.QuaternionFromDirections }, + // math/quatMul: BJS reuses the generic Multiply with config.type=Quaternion; + // Lite has a dedicated Hamilton-product block (generic Multiply is component- + // wise). glTF inputs `a`/`b` map to identically named sockets. + "math/quatMul": { block: FgBlockType.QuaternionMultiplication }, "variable/get": { block: FgBlockType.GetVariable, variableConfigKey: "variable" }, "variable/set": { block: FgBlockType.SetVariable, variableConfigKey: "variables", valueInputs: { value: "value" } }, @@ -278,6 +282,18 @@ const NATIVE_OPS: Readonly> = { flowOutputs: { err: "error" }, }, "animation/stop": { block: FgBlockType.StopAnimation, valueInputs: { animation: "animation" }, flowOutputs: { err: "error" } }, + // animation/stopAt: defers the stop until playback reaches `stopAtFrame`. + // glTF `stopTime` (seconds) → `stopAtFrame` via the FPS transform. + "animation/stopAt": { + block: FgBlockType.StopAnimation, + valueInputs: { animation: "animation", stopTime: "stopAtFrame" }, + valueTransform: { stopTime: FPS }, + flowOutputs: { err: "error" }, + }, + + // debug/log: core op (vs BABYLON-extension flow/log). The `message` config is + // a template with `{name}` placeholders that the ConsoleLog block expands. + "debug/log": { block: FgBlockType.ConsoleLog, configKeys: { message: "messageTemplate" } }, // ─── Phase 3i event ops ──────────────────────────────────────────────────── // event/send: `configuration["event"]` holds the integer event-table index, @@ -335,3 +351,19 @@ export function getOpMapping(op: string, extension?: string): FgOpMapping | null } return NATIVE_OPS[op] ?? null; } + +/** Every distinct Lite block type referenced by some op mapping (native or + * extension). Used by a coverage guard to prove every mapped op resolves to a + * registered block def. */ +export function allMappedBlockTypes(): FgBlockType[] { + const types = new Set(); + for (const m of Object.values(NATIVE_OPS)) { + types.add(m.block); + } + for (const table of Object.values(EXTENSION_OPS)) { + for (const m of Object.values(table)) { + types.add(m.block); + } + } + return [...types]; +} diff --git a/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts index 7ecfbbdabd..a43cdac5a4 100644 --- a/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts +++ b/packages/babylon-lite/src/flow-graph/scene-flow-graph.ts @@ -8,7 +8,7 @@ import { onBeforeRender, onSceneDispose, type SceneContext } from "../scene/scen import type { FgRuntime } from "./runtime.js"; import { createFgRuntime, disposeFlowGraph, startFlowGraph, tickFlowGraph } from "./runtime.js"; import type { AnimationGroup } from "../animation/animation-group.js"; -import { playAnimation as agPlay, stopAnimation as agStop } from "../animation/animation-group.js"; +import { playAnimation as agPlay, stopAnimation as agStop, goToFrame as agGoToFrame } from "../animation/animation-group.js"; import type { FgCapabilities, LoadedFlowGraph } from "./context.js"; /** Attach a flow-graph runtime to a scene. The runtime starts on the first @@ -59,6 +59,9 @@ function sceneAnimationCaps(): FgCapabilities { agPlay(group); }, stopAnimation: (group: AnimationGroup) => agStop(group), + // Halt at the requested frame (goToFrame sets currentTime + clears + // isPlaying), leaving the target posed at that frame rather than reset. + stopAnimationAt: (group: AnimationGroup, frame: number) => agGoToFrame(group, frame), }; } diff --git a/tests/lite/unit/flow-graph-blocks.test.ts b/tests/lite/unit/flow-graph-blocks.test.ts index 582aecdf6f..f213384f56 100644 --- a/tests/lite/unit/flow-graph-blocks.test.ts +++ b/tests/lite/unit/flow-graph-blocks.test.ts @@ -728,6 +728,43 @@ describe("flow-graph blocks — animation", () => { startFlowGraph(rt); expect(stop).toHaveBeenCalledWith(group); }); + + it("StopAnimation with stopAtFrame defers the stop until the frame is reached", async () => { + const group = mockGroup(); + (group as { frameRate: number }).frameRate = 60; + group.isPlaying = true; + const stop = vi.fn(); + const stopAt = vi.fn(); + const log: { label: string; value: FgValue }[] = []; + const rt = await makeRuntime( + [ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "stop", socket: "in" }] } }, + { + id: "stop", + type: "StopAnimation", + dataDefaults: { animation: 0, stopAtFrame: 30 }, + signalTargets: { out: [{ blockId: "o", socket: "in" }] }, + }, + { id: "o", type: RECORD, config: { label: "out" } }, + ], + { wiring: { animations: [group], caps: { stopAnimation: stop, stopAnimationAt: stopAt } }, defs: { [RECORD]: recorderDef(log) } } + ); + startFlowGraph(rt); + // out fires immediately; no immediate stop, deferred monitor armed. + expect(log.map((e) => e.label)).toEqual(["out"]); + expect(stop).not.toHaveBeenCalled(); + expect(stopAt).not.toHaveBeenCalled(); + + // Not yet at the target frame. + group.currentTime = 0.25; // frame 15 + tickFlowGraph(rt, 16); + expect(stopAt).not.toHaveBeenCalled(); + + // Reached the target frame (30 / 60 = 0.5s). + group.currentTime = 0.5; + tickFlowGraph(rt, 16); + expect(stopAt).toHaveBeenCalledWith(group, 30); + }); }); describe("flow-graph blocks — matrix/quaternion", () => { @@ -985,6 +1022,27 @@ describe("flow-graph blocks — matrix/quaternion", () => { expect(r.z).toBeCloseTo(Math.sin(Math.PI / 4), 5); expect(r.w).toBeCloseTo(Math.cos(Math.PI / 4), 5); }); + + it("QuaternionMultiplication: Hamilton product i⊗j = k", async () => { + const i = { x: 1, y: 0, z: 0, w: 0 }; + const j = { x: 0, y: 1, z: 0, w: 0 }; + const r = (await evalOp("QuaternionMultiplication", { a: i, b: j })) as { x: number; y: number; z: number; w: number }; + expect(r.x).toBeCloseTo(0, 8); + expect(r.y).toBeCloseTo(0, 8); + expect(r.z).toBeCloseTo(1, 8); + expect(r.w).toBeCloseTo(0, 8); + }); + + it("QuaternionMultiplication: two Y-axis 90° rotations compose to Y-axis 180°", async () => { + const s = Math.sin(Math.PI / 4); + const c = Math.cos(Math.PI / 4); + const q = { x: 0, y: s, z: 0, w: c }; + const r = (await evalOp("QuaternionMultiplication", { a: q, b: q })) as { x: number; y: number; z: number; w: number }; + expect(r.x).toBeCloseTo(0, 8); + expect(r.y).toBeCloseTo(1, 8); + expect(r.z).toBeCloseTo(0, 8); + expect(r.w).toBeCloseTo(0, 8); + }); }); // ───────────────────────────────────────────────────────────────────────────── @@ -1936,3 +1994,61 @@ describe("flow-graph blocks — events + interpolation Phase 3i", () => { expect(log.find((e) => e.label === "done")?.value).toBe(200); }); }); + +// ───────────────────────────────────────────────────────────────────────────── +// Phase 4 — ConsoleLog (flow/log + debug/log messageTemplate) +// ───────────────────────────────────────────────────────────────────────────── + +describe("flow-graph blocks — ConsoleLog", () => { + it("flow/log: logs the raw `message` input", async () => { + const spy = vi.spyOn(console, "log").mockImplementation(() => {}); + try { + const rt = await makeRuntime([ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "log", socket: "in" }] } }, + { id: "log", type: "ConsoleLog", dataDefaults: { message: "hello" } }, + ]); + startFlowGraph(rt); + expect(spy).toHaveBeenCalledWith("hello"); + } finally { + spy.mockRestore(); + } + }); + + it("debug/log: expands `{name}` placeholders from named data inputs", async () => { + const spy = vi.spyOn(console, "log").mockImplementation(() => {}); + try { + const rt = await makeRuntime([ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "log", socket: "in" }] } }, + { + id: "log", + type: "ConsoleLog", + config: { messageTemplate: "x={x} y={y}" }, + dataDefaults: { x: 1, y: 2 }, + }, + ]); + startFlowGraph(rt); + expect(spy).toHaveBeenCalledWith("x=1 y=2"); + } finally { + spy.mockRestore(); + } + }); + + it("debug/log: pulls placeholders from a `message` object's keys", async () => { + const spy = vi.spyOn(console, "log").mockImplementation(() => {}); + try { + const rt = await makeRuntime([ + { id: "start", type: "SceneReadyEvent", signalTargets: { out: [{ blockId: "log", socket: "in" }] } }, + { + id: "log", + type: "ConsoleLog", + config: { messageTemplate: "pos={x},{y},{z}" }, + dataDefaults: { message: { x: 1, y: 2, z: 3 } as unknown as FgValue }, + }, + ]); + startFlowGraph(rt); + expect(spy).toHaveBeenCalledWith("pos=1,2,3"); + } finally { + spy.mockRestore(); + } + }); +}); diff --git a/tests/lite/unit/flow-graph-gltf-parser.test.ts b/tests/lite/unit/flow-graph-gltf-parser.test.ts index 72135fd014..701480f658 100644 --- a/tests/lite/unit/flow-graph-gltf-parser.test.ts +++ b/tests/lite/unit/flow-graph-gltf-parser.test.ts @@ -194,3 +194,21 @@ describe("KHR_interactivity parser — pointer templating & new ops", () => { // Silence the ConsoleLog block's console.log in the end-to-end run. vi.spyOn(console, "log").mockImplementation(() => {}); + +// ───────────────────────────────────────────────────────────────────────────── +// Coverage guard: every mapped glTF op must resolve to a registered block def. +// Prevents adding an op mapping without wiring its block into the registry. +// ───────────────────────────────────────────────────────────────────────────── + +describe("declaration-mapper — block coverage", () => { + it("every mapped block type resolves to a registered, type-matching def", async () => { + const { allMappedBlockTypes } = await import("../../../packages/babylon-lite/src/flow-graph/gltf/declaration-mapper"); + const { getBlockDef } = await import("../../../packages/babylon-lite/src/flow-graph/index"); + for (const type of allMappedBlockTypes()) { + const factory = getBlockDef(type); + expect(factory, `no registry entry for mapped block type "${type}"`).toBeTruthy(); + const def = await factory!(); + expect(def.type).toBe(type); + } + }); +}); From 4d101a3f136a2db4b98af36450d257b56feaa322 Mon Sep 17 00:00:00 2001 From: Raanan Weber Date: Wed, 24 Jun 2026 21:42:43 +0200 Subject: [PATCH 13/13] build(flow-graph): regenerate bundle manifest for Phase 4a op mapper Only the inert gltf-feature-registry chunk hash changes across 48 glTF scenes (it lazily references the flow-graph block graph, which gained the QuaternionMultiplication block + ConsoleLog/StopAnimation edits). No rendering chunk changed; all 198 bundle-size ceilings pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- lab/public/bundle/manifest.json | 108 ++++++++++++++++---------------- 1 file changed, 54 insertions(+), 54 deletions(-) diff --git a/lab/public/bundle/manifest.json b/lab/public/bundle/manifest.json index 6d6befb70e..a85349bf04 100644 --- a/lab/public/bundle/manifest.json +++ b/lab/public/bundle/manifest.json @@ -68,7 +68,7 @@ "scene5-gltf-color-normalize-BtnJk1yq.js", "scene5-gltf-feature-animations-NJC85MBJ.js", "scene5-gltf-feature-morph-BNcyLEaQ.js", - "scene5-gltf-feature-registry-_5DT5FoO.js", + "scene5-gltf-feature-registry-DfOei33V.js", "scene5-gltf-feature-skeleton-Siixi_P0.js", "scene5-gltf-json-asset-DS0i23k1.js", "scene5-morph-fragment-SUVkfdAM.js", @@ -107,7 +107,7 @@ "scene7-gltf-animation-B7Xr33me.js", "scene7-gltf-feature-animations-DNqmTY-c.js", "scene7-gltf-feature-extras-VHPteGay.js", - "scene7-gltf-feature-registry-BvQc5lz0.js", + "scene7-gltf-feature-registry-BnU2J8EP.js", "scene7-gltf-feature-skeleton-BCWZyzWC.js", "scene7-gltf-json-asset-CAp-SN2V.js", "scene7-ibl-fragment-CeRrvT96.js", @@ -173,7 +173,7 @@ "scene11-gltf-ext-spec-gloss-D60sFZYX.js", "scene11-gltf-feature-animations-CmHJNYiV.js", "scene11-gltf-feature-extras-VHPteGay.js", - "scene11-gltf-feature-registry-BK2fq-aN.js", + "scene11-gltf-feature-registry-a7ll1ICi.js", "scene11-gltf-feature-skeleton-CrXfHDG6.js", "scene11-gltf-glb-parser-B0CzN8nR.js", "scene11-gltf-sampler-desc-DP9TFn1W.js", @@ -192,7 +192,7 @@ "scene12-generate-mipmaps-Bsp4UQ3D.js", "scene12-gltf-animation-BDKbEYQd.js", "scene12-gltf-feature-animations-BFGZaHvm.js", - "scene12-gltf-feature-registry-B5462gW5.js", + "scene12-gltf-feature-registry-D4uNB6sD.js", "scene12-gltf-feature-skeleton-CN1CorcX.js", "scene12-gltf-glb-parser-BrsOlymf.js", "scene12-ibl-fragment-CeRrvT96.js", @@ -224,7 +224,7 @@ }, "scene14": { "rawKB": 88.7, - "gzipKB": 36.9, + "gzipKB": 37, "ignoredRawKB": 0, "runtimeChunks": [ "scene14-background-dds-skybox-D8l6lgM7.js", @@ -435,7 +435,7 @@ "runtimeChunks": [ "scene27-generate-mipmaps-bqbQDZJl.js", "scene27-gltf-ext-dielectric-C6hvXXiF.js", - "scene27-gltf-feature-registry-jUkTs8TS.js", + "scene27-gltf-feature-registry-B5rFsSXl.js", "scene27-gltf-feature-variants-D5VxGN7_.js", "scene27-gltf-glb-parser-By8noE3G.js", "scene27-gltf-pbr-builder-ext-BvS-rcCP.js", @@ -455,7 +455,7 @@ "scene28-clearcoat-fragment-AiyWBFX1.js", "scene28-generate-mipmaps-7w1hCgCw.js", "scene28-gltf-ext-clearcoat-BgaLgSgD.js", - "scene28-gltf-feature-registry-vfc93Ul-.js", + "scene28-gltf-feature-registry-LeObX4lm.js", "scene28-gltf-json-asset-DNaJyx0P.js", "scene28-ibl-fragment-CeRrvT96.js", "scene28-pbr-renderable-eX7eFIi2.js", @@ -472,7 +472,7 @@ "scene29-generate-mipmaps-DJCYSY1_.js", "scene29-gltf-ext-sheen-Dv23b_3T.js", "scene29-gltf-ext-uv-transform-tUSEOqA7.js", - "scene29-gltf-feature-registry-hOmU7_Sw.js", + "scene29-gltf-feature-registry-D_dLqX6E.js", "scene29-gltf-json-asset-EOtWL8g4.js", "scene29-gltf-pbr-builder-ext-CiV9PuhY.js", "scene29-ibl-fragment-CeRrvT96.js", @@ -496,7 +496,7 @@ "scene30-gltf-ext-dielectric-C6hvXXiF.js", "scene30-gltf-ext-uv-transform-DQN5DAiE.js", "scene30-gltf-feature-draco-BSbw1ZBU.js", - "scene30-gltf-feature-registry-C27hv4YD.js", + "scene30-gltf-feature-registry-DOa8b0AB.js", "scene30-gltf-glb-parser-DJ0cTJ-4.js", "scene30-gltf-pbr-builder-ext-pNz5pvxP.js", "scene30-ibl-fragment-CeRrvT96.js", @@ -519,7 +519,7 @@ "scene31-emissive-fragment-C1TNSo0w.js", "scene31-generate-mipmaps-CoCbB-UD.js", "scene31-gltf-ext-emissive-strength-CButLZnK.js", - "scene31-gltf-feature-registry-9VDR-B_R.js", + "scene31-gltf-feature-registry-BVpcVQGo.js", "scene31-gltf-glb-parser-CzRZVo57.js", "scene31-ibl-fragment-CeRrvT96.js", "scene31-pbr-renderable-DBEVLcPa.js", @@ -535,7 +535,7 @@ "runtimeChunks": [ "scene32-generate-mipmaps-DdnhjgK3.js", "scene32-gltf-ext-unlit-1vUYfF7v.js", - "scene32-gltf-feature-registry-OzSd1WXD.js", + "scene32-gltf-feature-registry-C65sQZbK.js", "scene32-gltf-glb-parser-BX2AS-bF.js", "scene32-ibl-fragment-CeRrvT96.js", "scene32-pbr-renderable-UXm0NIAX.js", @@ -553,7 +553,7 @@ "scene33-generate-mipmaps-Z_0Gnbub.js", "scene33-gltf-ext-dielectric-C6hvXXiF.js", "scene33-gltf-feature-lights-punctual-B3W8Lfux.js", - "scene33-gltf-feature-registry-D4s0gD8X.js", + "scene33-gltf-feature-registry-CuyZ5EuV.js", "scene33-gltf-glb-parser-DMBUHtjv.js", "scene33-gltf-light-pointer-state-B7kFTRxK.js", "scene33-gltf-sampler-desc-ChMUJ3dG.js", @@ -580,7 +580,7 @@ "scene34-gltf-ext-node-visibility-CyR_MQR5.js", "scene34-gltf-feature-animation-pointer-rAfd1hLG.js", "scene34-gltf-feature-animations-Bl_MxMv-.js", - "scene34-gltf-feature-registry-D62J6fVc.js", + "scene34-gltf-feature-registry-C_-XttLH.js", "scene34-gltf-glb-parser-BxoFTGKn.js", "scene34-ibl-fragment-CeRrvT96.js", "scene34-pbr-renderable-BmEHhHi_.js", @@ -597,7 +597,7 @@ "runtimeChunks": [ "scene35-generate-mipmaps-Dw2dswCB.js", "scene35-gltf-feature-gpu-instancing-RMojEpZv.js", - "scene35-gltf-feature-registry-CzHQY-Hc.js", + "scene35-gltf-feature-registry-f-legoXu.js", "scene35-gltf-glb-parser-BJyme4Vk.js", "scene35-ibl-fragment-CeRrvT96.js", "scene35-pbr-renderable-CM5qYb7h.js", @@ -629,7 +629,7 @@ "scene37-gltf-ext-dielectric-C6hvXXiF.js", "scene37-gltf-ext-sheen-Dv23b_3T.js", "scene37-gltf-ext-uv-transform-hVTzf5Q9.js", - "scene37-gltf-feature-registry-Dlwg9yLI.js", + "scene37-gltf-feature-registry-fIkQ1EVx.js", "scene37-gltf-glb-parser-CkbGcOCI.js", "scene37-gltf-pbr-builder-ext-BweVn8Hl.js", "scene37-ibl-fragment-CeRrvT96.js", @@ -669,7 +669,7 @@ "scene39-gltf-feature-animation-pointer-BOWPlTMd.js", "scene39-gltf-feature-animations-BdsovlyG.js", "scene39-gltf-feature-lights-punctual-CM09I-Ul.js", - "scene39-gltf-feature-registry-BIGqGo9B.js", + "scene39-gltf-feature-registry-B8ig8ll3.js", "scene39-gltf-json-asset-CnK_Yal2.js", "scene39-gltf-light-pointer-state-B7kFTRxK.js", "scene39-gltf-pbr-builder-ext-BVnHLdY7.js", @@ -698,7 +698,7 @@ "scene99-generate-mipmaps-DGydlezW.js", "scene99-gltf-animation-CLRicPbx.js", "scene99-gltf-feature-animations-BknhhNc3.js", - "scene99-gltf-feature-registry-B7Nk4ze3.js", + "scene99-gltf-feature-registry-B3LcBATD.js", "scene99-gltf-feature-skeleton-DAg3sIKL.js", "scene99-gltf-glb-parser-BtneRupN.js", "scene99-multilight-wgsl-PWSzw1Ef.js", @@ -720,12 +720,12 @@ }, "scene41": { "rawKB": 92, - "gzipKB": 36.5, + "gzipKB": 36.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene41-generate-mipmaps-BWxJCIcc.js", "scene41-gltf-ext-spec-gloss-D60sFZYX.js", - "scene41-gltf-feature-registry-BOAnuBc1.js", + "scene41-gltf-feature-registry-b3wRMyaT.js", "scene41-gltf-glb-parser-CkOP9avo.js", "scene41-gltf-sampler-desc-E_7RaQlV.js", "scene41-point-light-CnkkP9oB.js", @@ -789,12 +789,12 @@ }, "scene47": { "rawKB": 91.2, - "gzipKB": 36.4, + "gzipKB": 36.5, "ignoredRawKB": 0, "runtimeChunks": [ "scene47-generate-mipmaps-CmIGpFd5.js", "scene47-gltf-ext-spec-gloss-D60sFZYX.js", - "scene47-gltf-feature-registry-CHSNRxvG.js", + "scene47-gltf-feature-registry-HOC_06Wd.js", "scene47-gltf-glb-parser-6-tsF2C2.js", "scene47-gltf-sampler-desc-BJMmnJDF.js", "scene47-shader-composer-CgJmQyJj.js", @@ -1223,7 +1223,7 @@ "scene73-fragment-output-CfRmfbPv.js", "scene73-generate-mipmaps-DcnO72FN.js", "scene73-gltf-ext-clearcoat-BgaLgSgD.js", - "scene73-gltf-feature-registry-6SgsE2Gt.js", + "scene73-gltf-feature-registry-DwxnV9OK.js", "scene73-gltf-glb-parser-Bm1IrZjT.js", "scene73-ibl-fragment-CeRrvT96.js", "scene73-input-block-lrbZBZJO.js", @@ -1743,7 +1743,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene104-generate-mipmaps-BGv6wRC-.js", - "scene104-gltf-feature-registry-CcotYfmb.js", + "scene104-gltf-feature-registry-4t7-jinb.js", "scene104-gltf-glb-parser-BJfNq64D.js", "scene104-shader-composer-CgJmQyJj.js", "scene104-standard-renderable-BYZDGzK-.js", @@ -1758,7 +1758,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene105-generate-mipmaps-Bw7xZIhD.js", - "scene105-gltf-feature-registry-Bsnwpi1i.js", + "scene105-gltf-feature-registry-Djs0y_aK.js", "scene105-gltf-glb-parser-BsWC1iTB.js", "scene105-shader-composer-CgJmQyJj.js", "scene105-standard-renderable-wWJPvbnz.js", @@ -1822,7 +1822,7 @@ }, "scene112": { "rawKB": 119, - "gzipKB": 48.3, + "gzipKB": 48.2, "ignoredRawKB": 0, "runtimeChunks": [ "scene112-background-dds-skybox-CBVfRJkx.js", @@ -1831,7 +1831,7 @@ "scene112-generate-mipmaps-r2o5vX6L.js", "scene112-gltf-ext-basisu-CRSWpXls.js", "scene112-gltf-ext-dielectric-C6hvXXiF.js", - "scene112-gltf-feature-registry-DfGapbqE.js", + "scene112-gltf-feature-registry-rj3PvtiF.js", "scene112-gltf-json-asset-CBZ_Aalp.js", "scene112-ibl-fragment-CeRrvT96.js", "scene112-pbr-refraction-gMVc2VQg.js", @@ -1880,7 +1880,7 @@ "scene115-gltf-color-normalize-BtnJk1yq.js", "scene115-gltf-feature-animations-Do6kXVEc.js", "scene115-gltf-feature-morph-DLWJRlR1.js", - "scene115-gltf-feature-registry-DOSw4opn.js", + "scene115-gltf-feature-registry-DxZaaSaT.js", "scene115-gltf-feature-skeleton-8Oys0O0p.js", "scene115-gltf-json-asset-D9q5e9Ta.js", "scene115-morph-fragment-DQefd8aW.js", @@ -2111,7 +2111,7 @@ "scene144-gltf-ext-spec-gloss-D60sFZYX.js", "scene144-gltf-feature-animations-Bud5JgI9.js", "scene144-gltf-feature-extras-VHPteGay.js", - "scene144-gltf-feature-registry-bhfEPzHG.js", + "scene144-gltf-feature-registry-uUxlsXJ7.js", "scene144-gltf-feature-skeleton-Dq3GN8sP.js", "scene144-gltf-glb-parser-CXf6hcyj.js", "scene144-gltf-pbr-builder-ext-pRXV-A0d.js", @@ -2182,7 +2182,7 @@ "scene147-directional-light-CwjabfgT.js", "scene147-generate-mipmaps-BfjMA7hX.js", "scene147-gltf-feature-lights-punctual-DdmW_Vp5.js", - "scene147-gltf-feature-registry-a5-CPjZi.js", + "scene147-gltf-feature-registry-D4h0oKKP.js", "scene147-gltf-glb-parser-BPCGAatE.js", "scene147-gltf-light-pointer-state-B7kFTRxK.js", "scene147-multilight-wgsl-CLgjeQ_G.js", @@ -2201,7 +2201,7 @@ "scene148-directional-light-DQDzxnQb.js", "scene148-generate-mipmaps-LgSJe-aH.js", "scene148-gltf-feature-lights-punctual-BLCC9HwV.js", - "scene148-gltf-feature-registry-pRGBNIs2.js", + "scene148-gltf-feature-registry-Bj2x7Jh0.js", "scene148-gltf-glb-parser-B33Edg7S.js", "scene148-gltf-light-pointer-state-B7kFTRxK.js", "scene148-pbr-geometry-view-CjV4zRl7.js", @@ -2223,7 +2223,7 @@ "scene149-generate-mipmaps-D6ALG8gN.js", "scene149-geometry-texture-output-BfeQftmX.js", "scene149-gltf-feature-lights-punctual-w2wC-7RK.js", - "scene149-gltf-feature-registry-srFjBMzZ.js", + "scene149-gltf-feature-registry-Be-9VsBW.js", "scene149-gltf-glb-parser-Cwf9MN9N.js", "scene149-gltf-light-pointer-state-B7kFTRxK.js", "scene149-input-block-DAEnTkZz.js", @@ -2268,7 +2268,7 @@ "scene152-gltf-ext-spec-gloss-D60sFZYX.js", "scene152-gltf-feature-animations-DtfqqyNl.js", "scene152-gltf-feature-extras-VHPteGay.js", - "scene152-gltf-feature-registry-B-6ccq2s.js", + "scene152-gltf-feature-registry-CTdXDF3L.js", "scene152-gltf-feature-skeleton-DdNk7nTu.js", "scene152-gltf-glb-parser-Dr_B2hXm.js", "scene152-gltf-sampler-desc-D0Q2VM93.js", @@ -2325,7 +2325,7 @@ "scene157-generate-mipmaps-CSgsFZsy.js", "scene157-gltf-animation-97jnT3rB.js", "scene157-gltf-feature-animations-3TPbmuLQ.js", - "scene157-gltf-feature-registry-CE_Ovhf9.js", + "scene157-gltf-feature-registry-MqLl8-FA.js", "scene157-gltf-feature-skeleton-sqEIM232.js", "scene157-gltf-glb-parser-DZ4Xgxsa.js", "scene157-multilight-wgsl-DMQZ6dS_.js", @@ -2343,7 +2343,7 @@ "scene158-generate-mipmaps-ONVnFwM1.js", "scene158-gltf-animation-D36FWf_9.js", "scene158-gltf-feature-animations-DfL_qlI0.js", - "scene158-gltf-feature-registry-D0z4K601.js", + "scene158-gltf-feature-registry-DHqG8Tw1.js", "scene158-gltf-feature-skeleton-BQO9mRtS.js", "scene158-gltf-glb-parser-BhqojsL9.js", "scene158-multilight-wgsl-DhVJV_xa.js", @@ -2409,7 +2409,7 @@ "scene164-gltf-color-normalize-BtnJk1yq.js", "scene164-gltf-feature-animations-DDqOp9Eq.js", "scene164-gltf-feature-morph-Dcma2yce.js", - "scene164-gltf-feature-registry-rcHjt908.js", + "scene164-gltf-feature-registry-ButWyLn5.js", "scene164-gltf-feature-skeleton-DOpy65Ao.js", "scene164-gltf-json-asset-BCxbuHbB.js", "scene164-morph-fragment-BrDXuWr6.js", @@ -2514,13 +2514,13 @@ }, "scene176": { "rawKB": 102.4, - "gzipKB": 41.2, + "gzipKB": 41.1, "ignoredRawKB": 0, "runtimeChunks": [ "scene176-generate-mipmaps-Dse5kXpK.js", "scene176-gltf-ext-dielectric-C6hvXXiF.js", "scene176-gltf-feature-extras-VHPteGay.js", - "scene176-gltf-feature-registry-BHxB0k8Y.js", + "scene176-gltf-feature-registry-7Bthuiau.js", "scene176-gltf-json-asset-CVMNQwdq.js", "scene176-ibl-fragment-CeRrvT96.js", "scene176-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2554,7 +2554,7 @@ "runtimeChunks": [ "scene178-generate-mipmaps-MoaS2Mzr.js", "scene178-gltf-ext-iridescence-b4LVniAM.js", - "scene178-gltf-feature-registry-YJ5vGCnH.js", + "scene178-gltf-feature-registry-6UwuYjyI.js", "scene178-gltf-glb-parser-d5msxooD.js", "scene178-ibl-fragment-CeRrvT96.js", "scene178-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2726,7 +2726,7 @@ "ignoredRawKB": 0, "runtimeChunks": [ "scene210-generate-mipmaps-BhUML67h.js", - "scene210-gltf-feature-registry-Dr6wU7WQ.js", + "scene210-gltf-feature-registry-UUWEG4w5.js", "scene210-gltf-feature-xmp-S8Tl-XNQ.js", "scene210-gltf-glb-parser-fJOQf1ny.js", "scene210-gltf-interleave-fvR_nHHs.js", @@ -2747,7 +2747,7 @@ "scene211-gltf-ext-quantization-Do-ofjB-.js", "scene211-gltf-feature-animations-CTZOLIzx.js", "scene211-gltf-feature-meshopt-Dt65KW5n.js", - "scene211-gltf-feature-registry-KnmTT4TG.js", + "scene211-gltf-feature-registry-BoQfoj_n.js", "scene211-gltf-feature-skeleton-C5YXdC68.js", "scene211-gltf-json-asset-_1B5yK0t.js", "scene211-gltf-multi-buffer-Cwm5u1Qq.js", @@ -2764,7 +2764,7 @@ "runtimeChunks": [ "scene212-generate-mipmaps-BA4GCk3y.js", "scene212-gltf-ext-dielectric-C6hvXXiF.js", - "scene212-gltf-feature-registry-BBvG5RdZ.js", + "scene212-gltf-feature-registry-DhJBJp9H.js", "scene212-gltf-glb-parser-DpbXuAuC.js", "scene212-ibl-fragment-CeRrvT96.js", "scene212-ibl-skybox-wgsl-CFIBOHHx.js", @@ -2851,7 +2851,7 @@ "scene218-gltf-ext-spec-gloss-D60sFZYX.js", "scene218-gltf-feature-animations-BhunLZUh.js", "scene218-gltf-feature-extras-VHPteGay.js", - "scene218-gltf-feature-registry-BcNKTtcL.js", + "scene218-gltf-feature-registry-B8LVL3Gw.js", "scene218-gltf-feature-skeleton-CuQWo93o.js", "scene218-gltf-glb-parser-BXHcqEF1.js", "scene218-gltf-sampler-desc-CS2bAJuk.js", @@ -2871,7 +2871,7 @@ "scene219-gltf-ext-spec-gloss-D60sFZYX.js", "scene219-gltf-feature-animations-7TJPdKpt.js", "scene219-gltf-feature-extras-VHPteGay.js", - "scene219-gltf-feature-registry-BpdMkjop.js", + "scene219-gltf-feature-registry-D-nL4k2x.js", "scene219-gltf-feature-skeleton-QiTS1ubb.js", "scene219-gltf-glb-parser-PDyH09Yg.js", "scene219-gltf-sampler-desc-CKWNJQQv.js", @@ -2984,7 +2984,7 @@ "scene240-generate-mipmaps-BQZ9ivTX.js", "scene240-gltf-animation-BKjmZpR3.js", "scene240-gltf-feature-animations-hHnIQ4Bv.js", - "scene240-gltf-feature-registry-K1plHaQL.js", + "scene240-gltf-feature-registry-DjvCYRLY.js", "scene240-gltf-json-asset-wZq70j5q.js", "scene240-gltf-multi-buffer-Cwm5u1Qq.js", "scene240-gltf-normals-DYhLwXNX.js", @@ -3019,7 +3019,7 @@ "scene241-gltf-feature-animation-pointer-CepPGaOM.js", "scene241-gltf-feature-animations-CJigVEWA.js", "scene241-gltf-feature-lights-punctual-DjeruV0x.js", - "scene241-gltf-feature-registry-CkN9RmeI.js", + "scene241-gltf-feature-registry-Ckb428t_.js", "scene241-gltf-json-asset-BI5mxnCG.js", "scene241-gltf-light-pointer-state-B7kFTRxK.js", "scene241-gltf-pbr-builder-ext-BK6naJUT.js", @@ -3057,7 +3057,7 @@ "scene242-gltf-ext-emissive-strength-CButLZnK.js", "scene242-gltf-feature-animation-pointer-DuUn5-xJ.js", "scene242-gltf-feature-animations-BvTxdDNR.js", - "scene242-gltf-feature-registry-BoIeBdL4.js", + "scene242-gltf-feature-registry-CW6xKIgS.js", "scene242-gltf-json-asset-CTUWQBxV.js", "scene242-ibl-fragment-CeRrvT96.js", "scene242-pbr-renderable-CmvfRP8M.js", @@ -3078,7 +3078,7 @@ "scene243-gltf-feature-animations-C5TP9MXt.js", "scene243-gltf-feature-extras-VHPteGay.js", "scene243-gltf-feature-morph-BCUQi4W_.js", - "scene243-gltf-feature-registry-22kVPIi6.js", + "scene243-gltf-feature-registry-C23yalDf.js", "scene243-gltf-json-asset-CnDTTIDf.js", "scene243-gltf-pbr-builder-ext-DSRj0KRz.js", "scene243-ibl-fragment-CeRrvT96.js", @@ -3093,7 +3093,7 @@ }, "scene244": { "rawKB": 132.2, - "gzipKB": 53.7, + "gzipKB": 53.6, "ignoredRawKB": 0, "runtimeChunks": [ "scene244-animation-pointer-ext-CoOxzYYy.js", @@ -3106,7 +3106,7 @@ "scene244-gltf-ext-uv-transform-YGWG8v_J.js", "scene244-gltf-feature-animation-pointer-Cv2YzJgj.js", "scene244-gltf-feature-animations-DmXCvx5H.js", - "scene244-gltf-feature-registry-BhL6FR73.js", + "scene244-gltf-feature-registry-DZB2Rivj.js", "scene244-gltf-json-asset-DaKe4-Lc.js", "scene244-gltf-pbr-builder-ext-Bi8wmQmz.js", "scene244-ibl-fragment-CeRrvT96.js", @@ -3133,7 +3133,7 @@ "scene245-generate-mipmaps-WM6bVf2v.js", "scene245-gltf-animation-Dvm46y_g.js", "scene245-gltf-feature-animations-B19wAXO_.js", - "scene245-gltf-feature-registry-D6WbLPzH.js", + "scene245-gltf-feature-registry-ComvNA2d.js", "scene245-gltf-feature-skeleton-IRWJQHYY.js", "scene245-gltf-interleave-D58ra88P.js", "scene245-gltf-json-asset-BtsXM9cU.js", @@ -3158,7 +3158,7 @@ "scene246-generate-mipmaps-DzKvtUax.js", "scene246-gltf-animation-DGsaicDt.js", "scene246-gltf-feature-animations-CPl_ISPs.js", - "scene246-gltf-feature-registry-C0jyX5bF.js", + "scene246-gltf-feature-registry-Dd-Cl0OW.js", "scene246-gltf-feature-skeleton-Bf1KbRoN.js", "scene246-gltf-interleave-BhCGfTMm.js", "scene246-gltf-json-asset-DZ_iAA05.js", @@ -3181,7 +3181,7 @@ "scene247-generate-mipmaps-Crazqgzv.js", "scene247-gltf-feature-extras-VHPteGay.js", "scene247-gltf-feature-gpu-instancing-Ctn1z3Jy.js", - "scene247-gltf-feature-registry-7cX4fW5H.js", + "scene247-gltf-feature-registry-D_YBbigE.js", "scene247-gltf-json-asset-nLezCZiO.js", "scene247-gltf-multi-buffer-Cwm5u1Qq.js", "scene247-ibl-fragment-CeRrvT96.js", @@ -3234,7 +3234,7 @@ "scene251-generate-mipmaps-ojYQxP8q.js", "scene251-gltf-animation-BJ2pOO_r.js", "scene251-gltf-feature-animations-Cj7oKyXf.js", - "scene251-gltf-feature-registry-DfsBNKUg.js", + "scene251-gltf-feature-registry-DlOXiKU4.js", "scene251-gltf-feature-skeleton-Dd5Pe1-h.js", "scene251-gltf-glb-parser-8AD91ACR.js", "scene251-multilight-wgsl-Cxg2lDtv.js", @@ -3281,7 +3281,7 @@ "scene253-gltf-feature-extras-VHPteGay.js", "scene253-gltf-feature-lights-punctual-B0T8d3mz.js", "scene253-gltf-feature-morph-OgvZWqfo.js", - "scene253-gltf-feature-registry-Q0Dxo0gu.js", + "scene253-gltf-feature-registry-CX0KDP3N.js", "scene253-gltf-feature-skeleton-Bjigd6Ok.js", "scene253-gltf-json-asset-CQyVogeZ.js", "scene253-gltf-light-pointer-state-B7kFTRxK.js",