@3driseai/3drise-core 1.0.1

package/dist/shaders/MeshEffectsMaterial.d.ts

@@ -0,0 +1,278 @@
+import { Vector2, Color } from "three";
+import type { Texture } from 'three';
+export interface MeshEffectsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uTexture: {
+        value: Texture | null;
+    };
+    uTargetTexture: {
+        value: Texture | null;
+    };
+    uMorphProgress: {
+        value: number;
+    };
+    uHasTexture: {
+        value: boolean;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uPointerEffectRadius: {
+        value: number;
+    };
+    uNormalizationScale: {
+        value: number;
+    };
+    uRippleEnabled: {
+        value: boolean;
+    };
+    uRippleIntensity: {
+        value: number;
+    };
+    uRippleSpeed: {
+        value: number;
+    };
+    uDisplacementEnabled: {
+        value: boolean;
+    };
+    uDisplacementIntensity: {
+        value: number;
+    };
+    uScaleEnabled: {
+        value: boolean;
+    };
+    uScaleIntensity: {
+        value: number;
+    };
+    uMinScale: {
+        value: number;
+    };
+    uMaxScale: {
+        value: number;
+    };
+    uVortexEnabled: {
+        value: boolean;
+    };
+    uVortexIntensity: {
+        value: number;
+    };
+    uVortexSpeed: {
+        value: number;
+    };
+    uWaveEnabled: {
+        value: boolean;
+    };
+    uWaveIntensity: {
+        value: number;
+    };
+    uWaveFrequency: {
+        value: number;
+    };
+    uGlowEnabled: {
+        value: boolean;
+    };
+    uGlowIntensity: {
+        value: number;
+    };
+    uGlowColor: {
+        value: Color;
+    };
+    uColorShiftEnabled: {
+        value: boolean;
+    };
+    uColorShiftIntensity: {
+        value: number;
+    };
+    uColorShiftTarget: {
+        value: Color;
+    };
+    uBrightnessEnabled: {
+        value: boolean;
+    };
+    uBrightnessIntensity: {
+        value: number;
+    };
+    uPulseEnabled: {
+        value: boolean;
+    };
+    uPulseIntensity: {
+        value: number;
+    };
+    uPulseSpeed: {
+        value: number;
+    };
+    uGeneralWaveEnabled: {
+        value: boolean;
+    };
+    uGeneralWaveIntensity: {
+        value: number;
+    };
+    uGeneralWaveFrequency: {
+        value: number;
+    };
+    uGeneralWaveSpeed: {
+        value: number;
+    };
+    uGeneralWaveDirection: {
+        value: number;
+    };
+    uGeneralVortexEnabled: {
+        value: boolean;
+    };
+    uGeneralVortexIntensity: {
+        value: number;
+    };
+    uGeneralVortexSpeed: {
+        value: number;
+    };
+    uGeneralVortexCenterX: {
+        value: number;
+    };
+    uGeneralVortexCenterY: {
+        value: number;
+    };
+    uGeneralRippleEnabled: {
+        value: boolean;
+    };
+    uGeneralRippleIntensity: {
+        value: number;
+    };
+    uGeneralRippleSpeed: {
+        value: number;
+    };
+    uGeneralRippleCenterX: {
+        value: number;
+    };
+    uGeneralRippleCenterY: {
+        value: number;
+    };
+    uGeneralGrayscaleEnabled: {
+        value: boolean;
+    };
+    uGeneralGrayscaleMode: {
+        value: number;
+    };
+    uGeneralGrayscaleIntensity: {
+        value: number;
+    };
+    uGeneralGrayscaleContrast: {
+        value: number;
+    };
+    uGeneralGrayscaleBrightness: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveFreq: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveDir: {
+        value: number;
+    };
+    uGeneralGrayscalePulseSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleCenterX: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleCenterY: {
+        value: number;
+    };
+    uPointerGrayscaleEnabled: {
+        value: boolean;
+    };
+    uPointerGrayscaleIntensity: {
+        value: number;
+    };
+    uPointerGrayscaleContrast: {
+        value: number;
+    };
+    uPointerGrayscaleBrightness: {
+        value: number;
+    };
+}
+declare const MeshEffectsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    uTexture: any;
+    uTargetTexture: any;
+    uHasTexture: false;
+    u_pointer: Vector2;
+    uColor: Color;
+    uMorphProgress: number;
+    uNormalizationScale: number;
+    uOpacity: number;
+    uPointerEffectRadius: number;
+    uRippleEnabled: false;
+    uRippleIntensity: number;
+    uRippleSpeed: number;
+    uDisplacementEnabled: false;
+    uDisplacementIntensity: number;
+    uScaleEnabled: false;
+    uScaleIntensity: number;
+    uMinScale: number;
+    uMaxScale: number;
+    uVortexEnabled: false;
+    uVortexIntensity: number;
+    uVortexSpeed: number;
+    uWaveEnabled: false;
+    uWaveIntensity: number;
+    uWaveFrequency: number;
+    uGlowEnabled: false;
+    uGlowIntensity: number;
+    uGlowColor: Color;
+    uColorShiftEnabled: false;
+    uColorShiftIntensity: number;
+    uColorShiftTarget: Color;
+    uBrightnessEnabled: false;
+    uBrightnessIntensity: number;
+    uPulseEnabled: false;
+    uPulseIntensity: number;
+    uPulseSpeed: number;
+    uGeneralWaveEnabled: false;
+    uGeneralWaveIntensity: number;
+    uGeneralWaveFrequency: number;
+    uGeneralWaveSpeed: number;
+    uGeneralWaveDirection: number;
+    uGeneralVortexEnabled: false;
+    uGeneralVortexIntensity: number;
+    uGeneralVortexSpeed: number;
+    uGeneralVortexCenterX: number;
+    uGeneralVortexCenterY: number;
+    uGeneralRippleEnabled: false;
+    uGeneralRippleIntensity: number;
+    uGeneralRippleSpeed: number;
+    uGeneralRippleCenterX: number;
+    uGeneralRippleCenterY: number;
+    uGeneralGrayscaleEnabled: false;
+    uGeneralGrayscaleMode: number;
+    uGeneralGrayscaleIntensity: number;
+    uGeneralGrayscaleContrast: number;
+    uGeneralGrayscaleBrightness: number;
+    uGeneralGrayscaleWaveFreq: number;
+    uGeneralGrayscaleWaveSpeed: number;
+    uGeneralGrayscaleWaveDir: number;
+    uGeneralGrayscalePulseSpeed: number;
+    uGeneralGrayscaleRippleSpeed: number;
+    uGeneralGrayscaleRippleCenterX: number;
+    uGeneralGrayscaleRippleCenterY: number;
+    uPointerGrayscaleEnabled: false;
+    uPointerGrayscaleIntensity: number;
+    uPointerGrayscaleContrast: number;
+    uPointerGrayscaleBrightness: number;
+}> & {
+    key: string;
+};
+export { MeshEffectsMaterial };
+//# sourceMappingURL=MeshEffectsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MeshEffectsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/MeshEffectsMaterial.ts"],"names":[],"mappings":"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"}

package/dist/shaders/MeshEffectsMaterial.js

@@ -0,0 +1,312 @@
+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 for mesh geometry
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+varying vec2 vUV;
+varying vec2 vTexCoords;
+uniform float uMorphProgress;
+uniform float uNormalizationScale;
+
+void main() {
+  // Pass UV to fragment shader
+  vUV = uv;
+  
+  vec3 pos = position;
+  
+  #include <begin_vertex>
+  
+  vec3 morphedPos = position;
+  
+  // Apply general effects first (global, always active)
+  
+  // General Wave effect
+  if (uGeneralWaveEnabled) {
+    float waveInput = 0.0;
+    if (uGeneralWaveDirection < 0.5) {
+      // Horizontal
+      waveInput = morphedPos.x;
+    } else if (uGeneralWaveDirection < 1.5) {
+      // Vertical
+      waveInput = morphedPos.y;
+    } else {
+      // Diagonal
+      waveInput = morphedPos.x + morphedPos.y;
+    }
+    morphedPos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+  }
+  
+  // General Vortex effect
+  if (uGeneralVortexEnabled) {
+    vec2 generalCenter = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);
+    vec2 toCenter = morphedPos.xy - generalCenter;
+    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = generalCenter + rotation * toCenter;
+  }
+  
+  // General Ripple effect
+  if (uGeneralRippleEnabled) {
+    morphedPos = applyGeneralRipple(morphedPos);
+  }
+  
+  // Apply pointer effects
+  // Scale pointer to match normalized position space
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(morphedPos.xy, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  // Ripple effect
+  if (uRippleEnabled && falloff > 0.0) {
+    float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;
+    morphedPos.z += wave * falloff * 0.5;
+  }
+  
+  // Displacement effect
+  if (uDisplacementEnabled && falloff > 0.0) {
+    vec2 dir = normalize(morphedPos.xy - scaledPointer);
+    morphedPos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+  }
+  
+  // Vortex effect
+  if (uVortexEnabled && falloff > 0.0) {
+    vec2 toPointer = morphedPos.xy - scaledPointer;
+    float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = scaledPointer + rotation * toPointer;
+  }
+  
+  // Wave effect
+  if (uWaveEnabled && falloff > 0.0) {
+    morphedPos.z += sin(morphedPos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;
+  }
+  
+  vTexCoords = morphedPos.xy;
+  
+  // Use the transformed position
+  transformed = morphedPos;
+  
+  #include <project_vertex>
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <worldpos_vertex>
+  #include <fog_vertex>
+}
+`;
+// Fragment shader for mesh geometry
+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;
+// Pointer effects
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+// Fragment effects
+uniform bool uGlowEnabled;
+uniform float uGlowIntensity;
+uniform vec3 uGlowColor;
+uniform bool uColorShiftEnabled;
+uniform float uColorShiftIntensity;
+uniform vec3 uColorShiftTarget;
+uniform bool uBrightnessEnabled;
+uniform float uBrightnessIntensity;
+uniform bool uPulseEnabled;
+uniform float uPulseIntensity;
+uniform float uPulseSpeed;
+// Grayscale effects
+uniform bool uGeneralGrayscaleEnabled;
+uniform float uGeneralGrayscaleMode;
+uniform float uGeneralGrayscaleIntensity;
+uniform float uGeneralGrayscaleContrast;
+uniform float uGeneralGrayscaleBrightness;
+uniform float uGeneralGrayscaleWaveFreq;
+uniform float uGeneralGrayscaleWaveSpeed;
+uniform float uGeneralGrayscaleWaveDir;
+uniform float uGeneralGrayscalePulseSpeed;
+uniform float uGeneralGrayscaleRippleSpeed;
+uniform float uGeneralGrayscaleRippleCenterX;
+uniform float uGeneralGrayscaleRippleCenterY;
+uniform bool uPointerGrayscaleEnabled;
+uniform float uPointerGrayscaleIntensity;
+uniform float uPointerGrayscaleContrast;
+uniform float uPointerGrayscaleBrightness;
+
+void main() {
+  vec4 outColor;
+  
+  if (uHasTexture) {
+    // Texture-based rendering using standard UVs
+    vec4 colorA = texture2D(uTexture, vUV) * vec4(uColor, 1.0);
+    vec4 colorB = texture2D(uTargetTexture, vUV) * vec4(uColor, 1.0);
+    outColor = mix(colorA, colorB, uMorphProgress);
+  } else {
+    // No texture - use solid color
+    outColor = vec4(uColor, 1.0);
+  }
+  
+  // Apply pointer fragment effects
+  // Scale pointer to match normalized position space
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(vTexCoords, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  // Glow effect
+  if (uGlowEnabled && falloff > 0.0) {
+    outColor.rgb += uGlowColor * uGlowIntensity * falloff;
+  }
+  
+  // Brightness effect
+  if (uBrightnessEnabled && falloff > 0.0) {
+    outColor.rgb *= (1.0 + uBrightnessIntensity * falloff);
+  }
+  
+  // Pulse effect
+  if (uPulseEnabled && falloff > 0.0) {
+    float pulse = sin(u_time * uPulseSpeed) * 0.5 + 0.5;
+    outColor.rgb += vec3(pulse * uPulseIntensity * falloff);
+  }
+  
+  // Color shift effect
+  if (uColorShiftEnabled && falloff > 0.0) {
+    outColor.rgb = mix(outColor.rgb, uColorShiftTarget, uColorShiftIntensity * falloff);
+  }
+  
+  // Pointer Grayscale effect
+  if (uPointerGrayscaleEnabled && falloff > 0.0) {
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uPointerGrayscaleContrast + 0.5 + uPointerGrayscaleBrightness;
+    vec3 grayscaleColor = vec3(gray);
+    outColor.rgb = mix(outColor.rgb, grayscaleColor, uPointerGrayscaleIntensity * falloff);
+  }
+  
+  // General Grayscale effect (applied globally with modes)
+  if (uGeneralGrayscaleEnabled) {
+    float grayscaleFactor = 0.0;
+    
+    if (uGeneralGrayscaleMode < 0.5) {
+      // Mode 0: Static
+      grayscaleFactor = uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 1.5) {
+      // Mode 1: Wave
+      float wavePos = 0.0;
+      if (uGeneralGrayscaleWaveDir < 0.5) {
+        // Horizontal
+        wavePos = vTexCoords.x;
+      } else if (uGeneralGrayscaleWaveDir < 1.5) {
+        // Vertical
+        wavePos = vTexCoords.y;
+      } else {
+        // Diagonal
+        wavePos = vTexCoords.x + vTexCoords.y;
+      }
+      grayscaleFactor = (sin(wavePos * uGeneralGrayscaleWaveFreq + u_time * uGeneralGrayscaleWaveSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 2.5) {
+      // Mode 2: Pulse
+      grayscaleFactor = (sin(u_time * uGeneralGrayscalePulseSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else {
+      // Mode 3: Ripple
+      vec2 rippleCenter = vec2(uGeneralGrayscaleRippleCenterX, uGeneralGrayscaleRippleCenterY);
+      float rippleDist = distance(vTexCoords, rippleCenter);
+      grayscaleFactor = (sin(rippleDist * 5.0 - u_time * uGeneralGrayscaleRippleSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    }
+    
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uGeneralGrayscaleContrast + 0.5 + uGeneralGrayscaleBrightness;
+    vec3 grayscaleColor = vec3(gray);
+    outColor.rgb = mix(outColor.rgb, grayscaleColor, grayscaleFactor);
+  }
+  
+  outColor.a *= uOpacity;
+  
+  gl_FragColor = outColor;
+  
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+// Create the shader material with uniforms
+const MeshEffectsMaterial = shaderMaterial({
+    u_time: 0,
+    uTexture: null,
+    uTargetTexture: null,
+    uHasTexture: false,
+    u_pointer: new Vector2(),
+    uColor: new Color(1.0, 1.0, 1.0),
+    uMorphProgress: 0.0,
+    uNormalizationScale: 1.0,
+    uOpacity: 1.0,
+    // Pointer effects
+    uPointerEffectRadius: 2.5,
+    // Vertex effects
+    uRippleEnabled: false,
+    uRippleIntensity: 0.5,
+    uRippleSpeed: 2.0,
+    uDisplacementEnabled: false,
+    uDisplacementIntensity: 0.5,
+    uScaleEnabled: false,
+    uScaleIntensity: 0.5,
+    uMinScale: 0.5,
+    uMaxScale: 2.0,
+    uVortexEnabled: false,
+    uVortexIntensity: 0.5,
+    uVortexSpeed: 1.0,
+    uWaveEnabled: false,
+    uWaveIntensity: 0.5,
+    uWaveFrequency: 5.0,
+    // Fragment effects
+    uGlowEnabled: false,
+    uGlowIntensity: 0.5,
+    uGlowColor: new Color(1.0, 1.0, 1.0),
+    uColorShiftEnabled: false,
+    uColorShiftIntensity: 0.5,
+    uColorShiftTarget: new Color(1.0, 0.4, 0.0),
+    uBrightnessEnabled: false,
+    uBrightnessIntensity: 0.5,
+    uPulseEnabled: false,
+    uPulseIntensity: 0.5,
+    uPulseSpeed: 2.0,
+    // General effects
+    uGeneralWaveEnabled: false,
+    uGeneralWaveIntensity: 0.3,
+    uGeneralWaveFrequency: 3.0,
+    uGeneralWaveSpeed: 1.0,
+    uGeneralWaveDirection: 0.0,
+    uGeneralVortexEnabled: false,
+    uGeneralVortexIntensity: 0.5,
+    uGeneralVortexSpeed: 0.5,
+    uGeneralVortexCenterX: 0.0,
+    uGeneralVortexCenterY: 0.0,
+    uGeneralRippleEnabled: false,
+    uGeneralRippleIntensity: 0.3,
+    uGeneralRippleSpeed: 2.0,
+    uGeneralRippleCenterX: 0.0,
+    uGeneralRippleCenterY: 0.0,
+    // Grayscale effects
+    uGeneralGrayscaleEnabled: false,
+    uGeneralGrayscaleMode: 0.0,
+    uGeneralGrayscaleIntensity: 1.0,
+    uGeneralGrayscaleContrast: 1.0,
+    uGeneralGrayscaleBrightness: 0.0,
+    uGeneralGrayscaleWaveFreq: 3.0,
+    uGeneralGrayscaleWaveSpeed: 1.0,
+    uGeneralGrayscaleWaveDir: 0.0,
+    uGeneralGrayscalePulseSpeed: 2.0,
+    uGeneralGrayscaleRippleSpeed: 2.0,
+    uGeneralGrayscaleRippleCenterX: 0.0,
+    uGeneralGrayscaleRippleCenterY: 0.0,
+    uPointerGrayscaleEnabled: false,
+    uPointerGrayscaleIntensity: 1.0,
+    uPointerGrayscaleContrast: 1.0,
+    uPointerGrayscaleBrightness: 0.0,
+}, vertexShader, fragmentShader);
+extend({ MeshEffectsMaterial });
+export { MeshEffectsMaterial };

package/dist/shaders/MorphingSimulation.d.ts

@@ -0,0 +1,17 @@
+import { ShaderMaterial } from "three";
+declare class MorphSimulationMaterial extends ShaderMaterial {
+    constructor(size: number, defaultSourceData: Float32Array, defaultTargetData: Float32Array);
+    updatePositions(sourceData: Float32Array, targetData: Float32Array, size: number): void;
+    getLinesAndColumns(): {
+        source: {
+            lines: number;
+            columns: number;
+        };
+        target: {
+            lines: number;
+            columns: number;
+        };
+    };
+}
+export default MorphSimulationMaterial;
+//# sourceMappingURL=MorphingSimulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MorphingSimulation.d.ts","sourceRoot":"","sources":["../../src/shaders/MorphingSimulation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,cAAc,EAAW,MAAM,OAAO,CAAC;AA0BpF,cAAM,uBAAwB,SAAQ,cAAc;gBACpC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY;IAkB1F,eAAe,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAYvF,kBAAkB,IAAI;QACV,MAAM,EAAE;YACJ,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,CAAC;SACnB,CAAC;QACF,MAAM,EAAE;YACJ,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,CAAC;SACnB,CAAC;KACL;CAOZ;AACD,eAAe,uBAAuB,CAAC"}

package/dist/shaders/MorphingSimulation.js

@@ -0,0 +1,66 @@
+import { DataTexture, FloatType, RGBAFormat, ShaderMaterial, Vector2 } from "three";
+// Simulation shaders for morphing between shapes
+const morphSimulationVertexShader = `
+void main() {
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+`;
+const morphSimulationFragmentShader = `
+uniform float u_time;
+uniform sampler2D uPositionsSource;
+uniform sampler2D uPositionsTarget;
+uniform vec2 resolution;
+uniform float uMorphProgress;
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / resolution.xy;
+  
+  vec4 positionSource = texture2D(uPositionsSource, uv);
+  vec4 positionTarget = texture2D(uPositionsTarget, uv);
+  
+  // Use the morphProgress uniform for smooth interpolation
+  vec4 finalPosition = mix(positionSource, positionTarget, uMorphProgress);
+  
+  gl_FragColor = finalPosition;
+}
+`;
+class MorphSimulationMaterial extends ShaderMaterial {
+    constructor(size, defaultSourceData, defaultTargetData) {
+        const sourceTexture = new DataTexture(defaultSourceData, size, size, RGBAFormat, FloatType);
+        sourceTexture.needsUpdate = true;
+        const targetTexture = new DataTexture(defaultTargetData, size, size, RGBAFormat, FloatType);
+        targetTexture.needsUpdate = true;
+        const uniforms = {
+            u_time: { value: 0.0 },
+            uPositionsSource: { value: sourceTexture },
+            uPositionsTarget: { value: targetTexture },
+            uMorphProgress: { value: 0.0 },
+            resolution: { value: new Vector2(size, size) }
+        };
+        super({
+            uniforms,
+            vertexShader: morphSimulationVertexShader,
+            fragmentShader: morphSimulationFragmentShader,
+        });
+    }
+    updatePositions(sourceData, targetData, size) {
+        // Update source texture
+        if (this.uniforms.uPositionsSource.value) {
+            this.uniforms.uPositionsSource.value.image.data = sourceData;
+            this.uniforms.uPositionsSource.value.needsUpdate = true;
+        }
+        // Update target texture
+        if (this.uniforms.uPositionsTarget.value) {
+            this.uniforms.uPositionsTarget.value.image.data = targetData;
+            this.uniforms.uPositionsTarget.value.needsUpdate = true;
+        }
+    }
+    getLinesAndColumns() {
+        const sourceTexture = this.uniforms.uPositionsSource.value;
+        const targetTexture = this.uniforms.uPositionsTarget.value;
+        const source = { lines: sourceTexture.image.height, columns: sourceTexture.image.width };
+        const target = { lines: targetTexture.image.height, columns: targetTexture.image.width };
+        return { source, target };
+    }
+}
+export default MorphSimulationMaterial;