@3driseai/3drise-core 1.0.1

package/dist/shaders/effects/baseFragment.glsl.js

@@ -0,0 +1,53 @@
+export const baseFragmentTemplate = /*glsl*/ `
+precision highp float;
+
+uniform sampler2D uTexture;
+uniform sampler2D uTargetTexture;
+uniform bool uHasTexture;
+uniform vec3 uColor;
+uniform float uOpacity;
+uniform float uTextureMorph;
+uniform float u_time;
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+uniform float uParticleUVScale;
+
+varying vec2 vTexCoords;
+varying vec2 vUV;
+varying vec2 vScreenPosition;
+varying float vPointerFalloff;
+
+// __EFFECT_HELPERS__
+// __EFFECT_UNIFORMS__
+
+float circle(vec2 uv, float border) {
+  float radius = 0.5;
+  float dist = radius - distance(uv, vec2(0.5));
+  return smoothstep(0.0, border, dist);
+}
+
+void main() {
+  vec4 outColor;
+
+  if (uHasTexture) {
+    vec2 scaledUV = gl_PointCoord * uParticleUVScale;
+    scaledUV.y *= -1.0;
+    scaledUV += vUV;
+    vec4 colorA = texture2D(uTexture, scaledUV) * vec4(uColor, 1.0);
+    vec4 colorB = texture2D(uTargetTexture, scaledUV) * vec4(uColor, 1.0);
+    outColor = mix(colorA, colorB, uTextureMorph);
+  } else {
+    outColor = vec4(uColor, 1.0);
+  }
+
+  outColor.a *= circle(gl_PointCoord, 0.2);
+
+  float falloff = vPointerFalloff;
+
+  // __EFFECT_FRAGMENT_BODY__
+
+  outColor.a *= uOpacity;
+
+  gl_FragColor = outColor;
+}
+`;

package/dist/shaders/effects/baseVertex.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const baseVertexTemplate = "\nprecision highp float;\n\nuniform float u_time;\nuniform vec2 u_pointer;\nuniform float uPointerEffectRadius;\nuniform float uPointSize;\nuniform float uMorphProgress;\nuniform float uNormalizationScale;\n\nattribute vec3 targetPosition;\nattribute vec2 aUV;\n\nvarying vec2 vTexCoords;\nvarying vec2 vUV;\nvarying vec2 vScreenPosition;\nvarying float vPointerFalloff;\n\n// __EFFECT_HELPERS__\n// __EFFECT_UNIFORMS__\n\nvoid main() {\n  vUV = aUV;\n  vec3 pos = position;\n\n  #include <begin_vertex>\n\n  vec3 morphedPos = mix(position, targetPosition, uMorphProgress);\n\n  // Pointer falloff is computed in screen-NDC space so it stays correct under any\n  // model transform (scale/rotation/position). uPointerEffectRadius is now in NDC\n  // units: ~0 = pinpoint, ~1.4 = covers full screen.\n  vec4 unmodifiedClip = projectionMatrix * modelViewMatrix * vec4(morphedPos, 1.0);\n  vec2 unmodifiedNDC = unmodifiedClip.xy / unmodifiedClip.w;\n  float falloff = smoothstep(uPointerEffectRadius, 0.0, distance(unmodifiedNDC, u_pointer));\n  vPointerFalloff = falloff;\n\n  // Local-space pointer approximation, kept for descriptors (e.g. displacement)\n  // that need a push direction. Magic 5.0 is a legacy constant; this still has\n  // the scale-mismatch issue for non-identity transforms \u2014 fix is per-descriptor.\n  vec2 scaledPointer = u_pointer * 5.0;\n\n  float sizeMultiplier = 1.0;\n\n  // __EFFECT_VERTEX_BODY__\n\n  vTexCoords = morphedPos.xy;\n  transformed = morphedPos;\n\n  #include <project_vertex>\n\n  gl_PointSize = uPointSize * sizeMultiplier;\n  vScreenPosition = gl_Position.xy / gl_Position.w;\n\n  #include <logdepthbuf_vertex>\n  #include <clipping_planes_vertex>\n  #include <worldpos_vertex>\n  #include <fog_vertex>\n}\n";
+//# sourceMappingURL=baseVertex.glsl.d.ts.map

package/dist/shaders/effects/baseVertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseVertex.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/baseVertex.glsl.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,guDA2D9B,CAAC"}

package/dist/shaders/effects/baseVertex.glsl.js

@@ -0,0 +1,60 @@
+export const baseVertexTemplate = /*glsl*/ `
+precision highp float;
+
+uniform float u_time;
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+uniform float uPointSize;
+uniform float uMorphProgress;
+uniform float uNormalizationScale;
+
+attribute vec3 targetPosition;
+attribute vec2 aUV;
+
+varying vec2 vTexCoords;
+varying vec2 vUV;
+varying vec2 vScreenPosition;
+varying float vPointerFalloff;
+
+// __EFFECT_HELPERS__
+// __EFFECT_UNIFORMS__
+
+void main() {
+  vUV = aUV;
+  vec3 pos = position;
+
+  #include <begin_vertex>
+
+  vec3 morphedPos = mix(position, targetPosition, uMorphProgress);
+
+  // Pointer falloff is computed in screen-NDC space so it stays correct under any
+  // model transform (scale/rotation/position). uPointerEffectRadius is now in NDC
+  // units: ~0 = pinpoint, ~1.4 = covers full screen.
+  vec4 unmodifiedClip = projectionMatrix * modelViewMatrix * vec4(morphedPos, 1.0);
+  vec2 unmodifiedNDC = unmodifiedClip.xy / unmodifiedClip.w;
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, distance(unmodifiedNDC, u_pointer));
+  vPointerFalloff = falloff;
+
+  // Local-space pointer approximation, kept for descriptors (e.g. displacement)
+  // that need a push direction. Magic 5.0 is a legacy constant; this still has
+  // the scale-mismatch issue for non-identity transforms — fix is per-descriptor.
+  vec2 scaledPointer = u_pointer * 5.0;
+
+  float sizeMultiplier = 1.0;
+
+  // __EFFECT_VERTEX_BODY__
+
+  vTexCoords = morphedPos.xy;
+  transformed = morphedPos;
+
+  #include <project_vertex>
+
+  gl_PointSize = uPointSize * sizeMultiplier;
+  vScreenPosition = gl_Position.xy / gl_Position.w;
+
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <worldpos_vertex>
+  #include <fog_vertex>
+}
+`;

package/dist/shaders/effects/buildShaderEffectsMaterial.d.ts

@@ -0,0 +1,17 @@
+import { ShaderMaterial } from 'three';
+import type { ShaderEffect, EffectShaderStage } from './types';
+export interface BuildShaderEffectsMaterialOptions {
+    effects: ShaderEffect[];
+    initialColor?: string;
+    initialOpacity?: number;
+    initialPointSize?: number;
+    initialParticleUVScale?: number;
+    initialPointerEffectRadius?: number;
+}
+export interface ShaderEffectsMaterialMeta {
+    __structureKey: string;
+    __effectPrefixes: Map<string, string>;
+}
+export declare function buildShaderEffectsMaterial(options: BuildShaderEffectsMaterialOptions): ShaderMaterial & ShaderEffectsMaterialMeta;
+export declare function getEffectStage(effectType: string): EffectShaderStage | undefined;
+//# sourceMappingURL=buildShaderEffectsMaterial.d.ts.map

package/dist/shaders/effects/buildShaderEffectsMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildShaderEffectsMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/buildShaderEffectsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAkB,MAAM,OAAO,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI/D,MAAM,WAAW,iCAAiC;IAC9C,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAgGD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iCAAiC,GAAG,cAAc,GAAG,yBAAyB,CAqDjI;AACD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAEhF"}

package/dist/shaders/effects/buildShaderEffectsMaterial.js

@@ -0,0 +1,156 @@
+import { ShaderMaterial, Vector2, Color } from 'three';
+import { buildUniformPrefix, structureKey } from './types.js';
+import { getDescriptor } from './registry/index.js';
+import { baseVertexTemplate } from './baseVertex.glsl.js';
+import { baseFragmentTemplate } from './baseFragment.glsl.js';
+function makeUniformValue(def, raw) {
+    const value = raw === undefined ? def.default : raw;
+    switch (def.glslType) {
+        case 'float':
+        case 'int':
+            return typeof value === 'number' ? value : Number(value) || 0;
+        case 'bool':
+            return Boolean(value);
+        case 'vec2': {
+            const v = Array.isArray(value) ? value : [0, 0];
+            return new Vector2(v[0] ?? 0, v[1] ?? 0);
+        }
+        case 'vec3': {
+            if (def.control.kind === 'color') {
+                if (typeof value === 'string')
+                    return new Color(value);
+                if (Array.isArray(value))
+                    return new Color(value[0] ?? 1, value[1] ?? 1, value[2] ?? 1);
+                return new Color(1, 1, 1);
+            }
+            const v = Array.isArray(value) ? value : [0, 0, 0];
+            return [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0];
+        }
+        case 'vec4': {
+            const v = Array.isArray(value) ? value : [0, 0, 0, 0];
+            return [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0, v[3] ?? 0];
+        }
+        default:
+            return value;
+    }
+}
+function appendDescriptorUniformDecls(state, prefix, desc) {
+    const lines = [];
+    for (const [key, def] of Object.entries(desc.uniforms)) {
+        lines.push(`uniform ${def.glslType} ${prefix}${key};`);
+    }
+    const block = lines.join('\n') + '\n';
+    if (desc.stage === 'vertex')
+        state.vertexUniformDecls += block;
+    else
+        state.fragmentUniformDecls += block;
+}
+function appendDescriptorHelpers(state, desc) {
+    if (!desc.helpers)
+        return;
+    if (desc.stage === 'vertex') {
+        if (state.helperIdsVertex.has(desc.id))
+            return;
+        state.helperIdsVertex.add(desc.id);
+        state.vertexHelpers += desc.helpers + '\n';
+    }
+    else {
+        if (state.helperIdsFragment.has(desc.id))
+            return;
+        state.helperIdsFragment.add(desc.id);
+        state.fragmentHelpers += desc.helpers + '\n';
+    }
+}
+function appendDescriptorBody(state, prefix, desc, scope) {
+    const body = desc.stage === 'vertex' ? desc.vertexBody : desc.fragmentBody;
+    if (!body)
+        return;
+    const replaced = body.replace(/\{\{prefix\}\}/g, prefix);
+    // Inject effectScopeFactor at the top of each body so descriptors can multiply
+    // by it without knowing their scope. global → 1.0, pointer → vPointerFalloff.
+    // Pointer scope is also gated by the falloff > 0 check (early-out).
+    // (Single-underscore prefixes are reserved in GLSL; double-underscore is
+    // reserved by spec — must avoid both.)
+    const scopeFactorDecl = scope === 'pointer'
+        ? 'float effectScopeFactor = vPointerFalloff;'
+        : 'float effectScopeFactor = 1.0;';
+    const withScope = `{ ${scopeFactorDecl}\n${replaced}\n}`;
+    const wrapped = scope === 'pointer' ? `if (vPointerFalloff > 0.0) ${withScope}` : withScope;
+    if (desc.stage === 'vertex')
+        state.vertexBody += wrapped + '\n';
+    else
+        state.fragmentBody += wrapped + '\n';
+}
+function processEffect(state, eff) {
+    if (!eff.enabled)
+        return;
+    const desc = getDescriptor(eff.type);
+    if (!desc) {
+        console.warn(`[effects] unknown effect type "${eff.type}"; skipping`);
+        return;
+    }
+    const prefix = buildUniformPrefix(eff.instanceId);
+    for (const [key, def] of Object.entries(desc.uniforms)) {
+        state.uniforms[`${prefix}${key}`] = { value: makeUniformValue(def, eff.values[key]) };
+    }
+    appendDescriptorUniformDecls(state, prefix, desc);
+    appendDescriptorHelpers(state, desc);
+    appendDescriptorBody(state, prefix, desc, eff.scope);
+}
+export function buildShaderEffectsMaterial(options) {
+    const { effects } = options;
+    const state = {
+        uniforms: {
+            u_time: { value: 0 },
+            u_pointer: { value: new Vector2() },
+            uPointerEffectRadius: { value: options.initialPointerEffectRadius ?? 0.4 },
+            uPointSize: { value: options.initialPointSize ?? 5.0 },
+            uMorphProgress: { value: 0 },
+            uTextureMorph: { value: 0 },
+            uNormalizationScale: { value: 1.0 },
+            uTexture: { value: null },
+            uTargetTexture: { value: null },
+            uHasTexture: { value: false },
+            uColor: { value: new Color(options.initialColor ?? '#ffffff') },
+            uOpacity: { value: options.initialOpacity ?? 1.0 },
+            uParticleUVScale: { value: options.initialParticleUVScale ?? 0.01 },
+        },
+        vertexUniformDecls: '',
+        fragmentUniformDecls: '',
+        vertexHelpers: '',
+        fragmentHelpers: '',
+        vertexBody: '',
+        fragmentBody: '',
+        helperIdsVertex: new Set(),
+        helperIdsFragment: new Set(),
+    };
+    const prefixes = new Map();
+    for (const eff of effects) {
+        if (!eff.enabled)
+            continue;
+        prefixes.set(eff.instanceId, buildUniformPrefix(eff.instanceId));
+        processEffect(state, eff);
+    }
+    const vertexShader = baseVertexTemplate
+        .replace('// __EFFECT_HELPERS__', state.vertexHelpers || '// (no helpers)')
+        .replace('// __EFFECT_UNIFORMS__', state.vertexUniformDecls || '// (no effect uniforms)')
+        .replace('// __EFFECT_VERTEX_BODY__', state.vertexBody || '// (no vertex effects)');
+    const fragmentShader = baseFragmentTemplate
+        .replace('// __EFFECT_HELPERS__', state.fragmentHelpers || '// (no helpers)')
+        .replace('// __EFFECT_UNIFORMS__', state.fragmentUniformDecls || '// (no effect uniforms)')
+        .replace('// __EFFECT_FRAGMENT_BODY__', state.fragmentBody || '// (no fragment effects)');
+    const material = new ShaderMaterial({
+        vertexShader,
+        fragmentShader,
+        uniforms: state.uniforms,
+        transparent: true,
+        depthTest: true,
+        depthWrite: false,
+    });
+    material.__structureKey = structureKey(effects);
+    material.__effectPrefixes = prefixes;
+    return material;
+}
+export function getEffectStage(effectType) {
+    return getDescriptor(effectType)?.stage;
+}

package/dist/shaders/effects/defaults.d.ts

@@ -0,0 +1,4 @@
+import type { ShaderEffect, EffectScope } from "./types";
+export declare function generateInstanceId(): string;
+export declare function createDefaultShaderEffect(type: string, scope?: EffectScope): ShaderEffect | undefined;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/shaders/effects/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/defaults.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAKzD,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,CAgBrG"}

package/dist/shaders/effects/defaults.js

@@ -0,0 +1,27 @@
+import { getDescriptor } from './registry/index.js';
+function defaultValueFor(def) {
+    return def.default;
+}
+export function generateInstanceId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+export function createDefaultShaderEffect(type, scope) {
+    const desc = getDescriptor(type);
+    if (!desc)
+        return undefined;
+    const resolvedScope = scope ?? desc.allowedScopes[0];
+    const values = {};
+    for (const [key, def] of Object.entries(desc.uniforms)) {
+        values[key] = defaultValueFor(def);
+    }
+    return {
+        type: desc.id,
+        instanceId: generateInstanceId(),
+        scope: resolvedScope,
+        enabled: true,
+        values,
+    };
+}

package/dist/shaders/effects/index.d.ts

@@ -0,0 +1,7 @@
+export * from './presets';
+export * from './types';
+export * from './EffectsFragmentFunctions.glsl';
+export * from './EffectsVertexFunctions.glsl';
+export * from './buildShaderEffectsMaterial';
+export * from './defaults';
+//# sourceMappingURL=index.d.ts.map

package/dist/shaders/effects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,YAAY,CAAC"}

package/dist/shaders/effects/index.js

@@ -0,0 +1,6 @@
+export * from './presets.js';
+export * from './types.js';
+export * from './EffectsFragmentFunctions.glsl.js';
+export * from './EffectsVertexFunctions.glsl.js';
+export * from './buildShaderEffectsMaterial.js';
+export * from './defaults.js';

package/dist/shaders/effects/noiseLib.glsl.d.ts

@@ -0,0 +1,6 @@
+export declare const noiseLibGLSL = "\n// ---------------------------------------------------------------------------\n// Hashing utilities\n// ---------------------------------------------------------------------------\nfloat nl_hash11(float p) {\n  p = fract(p * 0.1031);\n  p *= p + 33.33;\n  p *= p + p;\n  return fract(p);\n}\n\nfloat nl_hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nvec2 nl_hash22(vec2 p) {\n  p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));\n  return -1.0 + 2.0 * fract(sin(p) * 43758.5453123);\n}\n\nvec3 nl_mod289_3(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\nvec2 nl_mod289_2(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\nvec3 nl_permute3(vec3 x) { return nl_mod289_3(((x * 34.0) + 1.0) * x); }\nvec4 nl_mod289_4(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\nvec4 nl_permute4(vec4 x) { return nl_mod289_4(((x * 34.0) + 1.0) * x); }\n\nvec2 nl_fade2(vec2 t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }\n\n// ---------------------------------------------------------------------------\n// White noise (uniform random)\n// ---------------------------------------------------------------------------\nfloat whiteNoise2D(vec2 p) {\n  return nl_hash21(p);\n}\n\n// ---------------------------------------------------------------------------\n// Value noise \u2014 bilinear interp of hashed corners\n// ---------------------------------------------------------------------------\nfloat valueNoise2D(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float a = nl_hash21(i);\n  float b = nl_hash21(i + vec2(1.0, 0.0));\n  float c = nl_hash21(i + vec2(0.0, 1.0));\n  float d = nl_hash21(i + vec2(1.0, 1.0));\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;\n}\n\n// ---------------------------------------------------------------------------\n// Perlin noise (2D, IQ/Stefan Gustavson formulation, returns roughly [-1, 1])\n// ---------------------------------------------------------------------------\nfloat perlinNoise2D(vec2 P) {\n  vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);\n  vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);\n  Pi = mod(Pi, 289.0);\n  vec4 ix = Pi.xzxz;\n  vec4 iy = Pi.yyww;\n  vec4 fx = Pf.xzxz;\n  vec4 fy = Pf.yyww;\n  vec4 i = nl_permute4(nl_permute4(ix) + iy);\n  vec4 gx = 2.0 * fract(i * 0.0243902439) - 1.0;\n  vec4 gy = abs(gx) - 0.5;\n  vec4 tx = floor(gx + 0.5);\n  gx = gx - tx;\n  vec2 g00 = vec2(gx.x, gy.x);\n  vec2 g10 = vec2(gx.y, gy.y);\n  vec2 g01 = vec2(gx.z, gy.z);\n  vec2 g11 = vec2(gx.w, gy.w);\n  vec4 norm = 1.79284291400159 - 0.85373472095314 *\n    vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));\n  g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w;\n  float n00 = dot(g00, vec2(fx.x, fy.x));\n  float n10 = dot(g10, vec2(fx.y, fy.y));\n  float n01 = dot(g01, vec2(fx.z, fy.z));\n  float n11 = dot(g11, vec2(fx.w, fy.w));\n  vec2 fade_xy = nl_fade2(Pf.xy);\n  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);\n  return 2.3 * mix(n_x.x, n_x.y, fade_xy.y);\n}\n\n// ---------------------------------------------------------------------------\n// Simplex noise (Stefan Gustavson 2D)\n// ---------------------------------------------------------------------------\nfloat simplexNoise2D(vec2 v) {\n  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);\n  vec2 i = floor(v + dot(v, C.yy));\n  vec2 x0 = v - i + dot(i, C.xx);\n  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n  vec4 x12 = x0.xyxy + C.xxzz;\n  x12.xy -= i1;\n  i = nl_mod289_2(i);\n  vec3 p = nl_permute3(nl_permute3(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));\n  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n  m = m * m; m = m * m;\n  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n  vec3 h = abs(x) - 0.5;\n  vec3 ox = floor(x + 0.5);\n  vec3 a0 = x - ox;\n  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);\n  vec3 g;\n  g.x = a0.x * x0.x + h.x * x0.y;\n  g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n  return 130.0 * dot(m, g);\n}\n\n// ---------------------------------------------------------------------------\n// Worley/cellular noise \u2014 distance to nearest random cell point in [0,1]\n// ---------------------------------------------------------------------------\nfloat worleyNoise2D(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float minDist = 1.5;\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 neighbor = vec2(float(x), float(y));\n      vec2 point = 0.5 + 0.5 * nl_hash22(i + neighbor);\n      vec2 diff = neighbor + point - f;\n      minDist = min(minDist, length(diff));\n    }\n  }\n  return minDist;\n}\n\n// ---------------------------------------------------------------------------\n// FBM/turbulence/ridged \u2014 fixed 4 octaves (loop bounds must be const in WebGL1)\n// ---------------------------------------------------------------------------\nfloat fractalNoise2D(vec2 p) {\n  float v = 0.0;\n  float amp = 0.5;\n  vec2 q = p;\n  for (int i = 0; i < 4; i++) {\n    v += amp * perlinNoise2D(q);\n    q *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\nfloat turbulenceNoise2D(vec2 p) {\n  float v = 0.0;\n  float amp = 0.5;\n  vec2 q = p;\n  for (int i = 0; i < 4; i++) {\n    v += amp * abs(perlinNoise2D(q));\n    q *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\nfloat ridgedNoise2D(vec2 p) {\n  float v = 0.0;\n  float amp = 0.5;\n  vec2 q = p;\n  for (int i = 0; i < 4; i++) {\n    float n = 1.0 - abs(perlinNoise2D(q));\n    v += amp * n * n;\n    q *= 2.0;\n    amp *= 0.5;\n  }\n  return v;\n}\n\nfloat domainWarpedNoise2D(vec2 p) {\n  vec2 warp = vec2(perlinNoise2D(p), perlinNoise2D(p + vec2(5.2, 1.3)));\n  return perlinNoise2D(p + warp * 0.5);\n}\n\n// ---------------------------------------------------------------------------\n// Dispatch \u2014 type select: 0=perlin 1=simplex 2=worley 3=value 4=white\n//                          5=fractal 6=ridged 7=turbulence 8=domainWarped\n// ---------------------------------------------------------------------------\nfloat sampleNoise(float type, vec2 p) {\n  if (type < 0.5) return perlinNoise2D(p);\n  if (type < 1.5) return simplexNoise2D(p);\n  if (type < 2.5) return worleyNoise2D(p) * 2.0 - 1.0;\n  if (type < 3.5) return valueNoise2D(p) * 2.0 - 1.0;\n  if (type < 4.5) return whiteNoise2D(p) * 2.0 - 1.0;\n  if (type < 5.5) return fractalNoise2D(p);\n  if (type < 6.5) return ridgedNoise2D(p);\n  if (type < 7.5) return turbulenceNoise2D(p);\n  return domainWarpedNoise2D(p);\n}\n";
+export declare const NOISE_TYPE_OPTIONS: {
+    value: number;
+    label: string;
+}[];
+//# sourceMappingURL=noiseLib.glsl.d.ts.map

package/dist/shaders/effects/noiseLib.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noiseLib.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/noiseLib.glsl.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,YAAY,8gNAwLxB,CAAC;AACF,eAAO,MAAM,kBAAkB,EAAE;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB,EAUR,CAAC"}

package/dist/shaders/effects/noiseLib.glsl.js

@@ -0,0 +1,214 @@
+// Pure-function noise library. Each function takes a position and returns a float.
+// Effect descriptors include this via their `helpers` field; the factory dedupes
+// by descriptor.id, so add `helpers: noiseLibGLSL` to any descriptor that needs it.
+//
+// Available functions (signature → float):
+//   perlinNoise2D(vec2)
+//   simplexNoise2D(vec2)
+//   worleyNoise2D(vec2)        — returns distance to nearest cell point
+//   valueNoise2D(vec2)
+//   whiteNoise2D(vec2)
+//   fractalNoise2D(vec2)       — fbm of perlin, 4 octaves
+//   ridgedNoise2D(vec2)        — ridged multifractal, 4 octaves
+//   turbulenceNoise2D(vec2)    — abs perlin fbm, 4 octaves
+//   domainWarpedNoise2D(vec2)  — perlin with self-warped coords
+//
+// And a dispatch helper:
+//   sampleNoise(float type, vec2 p)  // type: 0=perlin 1=simplex 2=worley 3=value
+//                                    //       4=white 5=fractal 6=ridged 7=turbulence 8=domainWarped
+export const noiseLibGLSL = /*glsl*/ `
+// ---------------------------------------------------------------------------
+// Hashing utilities
+// ---------------------------------------------------------------------------
+float nl_hash11(float p) {
+  p = fract(p * 0.1031);
+  p *= p + 33.33;
+  p *= p + p;
+  return fract(p);
+}
+
+float nl_hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+vec2 nl_hash22(vec2 p) {
+  p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+  return -1.0 + 2.0 * fract(sin(p) * 43758.5453123);
+}
+
+vec3 nl_mod289_3(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec2 nl_mod289_2(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec3 nl_permute3(vec3 x) { return nl_mod289_3(((x * 34.0) + 1.0) * x); }
+vec4 nl_mod289_4(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 nl_permute4(vec4 x) { return nl_mod289_4(((x * 34.0) + 1.0) * x); }
+
+vec2 nl_fade2(vec2 t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }
+
+// ---------------------------------------------------------------------------
+// White noise (uniform random)
+// ---------------------------------------------------------------------------
+float whiteNoise2D(vec2 p) {
+  return nl_hash21(p);
+}
+
+// ---------------------------------------------------------------------------
+// Value noise — bilinear interp of hashed corners
+// ---------------------------------------------------------------------------
+float valueNoise2D(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  float a = nl_hash21(i);
+  float b = nl_hash21(i + vec2(1.0, 0.0));
+  float c = nl_hash21(i + vec2(0.0, 1.0));
+  float d = nl_hash21(i + vec2(1.0, 1.0));
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
+// ---------------------------------------------------------------------------
+// Perlin noise (2D, IQ/Stefan Gustavson formulation, returns roughly [-1, 1])
+// ---------------------------------------------------------------------------
+float perlinNoise2D(vec2 P) {
+  vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
+  vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
+  Pi = mod(Pi, 289.0);
+  vec4 ix = Pi.xzxz;
+  vec4 iy = Pi.yyww;
+  vec4 fx = Pf.xzxz;
+  vec4 fy = Pf.yyww;
+  vec4 i = nl_permute4(nl_permute4(ix) + iy);
+  vec4 gx = 2.0 * fract(i * 0.0243902439) - 1.0;
+  vec4 gy = abs(gx) - 0.5;
+  vec4 tx = floor(gx + 0.5);
+  gx = gx - tx;
+  vec2 g00 = vec2(gx.x, gy.x);
+  vec2 g10 = vec2(gx.y, gy.y);
+  vec2 g01 = vec2(gx.z, gy.z);
+  vec2 g11 = vec2(gx.w, gy.w);
+  vec4 norm = 1.79284291400159 - 0.85373472095314 *
+    vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11));
+  g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w;
+  float n00 = dot(g00, vec2(fx.x, fy.x));
+  float n10 = dot(g10, vec2(fx.y, fy.y));
+  float n01 = dot(g01, vec2(fx.z, fy.z));
+  float n11 = dot(g11, vec2(fx.w, fy.w));
+  vec2 fade_xy = nl_fade2(Pf.xy);
+  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
+  return 2.3 * mix(n_x.x, n_x.y, fade_xy.y);
+}
+
+// ---------------------------------------------------------------------------
+// Simplex noise (Stefan Gustavson 2D)
+// ---------------------------------------------------------------------------
+float simplexNoise2D(vec2 v) {
+  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+  i = nl_mod289_2(i);
+  vec3 p = nl_permute3(nl_permute3(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
+  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+  m = m * m; m = m * m;
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+// ---------------------------------------------------------------------------
+// Worley/cellular noise — distance to nearest random cell point in [0,1]
+// ---------------------------------------------------------------------------
+float worleyNoise2D(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  float minDist = 1.5;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 neighbor = vec2(float(x), float(y));
+      vec2 point = 0.5 + 0.5 * nl_hash22(i + neighbor);
+      vec2 diff = neighbor + point - f;
+      minDist = min(minDist, length(diff));
+    }
+  }
+  return minDist;
+}
+
+// ---------------------------------------------------------------------------
+// FBM/turbulence/ridged — fixed 4 octaves (loop bounds must be const in WebGL1)
+// ---------------------------------------------------------------------------
+float fractalNoise2D(vec2 p) {
+  float v = 0.0;
+  float amp = 0.5;
+  vec2 q = p;
+  for (int i = 0; i < 4; i++) {
+    v += amp * perlinNoise2D(q);
+    q *= 2.0;
+    amp *= 0.5;
+  }
+  return v;
+}
+
+float turbulenceNoise2D(vec2 p) {
+  float v = 0.0;
+  float amp = 0.5;
+  vec2 q = p;
+  for (int i = 0; i < 4; i++) {
+    v += amp * abs(perlinNoise2D(q));
+    q *= 2.0;
+    amp *= 0.5;
+  }
+  return v;
+}
+
+float ridgedNoise2D(vec2 p) {
+  float v = 0.0;
+  float amp = 0.5;
+  vec2 q = p;
+  for (int i = 0; i < 4; i++) {
+    float n = 1.0 - abs(perlinNoise2D(q));
+    v += amp * n * n;
+    q *= 2.0;
+    amp *= 0.5;
+  }
+  return v;
+}
+
+float domainWarpedNoise2D(vec2 p) {
+  vec2 warp = vec2(perlinNoise2D(p), perlinNoise2D(p + vec2(5.2, 1.3)));
+  return perlinNoise2D(p + warp * 0.5);
+}
+
+// ---------------------------------------------------------------------------
+// Dispatch — type select: 0=perlin 1=simplex 2=worley 3=value 4=white
+//                          5=fractal 6=ridged 7=turbulence 8=domainWarped
+// ---------------------------------------------------------------------------
+float sampleNoise(float type, vec2 p) {
+  if (type < 0.5) return perlinNoise2D(p);
+  if (type < 1.5) return simplexNoise2D(p);
+  if (type < 2.5) return worleyNoise2D(p) * 2.0 - 1.0;
+  if (type < 3.5) return valueNoise2D(p) * 2.0 - 1.0;
+  if (type < 4.5) return whiteNoise2D(p) * 2.0 - 1.0;
+  if (type < 5.5) return fractalNoise2D(p);
+  if (type < 6.5) return ridgedNoise2D(p);
+  if (type < 7.5) return turbulenceNoise2D(p);
+  return domainWarpedNoise2D(p);
+}
+`;
+export const NOISE_TYPE_OPTIONS = [
+    { value: 0, label: 'Perlin' },
+    { value: 1, label: 'Simplex' },
+    { value: 2, label: 'Worley' },
+    { value: 3, label: 'Value' },
+    { value: 4, label: 'White' },
+    { value: 5, label: 'Fractal' },
+    { value: 6, label: 'Ridged' },
+    { value: 7, label: 'Turbulence' },
+    { value: 8, label: 'Domain warped' },
+];

package/dist/shaders/effects/presets.d.ts

@@ -0,0 +1,20 @@
+import type { ShaderEffect, EffectScope, EffectValue } from "./types";
+export interface EffectPresetEntry {
+    type: string;
+    scope: EffectScope;
+    enabled: boolean;
+    values: Record<string, EffectValue>;
+}
+export interface EffectPreset {
+    id: string;
+    label: string;
+    description?: string;
+    pointerRadius?: number;
+    effects: EffectPresetEntry[];
+}
+export declare const EFFECT_PRESETS: EffectPreset[];
+export declare function instantiatePreset(preset: EffectPreset): ShaderEffect[];
+export declare function listPresets(): EffectPreset[];
+export declare function getPreset(id: string): EffectPreset | undefined;
+export declare function getRandomPreset(): EffectPreset;
+//# sourceMappingURL=presets.d.ts.map

package/dist/shaders/effects/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/presets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtE,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAChC;AAOD,eAAO,MAAM,cAAc,EAAE,YAAY,EAwQxC,CAAC;AACF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,EAAE,CAQtE;AACD,wBAAgB,WAAW,IAAI,YAAY,EAAE,CAE5C;AACD,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAE9D;AACD,wBAAgB,eAAe,IAAI,YAAY,CAE9C"}