@3driseai/3drise-viewer 0.1.1

package/dist/shaders/ShaderEffectsMaterial.js

@@ -0,0 +1,233 @@
+import { Vector2, Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+import { effectsVertexGLSL } from './effects/EffectsVertexFunctions.glsl.js';
+// ─── Vertex shader ────────────────────────────────────────────────────────────
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+uniform float uPointSize;
+uniform float uMorphProgress;
+uniform float uNormalizationScale;
+attribute vec2 aUV;
+varying vec2 vUV;
+varying vec2 vTexCoords;
+varying vec2 vScreenPosition;
+
+void main() {
+  vUV = aUV;
+
+  #include <begin_vertex>
+  vec3 morphedPos = mix(position, position, uMorphProgress);
+
+  vec2 scaledPointer = u_pointer * 5.0;
+  morphedPos = applyAllVertexEffects(morphedPos, scaledPointer);
+
+  vTexCoords = morphedPos.xy;
+  transformed = morphedPos;
+  #include <project_vertex>
+
+  gl_PointSize = uPointSize * getScaleMultiplier(morphedPos, scaledPointer);
+  vScreenPosition = gl_Position.xy / gl_Position.w;
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <worldpos_vertex>
+  #include <fog_vertex>
+}
+`;
+// ─── Fragment shader ──────────────────────────────────────────────────────────
+const fragmentShader = /*glsl*/ `
+uniform sampler2D uTexture;
+uniform sampler2D uTargetTexture;
+uniform bool uHasTexture;
+uniform vec3 uColor;
+uniform float uOpacity;
+varying vec2 vTexCoords;
+varying vec2 vUV;
+uniform float uMorphProgress;
+uniform float u_time;
+uniform float uParticleUVScale;
+uniform vec2 u_pointer;
+uniform float uPtrRadius;
+varying vec2 vScreenPosition;
+
+// ── General fragment uniforms ─────────────────────────────────────────────
+uniform float uGenFragmentType;
+uniform bool uGenFragmentEnabled;
+uniform float uGenFragmentIntensity;
+uniform float uGenFragmentSpeed;
+uniform vec3 uGenFragmentColor;
+uniform float uGenGrayscaleMode;
+uniform float uGenGrayscaleContrast;
+uniform float uGenGrayscaleBrightness;
+uniform float uGenGrayscaleWaveFreq;
+uniform float uGenGrayscaleWaveDir;
+uniform float uGenGrayscaleCenterX;
+uniform float uGenGrayscaleCenterY;
+
+// ── Pointer fragment uniforms ─────────────────────────────────────────────
+uniform float uPtrFragmentType;
+uniform bool uPtrFragmentEnabled;
+uniform float uPtrFragmentIntensity;
+uniform float uPtrFragmentSpeed;
+uniform vec3 uPtrFragmentColor;
+uniform float uPtrGrayscaleMode;
+uniform float uPtrGrayscaleContrast;
+uniform float uPtrGrayscaleBrightness;
+uniform float uPtrGrayscaleWaveFreq;
+uniform float uPtrGrayscaleWaveDir;
+uniform float uPtrGrayscaleCenterX;
+uniform float uPtrGrayscaleCenterY;
+
+// ─────────────────────────────────────────────────────────────────────────
+
+float circle(vec2 uv, float border) {
+  float dist = 0.5 - distance(uv, vec2(0.5));
+  return smoothstep(0.0, border, dist);
+}
+
+vec4 applyFragmentEffect(
+  vec4 color,
+  float type, float intensity, float speed,
+  vec3 fColor,
+  float grayscaleMode, float contrast, float brightness,
+  float waveFreq, float waveDir, float cx, float cy
+) {
+  if (type < 1.5) {
+    // Grayscale
+    float factor = 0.0;
+    if (grayscaleMode < 0.5) {
+      factor = intensity;
+    } else if (grayscaleMode < 1.5) {
+      float pos = waveDir < 0.5 ? vTexCoords.x : (waveDir < 1.5 ? vTexCoords.y : vTexCoords.x + vTexCoords.y);
+      factor = (sin(pos * waveFreq + u_time * speed) * 0.5 + 0.5) * intensity;
+    } else if (grayscaleMode < 2.5) {
+      factor = (sin(u_time * speed) * 0.5 + 0.5) * intensity;
+    } else {
+      float d = distance(vTexCoords, vec2(cx, cy));
+      factor = (sin(d * 5.0 - u_time * speed) * 0.5 + 0.5) * intensity;
+    }
+    float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * contrast + 0.5 + brightness;
+    color.rgb = mix(color.rgb, vec3(gray), factor);
+  } else if (type < 2.5) {
+    // Glow
+    color.rgb += fColor * intensity;
+  } else if (type < 3.5) {
+    // ColorShift
+    color.rgb = mix(color.rgb, fColor, intensity);
+  }
+  return color;
+}
+
+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, uMorphProgress);
+  } else {
+    outColor = vec4(uColor, 1.0);
+  }
+
+  outColor.a *= circle(gl_PointCoord, 0.2);
+
+  // General fragment effect (global)
+  if (uGenFragmentEnabled && uGenFragmentType > 0.5) {
+    outColor = applyFragmentEffect(
+      outColor,
+      uGenFragmentType, uGenFragmentIntensity, uGenFragmentSpeed,
+      uGenFragmentColor,
+      uGenGrayscaleMode, uGenGrayscaleContrast, uGenGrayscaleBrightness,
+      uGenGrayscaleWaveFreq, uGenGrayscaleWaveDir, uGenGrayscaleCenterX, uGenGrayscaleCenterY
+    );
+  }
+
+  // Pointer fragment effect (within radius)
+  if (uPtrFragmentEnabled && uPtrFragmentType > 0.5) {
+    vec2 scaledPointer = u_pointer * 5.0;
+    float falloff = smoothstep(uPtrRadius, 0.0, distance(vTexCoords, scaledPointer));
+    if (falloff > 0.0) {
+      outColor = applyFragmentEffect(
+        outColor,
+        uPtrFragmentType, uPtrFragmentIntensity * falloff, uPtrFragmentSpeed,
+        uPtrFragmentColor,
+        uPtrGrayscaleMode, uPtrGrayscaleContrast, uPtrGrayscaleBrightness,
+        uPtrGrayscaleWaveFreq, uPtrGrayscaleWaveDir, uPtrGrayscaleCenterX, uPtrGrayscaleCenterY
+      );
+    }
+  }
+
+  outColor.a *= uOpacity;
+  gl_FragColor = outColor;
+}
+`;
+// ─── Material definition ──────────────────────────────────────────────────────
+const ShaderEffectsMaterial = shaderMaterial({
+    // Base
+    u_time: 0,
+    u_pointer: new Vector2(),
+    uPointSize: 1.0,
+    uTexture: null,
+    uTargetTexture: null,
+    uHasTexture: false,
+    uMorphProgress: 0.0,
+    uColor: new Color(1.0, 1.0, 1.0),
+    uOpacity: 1.0,
+    uNormalizationScale: 1.0,
+    uParticleUVScale: 0.01,
+    // General vertex effect
+    uGenVertexType: 0,
+    uGenVertexEnabled: false,
+    uGenVertexIntensity: 0.3,
+    uGenVertexSpeed: 1.0,
+    uGenVertexFrequency: 3.0,
+    uGenVertexDirection: 0,
+    uGenVertexCenterX: 0.0,
+    uGenVertexCenterY: 0.0,
+    uGenVertexMinScale: 0.5,
+    uGenVertexMaxScale: 2.0,
+    // Pointer vertex effect
+    uPtrRadius: 2.5,
+    uPtrVertexType: 0,
+    uPtrVertexEnabled: false,
+    uPtrVertexIntensity: 0.3,
+    uPtrVertexSpeed: 1.0,
+    uPtrVertexFrequency: 3.0,
+    uPtrVertexDirection: 0,
+    uPtrVertexCenterX: 0.0,
+    uPtrVertexCenterY: 0.0,
+    uPtrVertexMinScale: 0.5,
+    uPtrVertexMaxScale: 2.0,
+    // General fragment effect
+    uGenFragmentType: 0,
+    uGenFragmentEnabled: false,
+    uGenFragmentIntensity: 1.0,
+    uGenFragmentSpeed: 1.0,
+    uGenFragmentColor: new Color(1.0, 1.0, 1.0),
+    uGenGrayscaleMode: 0,
+    uGenGrayscaleContrast: 1.0,
+    uGenGrayscaleBrightness: 0.0,
+    uGenGrayscaleWaveFreq: 3.0,
+    uGenGrayscaleWaveDir: 0,
+    uGenGrayscaleCenterX: 0.0,
+    uGenGrayscaleCenterY: 0.0,
+    // Pointer fragment effect
+    uPtrFragmentType: 0,
+    uPtrFragmentEnabled: false,
+    uPtrFragmentIntensity: 1.0,
+    uPtrFragmentSpeed: 1.0,
+    uPtrFragmentColor: new Color(1.0, 1.0, 1.0),
+    uPtrGrayscaleMode: 0,
+    uPtrGrayscaleContrast: 1.0,
+    uPtrGrayscaleBrightness: 0.0,
+    uPtrGrayscaleWaveFreq: 3.0,
+    uPtrGrayscaleWaveDir: 0,
+    uPtrGrayscaleCenterX: 0.0,
+    uPtrGrayscaleCenterY: 0.0,
+}, vertexShader, fragmentShader);
+extend({ ShaderEffectsMaterial });
+export { ShaderEffectsMaterial };

package/dist/shaders/ShootingStarMaterial.d.ts

@@ -0,0 +1,14 @@
+import { Color } from 'three';
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        shootingStarMaterial: any;
+    }
+}
+declare const ShootingStarMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    color: Color;
+    opacity: number;
+}> & {
+    key: string;
+};
+export { ShootingStarMaterial };
+//# sourceMappingURL=ShootingStarMaterial.d.ts.map

package/dist/shaders/ShootingStarMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStarMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ShootingStarMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAG9B,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,oBAAoB,EAAE,GAAG,CAAC;KAC7B;CACJ;AA0BD,QAAA,MAAM,oBAAoB;;;;;CAGM,CAAC;AAEjC,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/shaders/ShootingStarMaterial.js

@@ -0,0 +1,33 @@
+import { Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying float vProgress;
+  attribute float progress;
+
+  void main() {
+    vUv = uv;
+    vProgress = progress;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform vec3 color;
+  uniform float opacity;
+  varying vec2 vUv;
+  varying float vProgress;
+
+  void main() {
+    float alpha = opacity * (1.0 - vProgress) * (1.0 - vProgress);
+    float glow = 1.0 - vProgress;
+    vec3 glowColor = color * (1.0 + glow * 0.5);
+    gl_FragColor = vec4(glowColor, alpha);
+  }
+`;
+const ShootingStarMaterial = shaderMaterial({
+    color: new Color(1.0, 1.0, 1.0),
+    opacity: 1.0,
+}, vertexShader, fragmentShader);
+extend({ ShootingStarMaterial });
+export { ShootingStarMaterial };

package/dist/shaders/SkyboxMaterial.d.ts

@@ -0,0 +1,38 @@
+import { Color } from 'three';
+export interface SkyboxMaterialUniforms {
+    uSunAzimuth: {
+        value: number;
+    };
+    uSunElevation: {
+        value: number;
+    };
+    uSunColor: {
+        value: Color;
+    };
+    uSkyColorLow: {
+        value: Color;
+    };
+    uSkyColorHigh: {
+        value: Color;
+    };
+    uSunSize: {
+        value: number;
+    };
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        skyboxMaterial: any;
+    }
+}
+declare const SkyboxMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    uSunAzimuth: number;
+    uSunElevation: number;
+    uSunColor: Color;
+    uSkyColorLow: Color;
+    uSkyColorHigh: Color;
+    uSunSize: number;
+}> & {
+    key: string;
+};
+export { SkyboxMaterial };
+//# sourceMappingURL=SkyboxMaterial.d.ts.map

package/dist/shaders/SkyboxMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyboxMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SkyboxMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAG9B,MAAM,WAAW,sBAAsB;IACnC,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,cAAc,EAAE,GAAG,CAAC;KACvB;CACJ;AA8CD,QAAA,MAAM,cAAc;;;;;;;;;CAOY,CAAC;AAEjC,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/shaders/SkyboxMaterial.js

@@ -0,0 +1,57 @@
+import { Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+const vertexShader = /*glsl*/ `
+  varying vec3 vWorldPosition;
+  varying vec3 vDirection;
+
+  void main() {
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+    vDirection = normalize(worldPosition.xyz);
+
+    vec4 pos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    gl_Position = pos.xyww;
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  precision mediump float;
+  varying vec3 vWorldPosition;
+  varying vec3 vDirection;
+
+  uniform float uSunAzimuth;
+  uniform float uSunElevation;
+  uniform vec3 uSunColor;
+  uniform vec3 uSkyColorLow;
+  uniform vec3 uSkyColorHigh;
+  uniform float uSunSize;
+
+  void main() {
+    vec3 direction = normalize(vWorldPosition);
+
+    vec3 skyColor = mix(uSkyColorLow, uSkyColorHigh, clamp(direction.y * 0.5 + 0.5, 0.0, 1.0));
+
+    float azimuth = radians(uSunAzimuth);
+    float elevation = radians(uSunElevation);
+    vec3 sunDirection = normalize(vec3(
+      cos(elevation) * sin(azimuth),
+      sin(elevation),
+      cos(elevation) * cos(azimuth)
+    ));
+
+    float sunIntensity = pow(max(dot(direction, sunDirection), 0.0), 1000.0 / uSunSize);
+    vec3 sunColor = uSunColor * sunIntensity;
+
+    gl_FragColor = vec4(skyColor + sunColor, 1.0);
+  }
+`;
+const SkyboxMaterial = shaderMaterial({
+    uSunAzimuth: 216,
+    uSunElevation: 24.68698059628387,
+    uSunColor: new Color(0xffe5b0),
+    uSkyColorLow: new Color(0x6fa2ef),
+    uSkyColorHigh: new Color(0x2053ff),
+    uSunSize: 1,
+}, vertexShader, fragmentShader);
+extend({ SkyboxMaterial });
+export { SkyboxMaterial };

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

@@ -0,0 +1,2 @@
+export declare const effectsVertexGLSL = "\n  // ============================================================================\n  // UNIFORMS\n  // ============================================================================\n  uniform float u_time;\n  uniform vec2 u_pointer;\n\n  // \u2500\u2500 General vertex effect (applied globally) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // type: 0=none 1=wave 2=vortex 3=ripple 4=scale\n  uniform float uGenVertexType;\n  uniform bool uGenVertexEnabled;\n  uniform float uGenVertexIntensity;\n  uniform float uGenVertexSpeed;\n  uniform float uGenVertexFrequency;\n  uniform float uGenVertexDirection; // 0=horizontal 1=vertical 2=diagonal\n  uniform float uGenVertexCenterX;\n  uniform float uGenVertexCenterY;\n  uniform float uGenVertexMinScale;\n  uniform float uGenVertexMaxScale;\n\n  // \u2500\u2500 Pointer vertex effect (applied within radius) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  uniform float uPtrRadius;\n  uniform float uPtrVertexType;\n  uniform bool uPtrVertexEnabled;\n  uniform float uPtrVertexIntensity;\n  uniform float uPtrVertexSpeed;\n  uniform float uPtrVertexFrequency;\n  uniform float uPtrVertexDirection;\n  uniform float uPtrVertexCenterX;\n  uniform float uPtrVertexCenterY;\n  uniform float uPtrVertexMinScale;\n  uniform float uPtrVertexMaxScale;\n  \n  // ============================================================================\n  // FUNCTIONS\n  // ============================================================================\n\n  float getPointerFalloff(vec3 pos, vec2 pointer, float radius) {\n    return smoothstep(radius, 0.0, distance(pos.xy, pointer));\n  }\n\n  // Applies a single vertex displacement effect (shared by both general and pointer).\n  // type: 1=wave 2=vortex 3=ripple  (4=scale is handled separately as a size multiplier)\n  vec3 applyVertexDisplacement(\n    vec3 pos, float type, float intensity, float speed,\n    float frequency, float direction, float cx, float cy\n  ) {\n    if (type < 1.5) {\n      // Wave\n      float waveInput = 0.0;\n      if (direction < 0.5) waveInput = pos.x;\n      else if (direction < 1.5) waveInput = pos.y;\n      else waveInput = pos.x + pos.y;\n      pos.z += sin(waveInput * frequency + u_time * speed) * intensity;\n    } else if (type < 2.5) {\n      // Vortex\n      vec2 center = vec2(cx, cy);\n      vec2 toCenter = pos.xy - center;\n      float angle = intensity * u_time * speed;\n      mat2 rot = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n      pos.xy = center + rot * toCenter;\n    } else if (type < 3.5) {\n      // Ripple\n      vec2 center = vec2(cx, cy);\n      float dist = distance(pos.xy, center);\n      pos.z += sin(dist * frequency - u_time * speed) * intensity;\n    }\n    return pos;\n  }\n\n  // ============================================================================\n  // APPLY ALL VERTEX EFFECTS\n  // ============================================================================\n\n  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {\n    // General \u2014 applied globally\n    if (uGenVertexEnabled && uGenVertexType > 0.5 && uGenVertexType < 3.5) {\n      pos = applyVertexDisplacement(\n        pos, uGenVertexType, uGenVertexIntensity, uGenVertexSpeed,\n        uGenVertexFrequency, uGenVertexDirection, uGenVertexCenterX, uGenVertexCenterY\n      );\n    }\n\n    // Pointer \u2014 applied within radius with falloff\n    if (uPtrVertexEnabled && uPtrVertexType > 0.5 && uPtrVertexType < 3.5) {\n      float falloff = getPointerFalloff(pos, pointer, uPtrRadius);\n      if (falloff > 0.0) {\n        pos = applyVertexDisplacement(\n          pos, uPtrVertexType, uPtrVertexIntensity * falloff, uPtrVertexSpeed,\n          uPtrVertexFrequency, uPtrVertexDirection, uPtrVertexCenterX, uPtrVertexCenterY\n        );\n      }\n    }\n\n    return pos;\n  }\n\n  // Returns the point-size multiplier from scale effects (gen or pointer).\n  float getScaleMultiplier(vec3 pos, vec2 pointer) {\n    float m = 1.0;\n    // General scale\n    if (uGenVertexEnabled && uGenVertexType > 3.5) {\n      m = mix(uGenVertexMinScale, uGenVertexMaxScale, uGenVertexIntensity);\n    }\n    // Pointer scale (overrides with falloff)\n    if (uPtrVertexEnabled && uPtrVertexType > 3.5) {\n      float falloff = getPointerFalloff(pos, pointer, uPtrRadius);\n      if (falloff > 0.0) {\n        m = mix(uPtrVertexMinScale, uPtrVertexMaxScale, falloff * uPtrVertexIntensity);\n      }\n    }\n    return m;\n  }\n";
+//# sourceMappingURL=EffectsVertexFunctions.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsVertexFunctions.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/EffectsVertexFunctions.glsl.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,smJAiH7B,CAAC"}

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

@@ -0,0 +1,115 @@
+// Shared vertex shader functions for all shader effects
+export const effectsVertexGLSL = /*glsl*/ `
+  // ============================================================================
+  // UNIFORMS
+  // ============================================================================
+  uniform float u_time;
+  uniform vec2 u_pointer;
+
+  // ── General vertex effect (applied globally) ──────────────────────────────
+  // type: 0=none 1=wave 2=vortex 3=ripple 4=scale
+  uniform float uGenVertexType;
+  uniform bool uGenVertexEnabled;
+  uniform float uGenVertexIntensity;
+  uniform float uGenVertexSpeed;
+  uniform float uGenVertexFrequency;
+  uniform float uGenVertexDirection; // 0=horizontal 1=vertical 2=diagonal
+  uniform float uGenVertexCenterX;
+  uniform float uGenVertexCenterY;
+  uniform float uGenVertexMinScale;
+  uniform float uGenVertexMaxScale;
+
+  // ── Pointer vertex effect (applied within radius) ─────────────────────────
+  uniform float uPtrRadius;
+  uniform float uPtrVertexType;
+  uniform bool uPtrVertexEnabled;
+  uniform float uPtrVertexIntensity;
+  uniform float uPtrVertexSpeed;
+  uniform float uPtrVertexFrequency;
+  uniform float uPtrVertexDirection;
+  uniform float uPtrVertexCenterX;
+  uniform float uPtrVertexCenterY;
+  uniform float uPtrVertexMinScale;
+  uniform float uPtrVertexMaxScale;
+  
+  // ============================================================================
+  // FUNCTIONS
+  // ============================================================================
+
+  float getPointerFalloff(vec3 pos, vec2 pointer, float radius) {
+    return smoothstep(radius, 0.0, distance(pos.xy, pointer));
+  }
+
+  // Applies a single vertex displacement effect (shared by both general and pointer).
+  // type: 1=wave 2=vortex 3=ripple  (4=scale is handled separately as a size multiplier)
+  vec3 applyVertexDisplacement(
+    vec3 pos, float type, float intensity, float speed,
+    float frequency, float direction, float cx, float cy
+  ) {
+    if (type < 1.5) {
+      // Wave
+      float waveInput = 0.0;
+      if (direction < 0.5) waveInput = pos.x;
+      else if (direction < 1.5) waveInput = pos.y;
+      else waveInput = pos.x + pos.y;
+      pos.z += sin(waveInput * frequency + u_time * speed) * intensity;
+    } else if (type < 2.5) {
+      // Vortex
+      vec2 center = vec2(cx, cy);
+      vec2 toCenter = pos.xy - center;
+      float angle = intensity * u_time * speed;
+      mat2 rot = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+      pos.xy = center + rot * toCenter;
+    } else if (type < 3.5) {
+      // Ripple
+      vec2 center = vec2(cx, cy);
+      float dist = distance(pos.xy, center);
+      pos.z += sin(dist * frequency - u_time * speed) * intensity;
+    }
+    return pos;
+  }
+
+  // ============================================================================
+  // APPLY ALL VERTEX EFFECTS
+  // ============================================================================
+
+  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {
+    // General — applied globally
+    if (uGenVertexEnabled && uGenVertexType > 0.5 && uGenVertexType < 3.5) {
+      pos = applyVertexDisplacement(
+        pos, uGenVertexType, uGenVertexIntensity, uGenVertexSpeed,
+        uGenVertexFrequency, uGenVertexDirection, uGenVertexCenterX, uGenVertexCenterY
+      );
+    }
+
+    // Pointer — applied within radius with falloff
+    if (uPtrVertexEnabled && uPtrVertexType > 0.5 && uPtrVertexType < 3.5) {
+      float falloff = getPointerFalloff(pos, pointer, uPtrRadius);
+      if (falloff > 0.0) {
+        pos = applyVertexDisplacement(
+          pos, uPtrVertexType, uPtrVertexIntensity * falloff, uPtrVertexSpeed,
+          uPtrVertexFrequency, uPtrVertexDirection, uPtrVertexCenterX, uPtrVertexCenterY
+        );
+      }
+    }
+
+    return pos;
+  }
+
+  // Returns the point-size multiplier from scale effects (gen or pointer).
+  float getScaleMultiplier(vec3 pos, vec2 pointer) {
+    float m = 1.0;
+    // General scale
+    if (uGenVertexEnabled && uGenVertexType > 3.5) {
+      m = mix(uGenVertexMinScale, uGenVertexMaxScale, uGenVertexIntensity);
+    }
+    // Pointer scale (overrides with falloff)
+    if (uPtrVertexEnabled && uPtrVertexType > 3.5) {
+      float falloff = getPointerFalloff(pos, pointer, uPtrRadius);
+      if (falloff > 0.0) {
+        m = mix(uPtrVertexMinScale, uPtrVertexMaxScale, falloff * uPtrVertexIntensity);
+      }
+    }
+    return m;
+  }
+`;

package/dist/utils/CameraSingleton.d.ts

@@ -0,0 +1,43 @@
+import { PerspectiveCamera, Vector3, Euler } from 'three';
+import type { Camera } from 'three';
+import type { Vector3Array, AnchorPosition, AnchorOffset } from "@3driseai/3drise-core";
+declare class CameraSingleton {
+    private static instance;
+    private camera;
+    private callbacks;
+    private cameraMoveCallbacks;
+    private lastPosition;
+    private lastRotation;
+    constructor();
+    static getInstance(): CameraSingleton;
+    animateCameraPosition(position: Vector3Array): Promise<void>;
+    setCamera(camera: PerspectiveCamera): void;
+    getCamera(): PerspectiveCamera | null;
+    getPosition(): Vector3;
+    getRotation(): Euler;
+    isSynced(position: Vector3Array, orientation: Vector3Array | [number, number, number, number]): boolean;
+    getWorldDirection(): Vector3;
+    getFOV(): number;
+    subscribe(callback: () => void): () => void;
+    private notifyCallbacks;
+    isAvailable(): boolean;
+    getDistanceToTarget(target: Vector3): number;
+    lookAt(target: Vector3): void;
+    calculateVisibleSize(targetDepth?: number, cam?: Camera): {
+        width: number;
+        height: number;
+    };
+    getCurrentViewportBounds(cam?: Camera): {
+        topLeft: Vector3;
+        topRight: Vector3;
+        bottomLeft: Vector3;
+        bottomRight: Vector3;
+        center: Vector3;
+    };
+    getAnchorPosition(anchor: AnchorPosition, targetDepth?: number, offset?: AnchorOffset, padding?: number): Vector3;
+    onCameraMove(callback: (position: Vector3, rotation: Euler) => void): () => void;
+    checkCameraMovement(epsilon?: number): boolean;
+}
+export declare const cameraManager: CameraSingleton;
+export default cameraManager;
+//# sourceMappingURL=CameraSingleton.d.ts.map

package/dist/utils/CameraSingleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CameraSingleton.d.ts","sourceRoot":"","sources":["../../src/utils/CameraSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAsB,OAAO,EAAE,KAAK,EAAc,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAExF,cAAM,eAAe;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,YAAY,CAAe;;IAEnC,MAAM,CAAC,WAAW,IAAI,eAAe;IAMrC,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB5D,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAM1C,SAAS,IAAI,iBAAiB,GAAG,IAAI;IACrC,WAAW,IAAI,OAAO;IACtB,WAAW,IAAI,KAAK;IACpB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAyBvG,iBAAiB,IAAI,OAAO;IAI5B,MAAM,IAAI,MAAM;IAChB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,OAAO,CAAC,eAAe;IAGvB,WAAW,IAAI,OAAO;IACtB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAG5C,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAM7B,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG;QAC9C,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAClB;IAeT,wBAAwB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG;QAC5B,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,WAAW,EAAE,OAAO,CAAC;QACrB,MAAM,EAAE,OAAO,CAAC;KACnB;IAqBT,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,GAAE,MAAU,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,OAAO,GAAE,MAAU,GAAG,OAAO;IA6CvH,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAIhF,mBAAmB,CAAC,OAAO,GAAE,MAAc,GAAG,OAAO;CAiBxD;AACD,eAAO,MAAM,aAAa,EAAE,eAA+C,CAAC;AAC5E,eAAe,aAAa,CAAC"}