@3driseai/3drise-viewer 0.1.40 → 0.1.42

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

@@ -0,0 +1,155 @@
+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;
+    layers: number;
+    separation: number;
+    softness: number;
+    edge: number;
+    changeTime: 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;
+    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: {
+        layers?: undefined;
+        separation?: undefined;
+        softness?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        layers: number;
+        separation: number;
+        softness?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        layers: number;
+        separation: number;
+        softness: number;
+    };
+})[];
+export declare function createUniforms(): {
+    uLayers: {
+        value: number;
+    };
+    uSep: {
+        value: number;
+    };
+    uSoft: {
+        value: number;
+    };
+    uEdge: {
+        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=depthLayers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"depthLayers.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/depthLayers.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAE8D,CAAC;AAEnF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAA6C,CAAC;AACrE,eAAO,MAAM,aAAa,UAAW,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAOf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkI;AAChK,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAA4H;AAuC5J,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}

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

@@ -0,0 +1,87 @@
+// The approved lab module, verbatim but for its import paths and the lab's picture loader (Claude outputs/gallery-lab/
+// layers.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.depthLayers) do not carry; its own autoplay is never used.
+// layers — "Depth Layers". Every picture is split by its own brightness into a few thin sheets floating one behind
+// another: the back sheet holds the whole picture, each sheet in front holds only what is brighter than its level
+// (a soft threshold with a fine lit edge), so the light parts of the picture stand forward. An inactive picture's
+// sheets are collapsed into one faint grey sheet. When it becomes the active one a soft wave crosses it and opens
+// the sheets into depth, taking their colour; the sheets then slide past each other as the camera, the lean or the
+// cursor moves — real parallax. The cursor opens the sheets a little further where it passes. Self-coloured.
+import * as THREE from 'three';
+import { BASE_DEFAULTS, BASE_GUI_MOTION, BASE_GUI_TAIL, LAYOUT_GUI, baseUniforms, applyBase, baseGlsl, instanced, shaderMaterial, makeGallery, withLean, fragHead } from '../kit/lookBase.js';
+export const catalog = { key: 'depthLayers', name: 'Depth Layers', camera: { position: [1.1, 0.3, 4.5], target: [0, 0, 0] },
+    description: 'Pictures split by brightness into thin sheets floating in depth: inactive ones are collapsed into one faint grey sheet, the active one opens into depth in full colour and its sheets slide past each other with real parallax. Use for editorial, music and dreamy showcases.',
+    tags: ['gallery', 'layers', 'depth', 'parallax', 'editorial', 'interactive'] };
+export const DEFAULTS = {
+    ...BASE_DEFAULTS, type: 'depthLayers', aspect: 1.4, width: 2.2, layers: 6, // structural
+    separation: 0.09, softness: 0.08, edge: 0.12, changeTime: 2.0, dim: 0.35,
+    pointerMode: 'open', pointerRadius: 0.6,
+};
+export const STRUCTURAL = ['imageUrls', 'aspect', 'width', 'layers'];
+export const POINTER_MODES = ['open'];
+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: 'layers', min: 2, max: 10, step: 1, tip: 'Sheets per picture' },
+    ...LAYOUT_GUI, ...BASE_GUI_MOTION,
+    { key: 'separation', min: 0, max: 0.4, step: 0.005, tip: 'Distance between the sheets when open' }, { key: 'softness', min: 0.01, max: 0.3, step: 0.005, tip: 'Softness of each sheet’s brightness threshold' },
+    { key: 'edge', min: 0, max: 1.5, step: 0.01, tip: 'Brightness of the fine edge along each sheet' },
+    { key: 'pointerMode', options: ['none', ...POINTER_MODES] }, ...BASE_GUI_TAIL,
+];
+export const PRESETS = [
+    { name: 'Layers', description: 'The default.', patch: {} },
+    { name: 'Deep', description: 'Few sheets, far apart.', patch: { layers: 4, separation: 0.18 } },
+    { name: 'Fine', description: 'Many close sheets, soft thresholds.', patch: { layers: 9, separation: 0.05, softness: 0.12 } },
+];
+export function createUniforms() { return { ...baseUniforms(), uLayers: { value: 6 }, uSep: { value: 0.09 }, uSoft: { value: 0.08 }, uEdge: { value: 0.35 } }; }
+export function applyConfig(u, c) { const set = applyBase(u, c, POINTER_MODES); set('uSep', c.separation); set('uSoft', c.softness); set('uEdge', c.edge); }
+const vert = /* glsl */ `
+    attribute vec4 aI;      // picture, sheet, -, -
+    ${baseGlsl}
+    uniform float uLayers, uSep;
+    varying vec2 vUv; varying float vImg; varying float vK; varying float vW; varying float vAlpha;
+    void main(){
+        float img = aI.x, k = aI.y; vec2 g = position.xy + 0.5;
+        vec2 p = vec2(position.x * uW, position.y * uH);
+        float w = waveAt(actOf(img), g);
+        float open = w * (1.0 + 1.5 * maskAt(p) * w);
+        vec3 local = vec3(p, k * uSep * open);
+        vUv = g; vImg = img; vK = k; vW = w; vAlpha = fadeAt(img);
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(placeAt(img, local), 1.0);
+    }
+`;
+const frag = /* glsl */ `
+    ${fragHead}
+    precision highp sampler2DArray;
+    uniform sampler2DArray uTex;
+    ${baseGlsl}
+    uniform float uLayers, uSoft, uEdge;
+    varying vec2 vUv; varying float vImg; varying float vK; varying float vW; varying float vAlpha;
+    void main(){
+        vec3 pic = texture(uTex, vec3(vUv, vImg)).rgb;
+        float L = lumOf(textureLod(uTex, vec3(vUv, vImg), 1.5).rgb);
+        float t = vK / uLayers;                                     // this sheet's brightness level
+        float m = vK < 0.5 ? 1.0 : smoothstep(t - uSoft, t + uSoft, L);
+        // a fine lit edge along the sheet's threshold (only while the sheets are open)
+        float e = vK < 0.5 ? 0.0 : exp(-pow((L - t) / max(uSoft * 0.2, 1e-3), 2.0)) * vW;
+        vec3 c = mix(fadedOf(pic), pic, vW) + pic * e * uEdge;
+        float a = m * vAlpha * uOpacity;
+        if (a < 0.003) discard;
+        gl_FragColor = vec4(c * uIntensity * a, a);
+        #include <tonemapping_fragment>
+        #include <colorspace_fragment>
+    }
+`;
+export function build(u, c) { return withLean(buildGallery(u, c), c); }
+function buildGallery(u, c) {
+    const W = c.width, H = W / c.aspect, N = Math.max(2, c.layers | 0);
+    u.uLayers.value = N;
+    const geo = instanced(new THREE.PlaneGeometry(1, 1, 16, 12), N, () => [0, 0]);
+    const mat = shaderMaterial(u, vert, frag, { depthWrite: false });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = () => { };
+    const g = makeGallery(u, c, { W, H, meshes: [mesh], setCount: (n) => { geo.instanceCount = n * N; } });
+    const apply = g.apply;
+    g.apply = (k) => { apply(k); applyConfig(u, k); };
+    return g;
+}

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

@@ -0,0 +1,162 @@
+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;
+    lines: number;
+    angle: number;
+    bend: number;
+    hairline: number;
+    changeTime: number;
+    dim: number;
+    pointerMode: string;
+    pointerRadius: number;
+    turn: 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: {
+        lines?: undefined;
+        bend?: undefined;
+        hairline?: undefined;
+        angle?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        lines: number;
+        bend: number;
+        hairline: number;
+        angle?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        lines: number;
+        bend: number;
+        hairline: number;
+        angle: number;
+    };
+})[];
+export declare function createUniforms(): {
+    uLines: {
+        value: number;
+    };
+    uAngle: {
+        value: number;
+    };
+    uBend: {
+        value: number;
+    };
+    uHair: {
+        value: number;
+    };
+    uTurn: {
+        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=engraving.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engraving.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/engraving.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAE8D,CAAC;AAEnF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAAmC,CAAC;AAC3D,eAAO,MAAM,aAAa,UAAW,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAQf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2J;AACzL,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAG/B;AAuCD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}

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

@@ -0,0 +1,96 @@
+// The approved lab module, verbatim but for its import paths and the lab's picture loader (Claude outputs/gallery-lab/
+// engraving.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.engraving) do not carry; its own autoplay is never used.
+// engraving — every picture is drawn as banknote engraving: one family of fine parallel lines, each line bent by
+// the picture's own tone (the lines swell around bright forms, as an engraver's burin follows them) and as wide as
+// the picture is bright, anti-aliased with fwidth. An inactive picture is a faint grey hatch of hairlines. When it
+// becomes the active one a soft wave crosses it: behind the wave the lines thicken and take the picture's colour
+// until they meet and the picture is whole. The cursor turns the hatching's angle under it, like light catching the
+// cut lines of a plate. Self-coloured.
+import * as THREE from 'three';
+import { BASE_DEFAULTS, BASE_GUI_MOTION, BASE_GUI_TAIL, LAYOUT_GUI, baseUniforms, applyBase, baseGlsl, instanced, shaderMaterial, makeGallery, withLean, fragHead } from '../kit/lookBase.js';
+export const catalog = { key: 'engraving', name: 'Engraving', camera: { position: [0.3, 0.15, 4.6], target: [0, 0, 0] },
+    description: 'Pictures drawn as banknote engraving, fine parallel lines bent and widened by the picture’s tone: inactive ones are a faint grey hatch, the active one thickens into full colour behind a soft wave; the cursor turns the hatching under it. Use for luxury, finance, heritage and editorial showcases.',
+    tags: ['gallery', 'engraving', 'hatching', 'lines', 'luxury', 'interactive'] };
+export const DEFAULTS = {
+    ...BASE_DEFAULTS, type: 'engraving', aspect: 1.4, width: 2.2,
+    lines: 70, angle: 28, bend: 1.6, hairline: 0.22, changeTime: 2.2, dim: 0.6,
+    pointerMode: 'turn', pointerRadius: 0.55, turn: 0.9,
+};
+export const STRUCTURAL = ['imageUrls', 'aspect', 'width'];
+export const POINTER_MODES = ['turn'];
+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 },
+    ...LAYOUT_GUI, ...BASE_GUI_MOTION,
+    { key: 'lines', min: 30, max: 300, step: 1, tip: 'Lines across the picture' }, { key: 'angle', min: -90, max: 90, step: 1, tip: 'Angle of the hatching (degrees)' },
+    { key: 'bend', min: 0, max: 5, step: 0.01, tip: 'How much the picture’s tone bends the lines' },
+    { key: 'hairline', min: 0.05, max: 0.8, step: 0.01, tip: 'Width of an inactive line, as a share of a bright line' },
+    { key: 'pointerMode', options: ['none', ...POINTER_MODES] }, ...BASE_GUI_TAIL, { key: 'turn', min: 0, max: 1.6, step: 0.01, tip: 'How far the cursor turns the hatching (radians)' },
+];
+export const PRESETS = [
+    { name: 'Plate', description: 'The default.', patch: {} },
+    { name: 'Banknote', description: 'Very fine lines, strongly bent.', patch: { lines: 220, bend: 2.8, hairline: 0.25 } },
+    { name: 'Woodcut', description: 'Few bold lines.', patch: { lines: 60, bend: 0.8, hairline: 0.45, angle: 0 } },
+];
+export function createUniforms() { return { ...baseUniforms(), uLines: { value: 120 }, uAngle: { value: 0.49 }, uBend: { value: 1.6 }, uHair: { value: 0.32 }, uTurn: { value: 0.9 } }; }
+export function applyConfig(u, c) {
+    const set = applyBase(u, c, POINTER_MODES);
+    set('uLines', c.lines);
+    set('uBend', c.bend);
+    set('uHair', c.hairline);
+    set('uTurn', c.turn);
+    if (c.angle !== undefined)
+        u.uAngle.value = c.angle * Math.PI / 180;
+}
+const vert = /* glsl */ `
+    attribute vec4 aI;
+    ${baseGlsl}
+    varying vec2 vUv; varying vec2 vP; varying float vImg; varying float vAct; varying float vAlpha;
+    void main(){
+        float img = aI.x; vec2 g = position.xy + 0.5;
+        vec2 p = vec2(position.x * uW, position.y * uH);
+        vUv = g; vP = p; vImg = img; vAct = actOf(img); vAlpha = fadeAt(img);
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(placeAt(img, vec3(p, 0.0)), 1.0);
+    }
+`;
+const frag = /* glsl */ `
+    ${fragHead}
+    precision highp sampler2DArray;
+    uniform sampler2DArray uTex;
+    ${baseGlsl}
+    uniform float uLines, uAngle, uBend, uHair, uTurn;
+    varying vec2 vUv; varying vec2 vP; varying float vImg; varying float vAct; varying float vAlpha;
+    void main(){
+        vec3 pic = texture(uTex, vec3(vUv, vImg)).rgb;
+        float L = lumOf(textureLod(uTex, vec3(vUv, vImg), 2.5).rgb);
+        float s = waveAt(vAct, vUv);
+        float ang = uAngle + uTurn * maskAt(vP);
+        vec2 q = vec2(cos(ang) * vP.x + sin(ang) * vP.y, -sin(ang) * vP.x + cos(ang) * vP.y);
+        float f = q.y * uLines / uH + L * uBend;                  // the line coordinate, bent by the tone
+        float dist = abs(fract(f) - 0.5);                           // 0 on a line's centre, 0.5 between
+        float px = max(fwidth(f), 1e-4);
+        float bright = lumOf(pic);
+        float width = mix(0.5 * uHair * (0.25 + 0.75 * bright), 0.56, s * s);
+        float line = 1.0 - smoothstep(width - px, width + px, dist);
+        vec3 c = mix(fadedOf(pic) * 1.3, pic, s);
+        float a = line * vAlpha * uOpacity;
+        if (a < 0.003) discard;
+        gl_FragColor = vec4(c * uIntensity * a, a);
+        #include <tonemapping_fragment>
+        #include <colorspace_fragment>
+    }
+`;
+export function build(u, c) { return withLean(buildGallery(u, c), c); }
+function buildGallery(u, c) {
+    const W = c.width, H = W / c.aspect;
+    const geo = instanced(new THREE.PlaneGeometry(1, 1, 1, 1), 1, () => [0, 0]);
+    const mat = shaderMaterial(u, vert, frag);
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = () => { };
+    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); };
+    return g;
+}

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

@@ -0,0 +1,180 @@
+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;
+    lines: number;
+    bend: number;
+    meander: number;
+    flow: number;
+    dashes: number;
+    hairline: number;
+    smoothing: number;
+    changeTime: number;
+    dim: number;
+    pointerMode: string;
+    pointerRadius: number;
+    part: 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: {
+        lines?: undefined;
+        meander?: undefined;
+        flow?: undefined;
+        hairline?: undefined;
+        dashes?: undefined;
+        bend?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        lines: number;
+        meander: number;
+        flow: number;
+        hairline: number;
+        dashes?: undefined;
+        bend?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        lines: number;
+        flow: number;
+        dashes: number;
+        bend: number;
+        meander?: undefined;
+        hairline?: undefined;
+    };
+})[];
+export declare function createUniforms(): {
+    uLines: {
+        value: number;
+    };
+    uBend: {
+        value: number;
+    };
+    uMeander: {
+        value: number;
+    };
+    uFlowT: {
+        value: number;
+    };
+    uDashes: {
+        value: number;
+    };
+    uHair: {
+        value: number;
+    };
+    uSmooth: {
+        value: number;
+    };
+    uPart: {
+        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=flowLines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowLines.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/flowLines.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAE0D,CAAC;AAE/E,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpB,CAAC;AACF,eAAO,MAAM,UAAU,UAAmC,CAAC;AAC3D,eAAO,MAAM,aAAa,UAAW,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;IAUf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAInB,CAAC;AACF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAE/B;AAiDD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}