@3driseai/3drise-viewer 0.1.6 → 0.1.8

package/dist/hooks/useCubeCamera.js

@@ -1,73 +1,31 @@
-import { useRef, useCallback, useEffect } from 'react';
-import { useThree, useFrame } from '@react-three/fiber';
-import * as THREE from 'three';
-import { createCubeCamera, updateCubeCamera, disposeCubeCamera, setSceneEnvironment, clearSceneEnvironment, } from '@3driseai/3drise-core';
-export const useCubeCamera = (options) => {
-    const { hdrSettings, skyVisible, sunSystemVisible, timeSettings, resolution = 512, position = new THREE.Vector3(0, 50, 0), onEnvironmentUpdate } = options;
+import { useEffect, useMemo } from 'react';
+import { useThree } from '@react-three/fiber';
+import { CubeCameraManager } from '@3driseai/3drise-core';
+export const useCubeCamera = (options = {}) => {
     const { scene, gl: renderer } = useThree();
-    const cubeCameraRef = useRef(null);
-    const isUpdatingRef = useRef(false);
-    const hdrActive = hdrSettings.visible && (hdrSettings.name || (hdrSettings.urls && hdrSettings.urls.length > 0)) ? true : false;
-    const initializeCubeCamera = useCallback(() => {
-        if (!renderer || !scene)
-            return null;
-        if (cubeCameraRef.current)
-            disposeCubeCamera(cubeCameraRef.current, scene);
-        cubeCameraRef.current = createCubeCamera(scene, resolution, position);
-        return cubeCameraRef.current;
-    }, [scene, renderer, resolution, position]);
-    const updateEnvironment = useCallback(() => {
-        if (!cubeCameraRef.current || !renderer || !scene)
-            return null;
-        if (isUpdatingRef.current)
-            return null;
-        try {
-            isUpdatingRef.current = true;
-            const texture = updateCubeCamera(cubeCameraRef.current, renderer, scene);
-            setSceneEnvironment(scene, texture);
-            onEnvironmentUpdate?.(texture);
-            return texture;
-        }
-        catch {
-            return null;
-        }
-        finally {
-            isUpdatingRef.current = false;
-        }
-    }, [scene, renderer, onEnvironmentUpdate]);
-    const dispose = useCallback(() => {
-        if (cubeCameraRef.current && scene) {
-            disposeCubeCamera(cubeCameraRef.current, scene);
-            cubeCameraRef.current = null;
-        }
-    }, [scene]);
-    // Create or dispose cube camera based on active sky / HDR state
+    const manager = CubeCameraManager.getInstance();
+    const { resolution = 512, position, onEnvironmentUpdate } = options;
     useEffect(() => {
-        if (hdrActive) {
-            dispose();
-            return;
-        }
-        if (skyVisible || sunSystemVisible) {
-            initializeCubeCamera();
-            updateEnvironment();
-        }
-        else {
-            dispose();
-            clearSceneEnvironment(scene);
-        }
-    }, [hdrActive, skyVisible, sunSystemVisible]);
-    // Live update when auto-animating (sky moves, environment changes)
-    const UPDATE_INTERVAL_MS = 300;
-    useFrame((state) => {
-        if (hdrActive || !(skyVisible || sunSystemVisible))
-            return;
-        if (!timeSettings.autoAnimate)
-            return;
-        if (state.clock.getElapsedTime() * 1000 > UPDATE_INTERVAL_MS) {
-            updateEnvironment();
-        }
-    });
-    // Cleanup on unmount
-    useEffect(() => () => dispose(), [dispose]);
-    return { cubeCamera: cubeCameraRef.current, updateEnvironment, initializeCubeCamera, dispose };
+        manager.attach(scene, renderer);
+        return () => {
+            manager.detach();
+        };
+    }, [manager, scene, renderer]);
+    useEffect(() => {
+        manager.setOnUpdate(onEnvironmentUpdate ?? null);
+        return () => {
+            manager.setOnUpdate(null);
+        };
+    }, [manager, onEnvironmentUpdate]);
+    return useMemo(() => ({
+        manager,
+        get cubeCamera() {
+            return manager.getCubeCamera();
+        },
+        initializeCubeCamera: () => manager.initCubeCamera(resolution, position),
+        updateEnvironment: () => manager.updateEnvironment(),
+        clear: () => manager.clear(),
+        dispose: () => manager.dispose(),
+    }), [manager, resolution, position]);
 };
+export default useCubeCamera;

package/dist/hooks/useEnvironmentProbe.d.ts

@@ -0,0 +1,32 @@
+/**
+ * When the scene's cube-camera probe should exist, and how often it refreshes.
+ *
+ * This is the *policy* half of the cube camera; useCubeCamera is the imperative
+ * half. It lives in a hook rather than inside EnvironmentManager because two
+ * hosts need it — the composed EnvironmentManager used by published scenes, and
+ * the editor's HDR connector, which subscribes to Redux and composes the leaf
+ * components itself. Duplicating a rule this fiddly is how the two paths drifted
+ * apart last time.
+ *
+ * The rule itself:
+ *  - An HDR background provides its own IBL, so the probe is disposed.
+ *  - Otherwise, if there is any sky, the probe exists and captures it.
+ *  - Otherwise there is nothing to capture, so dispose and clear the environment.
+ *
+ * The refresh accumulates delta and resets. The obvious-looking
+ * `clock.getElapsedTime() * 1000 > interval` is true on *every* frame after the
+ * first 0.3 s, which re-renders all six cube faces per frame.
+ */
+export interface UseEnvironmentProbeOptions {
+    /** An HDR background or playlist is supplying the environment map. */
+    hdrActive: boolean;
+    /** Analytic sky or the sun rig is visible — something worth capturing. */
+    skyActive: boolean;
+    /** Time of day is animating, so the capture goes stale and needs refreshing. */
+    autoAnimate: boolean;
+    resolution?: number;
+    intervalMs?: number;
+}
+export declare function useEnvironmentProbe({ hdrActive, skyActive, autoAnimate, resolution, intervalMs, }: UseEnvironmentProbeOptions): void;
+export default useEnvironmentProbe;
+//# sourceMappingURL=useEnvironmentProbe.d.ts.map

package/dist/hooks/useEnvironmentProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnvironmentProbe.d.ts","sourceRoot":"","sources":["../../src/hooks/useEnvironmentProbe.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,0BAA0B;IACvC,sEAAsE;IACtE,SAAS,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,SAAS,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,mBAAmB,CAAC,EAChC,SAAS,EACT,SAAS,EACT,WAAW,EACX,UAAgB,EAChB,UAAgB,GACnB,EAAE,0BAA0B,GAAG,IAAI,CA6BnC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/hooks/useEnvironmentProbe.js

@@ -0,0 +1,35 @@
+import { useEffect, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useCubeCamera } from './useCubeCamera.js';
+export function useEnvironmentProbe({ hdrActive, skyActive, autoAnimate, resolution = 512, intervalMs = 300, }) {
+    const { manager, initializeCubeCamera, updateEnvironment, dispose, clear } = useCubeCamera({
+        resolution,
+    });
+    useEffect(() => {
+        if (hdrActive) {
+            dispose();
+            return;
+        }
+        if (skyActive) {
+            initializeCubeCamera();
+            updateEnvironment();
+        }
+        else {
+            dispose();
+            clear();
+        }
+    }, [hdrActive, skyActive, initializeCubeCamera, updateEnvironment, dispose, clear]);
+    const elapsedMsRef = useRef(0);
+    useFrame((_, delta) => {
+        if (hdrActive || !skyActive || !autoAnimate)
+            return;
+        if (!manager.hasCubeCamera())
+            return;
+        elapsedMsRef.current += delta * 1000;
+        if (elapsedMsRef.current >= intervalMs) {
+            elapsedMsRef.current = 0;
+            updateEnvironment();
+        }
+    });
+}
+export default useEnvironmentProbe;

package/dist/hooks/useFrameRenderer.d.ts

@@ -0,0 +1,15 @@
+import { type FrameRenderer } from '../utils/frameRenderer';
+/**
+ * Declare that this component produces the finished frame.
+ *
+ * For a full-screen pass that runs at `useFrame(…, 1)` and composites to the canvas
+ * itself. Everything that needs a complete image — screenshots, thumbnails — asks
+ * through `renderFrame()` rather than calling `gl.render(scene, camera)`, which would
+ * draw the scene graph and silently drop whatever the pass adds.
+ *
+ * Pass a stable callback (a ref-held function or useCallback); it is registered on
+ * mount and released on unmount, so plain rendering resumes when the pass goes away.
+ */
+export declare function useFrameRenderer(render: FrameRenderer | null | undefined): void;
+export default useFrameRenderer;
+//# sourceMappingURL=useFrameRenderer.d.ts.map

package/dist/hooks/useFrameRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFrameRenderer.d.ts","sourceRoot":"","sources":["../../src/hooks/useFrameRenderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEnF;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAM/E;AAED,eAAe,gBAAgB,CAAC"}

package/dist/hooks/useFrameRenderer.js

@@ -0,0 +1,23 @@
+import { useEffect } from 'react';
+import { useThree } from '@react-three/fiber';
+import { registerFrameRenderer } from '../utils/frameRenderer.js';
+/**
+ * Declare that this component produces the finished frame.
+ *
+ * For a full-screen pass that runs at `useFrame(…, 1)` and composites to the canvas
+ * itself. Everything that needs a complete image — screenshots, thumbnails — asks
+ * through `renderFrame()` rather than calling `gl.render(scene, camera)`, which would
+ * draw the scene graph and silently drop whatever the pass adds.
+ *
+ * Pass a stable callback (a ref-held function or useCallback); it is registered on
+ * mount and released on unmount, so plain rendering resumes when the pass goes away.
+ */
+export function useFrameRenderer(render) {
+    const gl = useThree((s) => s.gl);
+    useEffect(() => {
+        if (!render)
+            return;
+        return registerFrameRenderer(gl, render);
+    }, [gl, render]);
+}
+export default useFrameRenderer;

package/dist/hooks/useLandscapeLive.d.ts

@@ -0,0 +1,29 @@
+import type { Object3D } from 'three';
+/**
+ * Live landscape editing, the counterpart to `useTerrainLive` and `useOceanLive`.
+ *
+ * The rule is the same — a slider drag writes straight into the renderer and
+ * Redux only hears about it on slider end — but the stakes are higher here.
+ * `meshError` re-runs RTIN, `chunks` rebuilds every index buffer,
+ * `arrayResolution` repacks the texture arrays and `surfaceSamples` recompiles
+ * the shader. Those are commit-on-release; everything else is a uniform and goes
+ * through this, and the renderer's handle enforces the split from
+ * `LANDSCAPE_LIVE_*_KEYS` so a controller cannot half-apply a rebuild key by
+ * passing it here.
+ *
+ * Pass the ID, not a resolved Object3D: the panel is routinely open before the
+ * landscape exists, and a findById() memoised in the controller resolves to null
+ * exactly once and stays null for the session.
+ */
+export declare const LANDSCAPE_LIVE_KEY = "__landscapeLive";
+export interface LandscapeLiveHandle {
+    config(key: string, value: number | boolean | string): void;
+    quality(key: string, value: number | boolean | string): void;
+    /** One field of one surface, by index. The surface list drives this. */
+    surface(index: number, key: string, value: number | boolean | string): void;
+    /** One field of the generated-splat block. Every one of them is a uniform. */
+    autoSplat(key: string, value: number | boolean | string): void;
+}
+export declare function useLandscapeLive(target?: Object3D | string | null): LandscapeLiveHandle;
+export default useLandscapeLive;
+//# sourceMappingURL=useLandscapeLive.d.ts.map

package/dist/hooks/useLandscapeLive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLandscapeLive.d.ts","sourceRoot":"","sources":["../../src/hooks/useLandscapeLive.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAGrC;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,kBAAkB,oBAAoB,CAAA;AAEnD,MAAM,WAAW,mBAAmB;IAChC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC3D,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5D,wEAAwE;IACxE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC3E,8EAA8E;IAC9E,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;CACjE;AASD,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,mBAAmB,CAcvF;AAED,eAAe,gBAAgB,CAAA"}

package/dist/hooks/useLandscapeLive.js

@@ -0,0 +1,41 @@
+import { useMemo } from 'react';
+import { findById } from '../utils/sceneQuery.js';
+/**
+ * Live landscape editing, the counterpart to `useTerrainLive` and `useOceanLive`.
+ *
+ * The rule is the same — a slider drag writes straight into the renderer and
+ * Redux only hears about it on slider end — but the stakes are higher here.
+ * `meshError` re-runs RTIN, `chunks` rebuilds every index buffer,
+ * `arrayResolution` repacks the texture arrays and `surfaceSamples` recompiles
+ * the shader. Those are commit-on-release; everything else is a uniform and goes
+ * through this, and the renderer's handle enforces the split from
+ * `LANDSCAPE_LIVE_*_KEYS` so a controller cannot half-apply a rebuild key by
+ * passing it here.
+ *
+ * Pass the ID, not a resolved Object3D: the panel is routinely open before the
+ * landscape exists, and a findById() memoised in the controller resolves to null
+ * exactly once and stays null for the session.
+ */
+export const LANDSCAPE_LIVE_KEY = '__landscapeLive';
+const NOOP = {
+    config: () => { },
+    quality: () => { },
+    surface: () => { },
+    autoSplat: () => { },
+};
+export function useLandscapeLive(target) {
+    return useMemo(() => {
+        const resolve = () => {
+            const object = typeof target === 'string' ? findById(target) : target;
+            const handle = object?.userData?.[LANDSCAPE_LIVE_KEY];
+            return handle ?? NOOP;
+        };
+        return {
+            config: (key, value) => resolve().config(key, value),
+            quality: (key, value) => resolve().quality(key, value),
+            surface: (index, key, value) => resolve().surface(index, key, value),
+            autoSplat: (key, value) => resolve().autoSplat(key, value),
+        };
+    }, [target]);
+}
+export default useLandscapeLive;

package/dist/hooks/useLandscapeMaps.d.ts

@@ -0,0 +1,32 @@
+import { type DecodedHeightmap } from '../utils/landscapeTextures';
+import type { LandscapeConfig, LandscapeQualityConfig } from '../types/landscapeConfigs';
+import type { LandscapeMapUniforms } from '../utils/landscapeUniforms';
+/**
+ * Every image a landscape needs, loaded and packed.
+ *
+ * The surfaces go into two `DataArrayTexture`s rather than sixteen samplers:
+ * one binding, one integer layer index, no branch tree. Every layer must be the
+ * same size and user uploads never are, so each image is redrawn at
+ * `arrayResolution` on the way in.
+ *
+ * **The height maps ride in the normal array's alpha channel.** A tangent-space
+ * normal map only needs RGB, so the surface's own height — the thing that makes
+ * a transition read as material rather than as a cross-fade — costs nothing but
+ * the channel that was already there. A third array would have been another
+ * 100 MB at 1024.
+ *
+ * Loading is one effect with a cancellation flag, and the previous set is
+ * disposed only after the new one is ready, so a change of preset does not blink
+ * the ground away.
+ */
+export interface LandscapeMapsState extends LandscapeMapUniforms {
+    /** The decoded heightmap, for RTIN and for CPU height queries. */
+    heightField: DecodedHeightmap | null;
+    ready: boolean;
+    error: string | null;
+    /** Surfaces that actually contributed a layer, in order. */
+    layerCount: number;
+}
+export declare function useLandscapeMaps(config: LandscapeConfig, quality: LandscapeQualityConfig): LandscapeMapsState;
+export default useLandscapeMaps;
+//# sourceMappingURL=useLandscapeMaps.d.ts.map

package/dist/hooks/useLandscapeMaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLandscapeMaps.d.ts","sourceRoot":"","sources":["../../src/hooks/useLandscapeMaps.ts"],"names":[],"mappings":"AAEA,OAAO,EAOH,KAAK,gBAAgB,EACxB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC5D,kEAAkE;IAClE,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACpC,KAAK,EAAE,OAAO,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAA;CACrB;AA4CD,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,sBAAsB,GAChC,kBAAkB,CAmHpB;AAED,eAAe,gBAAgB,CAAA"}

package/dist/hooks/useLandscapeMaps.js

@@ -0,0 +1,138 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { buildFieldTexture, buildTextureArray, decodeHeightmap, loadImage, smoothHeightfield, textureFromImage, } from '../utils/landscapeTextures.js';
+const EMPTY = {
+    height: null,
+    heightSize: new THREE.Vector2(1, 1),
+    field: null,
+    fieldSize: new THREE.Vector2(1, 1),
+    gradScale: 1,
+    diffuse: null,
+    normal: null,
+    splat0: null,
+    splat1: null,
+    ao: null,
+    means: [],
+    heightField: null,
+    ready: false,
+    error: null,
+    layerCount: 0,
+};
+function disposeState(state) {
+    state.height?.dispose();
+    state.field?.dispose();
+    state.diffuse?.dispose();
+    state.normal?.dispose();
+    state.splat0?.dispose();
+    state.splat1?.dispose();
+    state.ao?.dispose();
+}
+/** Only the URLs and the packing size matter; nothing here should re-run because
+ *  a slider moved. */
+function mapsKey(config, quality) {
+    return JSON.stringify([
+        config.heightMap,
+        config.heightEncoding,
+        config.splatMaps,
+        config.aoMap ?? '',
+        quality.arrayResolution,
+        quality.anisotropy,
+        config.surfaces.map((s) => [s.diffuse, s.normal ?? '', s.displacement ?? '']),
+    ]);
+}
+export function useLandscapeMaps(config, quality) {
+    const key = useMemo(() => mapsKey(config, quality), [config, quality]);
+    const [state, setState] = useState(EMPTY);
+    const current = useRef(EMPTY);
+    useEffect(() => {
+        let cancelled = false;
+        const surfaces = config.surfaces.filter((s) => !!s.diffuse);
+        if (!config.heightMap || surfaces.length === 0) {
+            setState({ ...EMPTY, error: null });
+            return () => { cancelled = true; };
+        }
+        const run = async () => {
+            const size = quality.arrayResolution;
+            const [heightImage, splatImages, aoImage, diffuseImages, normalImages, heightImages] = await Promise.all([
+                loadImage(config.heightMap),
+                Promise.all(config.splatMaps.slice(0, 2).map((url) => loadImage(url))),
+                config.aoMap ? loadImage(config.aoMap) : Promise.resolve(null),
+                Promise.all(surfaces.map((s) => loadImage(s.diffuse))),
+                Promise.all(surfaces.map((s) => (s.normal ? loadImage(s.normal) : Promise.resolve(null)))),
+                Promise.all(surfaces.map((s) => (s.displacement ? loadImage(s.displacement) : Promise.resolve(null)))),
+            ]);
+            if (cancelled)
+                return;
+            // Smoothed before anything else uses it. An 8-bit heightmap's own
+            // quantisation is a 1.33 m staircase over 340 m of relief, which is
+            // what RTIN's error metric measures instead of the terrain, and what
+            // the surface gradient would otherwise be computed from.
+            const raw = decodeHeightmap(heightImage, config.heightEncoding);
+            const heightField = smoothHeightfield(raw, 1);
+            const field = buildFieldTexture(heightField);
+            const height = textureFromImage(heightImage, THREE.NoColorSpace);
+            // No mips and no filtering surprises: the vertex stage samples this
+            // at lod 0 and the bicubic filter does its own footprint widening.
+            height.minFilter = THREE.LinearFilter;
+            height.magFilter = THREE.LinearFilter;
+            height.generateMipmaps = false;
+            const diffuse = buildTextureArray(diffuseImages, size, THREE.SRGBColorSpace);
+            const normal = buildTextureArray(normalImages, size, THREE.NoColorSpace, heightImages, 
+            // A flat normal for a surface with no normal map.
+            [128, 128, 255, 128]);
+            diffuse.texture.anisotropy = quality.anisotropy;
+            normal.texture.anisotropy = quality.anisotropy;
+            const splats = splatImages.map((image) => {
+                const texture = textureFromImage(image, THREE.NoColorSpace);
+                texture.generateMipmaps = false;
+                texture.minFilter = THREE.LinearFilter;
+                return texture;
+            });
+            const ao = aoImage ? textureFromImage(aoImage, THREE.NoColorSpace) : null;
+            if (cancelled) {
+                height.dispose();
+                field.texture.dispose();
+                diffuse.texture.dispose();
+                normal.texture.dispose();
+                splats.forEach((t) => t.dispose());
+                ao?.dispose();
+                return;
+            }
+            const next = {
+                height,
+                heightSize: new THREE.Vector2(heightField.tileSize, heightField.tileSize),
+                field: field.texture,
+                fieldSize: new THREE.Vector2(heightField.tileSize, heightField.tileSize),
+                gradScale: field.gradScale,
+                diffuse: diffuse.texture,
+                normal: normal.texture,
+                splat0: splats[0] ?? null,
+                splat1: splats[1] ?? null,
+                ao,
+                means: diffuse.means,
+                heightField,
+                ready: true,
+                error: null,
+                layerCount: surfaces.length,
+            };
+            const previous = current.current;
+            current.current = next;
+            setState(next);
+            // Only now — swapping first would blink the ground away mid-edit.
+            disposeState(previous);
+        };
+        run().catch((error) => {
+            if (cancelled)
+                return;
+            const message = error instanceof Error ? error.message : String(error);
+            // eslint-disable-next-line no-console
+            console.error('[landscape] map load failed:', message);
+            setState({ ...EMPTY, error: message });
+        });
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [key]);
+    useEffect(() => () => { disposeState(current.current); }, []);
+    return state;
+}
+export default useLandscapeMaps;

package/dist/hooks/useMaterialApplication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMaterialApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialApplication.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAI/D,eAAO,MAAM,sBAAsB,GAAI,QAAQ,cAAc,EAAE,kBAAkB,gBAAgB,EAAE,4BAA4B,OAAO,EAAE,YAAY,MAAM,IAAI,KAAG,IAqIhK,CAAC"}
+{"version":3,"file":"useMaterialApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialApplication.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG/D,eAAO,MAAM,sBAAsB,GAAI,QAAQ,cAAc,EAAE,kBAAkB,gBAAgB,EAAE,4BAA4B,OAAO,EAAE,YAAY,MAAM,IAAI,KAAG,IAuIhK,CAAC"}

package/dist/hooks/useMaterialApplication.js

@@ -8,8 +8,6 @@
 import { useEffect, useRef } from 'react';
 import { createAndApplyMaterial, MATERIAL_INSTANCE_KEY, MaterialRegistryAPI, ObjectManager, resolveTextures, traverseSkippingEdgesAndEffects } from '@3driseai/3drise-core';
 import { resolveObject3D } from "../utils/resolveObject3D.js";
-// TEST: 0=raw defaults, 1=+DoubleSide, 2=+transparent, 3=+metalness/roughness
-const TEST_MATERIAL_MODE = 1;
 export const useMaterialApplication = (source, materialSettings, shouldApply3driseMaterial, onApplied) => {
     // Track all material instances we've created so we can release them on change/unmount
     // const { getTypeByName } = useObjectTypes();
@@ -29,7 +27,8 @@ export const useMaterialApplication = (source, materialSettings, shouldApply3dri
         // attached refs, so this is the first point the object reliably exists.
         const obj = resolveObject3D(source);
         if (!obj || !materialSettings || materialSettings.materialType === 'advanced' ||
-            materialSettings.materialVariant === '3dRiseShader' || (shouldApply3driseMaterial === false))
+            materialSettings.materialVariant === '3dRiseShader'
+            || (shouldApply3driseMaterial === false))
             return;
         handleSettingsChange(obj, materialSettings);
         return () => {

package/dist/hooks/useMaterialOptions.d.ts

@@ -1,5 +1,5 @@
 import { MaterialRegistryAPI } from '@3driseai/3drise-core';
-import type { CreatedObjectType, DisplayMode, MaterialSettings, SelectOptions } from '@3driseai/3drise-core';
+import type { CreatedObjectType, MaterialSettings, ModeGroup, SelectOptions } from '@3driseai/3drise-core';
 type RegistryMaterialType = Exclude<Parameters<typeof MaterialRegistryAPI.getVariants>[0], undefined>;
 export interface UseMaterialOptionsReturn {
     selectedType: RegistryMaterialType;
@@ -9,6 +9,6 @@ export interface UseMaterialOptionsReturn {
     handleTypeChange: (type: RegistryMaterialType) => void;
     handleVariantChange: (variant: string) => void;
 }
-export declare const useMaterialOptions: (initialSettings: MaterialSettings, onSettingsChange?: (newSettings: MaterialSettings) => void, objectType?: CreatedObjectType, displayMode?: DisplayMode) => UseMaterialOptionsReturn;
+export declare const useMaterialOptions: (initialSettings: MaterialSettings, onSettingsChange?: (newSettings: MaterialSettings) => void, objectType?: CreatedObjectType, surface?: ModeGroup) => UseMaterialOptionsReturn;
 export {};
 //# sourceMappingURL=useMaterialOptions.d.ts.map

package/dist/hooks/useMaterialOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMaterialOptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialOptions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE7G,KAAK,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEtG,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,oBAAoB,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,aAAa,CAAC;IACnC,cAAc,EAAE,aAAa,CAAC;IAC9B,gBAAgB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACvD,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,gBAAgB,EAAE,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI,EAAE,aAAY,iBAA0B,EAAE,cAAa,WAAqB,KAAG,wBA4G9M,CAAC"}
+{"version":3,"file":"useMaterialOptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useMaterialOptions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAA2B,MAAM,uBAAuB,CAAC;AACrF,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3G,KAAK,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEtG,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,oBAAoB,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,aAAa,CAAC;IACnC,cAAc,EAAE,aAAa,CAAC;IAC9B,gBAAgB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACvD,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,gBAAgB,EAAE,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI,EAAE,aAAY,iBAA0B,EAAE,UAAS,SAAkB,KAAG,wBA0FvM,CAAC"}

package/dist/hooks/useMaterialOptions.js

@@ -1,7 +1,7 @@
 import { useState, useEffect } from 'react';
-import { MaterialRegistryAPI } from '@3driseai/3drise-core';
+import { MaterialRegistryAPI, materialTypeFitsSurface } from '@3driseai/3drise-core';
 import { FrontSide } from 'three';
-export const useMaterialOptions = (initialSettings, onSettingsChange, objectType = 'mesh', displayMode = 'solid') => {
+export const useMaterialOptions = (initialSettings, onSettingsChange, objectType = 'mesh', surface = 'mesh') => {
     // Ensure we always have a valid material type
     const validType = (initialSettings.materialType || 'basic');
     const [selectedType, setSelectedType] = useState(validType);
@@ -18,35 +18,17 @@ export const useMaterialOptions = (initialSettings, onSettingsChange, objectType
         setSelectedVariant(initialSettings.materialVariant || variants[0] || '');
     }, [initialSettings.materialType, initialSettings.materialVariant]);
     const allmaterialTypes = MaterialRegistryAPI.getTypes();
-    const is3dRiseShaderMaterial = initialSettings.materialType === 'particles' || initialSettings.materialType === 'custom';
-    const isLineMaterial = initialSettings.materialType === 'line';
-    const meshMaterialTypes = allmaterialTypes.filter(type => type !== 'particles' && type !== 'custom' && type !== 'line');
-    const lineMaterialTypes = allmaterialTypes.filter(type => type === 'line');
-    const dRiseShaderMaterialTypes = allmaterialTypes.filter(type => type === 'particles' || type === 'custom');
-    const materialTypeOptions = () => {
-        if (objectType === 'mesh') {
-            return allmaterialTypes.map((type) => ({
-                value: type,
-                label: type.charAt(0).toUpperCase() + type.slice(1)
-            }));
-        }
-        if (is3dRiseShaderMaterial) {
-            return dRiseShaderMaterialTypes.map((type) => ({
-                value: type,
-                label: type.charAt(0).toUpperCase() + type.slice(1)
-            }));
-        }
-        if (isLineMaterial) {
-            return lineMaterialTypes.map((type) => ({
-                value: type,
-                label: type.charAt(0).toUpperCase() + type.slice(1)
-            }));
-        }
-        return meshMaterialTypes.map((type) => ({
-            value: type,
-            label: type.charAt(0).toUpperCase() + type.slice(1)
-        }));
-    };
+    // Offer only the families that can actually draw on this object's surface.
+    // A <points> takes the `particles` family and nothing else; every other
+    // surface takes everything except it. Note this keys off the surface, never
+    // off the currently selected material — the previous version did the latter,
+    // which meant an object could never get back to a family once it left it.
+    const materialTypeOptions = () => allmaterialTypes
+        .filter((type) => materialTypeFitsSurface(type, surface))
+        .map((type) => ({
+        value: type,
+        label: type.charAt(0).toUpperCase() + type.slice(1)
+    }));
     // is3dRiseShaderMaterial ?
     // dRiseShaderMaterialTypes.map((type: string) => ({
     //   value: type,

package/dist/hooks/useObjectEdges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useObjectEdges.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectEdges.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAiK/D,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CA6ChH"}
+{"version":3,"file":"useObjectEdges.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectEdges.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAmH/D,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CA6ChH"}