@3driseai/3drise-viewer 0.1.39 → 0.1.41

package/dist/components/gallery/looks/strata.d.ts

@@ -0,0 +1,172 @@
+import * as THREE from 'three';
+export declare const catalog: {
+    key: string;
+    name: string;
+    camera: {
+        position: number[];
+        target: number[];
+    };
+    description: string;
+    tags: string[];
+};
+export declare const DEFAULTS: {
+    type: string;
+    aspect: number;
+    width: number;
+    plates: number;
+    relief: number;
+    base: number;
+    gap: number;
+    smoothing: number;
+    roughness: number;
+    plateColor: string;
+    changeTime: number;
+    wave: number;
+    slant: number;
+    dim: number;
+    pointerMode: string;
+    pointerRadius: number;
+    enabled: boolean;
+    lean: number;
+    imageUrls: any[];
+    autoplay: number;
+    intensity: number;
+    opacity: number;
+    layout: string;
+    spacing: number;
+    depth: number;
+    visible: number;
+    shape: number;
+    stiffness: number;
+    damping: number;
+    throwing: number;
+    pointerStrength: number;
+};
+export declare const STRUCTURAL: string[];
+export declare const POINTER_MODES: string[];
+export declare const GUI: ({
+    key: string;
+    options: string[];
+    tip: string;
+    min?: undefined;
+    max?: undefined;
+    step?: undefined;
+} | {
+    key: string;
+    min: number;
+    max: number;
+    step: number;
+} | {
+    key: string;
+    options: string[];
+    color?: undefined;
+} | {
+    key: string;
+    color: boolean;
+    options?: undefined;
+})[];
+export declare const PRESETS: ({
+    name: string;
+    description: string;
+    patch: {
+        plates?: undefined;
+        gap?: undefined;
+        relief?: undefined;
+        smoothing?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        plates: number;
+        gap: number;
+        relief: number;
+        smoothing?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        plates: number;
+        gap: number;
+        relief: number;
+        smoothing: number;
+    };
+})[];
+export declare function createUniforms(): {
+    uPlates: {
+        value: number;
+    };
+    uRelief: {
+        value: number;
+    };
+    uBase: {
+        value: number;
+    };
+    uGap: {
+        value: number;
+    };
+    uSmooth: {
+        value: number;
+    };
+    uPlate: {
+        value: THREE.Color;
+    };
+    uTex: {
+        value: any;
+    };
+    uS: {
+        value: number;
+    };
+    uCount: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+    uAct: {
+        value: Float32Array<ArrayBuffer>;
+    };
+    uW: {
+        value: number;
+    };
+    uH: {
+        value: number;
+    };
+    uWave: {
+        value: number;
+    };
+    uSlant: {
+        value: number;
+    };
+    uDim: {
+        value: number;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPlace: {
+        value: THREE.Matrix4[];
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): any;
+//# sourceMappingURL=strata.d.ts.map

package/dist/components/gallery/looks/strata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strata.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/strata.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAE6D,CAAC;AAElF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAA6C,CAAC;AACrE,eAAO,MAAM,aAAa,UAAW,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;IASf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0M;AACxO,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAA+K;AAmC/M,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}

package/dist/components/gallery/looks/strata.js

@@ -0,0 +1,88 @@
+// The approved lab module, verbatim but for its import paths and the lab's picture loader (Claude outputs/gallery-lab/
+// strata.mjs). Plain JS-shaped code (the viewer compiles non-strict); typed at its one door, kit/GalleryVariant.tsx. Its own DEFAULTS only fill knobs the
+// core defaults (DEFAULT_GALLERY_OBJECTS.strata) do not carry; its own autoplay is never used.
+// strata — every picture is a stack of thin horizontal plates, like a laser-cut relief: each plate's front edge
+// follows the picture's brightness along its own row (bright stands forward), its front face carries its strip of
+// the picture, its top, bottom and back are plain card. Lit by the scene, so from an angle the stack reads as
+// layered relief, and the gaps between the plates draw fine dark lines. An inactive picture is a flat grey stack of
+// thin plates. When it becomes the active one a soft wave crosses it and the plates slide forward into the relief,
+// in full colour; leaving slides them back. The cursor pushes the plates near it back in. Scene-lit (standard
+// material); the gallery adds no light.
+import * as THREE from 'three';
+import { BASE_DEFAULTS, BASE_GUI_MOTION, BASE_GUI_TAIL, LAYOUT_GUI, baseUniforms, applyBase, instanced, litMaterial, makeGallery, withLean } from '../kit/lookBase.js';
+export const catalog = { key: 'strata', name: 'Strata', camera: { position: [1.5, 0.7, 4.2], target: [0, 0, 0] },
+    description: 'Pictures as stacks of thin horizontal plates lit by the scene, each plate’s front following the picture’s brightness like a laser-cut relief: inactive ones are a flat grey stack, the active one slides forward into relief in full colour; the cursor pushes plates back. Use for architecture, product, interiors and craft showcases.',
+    tags: ['gallery', 'strata', 'plates', 'relief', 'scene-lit', 'interactive'] };
+export const DEFAULTS = {
+    ...BASE_DEFAULTS, type: 'strata', aspect: 1.4, width: 2.2, plates: 30, // structural
+    relief: 0.3, base: 0.1, gap: 0.12, smoothing: 2.0, roughness: 0.7, plateColor: '#bdb7ad', changeTime: 2.0, wave: 0.45, slant: 0.15, dim: 0.5,
+    pointerMode: 'push', pointerRadius: 0.5,
+};
+export const STRUCTURAL = ['imageUrls', 'aspect', 'width', 'plates'];
+export const POINTER_MODES = ['push'];
+export const GUI = [
+    { key: 'lean', min: 0, max: 3, step: 0.01, tip: 'The gallery turns toward the cursor' },
+    { key: 'aspect', min: 0.6, max: 2.5, step: 0.01 }, { key: 'width', min: 1, max: 4, step: 0.01 }, { key: 'plates', min: 6, max: 120, step: 1, tip: 'Plates down a picture' },
+    ...LAYOUT_GUI, ...BASE_GUI_MOTION,
+    { key: 'relief', min: 0, max: 0.6, step: 0.005, tip: 'How far the brightest part of a plate stands forward' }, { key: 'base', min: 0, max: 1, step: 0.01, tip: 'Depth of the darkest part, as a share of the brightest' },
+    { key: 'gap', min: 0, max: 0.6, step: 0.01, tip: 'Gap between plates, as a share of a plate' },
+    { key: 'smoothing', min: 0, max: 5, step: 0.1, tip: 'How much the brightness is smoothed before it shapes the plates' }, { key: 'roughness', min: 0, max: 1, step: 0.01 },
+    { key: 'pointerMode', options: ['none', ...POINTER_MODES] }, ...BASE_GUI_TAIL,
+    { key: 'plateColor', color: true },
+];
+export const PRESETS = [
+    { name: 'Strata', description: 'The default.', patch: {} },
+    { name: 'Fine cut', description: 'Many thin plates.', patch: { plates: 80, gap: 0.08, relief: 0.18 } },
+    { name: 'Slabs', description: 'A few thick plates, deep.', patch: { plates: 12, gap: 0.18, relief: 0.32, smoothing: 3 } },
+];
+export function createUniforms() { return { ...baseUniforms(), uPlates: { value: 30 }, uRelief: { value: 0.22 }, uBase: { value: 0.1 }, uGap: { value: 0.12 }, uSmooth: { value: 2 }, uPlate: { value: new THREE.Color('#bdb7ad') } }; }
+export function applyConfig(u, c) { const set = applyBase(u, c, POINTER_MODES); set('uRelief', c.relief); set('uBase', c.base); set('uGap', c.gap); set('uSmooth', c.smoothing); set('uPlate', c.plateColor); }
+const vertex = {
+    head: /* glsl */ `
+        uniform float uPlates, uRelief, uBase, uGap, uSmooth;
+        varying vec2 vUv; varying float vImg; varying float vW; varying float vFront; varying float vAlpha;
+        float depthAt(float img, vec2 g, float act){
+            float L = lumOf(textureLod(uTex, vec3(g, img), uSmooth).rgb);
+            vec2 p = vec2((g.x - 0.5) * uW, (g.y - 0.5) * uH);
+            return 0.012 + uRelief * (uBase + (1.0 - uBase) * L) * waveAt(act, g) * (1.0 - 0.9 * maskAt(p));
+        }
+    `,
+    body: /* glsl */ `
+        float img = aI.x, j = aI.y; float act = actOf(img);
+        float yj = (j + 0.5) / uPlates, ph = uH / uPlates * (1.0 - uGap);
+        vec2 g = vec2(position.x + 0.5, yj);
+        float front = step(0.0, position.z);
+        float dz = depthAt(img, g, act);
+        float d = 1.0 / 160.0;
+        float dzx = (depthAt(img, g + vec2(d, 0.0), act) - dz) / (d * uW);
+        gPos = vec3(position.x * uW, (yj - 0.5) * uH + position.y * ph, front * dz);
+        // the front edge bends with the relief; the plate's top / bottom / sides keep their own normals
+        if (normal.z > 0.5) gNrm = normalize(vec3(-dzx, 0.0, 1.0));
+        vUv = vec2(g.x, yj + position.y * ph / uH); vImg = img; vW = waveAt(act, g); vFront = step(0.5, normal.z); vAlpha = fadeAt(img);
+    `,
+};
+const fragment = {
+    head: /* glsl */ `uniform vec3 uPlate; varying vec2 vUv; varying float vImg; varying float vW; varying float vFront; varying float vAlpha;`,
+    body: /* glsl */ `
+        vec3 pic = texture(uTex, vec3(vUv, vImg)).rgb;
+        vec3 face = mix(fadedOf(pic) * 1.7, pic, vW);
+        diffuseColor.rgb = mix(uPlate * mix(0.45, 0.8, vW), face, vFront) * uIntensity;
+        diffuseColor.a *= vAlpha * uOpacity; if (diffuseColor.a < 0.01) discard;
+    `,
+};
+export function build(u, c) { return withLean(buildGallery(u, c), c); }
+function buildGallery(u, c) {
+    const W = c.width, H = W / c.aspect, R = Math.max(2, c.plates | 0);
+    u.uPlates.value = R;
+    const geo = instanced(new THREE.BoxGeometry(1, 1, 1, 96, 1, 1), R, () => [0, 0]);
+    const mat = litMaterial(u, 'strata', vertex, fragment, { roughness: c.roughness });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = () => { };
+    mesh.receiveShadow = true;
+    const g = makeGallery(u, c, { W, H, meshes: [mesh], setCount: (n) => { geo.instanceCount = n * R; } });
+    const apply = g.apply;
+    g.apply = (k) => { apply(k); applyConfig(u, k); if (k.roughness !== undefined)
+        mat.roughness = k.roughness; };
+    return g;
+}

package/dist/components/gallery/looks/terraces.d.ts

@@ -0,0 +1,168 @@
+import * as THREE from 'three';
+export declare const catalog: {
+    key: string;
+    name: string;
+    camera: {
+        position: number[];
+        target: number[];
+    };
+    description: string;
+    tags: string[];
+};
+export declare const DEFAULTS: {
+    type: string;
+    aspect: number;
+    width: number;
+    resolution: number;
+    levels: number;
+    relief: number;
+    sharpness: number;
+    smoothing: number;
+    edges: number;
+    roughness: number;
+    changeTime: number;
+    dim: number;
+    pointerMode: string;
+    pointerRadius: number;
+    lift: number;
+    enabled: boolean;
+    lean: number;
+    imageUrls: any[];
+    autoplay: number;
+    intensity: number;
+    opacity: number;
+    layout: string;
+    spacing: number;
+    depth: number;
+    visible: number;
+    shape: number;
+    stiffness: number;
+    damping: number;
+    throwing: number;
+    wave: number;
+    slant: number;
+    pointerStrength: number;
+};
+export declare const STRUCTURAL: string[];
+export declare const POINTER_MODES: string[];
+export declare const GUI: ({
+    key: string;
+    options: string[];
+    tip: string;
+    min?: undefined;
+    max?: undefined;
+    step?: undefined;
+} | {
+    key: string;
+    min: number;
+    max: number;
+    step: number;
+} | {
+    key: string;
+    options: string[];
+})[];
+export declare const PRESETS: ({
+    name: string;
+    description: string;
+    patch: {
+        levels?: undefined;
+        relief?: undefined;
+        edges?: undefined;
+        smoothing?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        levels: number;
+        relief: number;
+        edges: number;
+        smoothing?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        levels: number;
+        relief: number;
+        smoothing: number;
+        edges?: undefined;
+    };
+})[];
+export declare function createUniforms(): {
+    uLevels: {
+        value: number;
+    };
+    uRelief: {
+        value: number;
+    };
+    uSharp: {
+        value: number;
+    };
+    uSmooth: {
+        value: number;
+    };
+    uEdges: {
+        value: number;
+    };
+    uLift: {
+        value: number;
+    };
+    uTex: {
+        value: any;
+    };
+    uS: {
+        value: number;
+    };
+    uCount: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+    uAct: {
+        value: Float32Array<ArrayBuffer>;
+    };
+    uW: {
+        value: number;
+    };
+    uH: {
+        value: number;
+    };
+    uWave: {
+        value: number;
+    };
+    uSlant: {
+        value: number;
+    };
+    uDim: {
+        value: number;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPlace: {
+        value: THREE.Matrix4[];
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): any;
+//# sourceMappingURL=terraces.d.ts.map

package/dist/components/gallery/looks/terraces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraces.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/terraces.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAEkE,CAAC;AAEvF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAAiD,CAAC;AACzE,eAAO,MAAM,aAAa,UAAW,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAQf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsL;AACpN,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAA4M;AAyC5O,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}

package/dist/components/gallery/looks/terraces.js

@@ -0,0 +1,91 @@
+// The approved lab module, verbatim but for its import paths and the lab's picture loader (Claude outputs/gallery-lab/
+// terraces.mjs). Plain JS-shaped code (the viewer compiles non-strict); typed at its one door, kit/GalleryVariant.tsx. Its own DEFAULTS only fill knobs the
+// core defaults (DEFAULT_GALLERY_OBJECTS.terraces) do not carry; its own autoplay is never used.
+// terraces — every picture is a topographic model made of stacked card: its brightness, softened, is cut into
+// `levels` flat plateaus (a stepped quantisation with crisp walls), and each plateau stands that many card
+// thicknesses high. Lit by the scene, so the walls catch the light and the plateaus read as card. An inactive picture
+// is flat: a grey contour map of its own levels. When it becomes the active one a soft wave crosses it and the
+// terraces rise behind it in full colour; leaving lays them down again. The cursor lifts the terraces near it
+// further. Scene-lit (standard material): the studio's lights draw the steps; the gallery adds none.
+import * as THREE from 'three';
+import { BASE_DEFAULTS, BASE_GUI_MOTION, BASE_GUI_TAIL, LAYOUT_GUI, baseUniforms, applyBase, instanced, litMaterial, makeGallery, withLean } from '../kit/lookBase.js';
+export const catalog = { key: 'terraces', name: 'Terraces', camera: { position: [1.4, 0.9, 4.2], target: [0, -0.05, 0] },
+    description: 'Pictures as topographic models of stacked card lit by the scene: inactive ones are a flat grey contour map, the active one rises into terraces of its own brightness in full colour behind a soft wave; the cursor lifts the terraces higher. Use for architecture, maps, data and craft showcases.',
+    tags: ['gallery', 'terraces', 'topographic', 'card', 'scene-lit', 'interactive'] };
+export const DEFAULTS = {
+    ...BASE_DEFAULTS, type: 'terraces', aspect: 1.4, width: 2.2, resolution: 150, // structural
+    levels: 9, relief: 0.2, sharpness: 0.85, smoothing: 2.4, edges: 0.5, roughness: 0.8, changeTime: 2.2, dim: 0.5,
+    pointerMode: 'lift', pointerRadius: 0.5, lift: 0.12,
+};
+export const STRUCTURAL = ['imageUrls', 'aspect', 'width', 'resolution'];
+export const POINTER_MODES = ['lift'];
+export const GUI = [
+    { key: 'lean', min: 0, max: 3, step: 0.01, tip: 'The gallery turns toward the cursor' },
+    { key: 'aspect', min: 0.6, max: 2.5, step: 0.01 }, { key: 'width', min: 1, max: 4, step: 0.01 }, { key: 'resolution', min: 40, max: 260, step: 2, tip: 'Grid resolution across a picture' },
+    ...LAYOUT_GUI, ...BASE_GUI_MOTION,
+    { key: 'levels', min: 2, max: 24, step: 1, tip: 'Number of terraces' }, { key: 'relief', min: 0, max: 0.6, step: 0.005, tip: 'Height of the top terrace' },
+    { key: 'sharpness', min: 0, max: 1, step: 0.01, tip: 'How crisp the terrace walls are' }, { key: 'smoothing', min: 0, max: 5, step: 0.1, tip: 'How much the brightness is smoothed before it is cut into terraces' },
+    { key: 'edges', min: 0, max: 1.5, step: 0.01, tip: 'Brightness of the thin card edge along each terrace' }, { key: 'roughness', min: 0, max: 1, step: 0.01 },
+    { key: 'pointerMode', options: ['none', ...POINTER_MODES] }, ...BASE_GUI_TAIL, { key: 'lift', min: 0, max: 0.4, step: 0.005, tip: 'How far the cursor lifts the terraces' },
+];
+export const PRESETS = [
+    { name: 'Terraces', description: 'The default.', patch: {} },
+    { name: 'Survey model', description: 'Many thin card layers.', patch: { levels: 18, relief: 0.24, edges: 0.7 } },
+    { name: 'Plateaus', description: 'A few broad, high steps.', patch: { levels: 4, relief: 0.3, smoothing: 3.4 } },
+];
+export function createUniforms() { return { ...baseUniforms(), uLevels: { value: 9 }, uRelief: { value: 0.2 }, uSharp: { value: 0.85 }, uSmooth: { value: 2.4 }, uEdges: { value: 0.5 }, uLift: { value: 0.12 } }; }
+export function applyConfig(u, c) { const set = applyBase(u, c, POINTER_MODES); set('uLevels', c.levels); set('uRelief', c.relief); set('uSharp', c.sharpness); set('uSmooth', c.smoothing); set('uEdges', c.edges); set('uLift', c.lift); }
+const vertex = {
+    head: /* glsl */ `
+        uniform float uLevels, uRelief, uSharp, uSmooth, uLift;
+        varying vec2 vUv; varying float vImg; varying float vW; varying float vAlpha;
+        float stepAt(float L){                                      // the level, with walls of width (1 - sharpness)
+            float x = L * uLevels, k = 0.5 * (1.0 - uSharp) + 0.02;
+            return (floor(x) + smoothstep(0.5 - k, 0.5 + k, fract(x))) / uLevels;
+        }
+        float heightAt(float img, vec2 g, float act){
+            float L = lumOf(textureLod(uTex, vec3(g, img), uSmooth).rgb);
+            vec2 p = vec2((g.x - 0.5) * uW, (g.y - 0.5) * uH);
+            float w = waveAt(act, g);
+            return stepAt(L) * w * (uRelief + uLift * maskAt(p));
+        }
+    `,
+    body: /* glsl */ `
+        float img = aI.x; float act = actOf(img);
+        vec2 g = position.xy + 0.5;
+        float h = heightAt(img, g, act);
+        float d = 1.0 / 220.0;
+        float hx = heightAt(img, g + vec2(d, 0.0), act), hy = heightAt(img, g + vec2(0.0, d), act);
+        gPos = vec3(position.x * uW, position.y * uH, h);
+        gNrm = normalize(vec3(-(hx - h) / (d * uW), -(hy - h) / (d * uH), 1.0));
+        vUv = g; vImg = img; vW = waveAt(act, g); vAlpha = fadeAt(img);
+    `,
+};
+const fragment = {
+    head: /* glsl */ `uniform float uLevels, uSmooth, uEdges; varying vec2 vUv; varying float vImg; varying float vW; varying float vAlpha;`,
+    body: /* glsl */ `
+        vec3 pic = texture(uTex, vec3(vUv, vImg)).rgb;
+        float L = lumOf(textureLod(uTex, vec3(vUv, vImg), uSmooth).rgb);
+        float f = L * uLevels, dist = abs(f - floor(f + 0.5)), px = max(fwidth(f), 1e-4);
+        float edge = 1.0 - smoothstep(0.0, px * 1.6, dist);         // the thin card edge on every level line
+        vec3 c = mix(fadedOf(pic), pic, vW);
+        c += vec3(1.0) * edge * mix(0.35, uEdges * 0.4, vW);
+        diffuseColor.rgb = c * uIntensity;
+        diffuseColor.a *= vAlpha * uOpacity; if (diffuseColor.a < 0.01) discard;
+    `,
+};
+export function build(u, c) { return withLean(buildGallery(u, c), c); }
+function buildGallery(u, c) {
+    const W = c.width, H = W / c.aspect, sx = Math.max(16, c.resolution | 0), sy = Math.max(12, Math.round(sx / c.aspect));
+    const geo = instanced(new THREE.PlaneGeometry(1, 1, sx, sy), 1, () => [0, 0]);
+    const mat = litMaterial(u, 'terraces', vertex, fragment, { roughness: c.roughness });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = () => { };
+    mesh.receiveShadow = true;
+    const g = makeGallery(u, c, { W, H, meshes: [mesh], setCount: (n) => { geo.instanceCount = n; } });
+    const apply = g.apply;
+    g.apply = (k) => { apply(k); applyConfig(u, k); if (k.roughness !== undefined)
+        mat.roughness = k.roughness; };
+    return g;
+}

package/dist/components/gallery/looks/wireRelief.d.ts

@@ -0,0 +1,153 @@
+import * as THREE from 'three';
+export declare const catalog: {
+    key: string;
+    name: string;
+    camera: {
+        position: number[];
+        target: number[];
+    };
+    description: string;
+    tags: string[];
+};
+export declare const DEFAULTS: {
+    type: string;
+    aspect: number;
+    width: number;
+    cells: number;
+    relief: number;
+    wire: number;
+    wireColor: string;
+    changeTime: number;
+    dim: number;
+    pointerMode: string;
+    pointerRadius: number;
+    lift: number;
+    enabled: boolean;
+    lean: number;
+    imageUrls: any[];
+    autoplay: number;
+    intensity: number;
+    opacity: number;
+    layout: string;
+    spacing: number;
+    depth: number;
+    visible: number;
+    shape: number;
+    stiffness: number;
+    damping: number;
+    throwing: number;
+    wave: number;
+    slant: number;
+    pointerStrength: number;
+};
+export declare const STRUCTURAL: string[];
+export declare const POINTER_MODES: string[];
+export declare const GUI: ({
+    key: string;
+    options: string[];
+    tip: string;
+    min?: undefined;
+    max?: undefined;
+    step?: undefined;
+} | {
+    key: string;
+    min: number;
+    max: number;
+    step: number;
+} | {
+    key: string;
+    options: string[];
+    color?: undefined;
+} | {
+    key: string;
+    color: boolean;
+    options?: undefined;
+})[];
+export declare const PRESETS: ({
+    name: string;
+    description: string;
+    patch: {
+        cells?: undefined;
+        relief?: undefined;
+        wire?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        cells: number;
+        relief: number;
+        wire: number;
+    };
+})[];
+export declare function createUniforms(): {
+    uRelief: {
+        value: number;
+    };
+    uWire: {
+        value: number;
+    };
+    uLift: {
+        value: number;
+    };
+    uWireColor: {
+        value: THREE.Color;
+    };
+    uTex: {
+        value: any;
+    };
+    uS: {
+        value: number;
+    };
+    uCount: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+    uAct: {
+        value: Float32Array<ArrayBuffer>;
+    };
+    uW: {
+        value: number;
+    };
+    uH: {
+        value: number;
+    };
+    uWave: {
+        value: number;
+    };
+    uSlant: {
+        value: number;
+    };
+    uDim: {
+        value: number;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPlace: {
+        value: THREE.Matrix4[];
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): any;
+//# sourceMappingURL=wireRelief.d.ts.map

package/dist/components/gallery/looks/wireRelief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wireRelief.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/wireRelief.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAEyD,CAAC;AAE9E,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAA4C,CAAC;AACpE,eAAO,MAAM,aAAa,UAAa,CAAC;AACxC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;IAOf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiK;AAC/L,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAAuJ;AAkEvL,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}