@treasuryspatial/viewer-kit 0.2.44 → 0.2.50

package/dist/scene.js

@@ -8,15 +8,164 @@ export const DEFAULT_CAMERA_RIG = {
     direction: [1, 0.7, 1],
     mode: "iso",
 };
+const UNIT_TO_METERS = {
+    mm: 0.001,
+    millimeter: 0.001,
+    millimeters: 0.001,
+    cm: 0.01,
+    centimeter: 0.01,
+    centimeters: 0.01,
+    m: 1,
+    meter: 1,
+    meters: 1,
+    ft: 0.3048,
+    foot: 0.3048,
+    feet: 0.3048,
+    in: 0.0254,
+    inch: 0.0254,
+    inches: 0.0254,
+};
+const DEFAULT_SCENE_CLIPPING = {
+    nearSafety: 1.6,
+    farSafety: 1.15,
+    minimumFar: 350,
+};
+const PLAN_PRESENTATION_ELEVATION = 0.012;
+export const resolveSceneUnitScale = (units) => {
+    const normalized = units?.trim().toLowerCase();
+    if (!normalized)
+        return 1;
+    return UNIT_TO_METERS[normalized] ?? 1;
+};
+export const applyUnitScaleToGroup = (group, units) => {
+    if (!group)
+        return 1;
+    const nextScale = resolveSceneUnitScale(units);
+    if (!Number.isFinite(nextScale) || nextScale <= 0)
+        return 1;
+    const currentScale = typeof group.userData?.__sceneUnitScale === "number" && Number.isFinite(group.userData.__sceneUnitScale)
+        ? group.userData.__sceneUnitScale
+        : 1;
+    if (Math.abs(currentScale - nextScale) < 1e-9)
+        return nextScale;
+    const ratio = nextScale / currentScale;
+    if (!Number.isFinite(ratio) || ratio <= 0)
+        return currentScale;
+    group.scale.multiplyScalar(ratio);
+    group.updateMatrixWorld(true);
+    group.userData = {
+        ...(group.userData ?? {}),
+        __sceneUnitScale: nextScale,
+        __sceneUnits: units ?? null,
+    };
+    return nextScale;
+};
+const resolveCameraKind = (handle, requested) => requested ?? handle.getCameraState().kind ?? "perspective";
+const computeClipRange = (distance, radius, clipping) => {
+    const resolved = { ...DEFAULT_SCENE_CLIPPING, ...(clipping ?? {}) };
+    let near = Math.max(0.01, distance - radius * resolved.nearSafety);
+    const maxNear = distance * 0.1;
+    if (Number.isFinite(maxNear) && maxNear > 0) {
+        near = Math.min(near, maxNear);
+    }
+    const dynamicMinimumFar = Math.max(1, distance * 1.5, radius * 6);
+    const minimumFar = Math.min(resolved.minimumFar, dynamicMinimumFar);
+    const far = Math.max(distance + radius * resolved.farSafety, near + Math.max(radius * 2, 1), minimumFar);
+    return { near, far };
+};
+const applyPlanPresentationStyling = (group) => {
+    if (!group || typeof group.traverse !== "function")
+        return;
+    const currentElevation = typeof group.userData?.__planElevation === "number" && Number.isFinite(group.userData.__planElevation)
+        ? group.userData.__planElevation
+        : 0;
+    const delta = PLAN_PRESENTATION_ELEVATION - currentElevation;
+    if (Math.abs(delta) > 1e-9) {
+        group.position.y += delta;
+        group.userData = {
+            ...(group.userData ?? {}),
+            __planElevation: PLAN_PRESENTATION_ELEVATION,
+        };
+    }
+    group.traverse((child) => {
+        if (child instanceof THREE.Mesh) {
+            child.renderOrder = 1;
+            child.frustumCulled = false;
+            const materials = Array.isArray(child.material) ? child.material : [child.material];
+            materials.forEach((material) => {
+                if (!material)
+                    return;
+                if ("color" in material && material.color) {
+                    material.color.setHex(0x2f855a);
+                }
+                if ("roughness" in material) {
+                    material.roughness = 1;
+                }
+                if ("metalness" in material) {
+                    material.metalness = 0;
+                }
+                if ("emissive" in material && material.emissive) {
+                    material.emissive.setHex(0x1f6f49);
+                }
+                if ("emissiveIntensity" in material) {
+                    material.emissiveIntensity = 0.18;
+                }
+                material.transparent = true;
+                material.opacity = Math.min(material.opacity ?? 1, 0.9);
+                material.depthWrite = false;
+                material.toneMapped = false;
+                material.side = THREE.DoubleSide;
+                material.polygonOffset = true;
+                material.polygonOffsetFactor = 1.5;
+                material.polygonOffsetUnits = 2;
+                material.needsUpdate = true;
+            });
+            return;
+        }
+        if (child instanceof THREE.Line) {
+            child.renderOrder = 200;
+            child.frustumCulled = false;
+            const material = child.material;
+            if (material instanceof THREE.LineBasicMaterial) {
+                material.color.setHex(0x1f1f1f);
+                material.transparent = true;
+                material.opacity = 1;
+                material.depthTest = false;
+                material.depthWrite = false;
+                material.toneMapped = false;
+                material.needsUpdate = true;
+            }
+            return;
+        }
+        if (child instanceof THREE.Points) {
+            child.renderOrder = 220;
+            child.frustumCulled = false;
+            const material = child.material;
+            if (material instanceof THREE.PointsMaterial) {
+                material.color.setHex(0x1f1f1f);
+                material.size = Math.max(material.size ?? 0, 10);
+                material.sizeAttenuation = false;
+                material.depthTest = false;
+                material.depthWrite = false;
+                material.toneMapped = false;
+                material.needsUpdate = true;
+            }
+        }
+    });
+};
 export function computeSceneStats(root) {
     let meshCount = 0;
     let vertexCount = 0;
     let triangleCount = 0;
+    let shadowCastingMeshCount = 0;
+    let shadowReceivingMeshCount = 0;
     if (!root || typeof root.traverse !== "function") {
         return {
             meshCount,
             vertexCount,
             triangleCount,
+            shadowCastingMeshCount,
+            shadowReceivingMeshCount,
             size: { x: 0, y: 0, z: 0 },
         };
     }
@@ -24,6 +173,10 @@ export function computeSceneStats(root) {
         const mesh = child;
         if (mesh.isMesh) {
             meshCount += 1;
+            if (mesh.castShadow)
+                shadowCastingMeshCount += 1;
+            if (mesh.receiveShadow)
+                shadowReceivingMeshCount += 1;
             const geometry = mesh.geometry;
             const position = geometry.getAttribute("position");
             if (position) {
@@ -45,12 +198,15 @@ export function computeSceneStats(root) {
         meshCount,
         vertexCount,
         triangleCount: Math.round(triangleCount),
+        shadowCastingMeshCount,
+        shadowReceivingMeshCount,
         size: { x: size.x, y: size.y, z: size.z },
     };
 }
-export const setCameraToBounds = (handle, bounds, config) => {
+export const setCameraToBounds = (handle, bounds, config, options) => {
     if (bounds.isEmpty())
         return;
+    const cameraKind = resolveCameraKind(handle, options?.kind);
     const fov = handle.getCameraState().fov ?? 60;
     const { position, target } = computeCameraFrame(bounds, fov, config);
     if (![position.x, position.y, position.z, target.x, target.y, target.z].every(Number.isFinite)) {
@@ -59,46 +215,41 @@ export const setCameraToBounds = (handle, bounds, config) => {
     const sphere = new THREE.Sphere();
     bounds.getBoundingSphere(sphere);
     const distance = position.distanceTo(target);
-    const safetyFar = 1.15;
-    const safetyNear = 1.6;
-    let near = Math.max(0.01, distance - sphere.radius * safetyNear);
-    const maxNear = distance * 0.1;
-    if (Number.isFinite(maxNear) && maxNear > 0) {
-        near = Math.min(near, maxNear);
-    }
-    const minSkyFar = 350;
-    const far = Math.max(distance + sphere.radius * safetyFar, near + sphere.radius * 2, minSkyFar);
+    const { near, far } = computeClipRange(distance, sphere.radius, options?.clipping);
+    const size = bounds.getSize(new THREE.Vector3());
+    const orthographicHeight = Math.max(size.x, size.y, size.z, 0.05) * (config?.padding ?? 1.22);
     handle.setCamera({
+        kind: cameraKind,
         position: [position.x, position.y, position.z],
         target: [target.x, target.y, target.z],
+        orthographicHeight: cameraKind === "orthographic" ? orthographicHeight : undefined,
         near,
         far,
     });
 };
-export const setCameraTopDown = (handle, bounds) => {
+export const setCameraTopDown = (handle, bounds, options) => {
     if (bounds.isEmpty())
         return;
+    const cameraKind = resolveCameraKind(handle, options?.kind);
     const center = bounds.getCenter(new THREE.Vector3());
     const size = bounds.getSize(new THREE.Vector3());
-    const span = Math.max(size.x, size.z, 1);
+    const span = Math.max(size.x, size.z, 0.05);
     const height = span * 1.5;
     const position = new THREE.Vector3(center.x, center.y + height, center.z);
     const target = center.clone();
     const sphere = new THREE.Sphere();
     bounds.getBoundingSphere(sphere);
     const distance = position.distanceTo(target);
-    const safetyFar = 1.2;
-    const safetyNear = 1.8;
-    let near = Math.max(0.01, distance - sphere.radius * safetyNear);
-    const maxNear = distance * 0.1;
-    if (Number.isFinite(maxNear) && maxNear > 0) {
-        near = Math.min(near, maxNear);
-    }
-    const minSkyFar = 350;
-    const far = Math.max(distance + sphere.radius * safetyFar, near + sphere.radius * 2, minSkyFar);
+    const { near, far } = computeClipRange(distance, sphere.radius, options?.clipping ?? {
+        nearSafety: 1.8,
+        farSafety: 1.2,
+    });
+    const orthographicHeight = Math.max(span * 1.1, 0.05);
     handle.setCamera({
+        kind: cameraKind,
         position: [position.x, position.y, position.z],
         target: [target.x, target.y, target.z],
+        orthographicHeight: cameraKind === "orthographic" ? orthographicHeight : undefined,
         near,
         far,
     });
@@ -209,11 +360,17 @@ export const normalizeRenderGroup = (group, options = {}) => {
     }
 };
 export function applyGroupToViewer(options) {
-    const { viewer, group, cameraRig, viewMode = "auto", frameConfig, materialsConfig, floorLevel, ceilingHeight, } = options;
+    const { viewer, group, cameraRig, preserveSceneAnchor = false, viewMode = "auto", frameConfig, presentation, materialsConfig, materialsPolicy, floorLevel, ceilingHeight, preserveCamera = false, } = options;
     if (!group)
         return null;
-    const normalization = normalizeObject3d(group, cameraRig);
-    const bounds = normalization.bounds;
+    const sceneAnchor = preserveSceneAnchor && viewer ? new THREE.Vector3(...viewer.getCameraState().target) : undefined;
+    const normalization = normalizeObject3d(group, sceneAnchor ? { ...cameraRig, anchor: sceneAnchor } : cameraRig);
+    let bounds = normalization.bounds;
+    if (presentation?.kind === "plan2d") {
+        applyPlanPresentationStyling(group);
+        group.updateMatrixWorld(true);
+        bounds = new THREE.Box3().setFromObject(group);
+    }
     const resolvedFloor = cameraRig?.floorToZero
         ? 0
         : typeof floorLevel === "number"
@@ -225,16 +382,24 @@ export function applyGroupToViewer(options) {
     const stats = computeSceneStats(group);
     if (viewer) {
         viewer.setSceneRoot(group);
-        const shouldTopDown = viewMode === "2d" || (viewMode === "auto" && stats.meshCount === 0);
-        if (shouldTopDown) {
-            setCameraTopDown(viewer, bounds);
-        }
-        else {
-            setCameraToBounds(viewer, bounds, frameConfig);
+        if (!preserveCamera) {
+            const shouldTopDown = viewMode === "2d" || (viewMode === "auto" && presentation?.kind === "plan2d");
+            if (shouldTopDown) {
+                setCameraTopDown(viewer, bounds, {
+                    kind: presentation?.cameraKind,
+                    clipping: presentation?.clipping,
+                });
+            }
+            else {
+                setCameraToBounds(viewer, bounds, frameConfig, {
+                    kind: presentation?.cameraKind,
+                    clipping: presentation?.clipping,
+                });
+            }
         }
     }
     if (materialsConfig) {
-        applyMaterialsToGroup(group, materialsConfig, resolvedFloor, resolvedHeight);
+        applyMaterialsToGroup(group, materialsConfig, resolvedFloor, resolvedHeight, materialsPolicy);
         viewer?.invalidate?.();
     }
     return { bounds, stats, normalization, resolvedFloor, resolvedHeight };

package/dist/sceneSemanticRegistry.d.ts

@@ -0,0 +1,64 @@
+import * as THREE from "three";
+export type SceneSemanticBounds = {
+    min: [number, number, number];
+    max: [number, number, number];
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    center: [number, number, number];
+};
+export type SceneSemanticObject = {
+    registryId: string;
+    threeUuid: string;
+    object: THREE.Mesh;
+    objectName?: string;
+    objectId?: string;
+    meshId?: string;
+    sourceId?: string;
+    buildResultId?: string;
+    surfaceDomainId?: string;
+    surfaceType?: string;
+    surfaceClass?: string;
+    spanId?: string;
+    cellId?: string;
+    verticalBandId?: string;
+    floorBandId?: string;
+    roofBandId?: string;
+    frameId?: string;
+    faceId?: string;
+    role?: string;
+    layer?: string;
+    className?: string;
+    subclassName?: string;
+    surface?: string;
+    visible: boolean;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    vertexCount: number;
+    triangleCount: number;
+    bounds: SceneSemanticBounds;
+    data: Record<string, string>;
+    userData: Record<string, string | number | boolean | null>;
+};
+export type SceneSemanticRegistry = {
+    objects: SceneSemanticObject[];
+    byRegistryId: Record<string, SceneSemanticObject>;
+    byThreeUuid: Record<string, SceneSemanticObject>;
+    bySurfaceDomainId: Record<string, string[]>;
+    byCellId: Record<string, string[]>;
+    bySurfaceClass: Record<string, string[]>;
+    dataKeys: string[];
+    counts: {
+        objectCount: number;
+        meshCount: number;
+        surfaceDomainCount: number;
+        cellCount: number;
+        surfaceClassCount: number;
+        dataKeyCount: number;
+    };
+};
+export declare function buildSceneSemanticRegistry(root?: THREE.Object3D | null): SceneSemanticRegistry;
+export declare function findSceneSemanticObjectByThreeUuid(registry: SceneSemanticRegistry | null | undefined, threeUuid: string | null | undefined): SceneSemanticObject | null;
+//# sourceMappingURL=sceneSemanticRegistry.d.ts.map

package/dist/sceneSemanticRegistry.d.ts.map

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

package/dist/sceneSemanticRegistry.js

@@ -0,0 +1,199 @@
+import * as THREE from "three";
+const pickString = (userData, ...keys) => {
+    for (const key of keys) {
+        const value = userData[key];
+        if (value === null || value === undefined)
+            continue;
+        const normalized = String(value).trim();
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return undefined;
+};
+const toSerializableUserData = (userData) => {
+    const output = {};
+    for (const [key, value] of Object.entries(userData)) {
+        if (key.startsWith("__"))
+            continue;
+        if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            output[key] = value;
+        }
+    }
+    return output;
+};
+const collectDataValues = (userData) => {
+    const data = {};
+    const nestedData = userData.data;
+    if (nestedData && typeof nestedData === "object" && !Array.isArray(nestedData)) {
+        for (const [key, value] of Object.entries(nestedData)) {
+            if (value === null || value === undefined)
+                continue;
+            const normalized = String(value).trim();
+            if (normalized.length > 0) {
+                data[key] = normalized;
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(userData)) {
+        if (!key.startsWith("data:") || value === null || value === undefined)
+            continue;
+        const normalized = String(value).trim();
+        if (normalized.length > 0) {
+            data[key.slice("data:".length)] = normalized;
+        }
+    }
+    return data;
+};
+const computeTriangleCount = (geometry) => {
+    if (!geometry)
+        return 0;
+    const index = geometry.getIndex();
+    if (index)
+        return Math.floor(index.count / 3);
+    const position = geometry.getAttribute("position");
+    return position ? Math.floor(position.count / 3) : 0;
+};
+const computeVertexCount = (geometry) => {
+    if (!geometry)
+        return 0;
+    const position = geometry.getAttribute("position");
+    return position?.count ?? 0;
+};
+const computeBounds = (object) => {
+    const box = new THREE.Box3().setFromObject(object);
+    if (box.isEmpty()) {
+        return {
+            min: [0, 0, 0],
+            max: [0, 0, 0],
+            size: { x: 0, y: 0, z: 0 },
+            center: [0, 0, 0],
+        };
+    }
+    const size = new THREE.Vector3();
+    const center = new THREE.Vector3();
+    box.getSize(size);
+    box.getCenter(center);
+    return {
+        min: [box.min.x, box.min.y, box.min.z],
+        max: [box.max.x, box.max.y, box.max.z],
+        size: { x: size.x, y: size.y, z: size.z },
+        center: [center.x, center.y, center.z],
+    };
+};
+const appendIndex = (target, key, registryId) => {
+    if (!key)
+        return;
+    if (!target[key]) {
+        target[key] = [];
+    }
+    target[key].push(registryId);
+};
+const makeUniqueRegistryId = (baseId, existing) => {
+    if (!existing[baseId])
+        return baseId;
+    let index = 2;
+    while (existing[`${baseId}#${index}`]) {
+        index += 1;
+    }
+    return `${baseId}#${index}`;
+};
+const buildSemanticObject = (mesh, existing) => {
+    const userData = (mesh.userData ?? {});
+    const meshId = pickString(userData, "meshId", "b2:meshId");
+    const objectId = pickString(userData, "objectId", "id", "b2:id", "packet");
+    const cellId = pickString(userData, "cellId", "b2:cellId");
+    const surfaceDomainId = pickString(userData, "surfaceDomainId", "b2:surfaceDomainId");
+    const baseId = meshId ?? objectId ?? cellId ?? surfaceDomainId ?? mesh.uuid;
+    const registryId = makeUniqueRegistryId(baseId, existing);
+    const data = collectDataValues(userData);
+    const surfaceClass = pickString(userData, "surfaceClass", "b2:surfaceClass", "surface");
+    return {
+        registryId,
+        threeUuid: mesh.uuid,
+        object: mesh,
+        objectName: mesh.name || undefined,
+        objectId,
+        meshId,
+        sourceId: pickString(userData, "sourceId", "b2:sourceId"),
+        buildResultId: pickString(userData, "buildResultId", "b2:buildResultId"),
+        surfaceDomainId,
+        surfaceType: pickString(userData, "surfaceType", "b2:surfaceType"),
+        surfaceClass,
+        spanId: pickString(userData, "spanId", "b2:spanId"),
+        cellId,
+        verticalBandId: pickString(userData, "verticalBandId", "b2:verticalBandId"),
+        floorBandId: pickString(userData, "floorBandId", "b2:floorBandId"),
+        roofBandId: pickString(userData, "roofBandId", "b2:roofBandId"),
+        frameId: pickString(userData, "frameId", "b2:frameId"),
+        faceId: pickString(userData, "faceId", "b2:faceId"),
+        role: pickString(userData, "role", "b2:role"),
+        layer: pickString(userData, "layer", "b2:layer"),
+        className: pickString(userData, "class", "className"),
+        subclassName: pickString(userData, "subclass", "subclassName"),
+        surface: pickString(userData, "surface"),
+        visible: mesh.visible,
+        castShadow: mesh.castShadow,
+        receiveShadow: mesh.receiveShadow,
+        vertexCount: computeVertexCount(mesh.geometry),
+        triangleCount: computeTriangleCount(mesh.geometry),
+        bounds: computeBounds(mesh),
+        data,
+        userData: toSerializableUserData(userData),
+    };
+};
+export function buildSceneSemanticRegistry(root) {
+    const byRegistryId = {};
+    const byThreeUuid = {};
+    const bySurfaceDomainId = {};
+    const byCellId = {};
+    const bySurfaceClass = {};
+    const dataKeys = new Set();
+    const surfaceDomainIds = new Set();
+    const cellIds = new Set();
+    const surfaceClasses = new Set();
+    if (root && typeof root.traverse === "function") {
+        root.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh || !mesh.geometry)
+                return;
+            if (mesh.userData?.excludeFromSemanticRegistry === true)
+                return;
+            const entry = buildSemanticObject(mesh, byRegistryId);
+            byRegistryId[entry.registryId] = entry;
+            byThreeUuid[entry.threeUuid] = entry;
+            appendIndex(bySurfaceDomainId, entry.surfaceDomainId, entry.registryId);
+            appendIndex(byCellId, entry.cellId, entry.registryId);
+            appendIndex(bySurfaceClass, entry.surfaceClass, entry.registryId);
+            if (entry.surfaceDomainId)
+                surfaceDomainIds.add(entry.surfaceDomainId);
+            if (entry.cellId)
+                cellIds.add(entry.cellId);
+            if (entry.surfaceClass)
+                surfaceClasses.add(entry.surfaceClass);
+            Object.keys(entry.data).forEach((key) => dataKeys.add(key));
+        });
+    }
+    const objects = Object.values(byRegistryId);
+    return {
+        objects,
+        byRegistryId,
+        byThreeUuid,
+        bySurfaceDomainId,
+        byCellId,
+        bySurfaceClass,
+        dataKeys: Array.from(dataKeys).sort((a, b) => a.localeCompare(b)),
+        counts: {
+            objectCount: objects.length,
+            meshCount: objects.length,
+            surfaceDomainCount: surfaceDomainIds.size,
+            cellCount: cellIds.size,
+            surfaceClassCount: surfaceClasses.size,
+            dataKeyCount: dataKeys.size,
+        },
+    };
+}
+export function findSceneSemanticObjectByThreeUuid(registry, threeUuid) {
+    if (!registry || !threeUuid)
+        return null;
+    return registry.byThreeUuid[threeUuid] ?? null;
+}

package/dist/sky/scienceSky.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scienceSky.d.ts","sourceRoot":"","sources":["../../src/sky/scienceSky.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,sBAAsB,CAAC,KAAK,CAAC,CAAC;CACrC,CAAC;AAmFF,wBAAgB,qBAAqB,IAAI,gBAAgB,EAAE,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE5E"}
+{"version":3,"file":"scienceSky.d.ts","sourceRoot":"","sources":["../../src/sky/scienceSky.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,sBAAsB,CAAC,KAAK,CAAC,CAAC;CACrC,CAAC;AAmGF,wBAAgB,qBAAqB,IAAI,gBAAgB,EAAE,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE5E"}

package/dist/sky/scienceSky.js

@@ -1,4 +1,5 @@
 const HDR_BASE = "https://assets.treasury.space/science/hdr/shared";
+const SKY_IMAGE_BASE = "https://assets.treasury.space/science/sky/shared";
 const SCIENCE_SKY_OPTIONS = [
     {
         id: "preset",
@@ -31,6 +32,21 @@ const SCIENCE_SKY_OPTIONS = [
             hdr: { src: `${HDR_BASE}/canary_wharf_4k.hdr`, exposure: 1.1 },
         },
     },
+    {
+        id: "spacex-interface",
+        label: "SpaceX Interface",
+        description: "Authored 2:1 LDR panorama wrap from the launch photo. Background only; not HDR lighting.",
+        sky: {
+            mode: "image",
+            image: {
+                src: `${SKY_IMAGE_BASE}/space_x_panorama_wrap_4096x2048_v2.jpg`,
+                projection: "equirectangular",
+                rotationY: 1.1,
+                showBackground: true,
+                showLighting: false,
+            },
+        },
+    },
     {
         id: "kloofendal",
         label: "Kloofendal Sky",

package/dist/systems/debugSystem.d.ts

@@ -1,10 +1,33 @@
 import * as THREE from "three";
 import type { RenderPresetDefinition } from "../engine/types";
+export declare const AO_DEPTH_PROXY_USER_DATA_KEY = "treasuryAoDepthProxy";
+export type DebugSystemState = {
+    groundEnabled: boolean;
+    gridEnabled: boolean;
+    groundY: number | null;
+    gridY: number | null;
+    gridSize: number | null;
+    gridDivisions: number | null;
+    gridStep: number | null;
+    gridMajorEvery: number | null;
+    gridSuperMajorEvery: number | null;
+    groundMode: "finite" | "infinite" | null;
+    gridMode: "finite" | "infinite" | null;
+};
 export declare class DebugSystem {
     private scene;
     private objects;
+    private ground;
+    private groundAoProxy;
+    private grid;
+    private groundInfinite;
+    private gridInfinite;
+    private gridDivisionSize;
+    private state;
     constructor(scene: THREE.Scene);
-    apply(preset: RenderPresetDefinition, bounds?: THREE.Box3 | null): void;
+    update(anchor?: THREE.Vector3 | null): void;
+    getState(): DebugSystemState;
+    apply(preset: RenderPresetDefinition, bounds?: THREE.Box3 | null, root?: THREE.Object3D | null): void;
     dispose(): void;
     private add;
     private clear;

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

@@ -1 +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;AAuMjF,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;IAmGvE,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,KAAK;CAmCd"}
+{"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;AAqDjF,eAAO,MAAM,4BAA4B,yBAAyB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,UAAU,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI,CAAC;IACzC,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI,CAAC;CACxC,CAAC;AAoRF,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,KAAK,CAYX;gBAEU,KAAK,EAAE,KAAK,CAAC,KAAK;IAI9B,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,IAAI;IAiB3C,QAAQ,IAAI,gBAAgB;IAI5B,KAAK,CAAC,MAAM,EAAE,sBAAsB,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,GAAG,IAAI;IA8KrG,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,KAAK;CAwDd"}