@vgai/engine 0.5.0 → 0.5.2

package/dist/scene/defaults.d.ts

@@ -1,252 +0,0 @@
-/** Single source of truth for all scene default values. */
-export declare const DEFAULTS: {
-    readonly transform: {
-        readonly position: [number, number, number];
-        readonly rotation: [number, number, number, number];
-        readonly scale: [number, number, number];
-    };
-    readonly entity: {
-        readonly visible: true;
-        readonly locked: false;
-        readonly pivot: [number, number, number];
-    };
-    readonly material: {
-        readonly type: "standard";
-        readonly color: "#888888";
-        readonly metalness: 0;
-        readonly roughness: 0.5;
-        readonly emissive: "#000000";
-        readonly emissiveIntensity: 0;
-        readonly opacity: 1;
-        readonly transparent: false;
-        readonly side: "front";
-        readonly flatShading: false;
-        readonly clearcoat: {
-            readonly clearcoat: 1;
-            readonly clearcoatRoughness: 0;
-        };
-        readonly transmission: {
-            readonly transmission: 1;
-            readonly ior: 1.5;
-            readonly thickness: 0.5;
-        };
-        readonly sheen: {
-            readonly sheen: 1;
-            readonly sheenColor: "#ffffff";
-            readonly sheenRoughness: 0.5;
-        };
-        readonly iridescence: {
-            readonly iridescence: 1;
-            readonly iridescenceIOR: 1.3;
-            readonly iridescenceThicknessRange: [number, number];
-        };
-        readonly displacementScale: 1;
-        readonly displacementBias: 0;
-    };
-    readonly light: {
-        readonly color: "#ffffff";
-        readonly intensity: 1;
-        readonly groundColor: "#000000";
-        readonly distance: 0;
-        readonly angle: number;
-        readonly penumbra: 0;
-        readonly width: 10;
-        readonly height: 10;
-    };
-    readonly camera: {
-        readonly fov: 60;
-        readonly near: 0.1;
-        readonly far: 1000;
-        readonly orthoSize: 5;
-        readonly width: 1920;
-        readonly height: 1080;
-    };
-    readonly audio: {
-        readonly spatial: true;
-        readonly volume: 1;
-        readonly refDistance: 1;
-        readonly rolloffFactor: 1;
-        readonly maxDistance: 10000;
-        readonly loop: false;
-        readonly autoplay: false;
-    };
-    readonly collider: {
-        readonly cuboid: {
-            readonly halfExtents: [number, number, number];
-        };
-        readonly ball: {
-            readonly radius: 0.5;
-        };
-        readonly capsule: {
-            readonly radius: 0.25;
-            readonly halfHeight: 0.5;
-        };
-    };
-    readonly shadow: {
-        readonly mapSize: 1024;
-    };
-    readonly animation: {
-        readonly loop: true;
-    };
-    readonly fog: {
-        readonly linear: {
-            readonly near: 1;
-            readonly far: 100;
-        };
-        readonly exponential: {
-            readonly density: 0.01;
-        };
-    };
-    readonly environment: {
-        readonly envMapIntensity: 1;
-    };
-    readonly toneMapping: {
-        readonly mode: "aces";
-        readonly exposure: 1;
-    };
-    readonly postProcessing: {
-        readonly bloom: {
-            readonly intensity: 1;
-            readonly luminanceThreshold: 0.9;
-            readonly luminanceSmoothing: 0.025;
-        };
-        readonly vignette: {
-            readonly darkness: 0.5;
-            readonly offset: 0.5;
-        };
-        readonly brightnessContrast: {
-            readonly brightness: 0;
-            readonly contrast: 0;
-        };
-        readonly hueSaturation: {
-            readonly hue: 0;
-            readonly saturation: 0;
-        };
-        readonly sepia: {
-            readonly intensity: 1;
-        };
-        readonly colorDepth: {
-            readonly bits: 16;
-        };
-        readonly chromaticAberration: {
-            readonly offsetX: 0.002;
-            readonly offsetY: 0.002;
-            readonly modulationOffset: 0.15;
-        };
-        readonly lensDistortion: {
-            readonly distortionX: 0;
-            readonly distortionY: 0;
-            readonly focalLengthX: 1;
-            readonly focalLengthY: 1;
-            readonly skew: 0;
-        };
-        readonly depthOfField: {
-            readonly worldFocusDistance: 10;
-            readonly worldFocusRange: 5;
-            readonly bokehScale: 3;
-            readonly focalLength: 0.04;
-        };
-        readonly tiltShift: {
-            readonly offset: 0;
-            readonly rotation: 0;
-            readonly focusArea: 0.4;
-            readonly feather: 0.3;
-        };
-        readonly noise: {
-            readonly premultiply: false;
-        };
-        readonly scanline: {
-            readonly density: 1.25;
-        };
-        readonly dotScreen: {
-            readonly angle: 1.57;
-            readonly scale: 1;
-        };
-        readonly grid: {
-            readonly scale: 1;
-            readonly lineWidth: 0;
-        };
-        readonly pixelation: {
-            readonly granularity: 6;
-        };
-        readonly glitch: {
-            readonly delayX: 1.5;
-            readonly delayY: 3.5;
-            readonly durationX: 0.6;
-            readonly durationY: 1;
-            readonly strengthX: 0.3;
-            readonly strengthY: 1;
-            readonly columns: 0.05;
-            readonly ratio: 0.85;
-        };
-        readonly shockWave: {
-            readonly speed: 2;
-            readonly maxRadius: 1;
-            readonly waveSize: 0.2;
-            readonly amplitude: 0.05;
-        };
-        readonly smaa: {
-            readonly preset: "high";
-        };
-        readonly ssao: {
-            readonly radius: 0.05;
-            readonly intensity: 2;
-            readonly bias: 0.025;
-            readonly samples: 16;
-            readonly rings: 7;
-            readonly fade: 0.01;
-        };
-        readonly n8ao: {
-            readonly aoSamples: 16;
-            readonly aoRadius: 5;
-            readonly intensity: 5;
-            readonly denoiseSamples: 8;
-            readonly denoiseRadius: 12;
-            readonly distanceFalloff: 1;
-        };
-        readonly godRays: {
-            readonly density: 0.96;
-            readonly decay: 0.93;
-            readonly weight: 0.4;
-            readonly exposure: 0.6;
-            readonly samples: 60;
-        };
-        readonly outline: {
-            readonly edgeStrength: 3;
-            readonly pulseSpeed: 0;
-            readonly visibleEdgeColor: "#ffffff";
-            readonly hiddenEdgeColor: "#22090a";
-        };
-        readonly ssr: {
-            readonly intensity: 1;
-            readonly exponent: 1;
-            readonly distance: 10;
-            readonly thickness: 10;
-            readonly maxRoughness: 1;
-        };
-        readonly ssgi: {
-            readonly intensity: 1;
-            readonly distance: 10;
-            readonly thickness: 10;
-            readonly maxRoughness: 1;
-        };
-        readonly motionBlur: {
-            readonly intensity: 1;
-            readonly jitter: 1;
-            readonly samples: 16;
-        };
-    };
-    readonly navigation: {
-        readonly cellSize: 0.3;
-        readonly cellHeight: 0.2;
-        readonly walkableSlopeAngle: 45;
-        readonly walkableHeight: 2;
-        readonly walkableClimb: 1;
-        readonly walkableRadius: 0.5;
-        readonly maxEdgeLen: 12;
-        readonly maxSimplificationError: 1.3;
-        readonly minRegionArea: 8;
-        readonly mergeRegionArea: 20;
-    };
-};
-//# sourceMappingURL=defaults.d.ts.map

package/dist/scene/defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/scene/defaults.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,eAAO,MAAM,QAAQ;;2BAEM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;2BACrB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;wBACtC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;;wBAMxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAoBD,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAsCjB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8F5D,CAAC"}

package/dist/scene/defaults.js

@@ -1,151 +0,0 @@
-/** Single source of truth for all scene default values. */
-export const DEFAULTS = {
-    transform: {
-        position: [0, 0, 0],
-        rotation: [0, 0, 0, 1],
-        scale: [1, 1, 1],
-    },
-    entity: {
-        visible: true,
-        locked: false,
-        pivot: [0, 0, 0],
-    },
-    material: {
-        type: 'standard',
-        color: '#888888',
-        metalness: 0,
-        roughness: 0.5,
-        emissive: '#000000',
-        emissiveIntensity: 0,
-        opacity: 1,
-        transparent: false,
-        side: 'front',
-        flatShading: false,
-        clearcoat: { clearcoat: 1, clearcoatRoughness: 0 },
-        transmission: { transmission: 1, ior: 1.5, thickness: 0.5 },
-        sheen: { sheen: 1, sheenColor: '#ffffff', sheenRoughness: 0.5 },
-        iridescence: {
-            iridescence: 1,
-            iridescenceIOR: 1.3,
-            iridescenceThicknessRange: [100, 400],
-        },
-        displacementScale: 1,
-        displacementBias: 0,
-    },
-    light: {
-        color: '#ffffff',
-        intensity: 1,
-        groundColor: '#000000',
-        distance: 0,
-        angle: Math.PI / 6,
-        penumbra: 0,
-        // three.js's own RectAreaLight constructor defaults (area lights only).
-        width: 10,
-        height: 10,
-    },
-    camera: {
-        fov: 60,
-        near: 0.1,
-        far: 1000,
-        orthoSize: 5,
-        width: 1920,
-        height: 1080,
-    },
-    audio: {
-        spatial: true,
-        volume: 1,
-        refDistance: 1,
-        rolloffFactor: 1,
-        maxDistance: 10000,
-        loop: false,
-        autoplay: false,
-    },
-    collider: {
-        cuboid: { halfExtents: [0.5, 0.5, 0.5] },
-        ball: { radius: 0.5 },
-        capsule: { radius: 0.25, halfHeight: 0.5 },
-    },
-    shadow: {
-        mapSize: 1024,
-    },
-    animation: {
-        loop: true,
-    },
-    fog: {
-        linear: { near: 1, far: 100 },
-        exponential: { density: 0.01 },
-    },
-    environment: {
-        envMapIntensity: 1.0,
-    },
-    toneMapping: {
-        // T1.13: the effective renderer default is ACES (see
-        // setup-renderer.ts's `createHostRenderer` + `applyScenePostProcessing`,
-        // which both hardcode `THREE.ACESFilmicToneMapping`/'aces' as the
-        // fallback when a scene omits `environment.toneMapping`) — NOT 'none'.
-        // This used to say 'none', silently disagreeing with the runtime and
-        // with the editor's Tone Mapping inspector dropdown.
-        mode: 'aces',
-        exposure: 1.0,
-    },
-    postProcessing: {
-        bloom: { intensity: 1.0, luminanceThreshold: 0.9, luminanceSmoothing: 0.025 },
-        vignette: { darkness: 0.5, offset: 0.5 },
-        brightnessContrast: { brightness: 0, contrast: 0 },
-        hueSaturation: { hue: 0, saturation: 0 },
-        sepia: { intensity: 1.0 },
-        colorDepth: { bits: 16 },
-        chromaticAberration: { offsetX: 0.002, offsetY: 0.002, modulationOffset: 0.15 },
-        lensDistortion: { distortionX: 0, distortionY: 0, focalLengthX: 1, focalLengthY: 1, skew: 0 },
-        depthOfField: { worldFocusDistance: 10, worldFocusRange: 5, bokehScale: 3, focalLength: 0.04 },
-        tiltShift: { offset: 0, rotation: 0, focusArea: 0.4, feather: 0.3 },
-        noise: { premultiply: false },
-        scanline: { density: 1.25 },
-        dotScreen: { angle: 1.57, scale: 1.0 },
-        grid: { scale: 1.0, lineWidth: 0.0 },
-        pixelation: { granularity: 6 },
-        glitch: {
-            delayX: 1.5,
-            delayY: 3.5,
-            durationX: 0.6,
-            durationY: 1.0,
-            strengthX: 0.3,
-            strengthY: 1.0,
-            columns: 0.05,
-            ratio: 0.85,
-        },
-        shockWave: { speed: 2, maxRadius: 1, waveSize: 0.2, amplitude: 0.05 },
-        smaa: { preset: 'high' },
-        ssao: { radius: 0.05, intensity: 2.0, bias: 0.025, samples: 16, rings: 7, fade: 0.01 },
-        n8ao: {
-            aoSamples: 16,
-            aoRadius: 5.0,
-            intensity: 5,
-            denoiseSamples: 8,
-            denoiseRadius: 12,
-            distanceFalloff: 1.0,
-        },
-        godRays: { density: 0.96, decay: 0.93, weight: 0.4, exposure: 0.6, samples: 60 },
-        outline: {
-            edgeStrength: 3,
-            pulseSpeed: 0,
-            visibleEdgeColor: '#ffffff',
-            hiddenEdgeColor: '#22090a',
-        },
-        ssr: { intensity: 1, exponent: 1, distance: 10, thickness: 10, maxRoughness: 1 },
-        ssgi: { intensity: 1, distance: 10, thickness: 10, maxRoughness: 1 },
-        motionBlur: { intensity: 1, jitter: 1, samples: 16 },
-    },
-    navigation: {
-        cellSize: 0.3,
-        cellHeight: 0.2,
-        walkableSlopeAngle: 45,
-        walkableHeight: 2,
-        walkableClimb: 1,
-        walkableRadius: 0.5,
-        maxEdgeLen: 12,
-        maxSimplificationError: 1.3,
-        minRegionArea: 8,
-        mergeRegionArea: 20,
-    },
-};

package/dist/scene/geometries/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Built-in geometry generators. Importing this module for its side effects
- * registers the built-ins into the geometry registry. Both the runtime factory
- * (scene-loader) and the editor factory (entity-factory) import it so generated
- * meshes resolve on whichever side builds first.
- */
-import './terrain';
-//# sourceMappingURL=index.d.ts.map

package/dist/scene/geometries/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scene/geometries/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,WAAW,CAAC"}

package/dist/scene/geometries/index.js

@@ -1,7 +0,0 @@
-/**
- * Built-in geometry generators. Importing this module for its side effects
- * registers the built-ins into the geometry registry. Both the runtime factory
- * (scene-loader) and the editor factory (entity-factory) import it so generated
- * meshes resolve on whichever side builds first.
- */
-import './terrain';

package/dist/scene/geometries/terrain.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=terrain.d.ts.map

package/dist/scene/geometries/terrain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terrain.d.ts","sourceRoot":"","sources":["../../../src/scene/geometries/terrain.ts"],"names":[],"mappings":""}

package/dist/scene/geometries/terrain.js

@@ -1,37 +0,0 @@
-import * as THREE from 'three';
-import { registerGeometryGenerator } from '../geometry-registry';
-/**
- * Built-in "Terrain" geometry generator — a horizontal heightfield (XZ plane,
- * height in +Y) displaced by a deterministic sum-of-sines, so it pairs with a
- * `trimesh` collider for matching terrain physics. Proof material for roadmap #3.
- *
- * Params: width, depth (world size), segments (grid resolution per axis),
- * amplitude (max height), frequency (wave scale). Deterministic — no Math.random.
- */
-function heightAt(x, z, amplitude, frequency) {
-    return (amplitude *
-        (Math.sin(x * frequency) * 0.5 +
-            Math.cos(z * frequency * 1.3) * 0.3 +
-            Math.sin((x + z) * frequency * 0.5) * 0.2));
-}
-registerGeometryGenerator('Terrain', {
-    build(params) {
-        const width = params['width'] ?? 40;
-        const depth = params['depth'] ?? 40;
-        const segments = params['segments'] ?? 64;
-        const amplitude = params['amplitude'] ?? 3;
-        const frequency = params['frequency'] ?? 0.25;
-        const geo = new THREE.PlaneGeometry(width, depth, segments, segments);
-        // Lay the plane flat (XZ) with normal +Y, then displace Y by the heightfield.
-        geo.rotateX(-Math.PI / 2);
-        const pos = geo.attributes['position'];
-        for (let i = 0; i < pos.count; i++) {
-            const x = pos.getX(i);
-            const z = pos.getZ(i);
-            pos.setY(i, heightAt(x, z, amplitude, frequency));
-        }
-        pos.needsUpdate = true;
-        geo.computeVertexNormals();
-        return geo;
-    },
-});

package/dist/scene/geometry-registry.d.ts

@@ -1,24 +0,0 @@
-import type * as THREE from 'three';
-/**
- * A geometry-generator definition. Registered by name and resolved when a scene
- * mesh declares `{ generator: <name> }`. Mirrors the material/instancer registry
- * pattern: the generation logic lives here in code, the authored params arrive as
- * scene data.
- *
- * `build` returns a real THREE.BufferGeometry. Paired with a `trimesh` collider,
- * the generated geometry also drives physics (e.g. terrain), so the visual and
- * collision surfaces match exactly.
- */
-export interface GeometryGeneratorDef {
-    build(params: Record<string, unknown>): THREE.BufferGeometry;
-}
-/** Register a geometry generator under `name`. */
-export declare function registerGeometryGenerator(name: string, def: GeometryGeneratorDef): void;
-/** Look up a registered geometry generator. */
-export declare function getGeometryGenerator(name: string): GeometryGeneratorDef | undefined;
-/**
- * Build a procedural geometry by registered generator name. Throws if the
- * generator is unknown (fail loud — same posture as the other registries).
- */
-export declare function buildGeneratedGeometry(name: string, params: Record<string, unknown>): THREE.BufferGeometry;
-//# sourceMappingURL=geometry-registry.d.ts.map

package/dist/scene/geometry-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry-registry.d.ts","sourceRoot":"","sources":["../../src/scene/geometry-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC;CAC9D;AAID,kDAAkD;AAClD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,IAAI,CAEvF;AAED,+CAA+C;AAC/C,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAEnF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,cAAc,CAMtB"}

package/dist/scene/geometry-registry.js

@@ -1,20 +0,0 @@
-const registry = new Map();
-/** Register a geometry generator under `name`. */
-export function registerGeometryGenerator(name, def) {
-    registry.set(name, def);
-}
-/** Look up a registered geometry generator. */
-export function getGeometryGenerator(name) {
-    return registry.get(name);
-}
-/**
- * Build a procedural geometry by registered generator name. Throws if the
- * generator is unknown (fail loud — same posture as the other registries).
- */
-export function buildGeneratedGeometry(name, params) {
-    const def = registry.get(name);
-    if (!def) {
-        throw new Error(`Geometry generator "${name}" not found in geometry registry`);
-    }
-    return def.build(params ?? {});
-}

package/dist/scene/instance-registry.d.ts

@@ -1,36 +0,0 @@
-import * as THREE from 'three';
-import type { InstancesFile } from './schema/instances';
-/**
- * An instancer definition. Registered by name and resolved when a scene mesh
- * declares `{ instancer: <name> }`. Mirrors the material-registry pattern: the
- * generation logic lives here in code (the "behavior" half), the authored params
- * arrive as scene data (the "data" half).
- *
- * `build` returns per-instance LOCAL transforms; the factory packs them into a
- * single THREE.InstancedMesh, so N instances cost one draw call.
- */
-export interface InstancerDef {
-    /** Produce per-instance local matrices from authored params. */
-    build(params: Record<string, unknown>): THREE.Matrix4[];
-}
-/** Register an instancer definition under `name`. */
-export declare function registerInstancer(name: string, def: InstancerDef): void;
-/** Look up a registered instancer. */
-export declare function getInstancer(name: string): InstancerDef | undefined;
-/**
- * Build a THREE.InstancedMesh from a registered instancer. Throws if the
- * instancer is unknown (fail loud — same posture as the component/material
- * registries). One InstancedMesh = one draw call for all instances.
- */
-export declare function buildInstancedMesh(geometry: THREE.BufferGeometry, material: THREE.Material, name: string, params: Record<string, unknown>): THREE.InstancedMesh;
-/**
- * Build a THREE.InstancedMesh directly from an already-parsed `.instances.json`
- * tuple array (F3, docs/VSCN-STRUCTURAL-GAPS-DESIGN.md — the declarative,
- * authored-data counterpart to `buildInstancedMesh`'s code-registered
- * instancers). Each tuple is
- * `[posX,posY,posZ, quatX,quatY,quatZ,quatW, scaleX,scaleY,scaleZ]`. Pure and
- * synchronous (no fetch) so it's exercisable headlessly by both the scene
- * loader (after it fetches+parses the asset) and unit tests.
- */
-export declare function buildInstancedMeshFromTuples(geometry: THREE.BufferGeometry, material: THREE.Material, tuples: InstancesFile): THREE.InstancedMesh;
-//# sourceMappingURL=instance-registry.d.ts.map

package/dist/scene/instance-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instance-registry.d.ts","sourceRoot":"","sources":["../../src/scene/instance-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,gEAAgE;IAChE,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;CACzD;AAID,qDAAqD;AACrD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAEvE;AAED,sCAAsC;AACtC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,KAAK,CAAC,aAAa,CAarB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EACxB,MAAM,EAAE,aAAa,GACpB,KAAK,CAAC,aAAa,CAgBrB"}

package/dist/scene/instance-registry.js

@@ -1,55 +0,0 @@
-import * as THREE from 'three';
-const registry = new Map();
-/** Register an instancer definition under `name`. */
-export function registerInstancer(name, def) {
-    registry.set(name, def);
-}
-/** Look up a registered instancer. */
-export function getInstancer(name) {
-    return registry.get(name);
-}
-/**
- * Build a THREE.InstancedMesh from a registered instancer. Throws if the
- * instancer is unknown (fail loud — same posture as the component/material
- * registries). One InstancedMesh = one draw call for all instances.
- */
-export function buildInstancedMesh(geometry, material, name, params) {
-    const def = registry.get(name);
-    if (!def) {
-        throw new Error(`Instancer "${name}" not found in instancer registry`);
-    }
-    const matrices = def.build(params ?? {});
-    const mesh = new THREE.InstancedMesh(geometry, material, matrices.length);
-    for (let i = 0; i < matrices.length; i++) {
-        mesh.setMatrixAt(i, matrices[i]);
-    }
-    mesh.instanceMatrix.needsUpdate = true;
-    mesh.userData['__instancer'] = name;
-    return mesh;
-}
-/**
- * Build a THREE.InstancedMesh directly from an already-parsed `.instances.json`
- * tuple array (F3, docs/VSCN-STRUCTURAL-GAPS-DESIGN.md — the declarative,
- * authored-data counterpart to `buildInstancedMesh`'s code-registered
- * instancers). Each tuple is
- * `[posX,posY,posZ, quatX,quatY,quatZ,quatW, scaleX,scaleY,scaleZ]`. Pure and
- * synchronous (no fetch) so it's exercisable headlessly by both the scene
- * loader (after it fetches+parses the asset) and unit tests.
- */
-export function buildInstancedMeshFromTuples(geometry, material, tuples) {
-    const mesh = new THREE.InstancedMesh(geometry, material, tuples.length);
-    const pos = new THREE.Vector3();
-    const quat = new THREE.Quaternion();
-    const scale = new THREE.Vector3();
-    const matrix = new THREE.Matrix4();
-    for (let i = 0; i < tuples.length; i++) {
-        const t = tuples[i];
-        pos.set(t[0], t[1], t[2]);
-        quat.set(t[3], t[4], t[5], t[6]);
-        scale.set(t[7], t[8], t[9]);
-        matrix.compose(pos, quat, scale);
-        mesh.setMatrixAt(i, matrix);
-    }
-    mesh.instanceMatrix.needsUpdate = true;
-    return mesh;
-}

package/dist/scene/instancers/grid.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=grid.d.ts.map

package/dist/scene/instancers/grid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../../src/scene/instancers/grid.ts"],"names":[],"mappings":""}

package/dist/scene/instancers/grid.js

@@ -1,36 +0,0 @@
-import * as THREE from 'three';
-import { registerInstancer } from '../instance-registry';
-/**
- * Built-in "Grid" instancer — a countX × countZ grid of instances on the XZ
- * plane, centred on the entity origin, with optional deterministic y-jitter.
- * Proof material for roadmap #2 (first-class instancing): a 100×100 grid is
- * 10,000 instances in one draw call.
- *
- * Determinism: uses a seeded LCG (not Math.random) so a scene renders the same
- * layout every load — important for reproducible scenes and tests.
- */
-registerInstancer('Grid', {
-    build(params) {
-        const countX = params['countX'] ?? 100;
-        const countZ = params['countZ'] ?? 100;
-        const spacing = params['spacing'] ?? 2;
-        const jitter = params['jitter'] ?? 0;
-        let seed = params['seed'] ?? 1;
-        const rand = () => {
-            seed = (seed * 1664525 + 1013904223) % 4294967296;
-            return seed / 4294967296;
-        };
-        const offX = ((countX - 1) * spacing) / 2;
-        const offZ = ((countZ - 1) * spacing) / 2;
-        const matrices = [];
-        const m = new THREE.Matrix4();
-        for (let x = 0; x < countX; x++) {
-            for (let z = 0; z < countZ; z++) {
-                const y = jitter ? (rand() - 0.5) * jitter : 0;
-                m.makeTranslation(x * spacing - offX, y, z * spacing - offZ);
-                matrices.push(m.clone());
-            }
-        }
-        return matrices;
-    },
-});

package/dist/scene/instancers/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Built-in instancer definitions. Importing this module for its side effects
- * registers the built-ins into the instancer registry. Both the runtime factory
- * (scene-loader) and the editor factory (entity-factory) import it so instanced
- * meshes resolve on whichever side builds first.
- */
-import './grid';
-//# sourceMappingURL=index.d.ts.map

package/dist/scene/instancers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scene/instancers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,QAAQ,CAAC"}