@vgai/engine 0.2.0 → 0.3.0

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

@@ -0,0 +1,30 @@
+/**
+ * Central asset registry — stores per-asset metadata (import corrections, etc.).
+ *
+ * Loaded once via fetch(), cached in memory. Both the runtime scene loader
+ * and editor entity factory import from this module.
+ */
+export interface ImportCorrection {
+    /** Uniform scale factor applied to the GLTF clone before entity transform. */
+    scale?: number;
+    /** Euler rotation in degrees [x, y, z] applied to the GLTF clone before entity transform. */
+    rotation?: [number, number, number];
+}
+export interface AssetMeta {
+    importCorrection?: ImportCorrection;
+}
+type AssetRegistry = Record<string, AssetMeta>;
+/**
+ * Fetch and cache the asset registry. Safe to call multiple times —
+ * returns the cached result after the first successful load.
+ */
+export declare function loadRegistry(): Promise<AssetRegistry>;
+/** Get metadata for an asset path, or undefined if not in the registry. */
+export declare function getAssetMeta(path: string): AssetMeta | undefined;
+/**
+ * Update the in-memory cache directly (used by the editor after saving
+ * import settings, to avoid a re-fetch).
+ */
+export declare function setRegistryCache(data: AssetRegistry): void;
+export {};
+//# sourceMappingURL=asset-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asset-registry.d.ts","sourceRoot":"","sources":["../../src/scene/asset-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,gBAAgB;IAC/B,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,SAAS;IACxB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAU/C;;;GAGG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC,CAgBrD;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAIhE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAG1D"}

package/dist/scene/asset-registry.js

@@ -0,0 +1,50 @@
+/**
+ * Central asset registry — stores per-asset metadata (import corrections, etc.).
+ *
+ * Loaded once via fetch(), cached in memory. Both the runtime scene loader
+ * and editor entity factory import from this module.
+ */
+import { resolveUrl } from '../loader';
+let registryCache = null;
+let registryPromise = null;
+/** Normalize asset path for registry lookup (strip leading slash). */
+function normalize(path) {
+    return path.startsWith('/') ? path.slice(1) : path;
+}
+/**
+ * Fetch and cache the asset registry. Safe to call multiple times —
+ * returns the cached result after the first successful load.
+ */
+export function loadRegistry() {
+    if (registryCache)
+        return Promise.resolve(registryCache);
+    if (registryPromise)
+        return registryPromise;
+    registryPromise = fetch(resolveUrl('asset-registry.json'))
+        .then((res) => {
+        if (!res.ok)
+            return {};
+        return res.json();
+    })
+        .catch(() => ({}))
+        .then((data) => {
+        registryCache = data;
+        return data;
+    });
+    return registryPromise;
+}
+/** Get metadata for an asset path, or undefined if not in the registry. */
+export function getAssetMeta(path) {
+    if (!registryCache)
+        return undefined;
+    // Try exact match first, then normalized
+    return registryCache[path] ?? registryCache[normalize(path)];
+}
+/**
+ * Update the in-memory cache directly (used by the editor after saving
+ * import settings, to avoid a re-fetch).
+ */
+export function setRegistryCache(data) {
+    registryCache = data;
+    registryPromise = null;
+}

package/dist/scene/collider-dimensions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared world-scale collider dimension math (T1.2).
+ *
+ * Rapier colliders have no notion of a parent Object3D's `scale` — a body's
+ * shape is defined in absolute world units at creation time. Three.js meshes,
+ * by contrast, scale visually for free via the normal Object3D hierarchy. To
+ * keep the physical collider matching what's on screen, the LOADER must bake
+ * the entity's composed WORLD scale (self × every transformed ancestor — see
+ * T1.1's world-transform composition) into the collider's dimensions at
+ * creation time.
+ *
+ * This is the ONE place that does that math, so both the runtime loader
+ * (scene-loader.ts `createPhysicsBody`) and the editor's collider gizmo
+ * (gizmo-registry.ts) agree on exactly the same numbers — previously the
+ * editor gizmo only rendered the entity's own live Object3D scale (via normal
+ * Three.js parenting) while the Rapier body ignored scale entirely, so the
+ * two silently agreed by coincidence for uniform scale and disagreed for
+ * everything else.
+ *
+ * Round colliders (ball/capsule) can only represent a uniform radius — Rapier
+ * has no ellipsoid/elliptical-capsule shape. A non-uniform world scale on a
+ * round collider's round axes throws a loud error naming the entity, rather
+ * than silently simulating (or rendering) the wrong shape.
+ */
+import type { SceneCollider } from './scene-types';
+export interface ColliderWorldDimensions {
+    /** cuboid only: per-axis half-extents, world scale applied. */
+    halfExtents?: [number, number, number];
+    /** ball/capsule only: radius, world scale applied (uniform axes required). */
+    radius?: number;
+    /** capsule only: half-height along the capsule's axis, world scale applied. */
+    halfHeight?: number;
+}
+/**
+ * Compute a collider's WORLD-space dimensions given the entity's composed
+ * world scale (self × ancestors, per-axis, in the entity's own local frame —
+ * X/Y/Z order matches `SceneEntity.transform.scale`).
+ *
+ * @param collider - the entity's authored (unscaled) collider definition.
+ * @param worldScale - composed world scale `[x, y, z]`.
+ * @param entityLabel - human-readable entity identifier, used only in thrown
+ *   error messages (loud-failure naming, never silently wrong).
+ * @throws if a ball/capsule collider's round cross-section axes have a
+ *   non-uniform world scale (beyond {@link UNIFORM_SCALE_EPSILON}).
+ */
+export declare function computeColliderWorldDimensions(collider: SceneCollider, worldScale: readonly [number, number, number], entityLabel: string): ColliderWorldDimensions;
+/**
+ * Compute a collider's WORLD-scaled translation offset (sibling to
+ * {@link computeColliderWorldDimensions}, same input contract).
+ *
+ * Rapier's `ColliderDesc.setTranslation` is a raw physics-engine offset with no
+ * notion of a parent Object3D's scale — like dimensions, an authored `offset`
+ * (in the entity's own local units) must be scaled per-axis by the entity's
+ * composed world scale before being handed to Rapier, or the collider's center
+ * silently drifts away from its visual anchor point under any non-1 scale.
+ * Applies to every collider type (including trimesh, which is otherwise not
+ * handled by {@link computeColliderWorldDimensions}).
+ *
+ * Returns `undefined` when no offset is authored, mirroring the `if (col.offset)`
+ * guard call sites already use.
+ */
+export declare function computeColliderWorldOffset(offset: readonly [number, number, number] | undefined, worldScale: readonly [number, number, number]): [number, number, number] | undefined;
+//# sourceMappingURL=collider-dimensions.d.ts.map

package/dist/scene/collider-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collider-dimensions.d.ts","sourceRoot":"","sources":["../../src/scene/collider-dimensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD,MAAM,WAAW,uBAAuB;IACtC,+DAA+D;IAC/D,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7C,WAAW,EAAE,MAAM,GAClB,uBAAuB,CA4CzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACrD,UAAU,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5C,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAItC"}

package/dist/scene/collider-dimensions.js

@@ -0,0 +1,98 @@
+/**
+ * Shared world-scale collider dimension math (T1.2).
+ *
+ * Rapier colliders have no notion of a parent Object3D's `scale` — a body's
+ * shape is defined in absolute world units at creation time. Three.js meshes,
+ * by contrast, scale visually for free via the normal Object3D hierarchy. To
+ * keep the physical collider matching what's on screen, the LOADER must bake
+ * the entity's composed WORLD scale (self × every transformed ancestor — see
+ * T1.1's world-transform composition) into the collider's dimensions at
+ * creation time.
+ *
+ * This is the ONE place that does that math, so both the runtime loader
+ * (scene-loader.ts `createPhysicsBody`) and the editor's collider gizmo
+ * (gizmo-registry.ts) agree on exactly the same numbers — previously the
+ * editor gizmo only rendered the entity's own live Object3D scale (via normal
+ * Three.js parenting) while the Rapier body ignored scale entirely, so the
+ * two silently agreed by coincidence for uniform scale and disagreed for
+ * everything else.
+ *
+ * Round colliders (ball/capsule) can only represent a uniform radius — Rapier
+ * has no ellipsoid/elliptical-capsule shape. A non-uniform world scale on a
+ * round collider's round axes throws a loud error naming the entity, rather
+ * than silently simulating (or rendering) the wrong shape.
+ */
+import { DEFAULTS } from './defaults';
+/** Axes are considered "uniform enough" within this tolerance (float error only). */
+const UNIFORM_SCALE_EPSILON = 1e-4;
+/**
+ * Compute a collider's WORLD-space dimensions given the entity's composed
+ * world scale (self × ancestors, per-axis, in the entity's own local frame —
+ * X/Y/Z order matches `SceneEntity.transform.scale`).
+ *
+ * @param collider - the entity's authored (unscaled) collider definition.
+ * @param worldScale - composed world scale `[x, y, z]`.
+ * @param entityLabel - human-readable entity identifier, used only in thrown
+ *   error messages (loud-failure naming, never silently wrong).
+ * @throws if a ball/capsule collider's round cross-section axes have a
+ *   non-uniform world scale (beyond {@link UNIFORM_SCALE_EPSILON}).
+ */
+export function computeColliderWorldDimensions(collider, worldScale, entityLabel) {
+    const [sx, sy, sz] = worldScale;
+    switch (collider.type) {
+        case 'cuboid': {
+            const he = collider.halfExtents ?? DEFAULTS.collider.cuboid.halfExtents;
+            return { halfExtents: [he[0] * sx, he[1] * sy, he[2] * sz] };
+        }
+        case 'ball': {
+            if (Math.abs(sx - sy) > UNIFORM_SCALE_EPSILON ||
+                Math.abs(sy - sz) > UNIFORM_SCALE_EPSILON ||
+                Math.abs(sx - sz) > UNIFORM_SCALE_EPSILON) {
+                throw new Error(`Entity "${entityLabel}" has a "ball" collider under a non-uniform world scale ` +
+                    `[${sx}, ${sy}, ${sz}]. Rapier ball colliders are always perfect spheres — a ` +
+                    `non-uniform scale cannot be represented and would silently simulate the wrong ` +
+                    `shape. Use a uniform scale on this entity (and every transformed ancestor), or ` +
+                    `switch to a "cuboid" collider.`);
+            }
+            const radius = collider.radius ?? DEFAULTS.collider.ball.radius;
+            return { radius: radius * sx };
+        }
+        case 'capsule': {
+            // Rapier capsules run their half-height along the local Y axis, with a
+            // circular cross-section in the XZ plane — so only X/Z need to match.
+            if (Math.abs(sx - sz) > UNIFORM_SCALE_EPSILON) {
+                throw new Error(`Entity "${entityLabel}" has a "capsule" collider whose X/Z world scale differs ` +
+                    `(x=${sx}, z=${sz}). Rapier capsule colliders have a circular cross-section — a ` +
+                    `non-uniform X/Z scale cannot be represented and would silently simulate the ` +
+                    `wrong shape. Use a uniform X/Z scale on this entity (and every transformed ` +
+                    `ancestor), or switch to a "cuboid" collider.`);
+            }
+            const radius = collider.radius ?? DEFAULTS.collider.capsule.radius;
+            const halfHeight = collider.halfHeight ?? DEFAULTS.collider.capsule.halfHeight;
+            return { radius: radius * sx, halfHeight: halfHeight * sy };
+        }
+        default:
+            return {};
+    }
+}
+/**
+ * Compute a collider's WORLD-scaled translation offset (sibling to
+ * {@link computeColliderWorldDimensions}, same input contract).
+ *
+ * Rapier's `ColliderDesc.setTranslation` is a raw physics-engine offset with no
+ * notion of a parent Object3D's scale — like dimensions, an authored `offset`
+ * (in the entity's own local units) must be scaled per-axis by the entity's
+ * composed world scale before being handed to Rapier, or the collider's center
+ * silently drifts away from its visual anchor point under any non-1 scale.
+ * Applies to every collider type (including trimesh, which is otherwise not
+ * handled by {@link computeColliderWorldDimensions}).
+ *
+ * Returns `undefined` when no offset is authored, mirroring the `if (col.offset)`
+ * guard call sites already use.
+ */
+export function computeColliderWorldOffset(offset, worldScale) {
+    if (!offset)
+        return undefined;
+    const [sx, sy, sz] = worldScale;
+    return [offset[0] * sx, offset[1] * sy, offset[2] * sz];
+}

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

@@ -0,0 +1,17 @@
+import type * as THREE from 'three';
+import type { ComponentManager } from '../ecs/component-manager';
+import { type GameComponentClass } from '../ecs/game-component';
+/** A registry mapping component names to GameComponent classes. */
+export type ComponentRegistry = Record<string, GameComponentClass>;
+/** Type guard: is this value a GameComponent class? */
+export declare function isGameComponentClass(entry: unknown): entry is GameComponentClass;
+/**
+ * Apply components from scene JSON data onto an entity (an Object3D).
+ *
+ * For each named component: look up its class in the registry, validate +
+ * default the authored data through the optional `static schema` (Zod), assign
+ * onto a fresh instance, and attach it via the ComponentManager (which wires the
+ * Object3D + physics refs and queues init()).
+ */
+export declare function applyComponents(registry: ComponentRegistry, object3D: THREE.Object3D, components: Record<string, Record<string, unknown>>, manager: ComponentManager): void;
+//# sourceMappingURL=component-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../../src/scene/component-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEnE,uDAAuD;AACvD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEhF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,KAAK,CAAC,QAAQ,EACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACnD,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAcN"}

package/dist/scene/component-registry.js

@@ -0,0 +1,28 @@
+import { GameComponent } from '../ecs/game-component';
+/** Type guard: is this value a GameComponent class? */
+export function isGameComponentClass(entry) {
+    return typeof entry === 'function' && entry.prototype instanceof GameComponent;
+}
+/**
+ * Apply components from scene JSON data onto an entity (an Object3D).
+ *
+ * For each named component: look up its class in the registry, validate +
+ * default the authored data through the optional `static schema` (Zod), assign
+ * onto a fresh instance, and attach it via the ComponentManager (which wires the
+ * Object3D + physics refs and queues init()).
+ */
+export function applyComponents(registry, object3D, components, manager) {
+    for (const [name, data] of Object.entries(components)) {
+        const Klass = registry[name];
+        if (!Klass) {
+            throw new Error(`Component "${name}" not found in registry`);
+        }
+        const parsed = Klass.schema ? Klass.schema.parse(data) : data;
+        const inst = new Klass();
+        Object.assign(inst, parsed);
+        // T5.4: record the registry name + raw authored data so a later `hotSwap`
+        // keys on this stable identity (not the live `constructor.name`) and can
+        // re-validate `data` against a NEW class version's schema.
+        manager.attach(object3D, inst, { key: name, props: data });
+    }
+}

package/dist/scene/defaults.d.ts

@@ -0,0 +1,252 @@
+/** 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

@@ -0,0 +1 @@
+{"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"}