@3driseai/3drise-viewer 0.1.35 → 0.1.37

package/dist/operations/catalogue/inShell.d.ts

@@ -0,0 +1,22 @@
+import type { Object3D } from 'three';
+/** The look knobs, as the shell's config carries them (same meaning as the operation's params). */
+export interface InShellLook {
+    look: 'film' | 'ghost';
+    bands: number;
+    seam: number;
+    warp: number;
+    core: number;
+}
+/**
+ * A shell found this object crossing it: give it the layer now (no data on the object, nothing
+ * saved) and keep it until `shellRelease`. An object that already carries the effect itself
+ * (its Effects tab, an action; `ownOn`, from the runtime) is left to that.
+ */
+export declare function shellAttach(target: Object3D, look: InShellLook, ownOn?: boolean): boolean;
+/** The object left the shell: take the layer off (only one the shell attached). */
+export declare function shellRelease(target: Object3D): void;
+/** Whether the shell put the effect on this object (as opposed to the object's own effects). */
+export declare const shellAttached: (target: Object3D) => boolean;
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=inShell.d.ts.map

package/dist/operations/catalogue/inShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inShell.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/inShell.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAgJtC,mGAAmG;AACnG,MAAM,WAAW,WAAW;IAAG,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AA4BhH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,UAAQ,GAAG,OAAO,CAevF;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,QAQ5C;AAED,gGAAgG;AAChG,eAAO,MAAM,aAAa,GAAI,QAAQ,QAAQ,KAAG,OAA8D,CAAC;;AAEhH,wBA+BG"}

package/dist/operations/catalogue/inShell.js

@@ -0,0 +1,245 @@
+// In shell — the object shows the Harmonic Shell it is in. Per pixel its material
+// evaluates the shell's own field (the shell's harmonics, bound and colours, or
+// its morph target), so the part inside the shell takes the shell's thin-film
+// look with slow scan bands, the crossing gets a seam in the rim colour, and the
+// part outside stays as it is. Per vertex the inside follows the membrane like
+// the contents of a bubble (`warp`). Nothing is baked per object: the shell and
+// the object may both move, the look follows. A state: in → hold → out.
+//
+// The shell is found, not picked: the nearest Harmonic Shell in the scene (by
+// centre), re-checked every tick. An object the shell is wrapping (its morph
+// target) is left alone — it IS the shell's surface, not something inside it.
+import { Matrix4, Vector3 } from 'three';
+import gsap from 'gsap';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { createFieldState, fieldUniforms, runProgress } from './transitionField.js';
+import { HSH_FIELD_FUNCS, copyShellUniforms, createShellUniforms, nearestShellField } from '../../components/effects/harmonicShellField.js';
+const P = 'Ins';
+const KEY = 'inShell';
+const STATE = '__opInShell';
+function layerFor(st) {
+    return {
+        uniforms: {
+            ...fieldUniforms(P, st.field),
+            ...st.shell,
+            uInsShellInv: st.u.shellInv, uInsShellMat: st.u.shellMat, uInsHas: st.u.has, uInsSelf: st.u.self,
+            uInsLook: st.u.look, uInsBands: st.u.bands, uInsSeam: st.u.seam, uInsWarp: st.u.warp, uInsCore: st.u.core,
+        },
+        common: /* glsl */ `
+        varying vec3 vInsWorld;
+        varying vec3 vInsView;
+        ${HSH_FIELD_FUNCS}
+        // how much this effect is on right now: its progress, only with a shell, never on the shell's own target
+        float insOn(){ return u${P}Progress * uInsHas * (1.0 - uInsSelf); }`,
+        vertexPars: /* glsl */ `
+        // The bubble's contents follow its membrane: a point inside, at direction n from the
+        // shell's centre, is scaled by the membrane's local radius R(n)/R0 — fully at the
+        // membrane, fading to the centre (uInsCore) — and blended out across the boundary so
+        // the part outside stays rigid. Off while the shell is morphing into a target.
+        vec3 insWarp(vec3 pObj){
+          float on = insOn() * uInsWarp * (1.0 - uHshMorph * step(0.5, uHshMode));
+          if (on <= 0.0) return pObj;
+          vec3 pl = (uInsShellInv * modelMatrix * vec4(pObj, 1.0)).xyz;
+          float r = length(pl); if (r < 1e-4) return pObj;
+          vec3 n = pl / r; float f; float R = hshRadius(n, f); float R0 = uHshBound * uHshSize;
+          if (r >= R * 0.98) return pObj;                         // outside, or at the membrane: untouched
+          // zero AT the membrane (the crossing never moves, nothing shows outside), growing inward;
+          // the centre stays put too (uInsCore)
+          float depth = 1.0 - smoothstep(R * 0.55, R * 0.98, r);
+          float k = pow(clamp(r / R0, 0.0, 1.0), mix(0.4, 3.0, uInsCore));
+          float w = on * depth * k;
+          float rNew = min(r * mix(1.0, R / R0, w), R * 0.985);   // never past the membrane
+          vec3 plNew = n * rNew;
+          return (inverse(modelMatrix) * uInsShellMat * vec4(plNew, 1.0)).xyz;
+        }`,
+        normal: /* glsl */ `
+        if (uInsWarp > 0.0 && insOn() > 0.0) {
+          // the warped normal, from two warped neighbours in the tangent plane
+          vec3 insUp = abs(objectNormal.y) > 0.99 ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 1.0, 0.0);
+          vec3 insT1 = normalize(cross(objectNormal, insUp)); vec3 insT2 = cross(objectNormal, insT1);
+          float insE = 0.02 * uHshBound;
+          vec3 insP0 = insWarp(position);
+          vec3 insD = insP0 - position;
+          vec3 insP1 = insWarp(position + insT1 * insE), insP2 = insWarp(position + insT2 * insE);
+          vec3 insN = cross(insP1 - insP0, insP2 - insP0);
+          // only where the vertex itself moved: outside the shell the normal stays the object's own
+          if (dot(insD, insD) > 1e-12 && dot(insN, insN) > 1e-14) { insN = normalize(insN); if (dot(insN, objectNormal) < 0.0) insN = -insN; objectNormal = insN; }
+        }`,
+        vertex: /* glsl */ `
+        transformed = insWarp(transformed);
+        vInsWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;
+        vInsView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+        fragmentPars: /* glsl */ `
+        float insInside = 0.0; float insSeam = 0.0; vec3 insFilm = vec3(0.0); float insBands = 0.5;`,
+        diffuse: /* glsl */ `
+        {
+          float on = insOn();
+          if (on > 0.0) {
+            float field;
+            float d = hshDist((uInsShellInv * vec4(vInsWorld, 1.0)).xyz, field);
+            float w = max(fwidth(d) * 1.5, 0.003 * uHshBound);
+            insInside = (1.0 - smoothstep(-w, w, d)) * on;
+            // the membrane over the crossing: a thin bright line, a soft halo fading into the inside
+            // one-sided: the glow lives on the inside of the membrane (d < 0); outside only a hair, for anti-aliasing
+            float ws = uHshBound * mix(0.012, 0.07, uInsSeam);
+            float inSide = d < 0.0 ? 1.0 : exp(-d / max(w, 1e-4));
+            float line = exp(-abs(d) / ws) * inSide;
+            float halo = (d < 0.0 ? exp(d / (ws * 4.0)) : 0.0) * 0.5;
+            insSeam = (line + halo) * step(0.001, uInsSeam) * on;
+            // the shell's film at this pixel, seen from the camera; scan bands drift with the shell's clock
+            vec3 nv = normalize(cross(dFdx(vInsView), dFdy(vInsView)));
+            float ndv = abs(dot(nv, normalize(-vInsView)));
+            insFilm = hshFilm(ndv, field);
+            insBands = 0.5 + 0.5 * sin((vInsWorld.y / uHshBound - uHshTime * 0.35) * 20.0 + d * 14.0);
+            float bands = mix(0.5, insBands, uInsBands);
+            vec3 lookFilm = mix(uHshColor * 0.35, insFilm, 0.55 + 0.45 * bands);
+            vec3 lookGhost = mix(diffuseColor.rgb, uHshColor, 0.75) * (0.8 + 0.5 * bands);
+            diffuseColor.rgb = mix(diffuseColor.rgb, mix(lookFilm, lookGhost, uInsLook), insInside);
+          }
+        }`,
+        // the glow goes on top of the lit result, so unlit materials get it too
+        fragment: /* glsl */ `
+        outgoingLight += uHshRim * insSeam * 1.4;
+        outgoingLight += insFilm * insInside * 0.16 * (0.6 + 0.4 * insBands) * (1.0 - uInsLook);`,
+    };
+}
+// ---------------------------------------------------------------- following the shell
+/** States that are on → their root. One ticker copies the nearest shell's values into each. */
+const live = new Map();
+let tick = null;
+const _pos = new Vector3();
+function sync(root, st) {
+    _pos.setFromMatrixPosition(root.matrixWorld);
+    const shell = nearestShellField(_pos);
+    if (!shell) {
+        st.u.has.value = 0;
+        return;
+    }
+    copyShellUniforms(shell.uniforms, st.shell);
+    // Both matrices from the same world matrix, read now: the shader maps the vertex into shell space
+    // with the inverse and back out with the matrix, so they must be exact mutual inverses of one moment.
+    // (shell.inv is the shell's own copy from its useFrame, a frame behind a moving shell - using it here
+    // displaced a moving object's inside by the frame's motion, mirrored, and jittered the warp.)
+    shell.root.updateWorldMatrix(true, false);
+    st.u.shellMat.value.copy(shell.root.matrixWorld);
+    st.u.shellInv.value.copy(st.u.shellMat.value).invert();
+    st.u.has.value = 1;
+    st.u.self.value = shell.target === root ? 1 : 0;
+}
+function follow(root, st) {
+    live.set(st, root);
+    sync(root, st);
+    if (tick)
+        return;
+    tick = () => live.forEach((r, s) => sync(r, s));
+    gsap.ticker.add(tick);
+}
+function unfollow(st) {
+    if (!live.delete(st) || live.size || !tick)
+        return;
+    gsap.ticker.remove(tick);
+    tick = null;
+}
+function build(target) {
+    const st = {
+        field: createFieldState(target),
+        shell: createShellUniforms(),
+        u: { shellInv: { value: new Matrix4() }, shellMat: { value: new Matrix4() }, has: { value: 0 }, self: { value: 0 }, look: { value: 0 }, bands: { value: 1 }, seam: { value: 1 }, warp: { value: 0.6 }, core: { value: 0.5 } },
+        mats: new Set(),
+    };
+    const layer = layerFor(st);
+    forEachMeshMaterial(target, (mat, mesh) => {
+        if (mesh.userData?.__opFxHelper)
+            return;
+        if (addLayer(mat, KEY, layer))
+            st.mats.add(mat);
+    });
+    target.userData[STATE] = st;
+    return st;
+}
+function setLook(st, p) {
+    if (p.look !== undefined)
+        st.u.look.value = p.look === 'ghost' ? 1 : 0;
+    if (p.bands !== undefined)
+        st.u.bands.value = Number(p.bands);
+    if (p.seam !== undefined)
+        st.u.seam.value = Number(p.seam);
+    if (p.warp !== undefined)
+        st.u.warp.value = Number(p.warp);
+    if (p.core !== undefined)
+        st.u.core.value = Number(p.core);
+}
+const AUTO = '__opInShellAuto';
+/**
+ * A shell found this object crossing it: give it the layer now (no data on the object, nothing
+ * saved) and keep it until `shellRelease`. An object that already carries the effect itself
+ * (its Effects tab, an action; `ownOn`, from the runtime) is left to that.
+ */
+export function shellAttach(target, look, ownOn = false) {
+    let st = target.userData[STATE];
+    if (st) {
+        if (target.userData[AUTO]) {
+            setLook(st, look);
+            return true;
+        }
+        // the object's own effect is on: it decides (false = the shell tries again later).
+        // A state that is neither auto nor on is a pre-warm passing through: wait for it.
+        return false;
+    }
+    if (ownOn)
+        return false;
+    st = build(target);
+    target.userData[AUTO] = true;
+    setLook(st, look);
+    follow(target, st);
+    void runProgress(target, st.field, 1, { duration: 0.25, ease: 'power1.out', hold: true });
+    return true;
+}
+/** The object left the shell: take the layer off (only one the shell attached). */
+export function shellRelease(target) {
+    const st = target.userData[STATE];
+    if (!st || !target.userData[AUTO])
+        return;
+    delete target.userData[AUTO];
+    void runProgress(target, st.field, 0, {
+        duration: 0.25, ease: 'power1.in',
+        onComplete: () => { if (target.userData[STATE] !== st)
+            return; unfollow(st); st.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+    });
+}
+/** Whether the shell put the effect on this object (as opposed to the object's own effects). */
+export const shellAttached = (target) => !!target.userData[AUTO] && !!target.userData[STATE];
+export default defineOperation({
+    value: 'inShell',
+    label: 'In shell',
+    description: 'The object shows the Harmonic Shell it is in: the part inside takes the shell\'s film, the crossing glows, and the inside sways with the membrane — reverting puts the plain object back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        look: { type: 'select', label: 'Inside look', default: 'film', options: [{ value: 'film', label: 'Soap film' }, { value: 'ghost', label: 'Ghost tint' }], hint: 'Soap film: the shell\'s thin-film colours. Ghost: the object tinted with the shell colour' },
+        bands: { type: 'number', label: 'Scan bands', default: 1, min: 0, max: 1, step: 0.01, hint: 'Bands drifting through the inside with the shell\'s clock' },
+        seam: { type: 'number', label: 'Seam', default: 1, min: 0, max: 1, step: 0.01, hint: 'Glow where the object crosses the shell' },
+        warp: { type: 'number', label: 'Warp', default: 0.6, min: 0, max: 1.5, step: 0.01, hint: 'How much the inside follows the membrane (needs a mesh with enough vertices to bend)' },
+        core: { type: 'number', label: 'Core hold', default: 0.5, min: 0, max: 1, step: 0.01, hint: 'How stiff the centre is: high = only near the membrane moves' },
+        duration: { type: 'number', label: 'Duration', default: 1.2, min: 0, max: 8, step: 0.1, unit: 's' },
+    },
+    apply(target, p) {
+        delete target.userData[AUTO]; // the object's own effect takes over from a shell-attached one
+        const s = target.userData[STATE] ?? build(target);
+        setLook(s, { look: p.look, bands: Number(p.bands), seam: Number(p.seam), warp: Number(p.warp), core: Number(p.core) });
+        follow(target, s);
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.out', hold: true });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration) * Math.max(0.05, s.field.progress.value), ease: 'power1.in',
+            onComplete: () => { unfollow(s); s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+        });
+    },
+});

package/dist/operations/catalogue/shaderLayers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shaderLayers.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/shaderLayers.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,WAAW,WAAW;IACxB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC7C,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAmCD,+FAA+F;AAC/F,eAAO,MAAM,QAAQ,GAAI,KAAK,QAAQ,KAAG,OAEmE,CAAC;AAO7G;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAOhH;AA6BD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCvE;AA8CD,0FAA0F;AAC1F,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,uBAAuB,CAAC,CAKnG;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAM5D;AAED,mDAAmD;AACnD,eAAO,MAAM,SAAS,GAAI,KAAK,QAAQ,KAAG,OACiC,CAAC;AAE5E,eAAO,MAAM,QAAQ,GAAI,KAAK,QAAQ,EAAE,KAAK,MAAM,KAAG,OACgB,CAAC;AAEvE,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,QAMzF;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAUxD;AAED,iDAAiD;AACjD,eAAO,MAAM,UAAU,4rBAWtB,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,QAAQ,4XAUpB,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,WAAW,4rBAoBvB,CAAC"}
+{"version":3,"file":"shaderLayers.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/shaderLayers.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,WAAW,WAAW;IACxB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC7C,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAmCD,+FAA+F;AAC/F,eAAO,MAAM,QAAQ,GAAI,KAAK,QAAQ,KAAG,OAEmE,CAAC;AAO7G;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAOhH;AA6BD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCvE;AA8CD,0FAA0F;AAC1F,wBAAgB,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,uBAAuB,CAAC,CAKnG;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAM5D;AAED,mDAAmD;AACnD,eAAO,MAAM,SAAS,GAAI,KAAK,QAAQ,KAAG,OACiC,CAAC;AAE5E,eAAO,MAAM,QAAQ,GAAI,KAAK,QAAQ,EAAE,KAAK,MAAM,KAAG,OACgB,CAAC;AAEvE,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,QAMzF;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAYxD;AAED,iDAAiD;AACjD,eAAO,MAAM,UAAU,4rBAWtB,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,QAAQ,4XAUpB,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,WAAW,4rBAoBvB,CAAC"}

package/dist/operations/catalogue/shaderLayers.js

@@ -263,14 +263,17 @@ export function forEachMeshMaterial(root, fn) {
 }
 /** `uniform <type> <name>;` from a uniform's current value. */
 export function uniformDecl(name, v) {
+    if (v instanceof Float32Array)
+        return `uniform float ${name}[${v.length}];`;
     const type = typeof v === 'number' ? 'float'
-        : v?.isColor ? 'vec3'
-            : v?.isVector3 ? 'vec3'
-                : v?.isVector2 ? 'vec2'
-                    : v?.isVector4 ? 'vec4'
-                        : v?.isMatrix4 ? 'mat4'
-                            : v?.isTexture ? 'sampler2D'
-                                : 'float';
+        : v?.isData3DTexture ? 'sampler3D'
+            : v?.isColor ? 'vec3'
+                : v?.isVector3 ? 'vec3'
+                    : v?.isVector2 ? 'vec2'
+                        : v?.isVector4 ? 'vec4'
+                            : v?.isMatrix4 ? 'mat4'
+                                : v?.isTexture ? 'sampler2D'
+                                    : 'float';
     return `uniform ${type} ${name};`;
 }
 /** Calm 3D value noise + 3-octave fBm (GLSL). */

package/dist/operations/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/operations/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA+DrF,eAAO,MAAM,UAAU,EAAE,mBAAmB,EAQ3C,CAAC;AAIF,eAAO,MAAM,YAAY,GAAI,MAAM,aAAa,KAAG,mBAAmB,GAAG,SAA6B,CAAC;AAEvG,2GAA2G;AAC3G,eAAO,MAAM,aAAa,GAAI,QAAQ,eAAe,EAAE,OAAM;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAO,KAAG,mBAAmB,EACG,CAAC;AAE7I,kGAAkG;AAClG,eAAO,MAAM,SAAS,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAE,KAAG,gBAC/B,CAAC;AAE1E,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,GAAG,EAAE,mBAAmB,EAAE,SAAS,CAAC,EAAE,eAAe,GAAG,eAAe,CAOpG"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/operations/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAgErF,eAAO,MAAM,UAAU,EAAE,mBAAmB,EAQ3C,CAAC;AAIF,eAAO,MAAM,YAAY,GAAI,MAAM,aAAa,KAAG,mBAAmB,GAAG,SAA6B,CAAC;AAEvG,2GAA2G;AAC3G,eAAO,MAAM,aAAa,GAAI,QAAQ,eAAe,EAAE,OAAM;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAO,KAAG,mBAAmB,EACG,CAAC;AAE7I,kGAAkG;AAClG,eAAO,MAAM,SAAS,GAAI,QAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAE,KAAG,gBAC/B,CAAC;AAE1E,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,GAAG,EAAE,mBAAmB,EAAE,SAAS,CAAC,EAAE,eAAe,GAAG,eAAe,CAOpG"}

package/dist/operations/registry.js

@@ -45,6 +45,7 @@ import orbit from './catalogue/orbit.js';
 import kintsugi from './catalogue/kintsugi.js';
 import rainBeads from './catalogue/rainBeads.js';
 import ivy from './catalogue/ivy.js';
+import inShell from './catalogue/inShell.js';
 import curlSmoke from './catalogue/curlSmoke.js';
 import lidarScan from './catalogue/lidarScan.js';
 import print3d from './catalogue/print3d.js';
@@ -63,7 +64,7 @@ export const OPERATIONS = [
     jelly, flip, spin, swirl, blastOff, vortexDrain, leafFall, pop, driftUp, slingshot, warp, knockAway, turnAway, flyBy, whoosh, slam, moveToFront,
     float, sway, bounce, wobble, pulse, shake, rotate, grow,
     glow, rimLight, dissolve, emberAsh, particleSwarm, hologram, shatter,
-    sandErosion, teleport, inkBloom, flock, liquidMetal, metalize, frost, heatCracks, petrify, kintsugi, rainBeads, ivy,
+    sandErosion, teleport, inkBloom, flock, liquidMetal, metalize, frost, heatCracks, petrify, kintsugi, rainBeads, ivy, inShell,
     portal, voxelize, unweave, petalPeel, curlSmoke, lidarScan, print3d, silkDrape, ...TRAILS,
     fade, visibility, displayImage,
     zoom, frame, focus, orbit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3driseai/3drise-viewer",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@3driseai/3drise-common": "^1.0.1",
-    "@3driseai/3drise-core": "^1.0.27"
+    "@3driseai/3drise-core": "^1.0.28",
+    "three-mesh-bvh": "^0.8.3"
   }
 }