@skenora/runtime 0.1.2

package/dist/projection/shape-factory.js

@@ -0,0 +1,101 @@
+/** Projects serializable shapes into owned Babylon meshes. */
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial";
+import { Color3 } from "@babylonjs/core/Maths/math.color";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { MeshBuilder } from "@babylonjs/core/Meshes/meshBuilder";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
+import { closePolyline } from "@skenora/geometry";
+import earcut from "earcut";
+import { applyTransform } from "./model-importer.js";
+export function createShapeEntity(scene, entity) {
+    const config = (entity.properties ?? {});
+    const points = validPoints(config.points);
+    const group = new TransformNode(entity.id, scene);
+    group.metadata = { skenora: { entityId: entity.id, generated: "shape" } };
+    applyTransform(group, entity.transform);
+    group.setEnabled(entity.enabled && entity.visible);
+    if (config.shape === "box") {
+        const box = MeshBuilder.CreateBox(`${entity.id}-box`, {
+            width: finite(config.width, 1),
+            height: finite(config.height, 1),
+            depth: finite(config.depth, 1),
+        }, scene);
+        box.material = createSurfaceMaterial(scene, entity.id, config);
+        box.parent = group;
+    }
+    else if (config.shape === "tube" && points.length >= 2) {
+        const tubePoints = config.closed ? closePolyline(points) : points;
+        const tube = MeshBuilder.CreateTube(`${entity.id}-tube`, {
+            path: tubePoints.map(toVector),
+            radius: finite(config.tubeRadius, 0.05),
+            tessellation: Math.max(3, Math.round(finite(config.segments, 8))),
+            cap: Mesh.CAP_ALL,
+        }, scene);
+        tube.material = createSurfaceMaterial(scene, entity.id, config);
+        tube.parent = group;
+    }
+    else if (config.shape === "wall" && points.length >= 2) {
+        const bottom = points.map(toVector);
+        const height = finite(config.wallHeight, 1);
+        const top = bottom.map((point) => point.add(new Vector3(0, height, 0)));
+        const wall = MeshBuilder.CreateRibbon(`${entity.id}-wall`, {
+            pathArray: [bottom, top],
+            closePath: config.closed ?? false,
+            sideOrientation: Mesh.DOUBLESIDE,
+        }, scene);
+        wall.material = createSurfaceMaterial(scene, entity.id, config);
+        wall.parent = group;
+    }
+    else if (config.shape !== "polyline" && points.length >= 3) {
+        const fill = MeshBuilder.CreatePolygon(`${entity.id}-fill`, { shape: points.map(toVector) }, scene, earcut);
+        fill.material = createSurfaceMaterial(scene, entity.id, config);
+        fill.parent = group;
+    }
+    const showStroke = config.shape !== "box" &&
+        config.shape !== "tube" &&
+        config.shape !== "wall";
+    const linePoints = config.closed === false ? points : closePolyline(points);
+    if (showStroke && linePoints.length >= 2) {
+        const line = MeshBuilder.CreateLines(`${entity.id}-stroke`, { points: linePoints.map(toVector), updatable: false }, scene);
+        line.color = toColor(config.strokeColor, { r: 0.3, g: 0.7, b: 1 });
+        line.parent = group;
+    }
+    return group;
+}
+function createSurfaceMaterial(scene, entityId, config) {
+    const material = new PBRMaterial(`${entityId}-surface-material`, scene);
+    material.albedoColor = toColor(config.fillColor, {
+        r: 0.2,
+        g: 0.55,
+        b: 1,
+    });
+    material.alpha = finite(config.fillAlpha, 0.35);
+    material.metallic = 0;
+    material.roughness = 0.8;
+    material.backFaceCulling = false;
+    return material;
+}
+function validPoints(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((point) => {
+        if (!point || typeof point !== "object")
+            return [];
+        const item = point;
+        if (![item.x, item.y, item.z].every(Number.isFinite))
+            return [];
+        return [{ x: item.x, y: item.y, z: item.z }];
+    });
+}
+function toVector(value) {
+    return new Vector3(value.x, value.y, value.z);
+}
+function toColor(value, fallback) {
+    const color = (value ?? fallback);
+    return new Color3(finite(color.r, fallback.r), finite(color.g, fallback.g), finite(color.b, fallback.b));
+}
+function finite(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+//# sourceMappingURL=shape-factory.js.map

package/dist/projection/shape-factory.js.map

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

package/dist/projection-entry.d.ts

@@ -0,0 +1,10 @@
+export * from "./core/runtime-session.js";
+export * from "./core/runtime-capability-registry.js";
+export { RuntimeDocumentCoordinator, type RuntimeDocumentProjectionContext, type RuntimeDocumentProjector, } from "./core/runtime-document-coordinator.js";
+export * from "./projection/entity-projection-registry.js";
+export { MaterialProjectionError } from "./systems/material-slots.js";
+export type { AnnotationProjection } from "./projection/annotation-projector.js";
+export { PARTICLE_PLAYBACK_CAPABILITY, type ParticlePlaybackCapability, } from "./projection/particle-capability.js";
+export type { CameraPathPlaybackOptions, CameraPathPlaybackState, } from "./systems/camera-path-controller.js";
+export { SkyboxController } from "./systems/skybox-controller.js";
+//# sourceMappingURL=projection-entry.d.ts.map

package/dist/projection-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-entry.d.ts","sourceRoot":"","sources":["../src/projection-entry.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AACnD,OAAO,EACL,0BAA0B,EAC1B,KAAK,gCAAgC,EACrC,KAAK,wBAAwB,GAC9B,MAAM,qCAAqC,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EACL,4BAA4B,EAC5B,KAAK,0BAA0B,GAChC,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EACV,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/projection-entry.js

@@ -0,0 +1,8 @@
+export * from "./core/runtime-session.js";
+export * from "./core/runtime-capability-registry.js";
+export { RuntimeDocumentCoordinator, } from "./core/runtime-document-coordinator.js";
+export * from "./projection/entity-projection-registry.js";
+export { MaterialProjectionError } from "./systems/material-slots.js";
+export { PARTICLE_PLAYBACK_CAPABILITY, } from "./projection/particle-capability.js";
+export { SkyboxController } from "./systems/skybox-controller.js";
+//# sourceMappingURL=projection-entry.js.map

package/dist/projection-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-entry.js","sourceRoot":"","sources":["../src/projection-entry.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AACnD,OAAO,EACL,0BAA0B,GAG3B,MAAM,qCAAqC,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EACL,4BAA4B,GAE7B,MAAM,kCAAkC,CAAC;AAK1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/simulation/fixed-step-scheduler.d.ts

@@ -0,0 +1,13 @@
+export interface FixedStepAdvance {
+    readonly steps: number;
+    readonly interpolation: number;
+    readonly droppedMilliseconds: number;
+}
+/** Deterministic bounded scheduler shared by the physical backend and mock tests. */
+export declare class FixedStepScheduler {
+    #private;
+    constructor(stepMilliseconds: number, maxSubsteps: number);
+    advance(timestamp: number): FixedStepAdvance;
+    reset(timestamp?: number): void;
+}
+//# sourceMappingURL=fixed-step-scheduler.d.ts.map

package/dist/simulation/fixed-step-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-step-scheduler.d.ts","sourceRoot":"","sources":["../../src/simulation/fixed-step-scheduler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAED,qFAAqF;AACrF,qBAAa,kBAAkB;;gBAMjB,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IASzD,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB;IA6B5C,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;CAIhC"}

package/dist/simulation/fixed-step-scheduler.js

@@ -0,0 +1,45 @@
+/** Deterministic bounded scheduler shared by the physical backend and mock tests. */
+export class FixedStepScheduler {
+    #stepMilliseconds;
+    #maxSubsteps;
+    #lastTimestamp;
+    #accumulator = 0;
+    constructor(stepMilliseconds, maxSubsteps) {
+        if (!Number.isFinite(stepMilliseconds) || stepMilliseconds <= 0)
+            throw new Error("Fixed step must be positive");
+        if (!Number.isInteger(maxSubsteps) || maxSubsteps < 1)
+            throw new Error("maxSubsteps must be a positive integer");
+        this.#stepMilliseconds = stepMilliseconds;
+        this.#maxSubsteps = maxSubsteps;
+    }
+    advance(timestamp) {
+        if (!Number.isFinite(timestamp))
+            throw new Error("Timestamp must be finite");
+        if (this.#lastTimestamp === undefined) {
+            this.#lastTimestamp = timestamp;
+            return Object.freeze({
+                steps: 0,
+                interpolation: 0,
+                droppedMilliseconds: 0,
+            });
+        }
+        const elapsed = Math.max(0, timestamp - this.#lastTimestamp);
+        this.#lastTimestamp = timestamp;
+        const maximum = this.#stepMilliseconds * this.#maxSubsteps;
+        const accepted = Math.min(elapsed, maximum);
+        const droppedMilliseconds = elapsed - accepted;
+        this.#accumulator += accepted;
+        const steps = Math.min(Math.floor(this.#accumulator / this.#stepMilliseconds), this.#maxSubsteps);
+        this.#accumulator -= steps * this.#stepMilliseconds;
+        return Object.freeze({
+            steps,
+            interpolation: this.#accumulator / this.#stepMilliseconds,
+            droppedMilliseconds,
+        });
+    }
+    reset(timestamp) {
+        this.#lastTimestamp = timestamp;
+        this.#accumulator = 0;
+    }
+}
+//# sourceMappingURL=fixed-step-scheduler.js.map

package/dist/simulation/fixed-step-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-step-scheduler.js","sourceRoot":"","sources":["../../src/simulation/fixed-step-scheduler.ts"],"names":[],"mappings":"AAMA,qFAAqF;AACrF,MAAM,OAAO,kBAAkB;IACpB,iBAAiB,CAAS;IAC1B,YAAY,CAAS;IAC9B,cAAc,CAAqB;IACnC,YAAY,GAAG,CAAC,CAAC;IAEjB,YAAY,gBAAwB,EAAE,WAAmB;QACvD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,gBAAgB,IAAI,CAAC;YAC7D,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC5D,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED,OAAO,CAAC,SAAiB;QACvB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACtC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;YAChC,OAAO,MAAM,CAAC,MAAM,CAAC;gBACnB,KAAK,EAAE,CAAC;gBACR,aAAa,EAAE,CAAC;gBAChB,mBAAmB,EAAE,CAAC;aACvB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QAC7D,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,YAAY,CAAC;QAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5C,MAAM,mBAAmB,GAAG,OAAO,GAAG,QAAQ,CAAC;QAC/C,IAAI,CAAC,YAAY,IAAI,QAAQ,CAAC;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CACpB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,EACtD,IAAI,CAAC,YAAY,CAClB,CAAC;QACF,IAAI,CAAC,YAAY,IAAI,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACpD,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,KAAK;YACL,aAAa,EAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB;YACzD,mBAAmB;SACpB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,SAAkB;QACtB,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;IACxB,CAAC;CACF"}

package/dist/simulation/simulation-runtime-model.d.ts

@@ -0,0 +1,24 @@
+import type { CompiledSimulationProgram } from "@skenora/procedural";
+export type SimulationRuntimeStatus = "initializing" | "running" | "paused" | "lost" | "disposed";
+/** Device-free ownership model used by WebGPU execution and deterministic tests. */
+export declare class SimulationRuntimeModel {
+    #private;
+    constructor(program: CompiledSimulationProgram);
+    get status(): SimulationRuntimeStatus;
+    get currentIndex(): 0 | 1;
+    start(): void;
+    pause(): void;
+    completePass(): void;
+    completeFixedStep(): void;
+    reset(): void;
+    markDeviceLost(): void;
+    dispose(): void;
+    snapshot(): Readonly<{
+        status: SimulationRuntimeStatus;
+        resourceIds: readonly [string, string];
+        currentResourceId: string;
+        swaps: number;
+        fixedSteps: number;
+    }>;
+}
+//# sourceMappingURL=simulation-runtime-model.d.ts.map

package/dist/simulation/simulation-runtime-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-runtime-model.d.ts","sourceRoot":"","sources":["../../src/simulation/simulation-runtime-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAErE,MAAM,MAAM,uBAAuB,GACjC,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE9D,oFAAoF;AACpF,qBAAa,sBAAsB;;gBAOrB,OAAO,EAAE,yBAAyB;IAI9C,IAAI,MAAM,IAAI,uBAAuB,CAEpC;IAED,IAAI,YAAY,IAAI,CAAC,GAAG,CAAC,CAExB;IAED,KAAK,IAAI,IAAI;IAKb,KAAK,IAAI,IAAI;IAKb,YAAY,IAAI,IAAI;IAMpB,iBAAiB,IAAI,IAAI;IAKzB,KAAK,IAAI,IAAI;IAOb,cAAc,IAAI,IAAI;IAItB,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,QAAQ,CAAC;QACnB,MAAM,EAAE,uBAAuB,CAAC;QAChC,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,iBAAiB,EAAE,MAAM,CAAC;QAC1B,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CAcH"}

package/dist/simulation/simulation-runtime-model.js

@@ -0,0 +1,63 @@
+/** Device-free ownership model used by WebGPU execution and deterministic tests. */
+export class SimulationRuntimeModel {
+    #program;
+    #status = "initializing";
+    #currentIndex = 0;
+    #swaps = 0;
+    #fixedSteps = 0;
+    constructor(program) {
+        this.#program = program;
+    }
+    get status() {
+        return this.#status;
+    }
+    get currentIndex() {
+        return this.#currentIndex;
+    }
+    start() {
+        this.#assertAvailable();
+        this.#status = "running";
+    }
+    pause() {
+        this.#assertAvailable();
+        this.#status = "paused";
+    }
+    completePass() {
+        this.#assertAvailable();
+        this.#currentIndex = this.#currentIndex === 0 ? 1 : 0;
+        this.#swaps += 1;
+    }
+    completeFixedStep() {
+        this.#assertAvailable();
+        this.#fixedSteps += 1;
+    }
+    reset() {
+        this.#assertAvailable();
+        this.#currentIndex = 0;
+        this.#swaps = 0;
+        this.#fixedSteps = 0;
+    }
+    markDeviceLost() {
+        if (this.#status !== "disposed")
+            this.#status = "lost";
+    }
+    dispose() {
+        this.#status = "disposed";
+    }
+    snapshot() {
+        return Object.freeze({
+            status: this.#status,
+            resourceIds: this.#program.resourceIds,
+            currentResourceId: this.#program.resourceIds[this.#currentIndex],
+            swaps: this.#swaps,
+            fixedSteps: this.#fixedSteps,
+        });
+    }
+    #assertAvailable() {
+        if (this.#status === "lost")
+            throw new Error("Simulation device is lost");
+        if (this.#status === "disposed")
+            throw new Error("Simulation is disposed");
+    }
+}
+//# sourceMappingURL=simulation-runtime-model.js.map

package/dist/simulation/simulation-runtime-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-runtime-model.js","sourceRoot":"","sources":["../../src/simulation/simulation-runtime-model.ts"],"names":[],"mappings":"AAKA,oFAAoF;AACpF,MAAM,OAAO,sBAAsB;IACxB,QAAQ,CAA4B;IAC7C,OAAO,GAA4B,cAAc,CAAC;IAClD,aAAa,GAAU,CAAC,CAAC;IACzB,MAAM,GAAG,CAAC,CAAC;IACX,WAAW,GAAG,CAAC,CAAC;IAEhB,YAAY,OAAkC;QAC5C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;IAC3B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;IAC1B,CAAC;IAED,YAAY;QACV,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;IACnB,CAAC;IAED,iBAAiB;QACf,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;IACvB,CAAC;IAED,cAAc;QACZ,IAAI,IAAI,CAAC,OAAO,KAAK,UAAU;YAAE,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACzD,CAAC;IAED,OAAO;QACL,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;IAC5B,CAAC;IAED,QAAQ;QAON,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW;YACtC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC;YAChE,KAAK,EAAE,IAAI,CAAC,MAAM;YAClB,UAAU,EAAE,IAAI,CAAC,WAAW;SAC7B,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;QACd,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC1E,IAAI,IAAI,CAAC,OAAO,KAAK,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC7E,CAAC;CACF"}

package/dist/simulation/simulation-wgsl.d.ts

@@ -0,0 +1,3 @@
+import type { SimulationKernel } from "@skenora/contracts";
+export declare function createSimulationWgsl(kernel: SimulationKernel, workgroupSize: 8 | 16): string;
+//# sourceMappingURL=simulation-wgsl.d.ts.map

package/dist/simulation/simulation-wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-wgsl.d.ts","sourceRoot":"","sources":["../../src/simulation/simulation-wgsl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,EACxB,aAAa,EAAE,CAAC,GAAG,EAAE,GACpB,MAAM,CAER"}

package/dist/simulation/simulation-wgsl.js

@@ -0,0 +1,294 @@
+export function createSimulationWgsl(kernel, workgroupSize) {
+    return `${header(workgroupSize)}\n${kernel === "fluid-2d" ? fluid() : kernel === "fft-ocean" ? ocean() : radiance()}\n${renderer(kernel)}`;
+}
+function header(workgroupSize) {
+    return `
+struct Params {
+  width: u32,
+  height: u32,
+  passKind: u32,
+  iteration: u32,
+  dt: f32,
+  time: f32,
+  pointerX: f32,
+  pointerY: f32,
+  strength: f32,
+  param0: f32,
+  param1: f32,
+  param2: f32,
+  span: u32,
+  kernel: u32,
+  pad0: u32,
+  pad1: u32,
+};
+@group(0) @binding(0) var<uniform> p: Params;
+@group(0) @binding(1) var<storage, read> source: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read_write> outputState: array<vec4<f32>>;
+
+fn indexOf(x: u32, y: u32) -> u32 { return y * p.width + x; }
+fn clampX(x: i32) -> u32 { return u32(clamp(x, 0, i32(p.width) - 1)); }
+fn clampY(y: i32) -> u32 { return u32(clamp(y, 0, i32(p.height) - 1)); }
+fn readAt(x: i32, y: i32) -> vec4<f32> {
+  return source[indexOf(clampX(x), clampY(y))];
+}
+fn hash21(value: vec2<f32>) -> f32 {
+  let mixed = fract(value * vec2<f32>(123.34, 456.21));
+  return fract((mixed.x + mixed.y) * (mixed.x + mixed.y + 45.32));
+}
+@compute @workgroup_size(${workgroupSize}, ${workgroupSize}, 1)
+fn computeMain(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= p.width || gid.y >= p.height) { return; }
+  computeCell(gid.xy);
+}`;
+}
+function fluid() {
+    return `
+fn sampleNearest(uv: vec2<f32>) -> vec4<f32> {
+  let xy = vec2<i32>(clamp(uv, vec2<f32>(0.0), vec2<f32>(0.99999)) * vec2<f32>(f32(p.width), f32(p.height)));
+  return readAt(xy.x, xy.y);
+}
+fn computeCell(cell: vec2<u32>) {
+  let at = indexOf(cell.x, cell.y);
+  let xy = vec2<i32>(cell);
+  let uv = (vec2<f32>(cell) + 0.5) / vec2<f32>(f32(p.width), f32(p.height));
+  let current = source[at];
+  if (p.passKind == 0u) {
+    let delta = uv - vec2<f32>(p.pointerX, p.pointerY);
+    let pulse = exp(-dot(delta, delta) * 180.0);
+    let tangent = normalize(vec2<f32>(-delta.y, delta.x) + vec2<f32>(0.0001));
+    outputState[at] = vec4<f32>(
+      current.xy + tangent * pulse * p.strength * p.dt * 0.18,
+      min(4.0, current.z + pulse * p.strength * p.dt),
+      current.w
+    );
+  } else if (p.passKind == 1u) {
+    let previousUv = uv - current.xy * p.dt * 0.12;
+    let advected = sampleNearest(previousUv);
+    let laplacian = readAt(xy.x - 1, xy.y).xy + readAt(xy.x + 1, xy.y).xy +
+      readAt(xy.x, xy.y - 1).xy + readAt(xy.x, xy.y + 1).xy - 4.0 * advected.xy;
+    outputState[at] = vec4<f32>(
+      advected.xy + laplacian * p.param0 * p.dt,
+      advected.z * pow(p.param1, p.dt * 60.0),
+      advected.w
+    );
+  } else {
+    let left = readAt(xy.x - 1, xy.y);
+    let right = readAt(xy.x + 1, xy.y);
+    let down = readAt(xy.x, xy.y - 1);
+    let up = readAt(xy.x, xy.y + 1);
+    let divergence = 0.5 * ((right.x - left.x) + (up.y - down.y));
+    let pressure = (left.w + right.w + down.w + up.w - divergence) * 0.25;
+    let velocity = current.xy - 0.5 * vec2<f32>(right.w - left.w, up.w - down.w);
+    outputState[at] = vec4<f32>(velocity, current.z, pressure);
+  }
+}`;
+}
+function ocean() {
+    return `
+fn reverseBits(value: u32, size: u32) -> u32 {
+  var input = value;
+  var output = 0u;
+  var count = size;
+  loop {
+    if (count <= 1u) { break; }
+    output = (output << 1u) | (input & 1u);
+    input = input >> 1u;
+    count = count >> 1u;
+  }
+  return output;
+}
+fn complexMul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+  return vec2<f32>(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
+}
+fn butterfly(a: vec2<f32>, b: vec2<f32>, index: u32, span: u32, upper: bool) -> vec2<f32> {
+  let angle = 6.28318530718 * f32(index) / f32(span);
+  let rotated = complexMul(b, vec2<f32>(cos(angle), sin(angle)));
+  return select(a - rotated, a + rotated, upper);
+}
+fn computeCell(cell: vec2<u32>) {
+  let at = indexOf(cell.x, cell.y);
+  if (p.passKind == 10u) {
+    let centered = vec2<f32>(cell) - vec2<f32>(f32(p.width), f32(p.height)) * 0.5;
+    let centeredLength = length(centered);
+    let wave = max(centeredLength, 1.0);
+    let direction = dot(centered / wave, normalize(vec2<f32>(0.85, 0.35)));
+    let phillips = 400.0 * p.param1 * exp(-1.0 / max(0.001, wave * wave * p.param0 * 0.015)) *
+      direction * direction / max(1.0, wave * wave);
+    let randomPhase = hash21(vec2<f32>(cell)) * 6.28318530718;
+    let omega = sqrt(9.81 * wave * 0.08);
+    let phase = randomPhase + omega * p.time;
+    outputState[at] = vec4<f32>(cos(phase), sin(phase), 0.0, 0.0) * phillips;
+    return;
+  }
+  if (p.passKind == 11u) {
+    outputState[at] = source[indexOf(reverseBits(cell.x, p.width), cell.y)];
+    return;
+  }
+  if (p.passKind == 13u) {
+    outputState[at] = source[indexOf(cell.x, reverseBits(cell.y, p.height))];
+    return;
+  }
+  let span = p.span;
+  let half = span / 2u;
+  let coordinate = select(cell.y, cell.x, p.passKind == 12u);
+  let block = (coordinate / span) * span;
+  let local = coordinate % span;
+  let pair = local % half;
+  var firstIndex: u32;
+  var secondIndex: u32;
+  if (p.passKind == 12u) {
+    firstIndex = indexOf(block + pair, cell.y);
+    secondIndex = indexOf(block + pair + half, cell.y);
+  } else {
+    firstIndex = indexOf(cell.x, block + pair);
+    secondIndex = indexOf(cell.x, block + pair + half);
+  }
+  var value = butterfly(source[firstIndex].xy, source[secondIndex].xy, pair, span, local < half);
+  if (p.passKind == 14u && span == p.height) {
+    value = value / f32(p.width * p.height);
+  }
+  outputState[at] = vec4<f32>(value, length(value) * p.param2, 1.0);
+}`;
+}
+function radiance() {
+    return `
+fn featureSeed(uv: vec2<f32>) -> vec4<f32> {
+  var best = vec4<f32>(-1.0, -1.0, 0.0, 0.0);
+  for (var index = 0u; index < 8u; index = index + 1u) {
+    if (f32(index) >= p.param0) { break; }
+    let fi = f32(index);
+    let center = vec2<f32>(0.5 + 0.31 * sin(p.time * (0.37 + fi * 0.04) + fi * 2.1),
+      0.5 + 0.31 * cos(p.time * (0.29 + fi * 0.03) + fi * 1.7));
+    if (distance(uv, center) < 0.018) { best = vec4<f32>(uv, 2.0, 1.0 + fi); }
+  }
+  let wallA = abs(uv.x - 0.34 - 0.07 * sin(uv.y * 12.0 + p.time * 0.3));
+  let wallB = abs(uv.x - 0.68 + 0.06 * cos(uv.y * 10.0 - p.time * 0.25));
+  let ring = abs(distance(uv, vec2<f32>(0.5)) - 0.24);
+  if (min(min(wallA, wallB), ring) < 0.008) { best = vec4<f32>(uv, 1.0, 0.0); }
+  return best;
+}
+fn computeCell(cell: vec2<u32>) {
+  let at = indexOf(cell.x, cell.y);
+  let uv = (vec2<f32>(cell) + 0.5) / vec2<f32>(f32(p.width), f32(p.height));
+  if (p.passKind == 20u) { outputState[at] = featureSeed(uv); return; }
+  if (p.passKind == 21u) {
+    var best = source[at];
+    var bestDistance = select(1e9, distance(uv, best.xy), best.x >= 0.0);
+    let jump = i32(p.span);
+    for (var oy = -1; oy <= 1; oy = oy + 1) {
+      for (var ox = -1; ox <= 1; ox = ox + 1) {
+        let candidate = readAt(i32(cell.x) + ox * jump, i32(cell.y) + oy * jump);
+        if (candidate.x >= 0.0) {
+          let candidateDistance = distance(uv, candidate.xy);
+          if (candidateDistance < bestDistance) {
+            best = candidate;
+            bestDistance = candidateDistance;
+          }
+        }
+      }
+    }
+    outputState[at] = best;
+    return;
+  }
+  if (p.passKind == 22u && p.iteration == 0u) {
+    let distanceToFeature = distance(uv, source[at].xy);
+    let hue = fract(source[at].w * 0.37 + p.time * 0.03);
+    let emitterColor = 0.55 + 0.45 * cos(6.28318530718 * (hue + vec3<f32>(0.0, 0.33, 0.67)));
+    let light = emitterColor * exp(-distanceToFeature * 8.0) * select(0.04, 2.2, source[at].z > 1.5);
+    outputState[at] = vec4<f32>(light, select(1.0, 0.0, source[at].z == 1.0));
+    return;
+  }
+  if (p.passKind == 22u) {
+    let jump = i32(p.span);
+    var light = source[at].rgb * 2.0;
+    light = light + readAt(i32(cell.x) - jump, i32(cell.y)).rgb;
+    light = light + readAt(i32(cell.x) + jump, i32(cell.y)).rgb;
+    light = light + readAt(i32(cell.x), i32(cell.y) - jump).rgb;
+    light = light + readAt(i32(cell.x), i32(cell.y) + jump).rgb;
+    light = light / 6.0;
+    outputState[at] = vec4<f32>(light * (0.94 + 0.02 * f32(p.iteration)), source[at].w);
+    return;
+  }
+  let mapped = source[at].rgb / (vec3<f32>(1.0) + source[at].rgb);
+  outputState[at] = vec4<f32>(pow(mapped, vec3<f32>(0.72)), source[at].w);
+}`;
+}
+function renderer(kernel) {
+    const sampling = kernel === "fft-ocean"
+        ? `
+  let screenUv = clamp(vec2<f32>(input.uv.x, 1.0 - input.uv.y), vec2<f32>(0.0), vec2<f32>(0.99999));
+  if (screenUv.y < 0.32) {
+    let horizon = screenUv.y / 0.32;
+    let sky = mix(vec3<f32>(0.015, 0.035, 0.12), vec3<f32>(0.18, 0.55, 0.72), horizon);
+    return vec4<f32>(sky, 1.0);
+  }
+  let depth = max(0.045, screenUv.y - 0.28);
+  let uv = vec2<f32>(
+    fract((screenUv.x - 0.5) / (depth * 2.1) + 0.5),
+    fract(0.14 / depth + p.time * 0.035)
+  );
+  let cell = vec2<u32>(uv * vec2<f32>(f32(p.width), f32(p.height)));
+  let value = source[indexOf(cell.x, cell.y)];`
+        : `
+  let uv = clamp(vec2<f32>(input.uv.x, 1.0 - input.uv.y), vec2<f32>(0.0), vec2<f32>(0.99999));
+  let cell = vec2<u32>(uv * vec2<f32>(f32(p.width), f32(p.height)));
+  let value = source[indexOf(cell.x, cell.y)];`;
+    const color = kernel === "fluid-2d"
+        ? `
+  let density = max(0.0, value.z);
+  let speed = length(value.xy);
+  let cold = vec3<f32>(0.01, 0.08, 0.22);
+  let cyan = vec3<f32>(0.0, 0.85, 1.2);
+  let magenta = vec3<f32>(1.1, 0.04, 0.65);
+  let color = cold + density * mix(cyan, magenta, clamp(speed * 4.0, 0.0, 1.0));
+  return vec4<f32>(color / (vec3<f32>(1.0) + color), 1.0);`
+        : kernel === "fft-ocean"
+            ? `
+  let left = source[indexOf(u32(max(i32(cell.x) - 1, 0)), cell.y)].x;
+  let up = source[indexOf(cell.x, u32(max(i32(cell.y) - 1, 0)))].x;
+  let normal = normalize(vec3<f32>((left - value.x) * 45.0, (up - value.x) * 45.0, 1.0));
+  let fresnel = pow(1.0 - max(normal.z, 0.0), 3.0);
+  let foam = smoothstep(0.015, 0.08, value.z);
+  var color = mix(vec3<f32>(0.0, 0.08, 0.19), vec3<f32>(0.0, 0.55, 0.78), normal.z);
+  color = mix(color, vec3<f32>(0.75, 0.95, 1.0), foam * 0.7 + fresnel * 0.35);
+  return vec4<f32>(color, 1.0);`
+            : `
+  var color = value.rgb;
+  for (var index = 0u; index < 8u; index = index + 1u) {
+    if (f32(index) >= p.param0) { break; }
+    let fi = f32(index);
+    let center = vec2<f32>(0.5 + 0.31 * sin(p.time * (0.37 + fi * 0.04) + fi * 2.1),
+      0.5 + 0.31 * cos(p.time * (0.29 + fi * 0.03) + fi * 1.7));
+    let glow = exp(-distance(uv, center) * 42.0);
+    let emitterColor = 0.55 + 0.45 * cos(6.28318530718 * (fi * 0.37 + vec3<f32>(0.0, 0.33, 0.67)));
+    color = color + emitterColor * glow * 2.4;
+  }
+  let wallA = abs(uv.x - 0.34 - 0.07 * sin(uv.y * 12.0 + p.time * 0.3));
+  let wallB = abs(uv.x - 0.68 + 0.06 * cos(uv.y * 10.0 - p.time * 0.25));
+  let ring = abs(distance(uv, vec2<f32>(0.5)) - 0.24);
+  let occlusion = smoothstep(0.002, 0.012, min(min(wallA, wallB), ring));
+  color = color * mix(0.08, 1.0, occlusion);
+  color = color / (vec3<f32>(1.0) + color);
+  return vec4<f32>(pow(color, vec3<f32>(0.78)), 1.0);`;
+    return `
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+@vertex
+fn vertexMain(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  var positions = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0)
+  );
+  var output: VertexOutput;
+  output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
+  output.uv = positions[vertexIndex] * 0.5 + 0.5;
+  return output;
+}
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+  ${sampling}
+  ${color}
+}`;
+}
+//# sourceMappingURL=simulation-wgsl.js.map

package/dist/simulation/simulation-wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-wgsl.js","sourceRoot":"","sources":["../../src/simulation/simulation-wgsl.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,oBAAoB,CAClC,MAAwB,EACxB,aAAqB;IAErB,OAAO,GAAG,MAAM,CAAC,aAAa,CAAC,KAAK,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;AAC7I,CAAC;AAED,SAAS,MAAM,CAAC,aAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiCkB,aAAa,KAAK,aAAa;;;;EAIxD,CAAC;AACH,CAAC;AAED,SAAS,KAAK;IACZ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCP,CAAC;AACH,CAAC;AAED,SAAS,KAAK;IACZ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgEP,CAAC;AACH,CAAC;AAED,SAAS,QAAQ;IACf,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DP,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,MAAwB;IACxC,MAAM,QAAQ,GACZ,MAAM,KAAK,WAAW;QACpB,CAAC,CAAC;;;;;;;;;;;;;+CAauC;QACzC,CAAC,CAAC;;;+CAGuC,CAAC;IAC9C,MAAM,KAAK,GACT,MAAM,KAAK,UAAU;QACnB,CAAC,CAAC;;;;;;;2DAOmD;QACrD,CAAC,CAAC,MAAM,KAAK,WAAW;YACtB,CAAC,CAAC;;;;;;;;gCAQsB;YACxB,CAAC,CAAC;;;;;;;;;;;;;;;;;sDAiB4C,CAAC;IACrD,OAAO;;;;;;;;;;;;;;;;;IAiBL,QAAQ;IACR,KAAK;EACP,CAAC;AACH,CAAC"}