core-vfx 0.0.3 → 0.0.4

package/README.md

@@ -27,16 +27,16 @@ npm install three @react-three/fiber react
 ## Quick Start
 
 ```tsx
-import { Canvas } from '@react-three/fiber';
-import { VFXParticles, Appearance, EmitterShape } from 'r3f-vfx';
-import * as THREE from 'three/webgpu';
+import { Canvas } from '@react-three/fiber'
+import { VFXParticles, Appearance, EmitterShape } from 'r3f-vfx'
+import * as THREE from 'three/webgpu'
 
 function App() {
   return (
     <Canvas>
       <VFXParticles debug />
     </Canvas>
-  );
+  )
 }
 ```
 
@@ -114,8 +114,8 @@ The main particle system component.
 
 ```ts
 interface StretchConfig {
-  factor: number; // Stretch multiplier
-  maxStretch: number; // Maximum stretch amount
+  factor: number // Stretch multiplier
+  maxStretch: number // Maximum stretch amount
 }
 ```
 
@@ -127,9 +127,9 @@ interface StretchConfig {
 
 ```ts
 interface TurbulenceConfig {
-  intensity: number; // Turbulence strength
-  frequency: number; // Noise scale
-  speed: number; // Animation speed
+  intensity: number // Turbulence strength
+  frequency: number // Noise scale
+  speed: number // Animation speed
 }
 ```
 
@@ -142,11 +142,11 @@ interface TurbulenceConfig {
 
 ```ts
 interface AttractorConfig {
-  position: [x, y, z];
-  strength: number; // Positive = attract, negative = repel
-  radius?: number; // 0 = infinite range
-  type?: 'point' | 'vortex';
-  axis?: [x, y, z]; // Vortex rotation axis
+  position: [x, y, z]
+  strength: number // Positive = attract, negative = repel
+  radius?: number // 0 = infinite range
+  type?: 'point' | 'vortex'
+  axis?: [x, y, z] // Vortex rotation axis
 }
 ```
 
@@ -158,11 +158,11 @@ interface AttractorConfig {
 
 ```ts
 interface CollisionConfig {
-  plane: { y: number }; // Plane Y position
-  bounce?: number; // Bounce factor (0-1)
-  friction?: number; // Horizontal friction
-  die?: boolean; // Kill on collision
-  sizeBasedGravity?: number; // Gravity multiplier by size
+  plane: { y: number } // Plane Y position
+  bounce?: number // Bounce factor (0-1)
+  friction?: number // Horizontal friction
+  die?: boolean // Kill on collision
+  sizeBasedGravity?: number // Gravity multiplier by size
 }
 ```
 
@@ -180,10 +180,10 @@ All curves use Bezier spline format:
 ```ts
 interface CurveData {
   points: Array<{
-    pos: [x, y]; // Position (x: 0-1 progress, y: value)
-    handleIn?: [x, y]; // Bezier handle in (offset)
-    handleOut?: [x, y]; // Bezier handle out (offset)
-  }>;
+    pos: [x, y] // Position (x: 0-1 progress, y: value)
+    handleIn?: [x, y] // Bezier handle in (offset)
+    handleOut?: [x, y] // Bezier handle out (offset)
+  }>
 }
 ```
 
@@ -205,21 +205,21 @@ interface CurveData {
 | `alphaTestNode`  | `NodeFunction` | Alpha test/discard             |
 
 ```ts
-type NodeFunction = (data: ParticleData, defaultColor?: Node) => Node;
+type NodeFunction = (data: ParticleData, defaultColor?: Node) => Node
 
 interface ParticleData {
-  progress: Node; // 0 → 1 over lifetime
-  lifetime: Node; // 1 → 0 over lifetime
-  position: Node; // vec3 world position
-  velocity: Node; // vec3 velocity
-  size: Node; // float size
-  rotation: Node; // vec3 rotation
-  colorStart: Node; // vec3 start color
-  colorEnd: Node; // vec3 end color
-  color: Node; // vec3 interpolated color
-  intensifiedColor: Node; // color × intensity
-  shapeMask: Node; // float alpha mask
-  index: Node; // particle index
+  progress: Node // 0 → 1 over lifetime
+  lifetime: Node // 1 → 0 over lifetime
+  position: Node // vec3 world position
+  velocity: Node // vec3 velocity
+  size: Node // float size
+  rotation: Node // vec3 rotation
+  colorStart: Node // vec3 start color
+  colorEnd: Node // vec3 end color
+  color: Node // vec3 interpolated color
+  intensifiedColor: Node // color × intensity
+  shapeMask: Node // float alpha mask
+  index: Node // particle index
 }
 ```
 
@@ -232,8 +232,8 @@ interface ParticleData {
 
 ```ts
 interface FlipbookConfig {
-  rows: number;
-  columns: number;
+  rows: number
+  columns: number
 }
 ```
 
@@ -276,13 +276,13 @@ Decoupled emitter component that links to a VFXParticles system.
 
 ```ts
 interface VFXEmitterAPI {
-  emit(): boolean; // Emit at current position
-  burst(count?: number): boolean; // Burst emit
-  start(): void; // Start auto-emission
-  stop(): void; // Stop auto-emission
-  isEmitting: boolean; // Current state
-  getParticleSystem(): ParticleAPI;
-  group: THREE.Group; // The group element
+  emit(): boolean // Emit at current position
+  burst(count?: number): boolean // Burst emit
+  start(): void // Start auto-emission
+  stop(): void // Stop auto-emission
+  isEmitting: boolean // Current state
+  getParticleSystem(): ParticleAPI
+  group: THREE.Group // The group element
 }
 ```
 
@@ -292,13 +292,13 @@ Programmatic emitter control.
 
 ```tsx
 function MyComponent() {
-  const { emit, burst, start, stop } = useVFXEmitter('sparks');
+  const { emit, burst, start, stop } = useVFXEmitter('sparks')
 
   const handleClick = () => {
-    burst([0, 1, 0], 100, { colorStart: ['#ff0000'] });
-  };
+    burst([0, 1, 0], 100, { colorStart: ['#ff0000'] })
+  }
 
-  return <mesh onClick={handleClick}>...</mesh>;
+  return <mesh onClick={handleClick}>...</mesh>
 }
 ```
 
@@ -310,18 +310,18 @@ interface UseVFXEmitterResult {
     position?: [x, y, z],
     count?: number,
     overrides?: SpawnOverrides
-  ): boolean;
+  ): boolean
   burst(
     position?: [x, y, z],
     count?: number,
     overrides?: SpawnOverrides
-  ): boolean;
-  start(): boolean;
-  stop(): boolean;
-  clear(): boolean;
-  isEmitting(): boolean;
-  getUniforms(): Record<string, { value: unknown }>;
-  getParticles(): ParticleAPI;
+  ): boolean
+  start(): boolean
+  stop(): boolean
+  clear(): boolean
+  isEmitting(): boolean
+  getUniforms(): Record<string, { value: unknown }>
+  getParticles(): ParticleAPI
 }
 ```
 
@@ -330,17 +330,17 @@ interface UseVFXEmitterResult {
 Zustand store for managing particle systems.
 
 ```ts
-const store = useVFXStore();
+const store = useVFXStore()
 
 // Access registered particle systems
-const sparks = store.getParticles('sparks');
-sparks?.spawn(0, 0, 0, 50);
+const sparks = store.getParticles('sparks')
+sparks?.spawn(0, 0, 0, 50)
 
 // Store methods
-store.emit('sparks', { x: 0, y: 0, z: 0, count: 20 });
-store.start('sparks');
-store.stop('sparks');
-store.clear('sparks');
+store.emit('sparks', { x: 0, y: 0, z: 0, count: 20 })
+store.start('sparks')
+store.stop('sparks')
+store.clear('sparks')
 ```
 
 ## Examples
@@ -388,9 +388,9 @@ store.clear('sparks');
 ### 3D Geometry Particles
 
 ```tsx
-import { BoxGeometry } from 'three/webgpu';
+import { BoxGeometry } from 'three/webgpu'
 
-<VFXParticles
+;<VFXParticles
   geometry={new BoxGeometry(1, 1, 1)}
   maxParticles={500}
   size={[0.1, 0.2]}
@@ -404,7 +404,7 @@ import { BoxGeometry } from 'three/webgpu';
   ]}
   shadow={true}
   lighting={Lighting.STANDARD}
-/>;
+/>
 ```
 
 ### Turbulent Smoke
@@ -464,7 +464,7 @@ import type {
   TurbulenceConfig,
   CollisionConfig,
   AttractorConfig,
-} from 'r3f-vfx';
+} from 'r3f-vfx'
 ```
 
 ## License

package/dist/index.d.ts

@@ -250,6 +250,8 @@ declare const DEFAULT_LINEAR_CURVE: {
         handleOut?: undefined;
     })[];
 };
+declare const createDefaultCurveTexture: () => THREE.DataTexture;
+declare const loadCurveTextureFromPath: (path: string, existingTexture?: THREE.DataTexture) => Promise<THREE.DataTexture>;
 
 type ParticleStorageArrays = {
     positions: StorageBufferNode;
@@ -257,11 +259,18 @@ type ParticleStorageArrays = {
     lifetimes: StorageBufferNode;
     fadeRates: StorageBufferNode;
     particleSizes: StorageBufferNode;
-    particleRotations: StorageBufferNode;
-    particleColorStarts: StorageBufferNode;
-    particleColorEnds: StorageBufferNode;
+    particleRotations: StorageBufferNode | null;
+    particleColorStarts: StorageBufferNode | null;
+    particleColorEnds: StorageBufferNode | null;
 };
 type ParticleUniforms = Record<string, Node>;
+type ShaderFeatures = {
+    turbulence: boolean;
+    attractors: boolean;
+    collision: boolean;
+    rotation: boolean;
+    perParticleColor: boolean;
+};
 type MaterialOptions = {
     alphaMap: THREE.Texture | null;
     flipbook: {
@@ -299,9 +308,9 @@ declare const createSpawnCompute: (storage: ParticleStorageArrays, uniforms: Par
 
 /**
  * Creates the update compute shader that simulates particle physics each frame.
- * Handles gravity, turbulence, attractors, collision, rotation, and lifetime.
+ * Features can be disabled to generate a simpler/faster shader.
  */
-declare const createUpdateCompute: (storage: ParticleStorageArrays, uniforms: ParticleUniforms, curveTexture: THREE.DataTexture, maxParticles: number) => THREE.ComputeNode;
+declare const createUpdateCompute: (storage: ParticleStorageArrays, uniforms: ParticleUniforms, curveTexture: THREE.DataTexture, maxParticles: number, features?: Partial<ShaderFeatures>) => THREE.ComputeNode;
 
 /**
  * Creates the particle material (either SpriteNodeMaterial or MeshNodeMaterial).
@@ -309,4 +318,4 @@ declare const createUpdateCompute: (storage: ParticleStorageArrays, uniforms: Pa
  */
 declare const createParticleMaterial: (storage: ParticleStorageArrays, uniforms: ParticleUniforms, curveTexture: THREE.DataTexture, options: MaterialOptions) => THREE.SpriteNodeMaterial | THREE.MeshBasicNodeMaterial | THREE.MeshStandardNodeMaterial | THREE.MeshPhysicalNodeMaterial;
 
-export { Appearance, type AttractorConfig, AttractorType, type BaseParticleProps, Blending, CURVE_RESOLUTION, type CollisionConfig, type CoreState, type CurveData, type CurvePoint, DEFAULT_LINEAR_CURVE, Easing, EmitterShape, type FlipbookConfig, type FrictionConfig, Lighting, MAX_ATTRACTORS, type MaterialOptions, type ParticleData, type ParticleStorageArrays, type ParticleUniforms, type Rotation3DInput, type StretchConfig, type TurbulenceConfig, axisToNumber, bakeCurveToArray, coreStore, createCombinedCurveTexture, createInitCompute, createParticleMaterial, createSpawnCompute, createUpdateCompute, easingToType, evaluateBezierSegment, hexToRgb, lifetimeToFadeRate, sampleCurveAtX, selectColor, toRange, toRotation3D };
+export { Appearance, type AttractorConfig, AttractorType, type BaseParticleProps, Blending, CURVE_RESOLUTION, type CollisionConfig, type CoreState, type CurveData, type CurvePoint, DEFAULT_LINEAR_CURVE, Easing, EmitterShape, type FlipbookConfig, type FrictionConfig, Lighting, MAX_ATTRACTORS, type MaterialOptions, type ParticleData, type ParticleStorageArrays, type ParticleUniforms, type Rotation3DInput, type ShaderFeatures, type StretchConfig, type TurbulenceConfig, axisToNumber, bakeCurveToArray, coreStore, createCombinedCurveTexture, createDefaultCurveTexture, createInitCompute, createParticleMaterial, createSpawnCompute, createUpdateCompute, easingToType, evaluateBezierSegment, hexToRgb, lifetimeToFadeRate, loadCurveTextureFromPath, sampleCurveAtX, selectColor, toRange, toRotation3D };

package/dist/index.js

@@ -301,8 +301,14 @@ var lifetimeToFadeRate = (seconds) => 1 / seconds;
 import * as THREE2 from "three/webgpu";
 var evaluateBezierSegment = (t, p0, p1, h0Out, h1In) => {
   const cp0 = p0;
-  const cp1 = [p0[0] + ((h0Out == null ? void 0 : h0Out[0]) || 0), p0[1] + ((h0Out == null ? void 0 : h0Out[1]) || 0)];
-  const cp2 = [p1[0] + ((h1In == null ? void 0 : h1In[0]) || 0), p1[1] + ((h1In == null ? void 0 : h1In[1]) || 0)];
+  const cp1 = [
+    p0[0] + ((h0Out == null ? void 0 : h0Out[0]) || 0),
+    p0[1] + ((h0Out == null ? void 0 : h0Out[1]) || 0)
+  ];
+  const cp2 = [
+    p1[0] + ((h1In == null ? void 0 : h1In[0]) || 0),
+    p1[1] + ((h1In == null ? void 0 : h1In[1]) || 0)
+  ];
   const cp3 = p1;
   const mt = 1 - t;
   const mt2 = mt * mt;
@@ -403,10 +409,68 @@ var createCombinedCurveTexture = (sizeCurve, opacityCurve, velocityCurve, rotati
 };
 var DEFAULT_LINEAR_CURVE = {
   points: [
-    { pos: [0, 1], handleOut: [0.33, 0] },
-    { pos: [1, 0], handleIn: [-0.33, 0] }
+    {
+      pos: [0, 1],
+      handleOut: [0.33, 0]
+    },
+    {
+      pos: [1, 0],
+      handleIn: [-0.33, 0]
+    }
   ]
 };
+var createDefaultCurveTexture = () => {
+  const rgba = new Float32Array(CURVE_RESOLUTION * 4);
+  for (let i = 0; i < CURVE_RESOLUTION; i++) {
+    const value = 1 - i / (CURVE_RESOLUTION - 1);
+    rgba[i * 4] = value;
+    rgba[i * 4 + 1] = value;
+    rgba[i * 4 + 2] = value;
+    rgba[i * 4 + 3] = value;
+  }
+  const tex = new THREE2.DataTexture(
+    rgba,
+    CURVE_RESOLUTION,
+    1,
+    THREE2.RGBAFormat,
+    THREE2.FloatType
+  );
+  tex.minFilter = THREE2.LinearFilter;
+  tex.magFilter = THREE2.LinearFilter;
+  tex.wrapS = THREE2.ClampToEdgeWrapping;
+  tex.needsUpdate = true;
+  return tex;
+};
+var loadCurveTextureFromPath = async (path, existingTexture) => {
+  const response = await fetch(path);
+  if (!response.ok) {
+    throw new Error(`Failed to load curve texture: HTTP ${response.status}`);
+  }
+  const buffer = await response.arrayBuffer();
+  const rgba = new Float32Array(buffer);
+  if (rgba.length !== CURVE_RESOLUTION * 4) {
+    throw new Error(
+      `Invalid curve texture size: expected ${CURVE_RESOLUTION * 4}, got ${rgba.length}`
+    );
+  }
+  if (existingTexture && existingTexture.image.data) {
+    existingTexture.image.data.set(rgba);
+    existingTexture.needsUpdate = true;
+    return existingTexture;
+  }
+  const tex = new THREE2.DataTexture(
+    rgba,
+    CURVE_RESOLUTION,
+    1,
+    THREE2.RGBAFormat,
+    THREE2.FloatType
+  );
+  tex.minFilter = THREE2.LinearFilter;
+  tex.magFilter = THREE2.LinearFilter;
+  tex.wrapS = THREE2.ClampToEdgeWrapping;
+  tex.needsUpdate = true;
+  return tex;
+};
 
 // src/shaders/helpers.ts
 var selectColor = (idx, c0, c1, c2, c3, c4, c5, c6, c7) => {
@@ -432,22 +496,27 @@ var selectColor = (idx, c0, c1, c2, c3, c4, c5, c6, c7) => {
 import { Fn, float, vec3, instanceIndex } from "three/tsl";
 var createInitCompute = (storage, maxParticles) => {
   return Fn(() => {
+    var _a, _b, _c;
     const position = storage.positions.element(instanceIndex);
     const velocity = storage.velocities.element(instanceIndex);
     const lifetime = storage.lifetimes.element(instanceIndex);
     const fadeRate = storage.fadeRates.element(instanceIndex);
     const particleSize = storage.particleSizes.element(instanceIndex);
-    const particleRotation = storage.particleRotations.element(instanceIndex);
-    const colorStart = storage.particleColorStarts.element(instanceIndex);
-    const colorEnd = storage.particleColorEnds.element(instanceIndex);
+    const particleRotation = (_a = storage.particleRotations) == null ? void 0 : _a.element(instanceIndex);
+    const colorStart = (_b = storage.particleColorStarts) == null ? void 0 : _b.element(instanceIndex);
+    const colorEnd = (_c = storage.particleColorEnds) == null ? void 0 : _c.element(instanceIndex);
     position.assign(vec3(0, -1e3, 0));
     velocity.assign(vec3(0, 0, 0));
     lifetime.assign(float(0));
     fadeRate.assign(float(0));
     particleSize.assign(float(0));
-    particleRotation.assign(vec3(0, 0, 0));
-    colorStart.assign(vec3(1, 1, 1));
-    colorEnd.assign(vec3(1, 1, 1));
+    if (particleRotation) {
+      particleRotation.assign(vec3(0, 0, 0));
+    }
+    if (colorStart && colorEnd) {
+      colorStart.assign(vec3(1, 1, 1));
+      colorEnd.assign(vec3(1, 1, 1));
+    }
   })().compute(maxParticles);
 };
 
@@ -478,14 +547,15 @@ var createSpawnCompute = (storage, uniforms, maxParticles) => {
       idx.greaterThanEqual(startIdx).or(idx.lessThan(endIdx))
     );
     If(inRange, () => {
+      var _a, _b, _c;
       const position = storage.positions.element(instanceIndex2);
       const velocity = storage.velocities.element(instanceIndex2);
       const lifetime = storage.lifetimes.element(instanceIndex2);
       const fadeRate = storage.fadeRates.element(instanceIndex2);
       const particleSize = storage.particleSizes.element(instanceIndex2);
-      const particleRotation = storage.particleRotations.element(instanceIndex2);
-      const pColorStart = storage.particleColorStarts.element(instanceIndex2);
-      const pColorEnd = storage.particleColorEnds.element(instanceIndex2);
+      const particleRotation = (_a = storage.particleRotations) == null ? void 0 : _a.element(instanceIndex2);
+      const pColorStart = (_b = storage.particleColorStarts) == null ? void 0 : _b.element(instanceIndex2);
+      const pColorEnd = (_c = storage.particleColorEnds) == null ? void 0 : _c.element(instanceIndex2);
       const particleSeed = idx.add(seed);
       const randDirX = hash(particleSeed.add(333));
       const randDirY = hash(particleSeed.add(444));
@@ -571,9 +641,7 @@ var createSpawnCompute = (storage, uniforms, maxParticles) => {
       const coneLocalX = coneR.mul(cos(theta));
       const coneLocalY = coneH.mul(cos(coneAngle));
       const coneLocalZ = coneR.mul(sin(theta));
-      const conePos = rotateToEmitDir(
-        vec32(coneLocalX, coneLocalY, coneLocalZ)
-      );
+      const conePos = rotateToEmitDir(vec32(coneLocalX, coneLocalY, coneLocalZ));
       const diskR = surfaceOnly.greaterThan(0.5).select(
         radiusOuter,
         mix(radiusInner, radiusOuter, sqrt(randRadius))
@@ -630,61 +698,61 @@ var createSpawnCompute = (storage, uniforms, maxParticles) => {
       const startPosLength = shapeOffset.length();
       const startPosDir = startPosLength.greaterThan(1e-3).select(shapeOffset.div(startPosLength), vec32(0, 0, 0));
       const dir = useStartPosAsDir.select(startPosDir, randomDir);
-      const randomSpeed = mix(
-        uniforms.speedMin,
-        uniforms.speedMax,
-        randSpeed
-      );
+      const randomSpeed = mix(uniforms.speedMin, uniforms.speedMax, randSpeed);
       const normalVelocity = dir.mul(randomSpeed);
       velocity.assign(
         useAttractToCenter.select(attractVelocity, normalVelocity)
       );
       const randomSize = mix(uniforms.sizeMin, uniforms.sizeMax, randSize);
       particleSize.assign(randomSize);
-      const rotX = mix(
-        uniforms.rotationMinX,
-        uniforms.rotationMaxX,
-        randRotationX
-      );
-      const rotY = mix(
-        uniforms.rotationMinY,
-        uniforms.rotationMaxY,
-        randRotationY
-      );
-      const rotZ = mix(
-        uniforms.rotationMinZ,
-        uniforms.rotationMaxZ,
-        randRotationZ
-      );
-      particleRotation.assign(vec32(rotX, rotY, rotZ));
-      const startColorIdx = floor(
-        randColorStart.mul(uniforms.colorStartCount)
-      );
-      const selectedStartColor = selectColor(
-        startColorIdx,
-        uniforms.colorStart0,
-        uniforms.colorStart1,
-        uniforms.colorStart2,
-        uniforms.colorStart3,
-        uniforms.colorStart4,
-        uniforms.colorStart5,
-        uniforms.colorStart6,
-        uniforms.colorStart7
-      );
-      pColorStart.assign(selectedStartColor);
-      const endColorIdx = floor(randColorEnd.mul(uniforms.colorEndCount));
-      const selectedEndColor = selectColor(
-        endColorIdx,
-        uniforms.colorEnd0,
-        uniforms.colorEnd1,
-        uniforms.colorEnd2,
-        uniforms.colorEnd3,
-        uniforms.colorEnd4,
-        uniforms.colorEnd5,
-        uniforms.colorEnd6,
-        uniforms.colorEnd7
-      );
-      pColorEnd.assign(selectedEndColor);
+      if (particleRotation) {
+        const rotX = mix(
+          uniforms.rotationMinX,
+          uniforms.rotationMaxX,
+          randRotationX
+        );
+        const rotY = mix(
+          uniforms.rotationMinY,
+          uniforms.rotationMaxY,
+          randRotationY
+        );
+        const rotZ = mix(
+          uniforms.rotationMinZ,
+          uniforms.rotationMaxZ,
+          randRotationZ
+        );
+        particleRotation.assign(vec32(rotX, rotY, rotZ));
+      }
+      if (pColorStart && pColorEnd) {
+        const startColorIdx = floor(
+          randColorStart.mul(uniforms.colorStartCount)
+        );
+        const selectedStartColor = selectColor(
+          startColorIdx,
+          uniforms.colorStart0,
+          uniforms.colorStart1,
+          uniforms.colorStart2,
+          uniforms.colorStart3,
+          uniforms.colorStart4,
+          uniforms.colorStart5,
+          uniforms.colorStart6,
+          uniforms.colorStart7
+        );
+        pColorStart.assign(selectedStartColor);
+        const endColorIdx = floor(randColorEnd.mul(uniforms.colorEndCount));
+        const selectedEndColor = selectColor(
+          endColorIdx,
+          uniforms.colorEnd0,
+          uniforms.colorEnd1,
+          uniforms.colorEnd2,
+          uniforms.colorEnd3,
+          uniforms.colorEnd4,
+          uniforms.colorEnd5,
+          uniforms.colorEnd6,
+          uniforms.colorEnd7
+        );
+        pColorEnd.assign(selectedEndColor);
+      }
       lifetime.assign(float2(1));
     });
   })().compute(maxParticles);
@@ -703,13 +771,22 @@ import {
   instanceIndex as instanceIndex3,
   mx_noise_vec3
 } from "three/tsl";
-var createUpdateCompute = (storage, uniforms, curveTexture, maxParticles) => {
+var DEFAULT_FEATURES = {
+  turbulence: true,
+  attractors: true,
+  collision: true,
+  rotation: true,
+  perParticleColor: true
+};
+var createUpdateCompute = (storage, uniforms, curveTexture, maxParticles, features = {}) => {
+  const f = __spreadValues(__spreadValues({}, DEFAULT_FEATURES), features);
   return Fn3(() => {
+    var _a;
     const position = storage.positions.element(instanceIndex3);
     const velocity = storage.velocities.element(instanceIndex3);
     const lifetime = storage.lifetimes.element(instanceIndex3);
     const fadeRate = storage.fadeRates.element(instanceIndex3);
-    const particleRotation = storage.particleRotations.element(instanceIndex3);
+    const particleRotation = f.rotation ? (_a = storage.particleRotations) == null ? void 0 : _a.element(instanceIndex3) : null;
     const particleSize = storage.particleSizes.element(instanceIndex3);
     const dt = uniforms.deltaTime;
     If2(lifetime.greaterThan(0), () => {
@@ -753,139 +830,143 @@ var createUpdateCompute = (storage, uniforms, curveTexture, maxParticles) => {
           return float3(1).sub(currentIntensity.mul(0.9));
         })()
       );
-      const turbIntensity = uniforms.turbulenceIntensity;
-      const turbFreq = uniforms.turbulenceFrequency;
-      const turbTime = uniforms.turbulenceTime;
-      If2(turbIntensity.greaterThan(1e-3), () => {
-        const noisePos = position.mul(turbFreq).add(vec33(turbTime, turbTime.mul(0.7), turbTime.mul(1.3)));
-        const eps = float3(0.01);
-        const nPosX = mx_noise_vec3(noisePos.add(vec33(eps, 0, 0)));
-        const nNegX = mx_noise_vec3(noisePos.sub(vec33(eps, 0, 0)));
-        const nPosY = mx_noise_vec3(noisePos.add(vec33(0, eps, 0)));
-        const nNegY = mx_noise_vec3(noisePos.sub(vec33(0, eps, 0)));
-        const nPosZ = mx_noise_vec3(noisePos.add(vec33(0, 0, eps)));
-        const nNegZ = mx_noise_vec3(noisePos.sub(vec33(0, 0, eps)));
-        const dFx_dy = nPosY.x.sub(nNegY.x).div(eps.mul(2));
-        const dFx_dz = nPosZ.x.sub(nNegZ.x).div(eps.mul(2));
-        const dFy_dx = nPosX.y.sub(nNegX.y).div(eps.mul(2));
-        const dFy_dz = nPosZ.y.sub(nNegZ.y).div(eps.mul(2));
-        const dFz_dx = nPosX.z.sub(nNegX.z).div(eps.mul(2));
-        const dFz_dy = nPosY.z.sub(nNegY.z).div(eps.mul(2));
-        const curlX = dFz_dy.sub(dFy_dz);
-        const curlY = dFx_dz.sub(dFz_dx);
-        const curlZ = dFy_dx.sub(dFx_dy);
-        const curl = vec33(curlX, curlY, curlZ);
-        velocity.addAssign(curl.mul(turbIntensity).mul(uniforms.deltaTime));
-      });
-      const attractorCount = uniforms.attractorCount;
-      const applyAttractor = (aPos, aStrength, aRadius, aType, aAxis) => {
-        If2(aStrength.abs().greaterThan(1e-3), () => {
-          const toAttractor = aPos.sub(position);
-          const dist = toAttractor.length();
-          const safeDist = dist.max(0.01);
-          const direction = toAttractor.div(safeDist);
-          const falloff = aRadius.greaterThan(1e-3).select(
-            float3(1).sub(dist.div(aRadius)).max(0),
-            // Linear falloff within radius
-            float3(1).div(safeDist.mul(safeDist).add(1))
-            // Inverse square falloff (softened)
+      if (f.turbulence) {
+        const turbIntensity = uniforms.turbulenceIntensity;
+        const turbFreq = uniforms.turbulenceFrequency;
+        const turbTime = uniforms.turbulenceTime;
+        If2(turbIntensity.greaterThan(1e-3), () => {
+          const noisePos = position.mul(turbFreq).add(vec33(turbTime, turbTime.mul(0.7), turbTime.mul(1.3)));
+          const eps = float3(0.01);
+          const nPosX = mx_noise_vec3(noisePos.add(vec33(eps, 0, 0)));
+          const nNegX = mx_noise_vec3(noisePos.sub(vec33(eps, 0, 0)));
+          const nPosY = mx_noise_vec3(noisePos.add(vec33(0, eps, 0)));
+          const nNegY = mx_noise_vec3(noisePos.sub(vec33(0, eps, 0)));
+          const nPosZ = mx_noise_vec3(noisePos.add(vec33(0, 0, eps)));
+          const nNegZ = mx_noise_vec3(noisePos.sub(vec33(0, 0, eps)));
+          const dFx_dy = nPosY.x.sub(nNegY.x).div(eps.mul(2));
+          const dFx_dz = nPosZ.x.sub(nNegZ.x).div(eps.mul(2));
+          const dFy_dx = nPosX.y.sub(nNegX.y).div(eps.mul(2));
+          const dFy_dz = nPosZ.y.sub(nNegZ.y).div(eps.mul(2));
+          const dFz_dx = nPosX.z.sub(nNegX.z).div(eps.mul(2));
+          const dFz_dy = nPosY.z.sub(nNegY.z).div(eps.mul(2));
+          const curl = vec33(
+            dFz_dy.sub(dFy_dz),
+            dFx_dz.sub(dFz_dx),
+            dFy_dx.sub(dFx_dy)
+          );
+          velocity.addAssign(curl.mul(turbIntensity).mul(uniforms.deltaTime));
+        });
+      }
+      if (f.attractors) {
+        const attractorCount = uniforms.attractorCount;
+        const applyAttractor = (aPos, aStrength, aRadius, aType, aAxis) => {
+          If2(aStrength.abs().greaterThan(1e-3), () => {
+            const toAttractor = aPos.sub(position);
+            const dist = toAttractor.length();
+            const safeDist = dist.max(0.01);
+            const direction = toAttractor.div(safeDist);
+            const falloff = aRadius.greaterThan(1e-3).select(
+              float3(1).sub(dist.div(aRadius)).max(0),
+              float3(1).div(safeDist.mul(safeDist).add(1))
+            );
+            const force = aType.lessThan(0.5).select(
+              direction.mul(aStrength).mul(falloff),
+              (() => {
+                const tangent = vec33(
+                  aAxis.y.mul(toAttractor.z).sub(aAxis.z.mul(toAttractor.y)),
+                  aAxis.z.mul(toAttractor.x).sub(aAxis.x.mul(toAttractor.z)),
+                  aAxis.x.mul(toAttractor.y).sub(aAxis.y.mul(toAttractor.x))
+                );
+                const tangentLen = tangent.length().max(1e-3);
+                return tangent.div(tangentLen).mul(aStrength).mul(falloff);
+              })()
+            );
+            velocity.addAssign(force.mul(uniforms.deltaTime));
+          });
+        };
+        If2(attractorCount.greaterThan(0), () => {
+          applyAttractor(
+            uniforms.attractor0Pos,
+            uniforms.attractor0Strength,
+            uniforms.attractor0Radius,
+            uniforms.attractor0Type,
+            uniforms.attractor0Axis
           );
-          const force = aType.lessThan(0.5).select(
-            // Point attractor: force along direction to attractor
-            direction.mul(aStrength).mul(falloff),
-            // Vortex: force perpendicular to both (toAttractor) and (axis)
-            // cross(axis, toAttractor) gives tangent direction
-            (() => {
-              const tangent = vec33(
-                aAxis.y.mul(toAttractor.z).sub(aAxis.z.mul(toAttractor.y)),
-                aAxis.z.mul(toAttractor.x).sub(aAxis.x.mul(toAttractor.z)),
-                aAxis.x.mul(toAttractor.y).sub(aAxis.y.mul(toAttractor.x))
-              );
-              const tangentLen = tangent.length().max(1e-3);
-              return tangent.div(tangentLen).mul(aStrength).mul(falloff);
-            })()
+        });
+        If2(attractorCount.greaterThan(1), () => {
+          applyAttractor(
+            uniforms.attractor1Pos,
+            uniforms.attractor1Strength,
+            uniforms.attractor1Radius,
+            uniforms.attractor1Type,
+            uniforms.attractor1Axis
           );
-          velocity.addAssign(force.mul(uniforms.deltaTime));
         });
-      };
-      If2(attractorCount.greaterThan(0), () => {
-        applyAttractor(
-          uniforms.attractor0Pos,
-          uniforms.attractor0Strength,
-          uniforms.attractor0Radius,
-          uniforms.attractor0Type,
-          uniforms.attractor0Axis
+        If2(attractorCount.greaterThan(2), () => {
+          applyAttractor(
+            uniforms.attractor2Pos,
+            uniforms.attractor2Strength,
+            uniforms.attractor2Radius,
+            uniforms.attractor2Type,
+            uniforms.attractor2Axis
+          );
+        });
+        If2(attractorCount.greaterThan(3), () => {
+          applyAttractor(
+            uniforms.attractor3Pos,
+            uniforms.attractor3Strength,
+            uniforms.attractor3Radius,
+            uniforms.attractor3Type,
+            uniforms.attractor3Axis
+          );
+        });
+      }
+      position.addAssign(velocity.mul(dt).mul(speedScale));
+      if (f.collision) {
+        If2(uniforms.collisionEnabled.greaterThan(0.5), () => {
+          const planeY = uniforms.collisionPlaneY;
+          const bounce = uniforms.collisionBounce;
+          const friction = uniforms.collisionFriction;
+          const shouldDie = uniforms.collisionDie;
+          If2(position.y.lessThan(planeY), () => {
+            If2(shouldDie.greaterThan(0.5), () => {
+              lifetime.assign(float3(0));
+              position.y.assign(float3(-1e3));
+            }).Else(() => {
+              position.y.assign(planeY);
+              velocity.y.assign(velocity.y.abs().mul(bounce));
+              velocity.x.mulAssign(friction);
+              velocity.z.mulAssign(friction);
+            });
+          });
+        });
+      }
+      if (particleRotation) {
+        const idx = float3(instanceIndex3);
+        const rotSpeedX = mix2(
+          uniforms.rotationSpeedMinX,
+          uniforms.rotationSpeedMaxX,
+          hash2(idx.add(8888))
         );
-      });
-      If2(attractorCount.greaterThan(1), () => {
-        applyAttractor(
-          uniforms.attractor1Pos,
-          uniforms.attractor1Strength,
-          uniforms.attractor1Radius,
-          uniforms.attractor1Type,
-          uniforms.attractor1Axis
+        const rotSpeedY = mix2(
+          uniforms.rotationSpeedMinY,
+          uniforms.rotationSpeedMaxY,
+          hash2(idx.add(9999))
         );
-      });
-      If2(attractorCount.greaterThan(2), () => {
-        applyAttractor(
-          uniforms.attractor2Pos,
-          uniforms.attractor2Strength,
-          uniforms.attractor2Radius,
-          uniforms.attractor2Type,
-          uniforms.attractor2Axis
+        const rotSpeedZ = mix2(
+          uniforms.rotationSpeedMinZ,
+          uniforms.rotationSpeedMaxZ,
+          hash2(idx.add(10101))
         );
-      });
-      If2(attractorCount.greaterThan(3), () => {
-        applyAttractor(
-          uniforms.attractor3Pos,
-          uniforms.attractor3Strength,
-          uniforms.attractor3Radius,
-          uniforms.attractor3Type,
-          uniforms.attractor3Axis
+        const rotSpeedCurveSample = texture(
+          curveTexture,
+          vec2(progress, float3(0.5))
+        ).w;
+        const rotSpeedMultiplier = uniforms.rotationSpeedCurveEnabled.greaterThan(0.5).select(rotSpeedCurveSample, float3(1));
+        particleRotation.addAssign(
+          vec33(rotSpeedX, rotSpeedY, rotSpeedZ).mul(uniforms.deltaTime).mul(rotSpeedMultiplier)
         );
-      });
-      position.addAssign(velocity.mul(dt).mul(speedScale));
-      If2(uniforms.collisionEnabled.greaterThan(0.5), () => {
-        const planeY = uniforms.collisionPlaneY;
-        const bounce = uniforms.collisionBounce;
-        const friction = uniforms.collisionFriction;
-        const shouldDie = uniforms.collisionDie;
-        If2(position.y.lessThan(planeY), () => {
-          If2(shouldDie.greaterThan(0.5), () => {
-            lifetime.assign(float3(0));
-            position.y.assign(float3(-1e3));
-          }).Else(() => {
-            position.y.assign(planeY);
-            velocity.y.assign(velocity.y.abs().mul(bounce));
-            velocity.x.mulAssign(friction);
-            velocity.z.mulAssign(friction);
-          });
-        });
-      });
-      const idx = float3(instanceIndex3);
-      const rotSpeedX = mix2(
-        uniforms.rotationSpeedMinX,
-        uniforms.rotationSpeedMaxX,
-        hash2(idx.add(8888))
-      );
-      const rotSpeedY = mix2(
-        uniforms.rotationSpeedMinY,
-        uniforms.rotationSpeedMaxY,
-        hash2(idx.add(9999))
-      );
-      const rotSpeedZ = mix2(
-        uniforms.rotationSpeedMinZ,
-        uniforms.rotationSpeedMaxZ,
-        hash2(idx.add(10101))
-      );
-      const rotSpeedCurveSample = texture(
-        curveTexture,
-        vec2(progress, float3(0.5))
-      ).w;
-      const rotSpeedMultiplier = uniforms.rotationSpeedCurveEnabled.greaterThan(0.5).select(rotSpeedCurveSample, float3(1));
-      particleRotation.addAssign(
-        vec33(rotSpeedX, rotSpeedY, rotSpeedZ).mul(uniforms.deltaTime).mul(rotSpeedMultiplier)
-      );
+      }
       lifetime.subAssign(fadeRate.mul(uniforms.deltaTime));
       If2(lifetime.lessThanEqual(0), () => {
         lifetime.assign(float3(0));
@@ -920,6 +1001,7 @@ import {
   clamp
 } from "three/tsl";
 var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
+  var _a, _b, _c, _d;
   const {
     alphaMap,
     flipbook,
@@ -937,13 +1019,13 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
   } = options;
   const lifetime = storage.lifetimes.element(instanceIndex4);
   const particleSize = storage.particleSizes.element(instanceIndex4);
-  const particleRotation = storage.particleRotations.element(instanceIndex4);
-  const pColorStart = storage.particleColorStarts.element(instanceIndex4);
-  const pColorEnd = storage.particleColorEnds.element(instanceIndex4);
+  const particleRotation = (_b = (_a = storage.particleRotations) == null ? void 0 : _a.element(instanceIndex4)) != null ? _b : vec34(0, 0, 0);
+  const pColorStart = (_c = storage.particleColorStarts) == null ? void 0 : _c.element(instanceIndex4);
+  const pColorEnd = (_d = storage.particleColorEnds) == null ? void 0 : _d.element(instanceIndex4);
   const particlePos = storage.positions.element(instanceIndex4);
   const particleVel = storage.velocities.element(instanceIndex4);
   const progress = float4(1).sub(lifetime);
-  const currentColor = mix3(pColorStart, pColorEnd, progress);
+  const currentColor = pColorStart && pColorEnd ? mix3(pColorStart, pColorEnd, progress) : mix3(uniforms.colorStart0, uniforms.colorEnd0, progress);
   const intensifiedColor = currentColor.mul(uniforms.intensity);
   const curveSample = texture2(curveTexture, vec22(progress, float4(0.5)));
   const sizeMultiplier = uniforms.fadeSizeCurveEnabled.greaterThan(0.5).select(
@@ -959,9 +1041,7 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
     const rows = float4(flipbook.rows || 1);
     const columns = float4(flipbook.columns || 1);
     const totalFrames = rows.mul(columns);
-    const frameIndex = floor2(
-      progress.mul(totalFrames).min(totalFrames.sub(1))
-    );
+    const frameIndex = floor2(progress.mul(totalFrames).min(totalFrames.sub(1)));
     const col = mod(frameIndex, columns);
     const row = floor2(frameIndex.div(columns));
     const scaledUV = uv().div(vec22(columns, rows));
@@ -991,20 +1071,19 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
     }
   }
   const baseOpacity = opacityMultiplier.mul(shapeMask).mul(lifetime.greaterThan(1e-3).select(float4(1), float4(0)));
-  const particleData = {
+  const particleData = __spreadProps(__spreadValues(__spreadValues({
     progress,
     lifetime,
     position: particlePos,
     velocity: particleVel,
     size: particleSize,
-    rotation: particleRotation,
-    colorStart: pColorStart,
-    colorEnd: pColorEnd,
+    rotation: particleRotation
+  }, pColorStart && { colorStart: pColorStart }), pColorEnd && { colorEnd: pColorEnd }), {
     color: currentColor,
     intensifiedColor,
     shapeMask,
     index: instanceIndex4
-  };
+  });
   let finalOpacity = opacityNode ? baseOpacity.mul(
     typeof opacityNode === "function" ? opacityNode(particleData) : opacityNode
   ) : baseOpacity;
@@ -1071,10 +1150,7 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
       const velDir = particleVel.div(velLen).mul(axisSign);
       const localAxis = axisIndex.lessThan(0.5).select(
         vec34(1, 0, 0),
-        axisIndex.lessThan(1.5).select(
-          vec34(0, 1, 0),
-          vec34(0, 0, 1)
-        )
+        axisIndex.lessThan(1.5).select(vec34(0, 1, 0), vec34(0, 0, 1))
       );
       const dotProduct = localAxis.dot(velDir).clamp(-1, 1);
       const crossProduct = localAxis.cross(velDir);
@@ -1092,10 +1168,7 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
       const kCrossV = rotAxis.cross(v);
       const rotatedByAxis = needsRotation.select(
         v.mul(cosAngleVal).add(kCrossV.mul(sinAngleVal)).add(rotAxis.mul(kDotV.mul(oneMinusCos))),
-        dotProduct.lessThan(-0.99).select(
-          v.negate(),
-          v
-        )
+        dotProduct.lessThan(-0.99).select(v.negate(), v)
       );
       rotatedPos = rotatedByAxis;
     } else {
@@ -1178,6 +1251,7 @@ export {
   bakeCurveToArray,
   coreStore,
   createCombinedCurveTexture,
+  createDefaultCurveTexture,
   createInitCompute,
   createParticleMaterial,
   createSpawnCompute,
@@ -1186,6 +1260,7 @@ export {
   evaluateBezierSegment,
   hexToRgb,
   lifetimeToFadeRate,
+  loadCurveTextureFromPath,
   sampleCurveAtX,
   selectColor,
   toRange,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-vfx",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "MIT",
   "type": "module",
   "repository": {