@base2datadesign/viewer-kit 0.1.0 → 0.1.2

package/dist/engine/ViewerEngine.d.ts

@@ -0,0 +1,32 @@
+import type { CameraState, ViewerCreateOptions, ViewerHandle, ViewerSnapshot } from "./types";
+export declare class ViewerEngine {
+    private container;
+    private renderer;
+    private scene;
+    private camera;
+    private controls;
+    private rootGroup;
+    private environmentSystem;
+    private lightingSystem;
+    private postFxSystem;
+    private debugSystem;
+    private presets;
+    private presetId;
+    private running;
+    private animationFrame;
+    constructor(options: ViewerCreateOptions);
+    getHandle(): ViewerHandle;
+    start(): void;
+    stop(): void;
+    resize(): void;
+    dispose(): void;
+    setPreset(presetId: string): void;
+    setSceneRoot(root: unknown): void;
+    setCamera(state: Partial<CameraState>): void;
+    getCameraState(): CameraState;
+    capturePng(): Promise<Blob>;
+    getSnapshot(): ViewerSnapshot;
+    private applyPreset;
+    private resolvePreset;
+}
+//# sourceMappingURL=ViewerEngine.d.ts.map

package/dist/engine/ViewerEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewerEngine.d.ts","sourceRoot":"","sources":["../../src/engine/ViewerEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAiB,WAAW,EAAyC,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAQpJ,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAc;IAEjC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAuB;gBAEjC,OAAO,EAAE,mBAAmB;IA6CxC,SAAS,IAAI,YAAY;IAezB,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IASd,OAAO,IAAI,IAAI;IAef,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIjC,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAOjC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI;IAc5C,cAAc,IAAI,WAAW;IAQvB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCjC,WAAW,IAAI,cAAc;IAe7B,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,aAAa;CAKtB"}

package/dist/engine/ViewerEngine.js

@@ -0,0 +1,201 @@
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { DEFAULT_PRESET_ID, DEFAULT_PRESETS } from "../presets/defaults";
+import { applyRendererConfig } from "../systems/rendererSystem";
+import { EnvironmentSystem } from "../systems/environmentSystem";
+import { LightingSystem } from "../systems/lightingSystem";
+import { PostFxSystem } from "../systems/postfxSystem";
+import { DebugSystem } from "../systems/debugSystem";
+export class ViewerEngine {
+    container;
+    renderer;
+    scene;
+    camera;
+    controls;
+    rootGroup;
+    environmentSystem;
+    lightingSystem;
+    postFxSystem;
+    debugSystem;
+    presets;
+    presetId;
+    running = false;
+    animationFrame = null;
+    constructor(options) {
+        this.container = options.container;
+        this.presets = options.presets ?? DEFAULT_PRESETS;
+        this.presetId = options.presetId ?? DEFAULT_PRESET_ID;
+        const width = this.container.clientWidth || 1;
+        const height = this.container.clientHeight || 1;
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.PerspectiveCamera(options.camera?.fov ?? 60, width / height, options.camera?.near ?? 0.1, options.camera?.far ?? 500);
+        const camPos = options.camera?.position ?? [15, 12, 15];
+        this.camera.position.set(...camPos);
+        const rendererOptions = {
+            antialias: options.renderer?.antialias ?? true,
+            alpha: options.renderer?.alpha ?? true,
+            preserveDrawingBuffer: options.renderer?.preserveDrawingBuffer ?? false,
+        };
+        this.renderer = new THREE.WebGLRenderer(rendererOptions);
+        this.renderer.setSize(width, height);
+        this.container.appendChild(this.renderer.domElement);
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.enableDamping = true;
+        this.controls.dampingFactor = 0.05;
+        const target = options.camera?.target ?? [0, 1.5, 0];
+        this.controls.target.set(...target);
+        this.controls.update();
+        this.rootGroup = new THREE.Group();
+        this.scene.add(this.rootGroup);
+        this.environmentSystem = new EnvironmentSystem(this.scene, this.renderer, options.assetResolver);
+        this.lightingSystem = new LightingSystem(this.scene);
+        this.postFxSystem = new PostFxSystem(this.renderer, this.scene, this.camera);
+        this.debugSystem = new DebugSystem(this.scene);
+        this.applyPreset(this.presetId);
+    }
+    getHandle() {
+        return {
+            start: () => this.start(),
+            stop: () => this.stop(),
+            resize: () => this.resize(),
+            dispose: () => this.dispose(),
+            setPreset: (presetId) => this.setPreset(presetId),
+            setSceneRoot: (root) => this.setSceneRoot(root),
+            setCamera: (state) => this.setCamera(state),
+            getCameraState: () => this.getCameraState(),
+            capturePng: () => this.capturePng(),
+            getSnapshot: () => this.getSnapshot(),
+        };
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        const loop = () => {
+            if (!this.running)
+                return;
+            this.controls.update();
+            this.postFxSystem.render();
+            this.animationFrame = requestAnimationFrame(loop);
+        };
+        this.animationFrame = requestAnimationFrame(loop);
+    }
+    stop() {
+        this.running = false;
+        if (this.animationFrame !== null) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+    }
+    resize() {
+        const width = this.container.clientWidth || 1;
+        const height = this.container.clientHeight || 1;
+        this.camera.aspect = width / height;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(width, height);
+        this.postFxSystem.resize(width, height);
+    }
+    dispose() {
+        this.stop();
+        this.environmentSystem.dispose();
+        this.lightingSystem.dispose();
+        this.postFxSystem.dispose();
+        this.debugSystem.dispose();
+        this.scene.clear();
+        this.controls.dispose();
+        this.renderer.dispose();
+        if (this.renderer.domElement.parentElement === this.container) {
+            this.container.removeChild(this.renderer.domElement);
+        }
+    }
+    setPreset(presetId) {
+        this.applyPreset(presetId);
+    }
+    setSceneRoot(root) {
+        this.rootGroup.clear();
+        if (root && root instanceof THREE.Object3D) {
+            this.rootGroup.add(root);
+        }
+    }
+    setCamera(state) {
+        if (state.position) {
+            this.camera.position.set(...state.position);
+        }
+        if (state.target) {
+            this.controls.target.set(...state.target);
+        }
+        if (typeof state.fov === "number") {
+            this.camera.fov = state.fov;
+            this.camera.updateProjectionMatrix();
+        }
+        this.controls.update();
+    }
+    getCameraState() {
+        return {
+            position: [this.camera.position.x, this.camera.position.y, this.camera.position.z],
+            target: [this.controls.target.x, this.controls.target.y, this.controls.target.z],
+            fov: this.camera.fov,
+        };
+    }
+    async capturePng() {
+        const width = this.renderer.domElement.width || 1;
+        const height = this.renderer.domElement.height || 1;
+        const target = new THREE.WebGLRenderTarget(width, height);
+        const previousTarget = this.renderer.getRenderTarget();
+        this.renderer.setRenderTarget(target);
+        // Render without postfx for now (upgrade later)
+        this.renderer.render(this.scene, this.camera);
+        const buffer = new Uint8Array(width * height * 4);
+        this.renderer.readRenderTargetPixels(target, 0, 0, width, height, buffer);
+        this.renderer.setRenderTarget(previousTarget);
+        target.dispose();
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            return new Blob();
+        }
+        const imageData = ctx.createImageData(width, height);
+        const rowSize = width * 4;
+        for (let y = 0; y < height; y += 1) {
+            const src = (height - 1 - y) * rowSize;
+            const dst = y * rowSize;
+            imageData.data.set(buffer.subarray(src, src + rowSize), dst);
+        }
+        ctx.putImageData(imageData, 0, 0);
+        return new Promise((resolve) => {
+            canvas.toBlob((blob) => resolve(blob ?? new Blob()), "image/png");
+        });
+    }
+    getSnapshot() {
+        const envState = this.environmentSystem.getState();
+        return {
+            capturedAt: new Date().toISOString(),
+            presetId: this.presetId,
+            renderer: {
+                toneMapping: String(this.renderer.toneMapping),
+                toneMappingExposure: this.renderer.toneMappingExposure,
+                outputColorSpace: String(this.renderer.outputColorSpace),
+            },
+            environment: envState,
+            postfx: this.postFxSystem.getState(),
+        };
+    }
+    applyPreset(presetId) {
+        const preset = this.resolvePreset(presetId);
+        this.presetId = preset.id;
+        applyRendererConfig(this.renderer, preset.renderer);
+        void this.environmentSystem.apply(preset);
+        this.lightingSystem.apply(preset);
+        this.postFxSystem.apply(preset.postfx);
+        this.debugSystem.apply(preset);
+    }
+    resolvePreset(presetId) {
+        if (presetId in this.presets)
+            return this.presets[presetId];
+        if (DEFAULT_PRESET_ID in this.presets)
+            return this.presets[DEFAULT_PRESET_ID];
+        return Object.values(this.presets)[0] ?? DEFAULT_PRESETS[DEFAULT_PRESET_ID];
+    }
+}

package/dist/engine/createViewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createViewer.d.ts","sourceRoot":"","sources":["../../src/engine/createViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAkB,MAAM,SAAS,CAAC;AAIjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CA0DvE"}
+{"version":3,"file":"createViewer.d.ts","sourceRoot":"","sources":["../../src/engine/createViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGjE,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAKvE"}

package/dist/engine/createViewer.js

@@ -1,57 +1,7 @@
-// NOTE: Stub engine: this exists to stabilize API and publishing early.
-// Rendering systems (Three.js) will be implemented next without breaking the surface area.
+import { ViewerEngine } from "./ViewerEngine";
 export function createViewer(options) {
-    const { hooks } = options;
-    let running = false;
-    let presetId = options.presetId;
-    const snapshot = () => ({
-        capturedAt: new Date().toISOString(),
-        presetId,
-        renderer: {
-            toneMapping: "NeutralToneMapping",
-            toneMappingExposure: 1.0,
-            outputColorSpace: "SRGBColorSpace",
-        },
-        environment: {
-            mode: "none",
-            backgroundEnabled: false,
-            lightingEnabled: false,
-        },
-    });
-    const handle = {
-        start() {
-            running = true;
-        },
-        stop() {
-            running = false;
-        },
-        resize() {
-            void running;
-        },
-        dispose() {
-            running = false;
-        },
-        setPreset(nextPresetId) {
-            presetId = nextPresetId;
-        },
-        setSceneRoot(_root) {
-            // placeholder
-        },
-        async capturePng() {
-            // placeholder blob (transparent 1x1 PNG)
-            const bytes = Uint8Array.from([
-                0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48,
-                0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00,
-                0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00, 0x0a, 0x49, 0x44, 0x41, 0x54, 0x78,
-                0x9c, 0x63, 0x00, 0x01, 0x00, 0x00, 0x05, 0x00, 0x01, 0x0d, 0x0a, 0x2d, 0xb4, 0x00,
-                0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
-            ]);
-            return new Blob([bytes], { type: "image/png" });
-        },
-        getSnapshot() {
-            return snapshot();
-        },
-    };
-    queueMicrotask(() => hooks?.onReady?.(handle));
+    const engine = new ViewerEngine(options);
+    const handle = engine.getHandle();
+    queueMicrotask(() => options.hooks?.onReady?.(handle));
     return handle;
 }

package/dist/engine/types.d.ts

@@ -4,6 +4,110 @@ export type AssetResolverResult = {
     headers?: Record<string, string>;
 };
 export type AssetResolver = (src: string, kind: AssetKind) => Promise<AssetResolverResult>;
+export type ToneMappingMode = "neutral" | "aces" | "linear";
+export type RendererConfig = {
+    toneMapping?: ToneMappingMode;
+    toneMappingExposure?: number;
+    outputColorSpace?: "srgb" | "linear";
+    maxPixelRatio?: number;
+    antialias?: boolean;
+    alpha?: boolean;
+    preserveDrawingBuffer?: boolean;
+    shadowMap?: {
+        enabled?: boolean;
+        type?: "pcfsoft" | "pcf" | "basic";
+    };
+};
+export type SkyGradientConfig = {
+    topColor: string;
+    horizonColor: string;
+    sunPosition: [number, number, number];
+    sunIntensity: number;
+    sunSize: number;
+};
+export type SkyHdrConfig = {
+    src: string;
+    exposure?: number;
+    rotationY?: number;
+    showBackground?: boolean;
+    showLighting?: boolean;
+    pmremResolution?: 256 | 512 | 1024;
+    usePmrem?: boolean;
+};
+export type SkyCubeConfig = {
+    px: string;
+    nx: string;
+    py: string;
+    ny: string;
+    pz: string;
+    nz: string;
+    exposure?: number;
+    rotationY?: number;
+    showBackground?: boolean;
+    showLighting?: boolean;
+    pmremResolution?: 256 | 512 | 1024;
+    usePmrem?: boolean;
+};
+export type SkyDefinition = {
+    mode: "none";
+} | {
+    mode: "gradient";
+    gradient: SkyGradientConfig;
+} | {
+    mode: "hdr";
+    hdr: SkyHdrConfig;
+} | {
+    mode: "cube";
+    cube: SkyCubeConfig;
+};
+export type LightingRigConfig = {
+    rig?: "studio" | "neutral" | "gallery" | "none";
+    ambient?: {
+        color: string;
+        intensity: number;
+    };
+    hemisphere?: {
+        skyColor: string;
+        groundColor: string;
+        intensity: number;
+    };
+    key?: {
+        color: string;
+        intensity: number;
+        position: [number, number, number];
+        castShadow?: boolean;
+    };
+    fill?: {
+        color: string;
+        intensity: number;
+        position: [number, number, number];
+    };
+};
+export type PostFxConfig = {
+    ao?: {
+        enabled: boolean;
+        intensity?: number;
+        radius?: number;
+        distanceFalloff?: number;
+        halfRes?: boolean;
+    };
+};
+export type SceneExtrasConfig = {
+    grid?: boolean;
+    ground?: boolean;
+    axes?: boolean;
+    origin?: boolean;
+};
+export type RenderPresetDefinition = {
+    id: string;
+    label?: string;
+    renderer?: RendererConfig;
+    sky?: SkyDefinition;
+    lighting?: LightingRigConfig;
+    postfx?: PostFxConfig;
+    sceneExtras?: SceneExtrasConfig;
+};
+export type PresetCatalog = Record<string, RenderPresetDefinition>;
 export type ViewerSnapshot = {
     capturedAt: string;
     presetId: string;
@@ -17,11 +121,33 @@ export type ViewerSnapshot = {
         backgroundEnabled: boolean;
         lightingEnabled: boolean;
     };
+    postfx: {
+        aoEnabled: boolean;
+    };
+};
+export type CameraState = {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number;
 };
 export type ViewerCreateOptions = {
     container: HTMLElement;
-    presetId: string;
+    presetId?: string;
+    presets?: PresetCatalog;
     assetResolver?: AssetResolver;
+    renderer?: {
+        antialias?: boolean;
+        alpha?: boolean;
+        preserveDrawingBuffer?: boolean;
+    };
+    camera?: {
+        fov?: number;
+        near?: number;
+        far?: number;
+        position?: [number, number, number];
+        target?: [number, number, number];
+    };
+    usePostprocessing?: boolean;
     hooks?: {
         onReady?: (handle: ViewerHandle) => void;
         onError?: (error: unknown) => void;
@@ -34,6 +160,8 @@ export type ViewerHandle = {
     dispose(): void;
     setPreset(presetId: string): void;
     setSceneRoot(root: unknown): void;
+    setCamera(state: Partial<CameraState>): void;
+    getCameraState(): CameraState;
     capturePng(): Promise<Blob>;
     getSnapshot(): ViewerSnapshot;
 };

package/dist/engine/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/engine/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;AAEvD,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAE3F,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;QAC3C,iBAAiB,EAAE,OAAO,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,WAAW,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;QACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;KACpC,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;IAEhB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAElC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,cAAc,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/engine/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;AAEvD,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAE3F,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,IAAI,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;KACpC,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAChD,OAAO,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,UAAU,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,GAAG,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACrG,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;CACjF,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,CAAC,EAAE;QACH,OAAO,EAAE,OAAO,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;QAC3C,iBAAiB,EAAE,OAAO,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE;QACN,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,WAAW,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,EAAE;QACT,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,CAAC;IACF,MAAM,CAAC,EAAE;QACP,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;KACnC,CAAC;IACF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;QACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;KACpC,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;IAEhB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IAC7C,cAAc,IAAI,WAAW,CAAC;IAE9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,cAAc,CAAC;CAC/B,CAAC"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export type { ViewerCreateOptions, ViewerHandle, ViewerSnapshot } from "./engine/types";
+export type { ViewerCreateOptions, ViewerHandle, ViewerSnapshot, CameraState, RenderPresetDefinition, PresetCatalog, } from "./engine/types";
 export { createViewer } from "./engine/createViewer";
+export { DEFAULT_PRESET_ID, DEFAULT_PRESETS } from "./presets/defaults";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,WAAW,EACX,sBAAsB,EACtB,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -1 +1,2 @@
 export { createViewer } from "./engine/createViewer";
+export { DEFAULT_PRESET_ID, DEFAULT_PRESETS } from "./presets/defaults";

package/dist/presets/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { PresetCatalog } from "../engine/types";
+export declare const DEFAULT_PRESET_ID = "default-studio";
+export declare const DEFAULT_PRESETS: PresetCatalog;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/presets/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD,eAAO,MAAM,eAAe,EAAE,aA2C7B,CAAC"}

package/dist/presets/defaults.js

@@ -0,0 +1,45 @@
+export const DEFAULT_PRESET_ID = "default-studio";
+export const DEFAULT_PRESETS = {
+    [DEFAULT_PRESET_ID]: {
+        id: DEFAULT_PRESET_ID,
+        label: "Default Studio",
+        renderer: {
+            toneMapping: "neutral",
+            toneMappingExposure: 1.0,
+            outputColorSpace: "srgb",
+            maxPixelRatio: 1.75,
+            antialias: true,
+            alpha: true,
+            shadowMap: {
+                enabled: true,
+                type: "pcfsoft",
+            },
+        },
+        sky: {
+            mode: "gradient",
+            gradient: {
+                topColor: "#ffffff",
+                horizonColor: "#d8d8d8",
+                sunPosition: [0.3, 0.8, 0.4],
+                sunIntensity: 0.15,
+                sunSize: 0.08,
+            },
+        },
+        lighting: {
+            rig: "studio",
+            ambient: { color: "#ffffff", intensity: 1.0 },
+            hemisphere: { skyColor: "#ffffff", groundColor: "#f4f4f4", intensity: 1.2 },
+            key: { color: "#ffffff", intensity: 1.6, position: [10, 15, 5], castShadow: true },
+            fill: { color: "#ffffff", intensity: 0.6, position: [-10, 10, -5] },
+        },
+        postfx: {
+            ao: { enabled: false, intensity: 1.0, radius: 2.0, distanceFalloff: 1.0, halfRes: false },
+        },
+        sceneExtras: {
+            grid: true,
+            ground: true,
+            axes: false,
+            origin: true,
+        },
+    },
+};

package/dist/systems/debugSystem.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+import type { RenderPresetDefinition } from "../engine/types";
+export declare class DebugSystem {
+    private scene;
+    private objects;
+    constructor(scene: THREE.Scene);
+    apply(preset: RenderPresetDefinition): void;
+    dispose(): void;
+    private add;
+    private clear;
+}
+//# sourceMappingURL=debugSystem.d.ts.map

package/dist/systems/debugSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugSystem.d.ts","sourceRoot":"","sources":["../../src/systems/debugSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAqB,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AASjF,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAwB;gBAE3B,KAAK,EAAE,KAAK,CAAC,KAAK;IAI9B,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAwC3C,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,KAAK;CAed"}

package/dist/systems/debugSystem.js

@@ -0,0 +1,73 @@
+import * as THREE from "three";
+const DEFAULT_EXTRAS = {
+    grid: true,
+    ground: true,
+    axes: false,
+    origin: true,
+};
+export class DebugSystem {
+    scene;
+    objects = [];
+    constructor(scene) {
+        this.scene = scene;
+    }
+    apply(preset) {
+        const extras = { ...DEFAULT_EXTRAS, ...(preset.sceneExtras ?? {}) };
+        this.clear();
+        if (extras.ground) {
+            const groundGeometry = new THREE.PlaneGeometry(300, 300);
+            const groundMaterial = new THREE.MeshStandardMaterial({
+                color: 0xf5f5f5,
+                roughness: 0.75,
+                metalness: 0.0,
+                toneMapped: false,
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            ground.position.y = -0.11;
+            ground.receiveShadow = true;
+            this.add(ground);
+        }
+        if (extras.grid) {
+            const gridHelper = new THREE.GridHelper(100, 50, 0xdedede, 0xeaeaea);
+            gridHelper.position.y = -0.09;
+            this.add(gridHelper);
+        }
+        if (extras.axes) {
+            const axes = new THREE.AxesHelper(3);
+            axes.position.set(-15, 0.1, -15);
+            this.add(axes);
+        }
+        if (extras.origin) {
+            const originGeometry = new THREE.SphereGeometry(0.1, 16, 16);
+            const originMaterial = new THREE.MeshBasicMaterial({ color: 0x666666 });
+            const origin = new THREE.Mesh(originGeometry, originMaterial);
+            origin.position.set(0, 0, 0);
+            this.add(origin);
+        }
+    }
+    dispose() {
+        this.clear();
+    }
+    add(object) {
+        this.scene.add(object);
+        this.objects.push(object);
+    }
+    clear() {
+        this.objects.forEach((object) => {
+            if (object.parent)
+                object.parent.remove(object);
+            if (object instanceof THREE.Mesh) {
+                object.geometry.dispose();
+                const material = object.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material.dispose?.();
+                }
+            }
+        });
+        this.objects = [];
+    }
+}

package/dist/systems/environmentSystem.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+import type { AssetResolver, RenderPresetDefinition } from "../engine/types";
+export type EnvironmentState = {
+    mode: "none" | "gradient" | "hdr" | "cube";
+    backgroundEnabled: boolean;
+    lightingEnabled: boolean;
+};
+export declare class EnvironmentSystem {
+    private scene;
+    private renderer;
+    private assetResolver?;
+    private pmremGenerator;
+    private currentObjects;
+    private currentBackground;
+    private currentEnvironment;
+    private objectUrls;
+    private loadToken;
+    private state;
+    constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer, assetResolver?: AssetResolver);
+    getState(): EnvironmentState;
+    apply(preset: RenderPresetDefinition): Promise<void>;
+    dispose(): void;
+    private disposeCurrent;
+    private applyGradientSky;
+    private resolveAsset;
+    private applyHdrSky;
+    private applyCubeSky;
+}
+//# sourceMappingURL=environmentSystem.d.ts.map

package/dist/systems/environmentSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentSystem.d.ts","sourceRoot":"","sources":["../../src/systems/environmentSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAA8C,MAAM,iBAAiB,CAAC;AAEzH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;IAC3C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,cAAc,CAAqC;IAE3D,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,iBAAiB,CAAkD;IAC3E,OAAO,CAAC,kBAAkB,CAAkD;IAC5E,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,KAAK,CAAwF;gBAEzF,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,aAAa;IAM5F,QAAQ,IAAI,gBAAgB;IAItB,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B1D,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,gBAAgB;YA6CV,YAAY;YAaZ,WAAW;YAqDX,YAAY;CAiD3B"}

package/dist/systems/environmentSystem.js

@@ -0,0 +1,232 @@
+import * as THREE from "three";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
+export class EnvironmentSystem {
+    scene;
+    renderer;
+    assetResolver;
+    pmremGenerator = null;
+    currentObjects = [];
+    currentBackground = null;
+    currentEnvironment = null;
+    objectUrls = [];
+    loadToken = 0;
+    state = { mode: "none", backgroundEnabled: false, lightingEnabled: false };
+    constructor(scene, renderer, assetResolver) {
+        this.scene = scene;
+        this.renderer = renderer;
+        this.assetResolver = assetResolver;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    async apply(preset) {
+        const sky = preset.sky;
+        this.disposeCurrent();
+        if (!sky || sky.mode === "none") {
+            this.scene.background = null;
+            this.scene.environment = null;
+            this.state = { mode: "none", backgroundEnabled: false, lightingEnabled: false };
+            return;
+        }
+        if (sky.mode === "gradient") {
+            this.applyGradientSky(sky.gradient);
+            this.state = { mode: "gradient", backgroundEnabled: true, lightingEnabled: false };
+            return;
+        }
+        if (sky.mode === "hdr") {
+            await this.applyHdrSky(sky.hdr);
+            return;
+        }
+        if (sky.mode === "cube") {
+            await this.applyCubeSky(sky.cube);
+        }
+    }
+    dispose() {
+        this.disposeCurrent();
+        if (this.pmremGenerator) {
+            this.pmremGenerator.dispose();
+            this.pmremGenerator = null;
+        }
+    }
+    disposeCurrent() {
+        this.currentObjects.forEach((obj) => {
+            if (obj.parent)
+                obj.parent.remove(obj);
+            if (obj instanceof THREE.Mesh) {
+                obj.geometry.dispose();
+                const material = obj.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material.dispose?.();
+                }
+            }
+        });
+        this.currentObjects = [];
+        if (this.scene.background === this.currentBackground) {
+            this.scene.background = null;
+        }
+        if (this.scene.environment === this.currentEnvironment) {
+            this.scene.environment = null;
+        }
+        if (this.currentBackground)
+            this.currentBackground.dispose();
+        if (this.currentEnvironment && this.currentEnvironment !== this.currentBackground) {
+            this.currentEnvironment.dispose();
+        }
+        this.currentBackground = null;
+        this.currentEnvironment = null;
+        this.objectUrls.forEach((url) => URL.revokeObjectURL(url));
+        this.objectUrls = [];
+    }
+    applyGradientSky(gradient) {
+        const skyGeometry = new THREE.SphereGeometry(300, 64, 64);
+        const skyMaterial = new THREE.ShaderMaterial({
+            uniforms: {
+                topColor: { value: new THREE.Color(gradient.topColor) },
+                horizonColor: { value: new THREE.Color(gradient.horizonColor) },
+                sunPosition: { value: new THREE.Vector3(...gradient.sunPosition) },
+                sunIntensity: { value: gradient.sunIntensity },
+                sunSize: { value: gradient.sunSize },
+            },
+            vertexShader: `
+        varying vec3 vPosition;
+        void main() {
+          vPosition = position;
+          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+        }
+      `,
+            fragmentShader: `
+        uniform vec3 topColor;
+        uniform vec3 horizonColor;
+        uniform vec3 sunPosition;
+        uniform float sunIntensity;
+        uniform float sunSize;
+        varying vec3 vPosition;
+        void main() {
+          vec3 direction = normalize(vPosition);
+          float h = direction.y;
+          float gradientFactor = smoothstep(-0.1, 0.4, h);
+          vec3 color = mix(horizonColor, topColor, gradientFactor);
+          vec3 sunDir = normalize(sunPosition);
+          float sunDist = distance(direction, sunDir);
+          float sun = smoothstep(sunSize, 0.0, sunDist) * sunIntensity;
+          color = mix(color, topColor, sun);
+          gl_FragColor = vec4(color, 1.0);
+        }
+      `,
+            side: THREE.BackSide,
+            depthWrite: false,
+        });
+        const sky = new THREE.Mesh(skyGeometry, skyMaterial);
+        sky.renderOrder = -1;
+        this.scene.add(sky);
+        this.currentObjects.push(sky);
+    }
+    async resolveAsset(src, kind) {
+        if (!this.assetResolver)
+            return src;
+        const { url, headers } = await this.assetResolver(src, kind);
+        if (!headers || Object.keys(headers).length === 0)
+            return url;
+        const response = await fetch(url, { headers });
+        if (!response.ok)
+            throw new Error(`Asset fetch failed: ${response.status}`);
+        const blob = await response.blob();
+        const objectUrl = URL.createObjectURL(blob);
+        this.objectUrls.push(objectUrl);
+        return objectUrl;
+    }
+    async applyHdrSky(hdr) {
+        const token = ++this.loadToken;
+        const backgroundEnabled = hdr.showBackground !== false;
+        const lightingEnabled = hdr.showLighting !== false;
+        const usePmrem = hdr.usePmrem !== false;
+        const resolved = await this.resolveAsset(hdr.src, "hdr");
+        if (token !== this.loadToken)
+            return;
+        const loader = new RGBELoader();
+        const texture = await loader.loadAsync(resolved);
+        if (token !== this.loadToken) {
+            texture.dispose();
+            return;
+        }
+        texture.mapping = THREE.EquirectangularReflectionMapping;
+        texture.colorSpace = THREE.LinearSRGBColorSpace;
+        texture.needsUpdate = true;
+        texture.center = new THREE.Vector2(0.5, 0.5);
+        if (typeof hdr.rotationY === "number") {
+            texture.rotation = hdr.rotationY;
+        }
+        let environmentTexture = null;
+        if (lightingEnabled) {
+            if (usePmrem) {
+                if (!this.pmremGenerator) {
+                    this.pmremGenerator = new THREE.PMREMGenerator(this.renderer);
+                    this.pmremGenerator.compileEquirectangularShader();
+                }
+                environmentTexture = this.pmremGenerator.fromEquirectangular(texture).texture;
+            }
+            else {
+                environmentTexture = texture;
+            }
+        }
+        if (backgroundEnabled) {
+            this.scene.background = texture;
+            this.currentBackground = texture;
+        }
+        if (environmentTexture) {
+            this.scene.environment = environmentTexture;
+            this.currentEnvironment = environmentTexture;
+            if (environmentTexture !== texture) {
+                this.currentEnvironment = environmentTexture;
+            }
+        }
+        this.state = { mode: "hdr", backgroundEnabled, lightingEnabled };
+    }
+    async applyCubeSky(cube) {
+        const token = ++this.loadToken;
+        const backgroundEnabled = cube.showBackground !== false;
+        const lightingEnabled = cube.showLighting !== false;
+        const usePmrem = cube.usePmrem !== false;
+        const faces = await Promise.all([
+            this.resolveAsset(cube.px, "cubeface"),
+            this.resolveAsset(cube.nx, "cubeface"),
+            this.resolveAsset(cube.py, "cubeface"),
+            this.resolveAsset(cube.ny, "cubeface"),
+            this.resolveAsset(cube.pz, "cubeface"),
+            this.resolveAsset(cube.nz, "cubeface"),
+        ]);
+        if (token !== this.loadToken)
+            return;
+        const loader = new THREE.CubeTextureLoader();
+        const texture = await loader.loadAsync(faces);
+        if (token !== this.loadToken) {
+            texture.dispose();
+            return;
+        }
+        texture.needsUpdate = true;
+        let environmentTexture = null;
+        if (lightingEnabled) {
+            if (usePmrem) {
+                if (!this.pmremGenerator) {
+                    this.pmremGenerator = new THREE.PMREMGenerator(this.renderer);
+                }
+                environmentTexture = this.pmremGenerator.fromCubemap(texture).texture;
+            }
+            else {
+                environmentTexture = texture;
+            }
+        }
+        if (backgroundEnabled) {
+            this.scene.background = texture;
+            this.currentBackground = texture;
+        }
+        if (environmentTexture) {
+            this.scene.environment = environmentTexture;
+            this.currentEnvironment = environmentTexture;
+        }
+        this.state = { mode: "cube", backgroundEnabled, lightingEnabled };
+    }
+}

package/dist/systems/lightingSystem.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+import type { RenderPresetDefinition } from "../engine/types";
+export declare class LightingSystem {
+    private scene;
+    private lights;
+    constructor(scene: THREE.Scene);
+    apply(preset: RenderPresetDefinition): void;
+    dispose(): void;
+    private add;
+    private clear;
+}
+//# sourceMappingURL=lightingSystem.d.ts.map

package/dist/systems/lightingSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightingSystem.d.ts","sourceRoot":"","sources":["../../src/systems/lightingSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAqB,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAUjF,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAAqB;gBAEvB,KAAK,EAAE,KAAK,CAAC,KAAK;IAI9B,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAqC3C,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,KAAK;CAMd"}

package/dist/systems/lightingSystem.js

@@ -0,0 +1,58 @@
+import * as THREE from "three";
+const DEFAULT_LIGHTING = {
+    rig: "studio",
+    ambient: { color: "#ffffff", intensity: 0.8 },
+    hemisphere: { skyColor: "#ffffff", groundColor: "#f4f4f4", intensity: 1.0 },
+    key: { color: "#ffffff", intensity: 1.4, position: [10, 15, 5], castShadow: true },
+    fill: { color: "#ffffff", intensity: 0.5, position: [-10, 10, -5] },
+};
+export class LightingSystem {
+    scene;
+    lights = [];
+    constructor(scene) {
+        this.scene = scene;
+    }
+    apply(preset) {
+        this.clear();
+        const config = preset.lighting ?? DEFAULT_LIGHTING;
+        if (config.rig === "none")
+            return;
+        const ambient = config.ambient ?? DEFAULT_LIGHTING.ambient;
+        if (ambient && ambient.intensity > 0) {
+            const light = new THREE.AmbientLight(new THREE.Color(ambient.color), ambient.intensity);
+            this.add(light);
+        }
+        const hemi = config.hemisphere ?? DEFAULT_LIGHTING.hemisphere;
+        if (hemi && hemi.intensity > 0) {
+            const light = new THREE.HemisphereLight(new THREE.Color(hemi.skyColor), new THREE.Color(hemi.groundColor), hemi.intensity);
+            this.add(light);
+        }
+        const key = config.key ?? DEFAULT_LIGHTING.key;
+        if (key && key.intensity > 0) {
+            const light = new THREE.DirectionalLight(new THREE.Color(key.color), key.intensity);
+            light.position.set(...key.position);
+            light.castShadow = key.castShadow ?? false;
+            this.add(light);
+        }
+        const fill = config.fill ?? DEFAULT_LIGHTING.fill;
+        if (fill && fill.intensity > 0) {
+            const light = new THREE.DirectionalLight(new THREE.Color(fill.color), fill.intensity);
+            light.position.set(...fill.position);
+            this.add(light);
+        }
+    }
+    dispose() {
+        this.clear();
+    }
+    add(light) {
+        this.scene.add(light);
+        this.lights.push(light);
+    }
+    clear() {
+        this.lights.forEach((light) => {
+            if (light.parent)
+                light.parent.remove(light);
+        });
+        this.lights = [];
+    }
+}

package/dist/systems/postfxSystem.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from "three";
+import type { PostFxConfig } from "../engine/types";
+export declare class PostFxSystem {
+    private renderer;
+    private scene;
+    private camera;
+    private composer;
+    private renderPass;
+    private aoPass;
+    private enabled;
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.PerspectiveCamera);
+    apply(config?: PostFxConfig): void;
+    render(): void;
+    resize(width: number, height: number): void;
+    dispose(): void;
+    getState(): {
+        aoEnabled: boolean;
+    };
+}
+//# sourceMappingURL=postfxSystem.d.ts.map

package/dist/systems/postfxSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postfxSystem.d.ts","sourceRoot":"","sources":["../../src/systems/postfxSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,OAAO,CAAS;gBAEZ,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,iBAAiB;IAM9F,KAAK,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI;IA6BlC,MAAM,IAAI,IAAI;IAQd,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAS3C,OAAO,IAAI,IAAI;IAUf,QAAQ,IAAI;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE;CAGnC"}

package/dist/systems/postfxSystem.js

@@ -0,0 +1,73 @@
+import { EffectComposer, RenderPass } from "postprocessing";
+import { N8AOPostPass } from "n8ao";
+export class PostFxSystem {
+    renderer;
+    scene;
+    camera;
+    composer = null;
+    renderPass = null;
+    aoPass = null;
+    enabled = false;
+    constructor(renderer, scene, camera) {
+        this.renderer = renderer;
+        this.scene = scene;
+        this.camera = camera;
+    }
+    apply(config) {
+        const ao = config?.ao;
+        const shouldEnable = Boolean(ao?.enabled);
+        if (!shouldEnable) {
+            this.enabled = false;
+            if (this.aoPass)
+                this.aoPass.enabled = false;
+            return;
+        }
+        if (!this.composer) {
+            this.composer = new EffectComposer(this.renderer);
+            this.renderPass = new RenderPass(this.scene, this.camera);
+            this.composer.addPass(this.renderPass);
+            this.aoPass = new N8AOPostPass(this.scene, this.camera, this.renderer.domElement.width, this.renderer.domElement.height);
+            this.composer.addPass(this.aoPass);
+        }
+        this.enabled = true;
+        if (this.aoPass) {
+            this.aoPass.enabled = true;
+            if (ao?.intensity !== undefined)
+                this.aoPass.configuration.intensity = ao.intensity;
+            if (ao?.radius !== undefined)
+                this.aoPass.configuration.aoRadius = ao.radius;
+            if (ao?.distanceFalloff !== undefined)
+                this.aoPass.configuration.distanceFalloff = ao.distanceFalloff;
+            if (ao?.halfRes !== undefined)
+                this.aoPass.configuration.halfRes = ao.halfRes;
+            this.aoPass.firstFrame?.();
+        }
+    }
+    render() {
+        if (this.enabled && this.composer) {
+            this.composer.render();
+            return;
+        }
+        this.renderer.render(this.scene, this.camera);
+    }
+    resize(width, height) {
+        if (this.composer) {
+            this.composer.setSize(width, height);
+        }
+        if (this.aoPass) {
+            this.aoPass.setSize(width, height);
+        }
+    }
+    dispose() {
+        if (this.composer) {
+            this.composer.dispose();
+        }
+        this.renderPass = null;
+        this.aoPass = null;
+        this.composer = null;
+        this.enabled = false;
+    }
+    getState() {
+        return { aoEnabled: Boolean(this.aoPass?.enabled) };
+    }
+}

package/dist/systems/rendererSystem.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from "three";
+import type { RendererConfig } from "../engine/types";
+export declare function applyRendererConfig(renderer: THREE.WebGLRenderer, config?: RendererConfig): void;
+//# sourceMappingURL=rendererSystem.d.ts.map

package/dist/systems/rendererSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendererSystem.d.ts","sourceRoot":"","sources":["../../src/systems/rendererSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAmB,MAAM,iBAAiB,CAAC;AAsBvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAuBhG"}

package/dist/systems/rendererSystem.js

@@ -0,0 +1,42 @@
+import * as THREE from "three";
+const DEFAULT_CONFIG = {
+    toneMapping: "neutral",
+    toneMappingExposure: 1.0,
+    outputColorSpace: "srgb",
+    maxPixelRatio: 1.75,
+    antialias: true,
+    alpha: true,
+    preserveDrawingBuffer: false,
+    shadowMap: {
+        enabled: true,
+        type: "pcfsoft",
+    },
+};
+const toneMappingMap = {
+    neutral: THREE.NeutralToneMapping,
+    aces: THREE.ACESFilmicToneMapping,
+    linear: THREE.LinearToneMapping,
+};
+export function applyRendererConfig(renderer, config) {
+    const merged = {
+        ...DEFAULT_CONFIG,
+        ...(config ?? {}),
+        shadowMap: { ...DEFAULT_CONFIG.shadowMap, ...(config?.shadowMap ?? {}) },
+    };
+    const targetRatio = typeof window !== "undefined" ? window.devicePixelRatio : 1;
+    renderer.setPixelRatio(Math.min(targetRatio, merged.maxPixelRatio));
+    renderer.outputColorSpace =
+        merged.outputColorSpace === "linear" ? THREE.LinearSRGBColorSpace : THREE.SRGBColorSpace;
+    renderer.toneMapping = toneMappingMap[merged.toneMapping];
+    renderer.toneMappingExposure = merged.toneMappingExposure;
+    renderer.shadowMap.enabled = merged.shadowMap.enabled ?? true;
+    if (merged.shadowMap.type === "pcf") {
+        renderer.shadowMap.type = THREE.PCFShadowMap;
+    }
+    else if (merged.shadowMap.type === "basic") {
+        renderer.shadowMap.type = THREE.BasicShadowMap;
+    }
+    else {
+        renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base2datadesign/viewer-kit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "license": "UNLICENSED",
   "main": "./dist/index.js",
@@ -17,6 +17,17 @@
   "publishConfig": {
     "access": "public"
   },
+  "peerDependencies": {
+    "three": "^0.180.0",
+    "postprocessing": "^6.37.8",
+    "n8ao": "^1.10.1"
+  },
+  "devDependencies": {
+    "@types/three": "^0.178.1",
+    "three": "^0.180.0",
+    "postprocessing": "^6.37.8",
+    "n8ao": "^1.10.1"
+  },
   "scripts": {
     "build": "tsc -b",
     "typecheck": "tsc -b --pretty false --noEmit"