@3driseai/3drise-viewer 0.1.40 → 0.1.41

package/dist/components/image/core/contour.js

@@ -0,0 +1,123 @@
+// GENERATED from the lab (Claude outputs/gallery-lab/image/contour.mjs) by emit_image.mjs — change the lab and re-emit.
+// contour — an image variant (type 'image', config.type 'contour'). Material: own ShaderMaterial, self-coloured (no
+// scene lighting; object effects do not attach).
+//
+// The picture as a topographic map of itself. Its luminance (a soft mip) is a height field; the change interpolates
+// the two fields, Φ = mix(L_A, L_B, s), and draws Φ's level sets — so mid-change the contour lines of the old
+// picture flow continuously into the contour lines of the new one (level sets of a continuous blend move, they
+// never jump). Under the travelling front the picture darkens away and its contours lift off into depth: the
+// lines are split into K bands by level and each band is drawn on its own sheet, offset in z by its level, so the
+// change is a floating, slowly re-forming contour stack you can see around when the camera moves. Lines are
+// hairline, anti-aliased with fwidth, coloured by the picture under them. Idle: the faintest contours remain and
+// drift a fraction of a level over a long cycle. Cursor: `open` — the picture opens into its contour stack around
+// the cursor; `ripple` — the levels near the cursor bend in a slow ring.
+import * as THREE from 'three';
+import { baseUniforms, applyBase, setU, createPicture, stepPointer, GLSL_COMMON, fragHead } from './imageCore.js';
+export const POINTER_MODES = ['open', 'ripple'];
+const K = 6;
+export const STRUCTURAL = ['imageUrls'];
+export function createUniforms() {
+    return { ...baseUniforms(), uLevels: { value: 26 }, uLineW: { value: 0.9 }, uDepth: { value: 1 }, uOpen: { value: 0.95 }, uSmooth: { value: 3.2 }, uIdle: { value: 0.04 }, uTint: { value: 0.35 }, uLineColor: { value: new THREE.Color('#cfe6ff') } };
+}
+export function applyConfig(u, c) {
+    applyBase(u, c, POINTER_MODES);
+    setU(u, 'uLevels', c.levels);
+    setU(u, 'uLineW', c.lineWidth);
+    setU(u, 'uDepth', c.depth);
+    setU(u, 'uOpen', c.open);
+    setU(u, 'uSmooth', c.smoothing);
+    setU(u, 'uIdle', c.idleLines);
+    setU(u, 'uTint', c.tint);
+    setU(u, 'uLineColor', c.lineColor);
+}
+const pars = /* glsl */ `
+uniform float uLevels, uLineW, uDepth, uOpen, uSmooth, uIdle, uTint, uBand; uniform vec3 uLineColor;
+varying vec2 vPic; varying float vL;
+// how open the picture is at uv: the front, plus the cursor in 'open' mode
+float openAt(vec2 uv, float l){
+  float o = pow(sin(PI * l), 0.8);
+  if (uPointerMode > -0.5 && uPointerMode < 0.5) o = max(o, smoothstep(0.0, 0.8, pointerBump((uv - 0.5) * uSize)));
+  return o;
+}
+`;
+const vert = /* glsl */ `
+${GLSL_COMMON}
+${pars}
+void main(){
+  vec2 uv = position.xy + 0.5;
+  float l = localP(uv);
+  float z = (uBand < -0.5) ? 0.0 : ((uBand + 0.5) / ${K}.0) * uDepth * 0.4 * openAt(uv, l) + 0.002 * (uBand + 1.0);
+  vPic = uv; vL = l;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position.xy * uSize, z, 1.0);
+}`;
+const baseFrag = /* glsl */ `
+${fragHead}
+${GLSL_COMMON}
+${pars}
+void main(){
+  float l = localP(vPic); float s = sstep(l);
+  vec3 c = mix(picA(vPic), picB(vPic), s);
+  float o = openAt(vPic, l);
+  c *= 1.0 - uOpen * 0.9 * o;
+  gl_FragColor = vec4(c * uIntensity, uOpacity);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const lineFrag = /* glsl */ `
+${fragHead}
+${GLSL_COMMON}
+${pars}
+void main(){
+  float l = localP(vPic); float s = sstep(l);
+  float lod = uSmooth;
+  float LA = luma(picAL(vPic, lod)), LB = luma(picBL(vPic, lod));
+  float phi = mix(LA, LB, s);
+  float v = phi * uLevels + uBreathe * 0.25 * sin(uTime * 0.12);              // the idle drift: a fraction of a level
+  if (uPointerMode > 0.5) { vec2 q = (vPic - 0.5) * uSize; float d = length(q - uPointer.xy); v += 0.7 * pointerBump(q) * sin(d * 22.0 - uTime * 2.0); }
+  float lev = floor(v + 0.5);
+  float band = floor(clamp(lev / uLevels, 0.0, 0.9999) * ${K}.0);
+  if (abs(band - uBand) > 0.5) discard;
+  float fw = max(fwidth(v), 1e-4);
+  float dpx = abs(v - lev) / fw;
+  float line = 1.0 - smoothstep(0.5 * uLineW - 0.5, 0.5 * uLineW + 0.5, dpx);
+  float o = openAt(vPic, l);
+  float vis = max(uIdle, o);
+  vec3 pc = mix(picAL(vPic, 1.0), picBL(vPic, 1.0), s);
+  pc = pc / max(luma(pc), 0.08) * 0.55;                                       // keep the hue, even out the brightness
+  vec3 col = mix(pc, uLineColor, uTint) * (0.75 + 0.5 * o);
+  float a = line * vis * uOpacity;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(col * uIntensity * a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+export function build(u, c) {
+    const object = new THREE.Group();
+    const geo = new THREE.PlaneGeometry(1, 1, 96, 60);
+    const baseMat = new THREE.ShaderMaterial({ uniforms: { ...u, uBand: { value: -1 } }, vertexShader: vert, fragmentShader: baseFrag, glslVersion: THREE.GLSL3, transparent: false });
+    const base = new THREE.Mesh(geo, baseMat);
+    base.frustumCulled = false;
+    object.add(base);
+    const mats = [baseMat];
+    for (let k = 0; k < K; k++) {
+        const m = new THREE.ShaderMaterial({ uniforms: { ...u, uBand: { value: k } }, vertexShader: vert, fragmentShader: lineFrag, glslVersion: THREE.GLSL3, transparent: true, depthWrite: false, premultipliedAlpha: true, side: THREE.DoubleSide });
+        const mesh = new THREE.Mesh(geo, m);
+        mesh.frustumCulled = false;
+        mesh.renderOrder = 3 + k;
+        object.add(mesh);
+        mats.push(m);
+    }
+    const cfg = { ...c };
+    const pic = createPicture(u, cfg);
+    const pst = {};
+    const api = {
+        object, materials: mats,
+        controls: { show: (t) => pic.show(t), get busy() { return pic.busy; }, pic },
+        apply(k) { Object.assign(cfg, k); applyConfig(u, k); if (k.opacity !== undefined)
+            baseMat.transparent = k.opacity < 1; },
+        update(dt, pointer) { dt = Math.min(dt, 0.1); u.uTime.value += dt; pic.step(dt); stepPointer(u, pointer, dt, pst); },
+        dispose() { geo.dispose(); for (const m of mats)
+            m.dispose(); pic.dispose(); },
+    };
+    return api;
+}

package/dist/components/image/core/engraving.d.ts

@@ -0,0 +1,135 @@
+import * as THREE from 'three';
+export declare const POINTER_MODES: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uGrid: {
+        value: THREE.Vector2;
+    };
+    uHatch: {
+        value: number;
+    };
+    uLen: {
+        value: number;
+    };
+    uWeight: {
+        value: number;
+    };
+    uRelief: {
+        value: number;
+    };
+    uLift: {
+        value: number;
+    };
+    uFlow: {
+        value: number;
+    };
+    uFill: {
+        value: number;
+    };
+    uTint: {
+        value: number;
+    };
+    uInk: {
+        value: THREE.Color;
+    };
+    uPlate: {
+        value: THREE.Color;
+    };
+    uTexA: {
+        value: any;
+    };
+    uTexB: {
+        value: any;
+    };
+    uFitA: {
+        value: THREE.Vector2;
+    };
+    uFitB: {
+        value: THREE.Vector2;
+    };
+    uP: {
+        value: number;
+    };
+    uHasA: {
+        value: number;
+    };
+    uSeq: {
+        value: number;
+    };
+    uSize: {
+        value: THREE.Vector2;
+    };
+    uTime: {
+        value: number;
+    };
+    uDir: {
+        value: THREE.Vector2;
+    };
+    uSpread: {
+        value: number;
+    };
+    uBlank: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uBreathe: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerVel: {
+        value: THREE.Vector2;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.ShaderMaterial[];
+    controls: {
+        show: (t: any) => void;
+        readonly busy: boolean;
+        pic: {
+            st: {
+                A: any;
+                B: any;
+                aspA: number;
+                aspB: number;
+                p: number;
+                dir: number;
+                pending: any;
+                seq: number;
+                frame: number;
+            };
+            show: (tex: any) => void;
+            jump: (tex: any) => void;
+            step: (dt: any) => void;
+            readonly busy: boolean;
+            dispose(): void;
+        };
+    };
+    apply(k: any): void;
+    update(dt: any, pointer: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=engraving.d.ts.map

package/dist/components/image/core/engraving.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engraving.d.ts","sourceRoot":"","sources":["../../../../src/components/image/core/engraving.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,aAAa,UAAoB,CAAC;AAC/C,eAAO,MAAM,UAAU,UAAwB,CAAC;AAEhD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAG/B;AA0FD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BzB"}

package/dist/components/image/core/engraving.js

@@ -0,0 +1,163 @@
+// GENERATED from the lab (Claude outputs/gallery-lab/image/engraving.mjs) by emit_image.mjs — change the lab and re-emit.
+// engraving — an image variant (type 'image', config.type 'engraving'). Material: own ShaderMaterial, self-coloured
+// (no scene lighting; object effects do not attach).
+//
+// The picture drawn as an engraving in ink on paper: a field of fine strokes, one per cell, each laid along the picture's
+// isophote (perpendicular to the luminance gradient of a soft mip, so strokes follow forms the way a burin does),
+// as wide as the picture is dark there and inked in its hue; strokes stand at a depth set by brightness, so
+// the plate has a fine relief that parallaxes when the camera moves. Where the gradient is too weak to give a
+// direction, strokes fall back to a slow, smooth flow field (never random). A change re-lays every stroke: as the
+// front passes, a stroke shortens a little, lifts off the plate, turns the shortest way (lines are π-periodic) to
+// its new isophote, takes on its new width and colour and settles — the whole plate re-aligns like filings in a
+// moving field. The first picture is drawn in from an empty plate. Idle: strokes sway a degree or two in a slow
+// flow. One instanced draw (+ a faint backing plate). Cursor: `comb` — strokes near the cursor align with its
+// motion; `swirl` — they wind around it.
+import * as THREE from 'three';
+import { baseUniforms, applyBase, setU, createPicture, stepPointer, GLSL_COMMON, fragHead, mulberry32 } from './imageCore.js';
+export const POINTER_MODES = ['comb', 'swirl'];
+export const STRUCTURAL = ['imageUrls', 'cols'];
+export function createUniforms() {
+    return { ...baseUniforms(), uGrid: { value: new THREE.Vector2(160, 104) }, uHatch: { value: 0.61 }, uLen: { value: 2.3 }, uWeight: { value: 0.85 }, uRelief: { value: 1 }, uLift: { value: 1 }, uFlow: { value: 3.2 }, uFill: { value: 0.12 }, uTint: { value: 0.6 }, uInk: { value: new THREE.Color('#1a1c22') }, uPlate: { value: new THREE.Color('#ece6d9') } };
+}
+export function applyConfig(u, c) {
+    applyBase(u, c, POINTER_MODES);
+    setU(u, 'uLen', c.length);
+    if (c.hatch !== undefined)
+        u.uHatch.value = c.hatch * Math.PI / 180;
+    setU(u, 'uWeight', c.weight);
+    setU(u, 'uRelief', c.relief);
+    setU(u, 'uLift', c.lift);
+    setU(u, 'uFlow', c.flow);
+    setU(u, 'uFill', c.fill);
+    setU(u, 'uPlate', c.plateColor);
+    setU(u, 'uInk', c.inkColor);
+    setU(u, 'uTint', c.tint);
+}
+const pars = /* glsl */ `
+uniform vec2 uGrid; uniform vec3 uInk; uniform float uTint, uHatch, uLen, uWeight, uRelief, uLift, uFlow, uFill; uniform vec3 uPlate;
+`;
+const strokeVert = /* glsl */ `
+${GLSL_COMMON}
+${pars}
+attribute vec3 aCell;                 // uv of the stroke, random
+varying vec2 vQ; varying vec3 vCol; varying float vA;
+// isophote angle of a picture at uv (and the gradient strength, for the fallback blend)
+vec2 iso(sampler2D t, vec2 fitS, vec2 uv, float has){
+  vec2 e = vec2(1.5 / uGrid.x, 1.5 / uGrid.y);
+  vec2 a = 0.5 + (uv - 0.5) * fitS;
+  float lx = luma(textureLod(t, a + vec2(e.x, 0.0) * fitS, uFlow).rgb) - luma(textureLod(t, a - vec2(e.x, 0.0) * fitS, uFlow).rgb);
+  float ly = luma(textureLod(t, a + vec2(0.0, e.y) * fitS, uFlow).rgb) - luma(textureLod(t, a - vec2(0.0, e.y) * fitS, uFlow).rgb);
+  vec2 g = vec2(lx / uSize.x, ly / uSize.y) * has;
+  float flowA = uHatch + 0.5 * (vnoise(uv * 1.6 + 3.0) - 0.5);      // the calm fallback: the plate's hatch direction, gently bent
+  float m = smoothstep(0.02, 0.09, length(g)) * 0.85;
+  float th = atan(g.y, g.x) + 1.5707963;
+  // blend angles on the doubled circle (lines are pi-periodic)
+  vec2 d = mix(vec2(cos(2.0 * flowA), sin(2.0 * flowA)), vec2(cos(2.0 * th), sin(2.0 * th)), m);
+  return vec2(0.5 * atan(d.y, d.x), m);
+}
+void main(){
+  vec2 c = aCell.xy;
+  float l = localP(c); float s = sstep(l); float fly = sin(PI * l);
+  vec3 ca = picAL(c, 1.5), cb = picBL(c, 1.5);
+  float La = luma(ca) * uHasA, Lb = luma(cb);
+  float ta = iso(uTexA, uFitA, c, uHasA).x, tb = iso(uTexB, uFitB, c, 1.0).x;
+  float dth = mod(tb - ta + 1.5707963, 3.14159265) - 1.5707963;       // the shortest way round
+  float th = ta + dth * s;
+  th += uBreathe * 0.03 * sin(uTime * 0.3 + c.x * 5.0 + c.y * 3.0);
+  vec2 xy = (c - 0.5) * uSize;
+  float pb = pointerBump(xy);
+  if (pb > 0.0) {
+    float tp = th;
+    if (uPointerMode < 0.5) { vec2 v = uPointerVel; tp = atan(v.y, v.x); pb *= smoothstep(0.05, 0.6, length(v)); }
+    else { vec2 d = xy - uPointer.xy; tp = atan(d.y, d.x) + 1.5707963; }
+    float dd = mod(tp - th + 1.5707963, 3.14159265) - 1.5707963;
+    th += dd * min(1.0, pb);
+  }
+  float L = mix(La, Lb, s);
+  vec2 pitch = uSize / uGrid;
+  float cell = min(pitch.x, pitch.y);
+  float len = cell * uLen * (1.0 - 0.35 * fly);
+  float w = cell * uWeight * (0.1 + 0.9 * (1.0 - L));                // ink: dense where the picture is dark
+  vec2 dir = vec2(cos(th), sin(th)), nrm = vec2(-dir.y, dir.x);
+  vec2 p = xy + dir * position.x * len + nrm * position.y * w;
+  float z = 0.004 + L * uRelief * 0.03 + fly * uLift * 0.06 * (0.6 + 0.8 * aCell.z);
+  vQ = position.xy * 2.0;
+  vec3 col = mix(ca, cb, s);
+  vec3 hue = col / max(luma(col), 0.05);
+  vCol = mix(uInk, hue * 0.4, uTint) * (0.2 + 0.5 * L);
+  vA = smoothstep(0.0, 0.06, w / cell) * (uHasA > 0.5 ? 1.0 : smoothstep(0.0, 0.6, l));
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(p, z, 1.0);
+}`;
+const strokeFrag = /* glsl */ `
+${fragHead}
+${pars}
+uniform float uIntensity, uOpacity;
+varying vec2 vQ; varying vec3 vCol; varying float vA;
+void main(){
+  float fy = max(fwidth(vQ.y), 1e-4);
+  float across = 1.0 - smoothstep(1.0 - 1.5 * fy, 1.0, abs(vQ.y));
+  float ends = 1.0 - smoothstep(0.55, 1.0, abs(vQ.x));               // tapered ends, like a burin's cut
+  float a = across * ends * vA * uOpacity;
+  if (a < 0.004) discard;
+  gl_FragColor = vec4(vCol * uIntensity * a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const plateVert = /* glsl */ `
+${GLSL_COMMON}
+varying vec2 vPic;
+void main(){ vPic = position.xy + 0.5; gl_Position = projectionMatrix * modelViewMatrix * vec4(position.xy * uSize, -0.01, 1.0); }`;
+const plateFrag = /* glsl */ `
+${fragHead}
+${GLSL_COMMON}
+${pars}
+varying vec2 vPic;
+void main(){
+  float s = sstep(localP(vPic));
+  vec3 c = mix(picAL(vPic, 2.0), picBL(vPic, 2.0), s);
+  vec3 wash = clamp(c / max(luma(c), 0.08), 0.0, 1.3);                     // the picture's hue as a light wash on the paper
+  gl_FragColor = vec4(uPlate * mix(vec3(1.0), wash, uFill) * uIntensity, uOpacity);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+export function build(u, c) {
+    const object = new THREE.Group();
+    const cols = Math.max(10, c.cols | 0), rows = Math.round(cols * 0.65);
+    u.uGrid.value.set(cols, rows);
+    const quad = new THREE.PlaneGeometry(1, 1);
+    const geo = new THREE.InstancedBufferGeometry();
+    geo.index = quad.index;
+    geo.setAttribute('position', quad.attributes.position);
+    const n = cols * rows, cell = new Float32Array(n * 3), rnd = mulberry32(9);
+    for (let j = 0; j < rows; j++)
+        for (let i = 0; i < cols; i++) {
+            const k = j * cols + i; // jittered so the hatch never reads as a grid
+            cell[k * 3] = (i + 0.5 + (rnd() - 0.5) * 0.2) / cols;
+            cell[k * 3 + 1] = (j + 0.5 + (rnd() - 0.5) * 0.2) / rows;
+            cell[k * 3 + 2] = rnd();
+        }
+    geo.setAttribute('aCell', new THREE.InstancedBufferAttribute(cell, 3));
+    geo.instanceCount = n;
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1.4);
+    const strokeMat = new THREE.ShaderMaterial({ uniforms: u, vertexShader: strokeVert, fragmentShader: strokeFrag, glslVersion: THREE.GLSL3, transparent: true, depthWrite: false, premultipliedAlpha: true, side: THREE.DoubleSide });
+    const strokes = new THREE.Mesh(geo, strokeMat);
+    strokes.frustumCulled = false;
+    strokes.renderOrder = 2;
+    const plateGeo = new THREE.PlaneGeometry(1, 1);
+    const plateMat = new THREE.ShaderMaterial({ uniforms: u, vertexShader: plateVert, fragmentShader: plateFrag, glslVersion: THREE.GLSL3 });
+    const plate = new THREE.Mesh(plateGeo, plateMat);
+    plate.frustumCulled = false;
+    object.add(plate, strokes);
+    const cfg = { ...c };
+    const pic = createPicture(u, cfg);
+    const pst = {};
+    const api = {
+        object, materials: [strokeMat, plateMat],
+        controls: { show: (t) => pic.show(t), get busy() { return pic.busy; }, pic },
+        apply(k) { Object.assign(cfg, k); applyConfig(u, k); if (k.opacity !== undefined)
+            plateMat.transparent = k.opacity < 1; },
+        update(dt, pointer) { dt = Math.min(dt, 0.1); u.uTime.value += dt; pic.step(dt); stepPointer(u, pointer, dt, pst); },
+        dispose() { quad.dispose(); geo.dispose(); plateGeo.dispose(); strokeMat.dispose(); plateMat.dispose(); pic.dispose(); },
+    };
+    return api;
+}

package/dist/components/image/core/frost.d.ts

@@ -0,0 +1,126 @@
+import * as THREE from 'three';
+export declare const POINTER_MODES: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uFrost: {
+        value: number;
+    };
+    uWhite: {
+        value: number;
+    };
+    uFeather: {
+        value: number;
+    };
+    uRim: {
+        value: number;
+    };
+    uSelf: {
+        value: number;
+    };
+    uFrostColor: {
+        value: THREE.Color;
+    };
+    uTrail: {
+        value: THREE.Vector3[];
+    };
+    uRefrost: {
+        value: number;
+    };
+    uTexA: {
+        value: any;
+    };
+    uTexB: {
+        value: any;
+    };
+    uFitA: {
+        value: THREE.Vector2;
+    };
+    uFitB: {
+        value: THREE.Vector2;
+    };
+    uP: {
+        value: number;
+    };
+    uHasA: {
+        value: number;
+    };
+    uSeq: {
+        value: number;
+    };
+    uSize: {
+        value: THREE.Vector2;
+    };
+    uTime: {
+        value: number;
+    };
+    uDir: {
+        value: THREE.Vector2;
+    };
+    uSpread: {
+        value: number;
+    };
+    uBlank: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uBreathe: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerVel: {
+        value: THREE.Vector2;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    controls: {
+        show: (t: any) => void;
+        readonly busy: boolean;
+        pic: {
+            st: {
+                A: any;
+                B: any;
+                aspA: number;
+                aspB: number;
+                p: number;
+                dir: number;
+                pending: any;
+                seq: number;
+                frame: number;
+            };
+            show: (tex: any) => void;
+            jump: (tex: any) => void;
+            step: (dt: any) => void;
+            readonly busy: boolean;
+            dispose(): void;
+        };
+    };
+    apply(k: any): void;
+    update(dt: any, pointer: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=frost.d.ts.map

package/dist/components/image/core/frost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../../../../src/components/image/core/frost.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,aAAa,UAAkB,CAAC;AAE7C,eAAO,MAAM,UAAU,UAAgB,CAAC;AAExC,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAG/B;AAmED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCzB"}