@treasuryspatial/viewer-kit 0.2.31

package/dist/sky/scienceSky.js

@@ -0,0 +1,85 @@
+const HDR_BASE = "https://assets.treasury.space/science/hdr/shared";
+const SCIENCE_SKY_OPTIONS = [
+    {
+        id: "preset",
+        label: "Preset Dome",
+        description: "Use the sky gradient defined by the active render preset.",
+    },
+    {
+        id: "debug-cube",
+        label: "Debug Cubemap",
+        description: "Axis/orientation test (E/W/N/S/U/D)",
+        sky: {
+            mode: "cube",
+            cube: {
+                px: "/debug/skybox/px.png",
+                nx: "/debug/skybox/nx.png",
+                py: "/debug/skybox/py.png",
+                ny: "/debug/skybox/ny.png",
+                pz: "/debug/skybox/pz.png",
+                nz: "/debug/skybox/nz.png",
+                exposure: 1.0,
+            },
+        },
+    },
+    {
+        id: "canary-wharf",
+        label: "Canary Wharf",
+        description: "Golden-hour skyline reflections",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/canary_wharf_4k.hdr`, exposure: 1.1 },
+        },
+    },
+    {
+        id: "kloofendal",
+        label: "Kloofendal Sky",
+        description: "Bright partly cloudy daylight",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/kloofendal_48d_partly_cloudy_puresky_4k.hdr`, exposure: 1.0 },
+        },
+    },
+    {
+        id: "venetian-crossroads",
+        label: "Venetian Crossroads",
+        description: "Cool overcast reflections",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/venetian_crossroads_4k.hdr`, exposure: 1.05 },
+        },
+    },
+    {
+        id: "rural-road",
+        label: "Rural Evening",
+        description: "Warm sunset horizon",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/rural_evening_road_4k.hdr`, exposure: 1.2 },
+        },
+    },
+    {
+        id: "spruit-sunrise",
+        label: "Spruit Sunrise",
+        description: "Soft morning bounce",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/spruit_sunrise_4k.hdr`, exposure: 1.08 },
+        },
+    },
+    {
+        id: "dikhololo-night",
+        label: "Dikhololo Night",
+        description: "Night sky with subtle fill",
+        sky: {
+            mode: "hdr",
+            hdr: { src: `${HDR_BASE}/dikhololo_night_4k.hdr`, exposure: 0.65 },
+        },
+    },
+];
+export function listScienceSkyOptions() {
+    return SCIENCE_SKY_OPTIONS;
+}
+export function getScienceSkyOption(id) {
+    return SCIENCE_SKY_OPTIONS.find((option) => option.id === id);
+}

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, bounds?: THREE.Box3 | null): 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;AAsKjF,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAwB;gBAE3B,KAAK,EAAE,KAAK,CAAC,KAAK;IAI9B,KAAK,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI;IAuFvE,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,KAAK;CAmCd"}

package/dist/systems/debugSystem.js

@@ -0,0 +1,283 @@
+import * as THREE from "three";
+const DEFAULT_EXTRAS = {
+    grid: true,
+    ground: true,
+    axes: true,
+    origin: true,
+    gridOpacity: 0.12,
+    gridDivisions: 100,
+    gridSize: 100,
+    groundRoughness: 0.8,
+    groundMetalness: 0.05,
+    lightTarget: [0, 1.5, 0],
+    originHighlight: true,
+    originLineColor: 0x94a3b8,
+    originLineLength: 40,
+    originLineThickness: 0.06,
+    axisLabelScale: 0.35,
+    axesLabels: {
+        lowerCase: true,
+        upperCase: true,
+        offset: 0.4,
+        secondaryOffset: 0.5,
+    },
+};
+const DEFAULT_GRID_SIZE = 100;
+const DEFAULT_GRID_DIVISIONS = 100;
+const DEFAULT_GRID_OPACITY = 0.12;
+const DEFAULT_GRID_HEIGHT_OFFSET = 0.02;
+const DEFAULT_GROUND_OFFSET = -0.11;
+const HDR_GROUND_SIZE = 30;
+const HDR_GRID_SIZE = 30;
+const AXIS_COLORS = {
+    x: 0xef4444,
+    y: 0x22c55e,
+    z: 0x3b82f6,
+};
+function createCanvasLabel(text, color) {
+    if (typeof document === "undefined")
+        return null;
+    const canvas = document.createElement("canvas");
+    const size = 128;
+    canvas.width = canvas.height = size;
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+        return null;
+    ctx.clearRect(0, 0, size, size);
+    ctx.font = 'bold 68px "IBM Plex Mono", monospace';
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillStyle = new THREE.Color(color).getStyle();
+    ctx.fillText(text, size / 2, size / 2 + 6);
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    return texture;
+}
+function createAxisLabelSprite(text, color, scale) {
+    const texture = createCanvasLabel(text, color);
+    if (!texture)
+        return null;
+    const material = new THREE.SpriteMaterial({ map: texture, transparent: true, depthTest: false, depthWrite: false });
+    const sprite = new THREE.Sprite(material);
+    sprite.scale.set(scale, scale, scale);
+    sprite.renderOrder = 5;
+    return sprite;
+}
+function buildAxisHelper(extras) {
+    const group = new THREE.Group();
+    const length = 1.8;
+    const coneHeight = 0.25;
+    const coneRadius = 0.07;
+    const labelScale = extras.axisLabelScale ?? 0.35;
+    const labelConfig = extras.axesLabels ?? {};
+    const lowerEnabled = labelConfig.lowerCase !== false;
+    const upperEnabled = labelConfig.upperCase !== false;
+    const lowerOffset = labelConfig.offset ?? 0.35;
+    const upperOffset = lowerOffset + (labelConfig.secondaryOffset ?? 0.2);
+    const rhinoAxisMap = { x: "X", y: "Z", z: "Y" };
+    ["x", "y", "z"].forEach((axis) => {
+        const dir = new THREE.Vector3(axis === "x" ? 1 : 0, axis === "y" ? 1 : 0, axis === "z" ? 1 : 0);
+        const color = AXIS_COLORS[axis];
+        const lineGeometry = new THREE.BufferGeometry().setFromPoints([
+            new THREE.Vector3(0, 0, 0),
+            dir.clone().multiplyScalar(length),
+        ]);
+        const lineMaterial = new THREE.LineBasicMaterial({ color, linewidth: 2 });
+        const line = new THREE.Line(lineGeometry, lineMaterial);
+        group.add(line);
+        const cone = new THREE.Mesh(new THREE.ConeGeometry(coneRadius, coneHeight, 16), new THREE.MeshBasicMaterial({ color }));
+        cone.position.copy(dir.clone().multiplyScalar(length));
+        cone.lookAt(dir.clone().multiplyScalar(length + 0.5));
+        group.add(cone);
+        if (lowerEnabled) {
+            const lowerLabel = createAxisLabelSprite(axis, color, labelScale);
+            if (lowerLabel) {
+                lowerLabel.position.copy(dir.clone().multiplyScalar(length + lowerOffset));
+                group.add(lowerLabel);
+            }
+        }
+        if (upperEnabled) {
+            const rhinoAxis = rhinoAxisMap[axis];
+            const upperLabel = createAxisLabelSprite(rhinoAxis, color, labelScale * 1.1);
+            if (upperLabel) {
+                const offsetDir = dir.clone().multiplyScalar(length + upperOffset);
+                upperLabel.position.copy(offsetDir);
+                group.add(upperLabel);
+            }
+        }
+    });
+    return group;
+}
+function buildOriginCross(extras, gridSize, groundY) {
+    const group = new THREE.Group();
+    const length = extras.originLineLength ?? gridSize / 2;
+    const thickness = extras.originLineThickness ?? 0.06;
+    const color = extras.originLineColor ?? 0x94a3b8;
+    const material = new THREE.MeshBasicMaterial({ color, transparent: true, opacity: 0.9, depthWrite: false });
+    const yPos = groundY + thickness * 0.5;
+    const xLine = new THREE.Mesh(new THREE.BoxGeometry(length * 2, thickness, thickness), material);
+    xLine.position.y = yPos;
+    const zLine = new THREE.Mesh(new THREE.BoxGeometry(thickness, thickness, length * 2), material.clone());
+    zLine.position.y = yPos;
+    group.add(xLine, zLine);
+    const markerCount = 5;
+    const markerThickness = thickness * 0.5;
+    for (let i = 1; i <= markerCount; i += 1) {
+        const offset = i;
+        const tickXPos = offset;
+        const tickZPos = offset;
+        const xTick = new THREE.Mesh(new THREE.BoxGeometry(markerThickness, thickness * 0.75, thickness * 4), material.clone());
+        xTick.position.set(tickXPos, yPos, 0);
+        const xTickNeg = xTick.clone();
+        xTickNeg.position.x = -tickXPos;
+        const zTick = new THREE.Mesh(new THREE.BoxGeometry(thickness * 4, thickness * 0.75, markerThickness), material.clone());
+        zTick.position.set(0, yPos, tickZPos);
+        const zTickNeg = zTick.clone();
+        zTickNeg.position.z = -tickZPos;
+        group.add(xTick, xTickNeg, zTick, zTickNeg);
+    }
+    return group;
+}
+function adjustGridColor(groundHex) {
+    const base = new THREE.Color(groundHex);
+    const hsl = { h: 0, s: 0, l: 0 };
+    base.getHSL(hsl);
+    hsl.l = Math.min(1, hsl.l + 0.15);
+    const adjusted = new THREE.Color();
+    adjusted.setHSL(hsl.h, hsl.s, hsl.l);
+    return adjusted.getHex();
+}
+export class DebugSystem {
+    scene;
+    objects = [];
+    constructor(scene) {
+        this.scene = scene;
+    }
+    apply(preset, bounds) {
+        const extras = { ...DEFAULT_EXTRAS, ...(preset.sceneExtras ?? {}) };
+        this.clear();
+        const skyMode = preset.sky?.mode ?? "gradient";
+        const isHdr = skyMode === "hdr";
+        const groundEnabled = extras.ground !== false;
+        const gridEnabled = extras.grid !== false;
+        const axesEnabled = extras.axes !== false;
+        const originEnabled = extras.origin !== false;
+        const groundColor = extras.groundColor ?? 0x2c2f33;
+        const boundsSize = bounds && !bounds.isEmpty() ? bounds.getSize(new THREE.Vector3()) : null;
+        const modelSpan = boundsSize ? Math.max(boundsSize.x, boundsSize.z, 1) : null;
+        const groundScale = isHdr ? (extras.groundAutoScaleHdr ?? 1.25) : (extras.groundAutoScale ?? 2.5);
+        const gridScale = isHdr
+            ? (extras.gridAutoScaleHdr ?? extras.groundAutoScaleHdr ?? 1.25)
+            : (extras.gridAutoScale ?? extras.groundAutoScale ?? 2.5);
+        const groundSizeDefault = isHdr ? HDR_GROUND_SIZE : DEFAULT_GRID_SIZE;
+        const gridSizeDefault = isHdr ? HDR_GRID_SIZE : DEFAULT_GRID_SIZE;
+        const derivedGroundSize = modelSpan ? modelSpan * groundScale : groundSizeDefault;
+        const derivedGridSize = groundEnabled
+            ? (extras.groundSize ?? derivedGroundSize)
+            : modelSpan
+                ? modelSpan * gridScale
+                : gridSizeDefault;
+        const groundOffset = extras.groundOffset ?? DEFAULT_GROUND_OFFSET;
+        const gridHeightOffset = extras.gridHeightOffset ?? DEFAULT_GRID_HEIGHT_OFFSET;
+        if (groundEnabled) {
+            const size = extras.groundSize ?? derivedGroundSize;
+            const groundGeometry = new THREE.PlaneGeometry(size, size);
+            const groundMaterial = new THREE.MeshStandardMaterial({
+                color: groundColor,
+                roughness: extras.groundRoughness ?? (isHdr ? 0.6 : 0.8),
+                metalness: extras.groundMetalness ?? (isHdr ? 0.02 : 0.05),
+                toneMapped: false,
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            ground.position.y = groundOffset;
+            ground.receiveShadow = true;
+            this.add(ground);
+        }
+        let lastGridPositionY = 0;
+        const gridSize = extras.gridSize ?? derivedGridSize;
+        if (gridEnabled) {
+            const gridPrimary = new THREE.Color(extras.gridColor ?? adjustGridColor(groundColor));
+            const gridSecondary = new THREE.Color(extras.gridColorSecondary ?? gridPrimary.getHex());
+            const gridDivisions = extras.gridDivisions ?? Math.max(1, gridSize);
+            const grid = new THREE.GridHelper(gridSize, gridDivisions, gridPrimary, gridSecondary);
+            const gridY = groundEnabled ? groundOffset + gridHeightOffset : -gridHeightOffset;
+            grid.position.y = gridY;
+            lastGridPositionY = grid.position.y;
+            const gridMaterial = grid.material;
+            const setTransparency = (mat) => {
+                mat.transparent = true;
+                mat.opacity = extras.gridOpacity ?? DEFAULT_GRID_OPACITY;
+            };
+            if (Array.isArray(gridMaterial)) {
+                gridMaterial.forEach((mat) => setTransparency(mat));
+            }
+            else if (gridMaterial) {
+                setTransparency(gridMaterial);
+            }
+            this.add(grid);
+        }
+        const originPlaneY = groundEnabled ? groundOffset : lastGridPositionY || -gridHeightOffset;
+        if (extras.originHighlight !== false) {
+            const originCross = buildOriginCross(extras, gridSize, originPlaneY);
+            this.add(originCross);
+        }
+        if (originEnabled) {
+            const originSize = extras.originSize ?? 0.1;
+            const originGeometry = new THREE.SphereGeometry(originSize, 16, 16);
+            const originMaterial = new THREE.MeshBasicMaterial({ color: extras.originColor ?? 0x666666 });
+            const origin = new THREE.Mesh(originGeometry, originMaterial);
+            origin.position.set(0, 0, 0);
+            this.add(origin);
+        }
+        if (axesEnabled) {
+            this.add(buildAxisHelper(extras));
+        }
+    }
+    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?.();
+                }
+                return;
+            }
+            if (object instanceof THREE.Line) {
+                object.geometry.dispose();
+                const material = object.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material?.dispose?.();
+                }
+                return;
+            }
+            if (object instanceof THREE.Sprite) {
+                const material = object.material;
+                if (material) {
+                    if (material.map) {
+                        material.map.dispose?.();
+                    }
+                    material.dispose?.();
+                }
+            }
+        });
+        this.objects = [];
+    }
+}

package/dist/systems/environmentSystem.d.ts

@@ -0,0 +1,31 @@
+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;
+    private fallbackGradient;
+    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;
+    private applyRotationToScene;
+}
+//# 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;IACrG,OAAO,CAAC,gBAAgB,CAMtB;gBAEU,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;IAuC1D,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,gBAAgB;YA6CV,YAAY;YAaZ,WAAW;YAwDX,YAAY;IAuD1B,OAAO,CAAC,oBAAoB;CAY7B"}