core-vfx 0.0.10 → 0.1.0

package/dist/index.js

@@ -207,6 +207,10 @@ var MAX_ATTRACTORS = 4;
 var CURVE_RESOLUTION = 256;
 
 // src/utils.ts
+var isWebGPUBackend = (renderer) => {
+  var _a;
+  return ((_a = renderer == null ? void 0 : renderer.backend) == null ? void 0 : _a.isWebGPUBackend) === true;
+};
 var hexToRgb = (hex) => {
   const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
   return result ? [
@@ -296,6 +300,156 @@ var toRotation3D = (value) => {
   ];
 };
 var lifetimeToFadeRate = (seconds) => 1 / seconds;
+var isNonDefaultRotation = (r) => {
+  if (r === null || r === void 0) return false;
+  if (typeof r === "number") return r !== 0;
+  if (Array.isArray(r) && r.length === 2 && typeof r[0] === "number") {
+    return r[0] !== 0 || r[1] !== 0;
+  }
+  if (Array.isArray(r)) {
+    return r.some(
+      (axis) => Array.isArray(axis) && (axis[0] !== 0 || axis[1] !== 0)
+    );
+  }
+  return false;
+};
+var normalizeProps = (props) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q;
+  const maxParticles = (_a = props.maxParticles) != null ? _a : 1e4;
+  const size = (_b = props.size) != null ? _b : [0.1, 0.3];
+  const speed = (_c = props.speed) != null ? _c : [0.1, 0.1];
+  const fadeSize = (_d = props.fadeSize) != null ? _d : [1, 0];
+  const fadeOpacity = (_e = props.fadeOpacity) != null ? _e : [1, 0];
+  const lifetime = (_f = props.lifetime) != null ? _f : [1, 2];
+  const gravity = (_g = props.gravity) != null ? _g : [0, 0, 0];
+  const direction = (_h = props.direction) != null ? _h : [
+    [-1, 1],
+    [0, 1],
+    [-1, 1]
+  ];
+  const startPosition = (_i = props.startPosition) != null ? _i : [
+    [0, 0],
+    [0, 0],
+    [0, 0]
+  ];
+  const rotation = (_j = props.rotation) != null ? _j : [0, 0];
+  const rotationSpeed = (_k = props.rotationSpeed) != null ? _k : [0, 0];
+  const friction = (_l = props.friction) != null ? _l : { intensity: 0, easing: "linear" };
+  const colorStart = (_m = props.colorStart) != null ? _m : ["#ffffff"];
+  const colorEnd = (_n = props.colorEnd) != null ? _n : null;
+  const emitterRadius = (_o = props.emitterRadius) != null ? _o : [0, 1];
+  const emitterHeight = (_p = props.emitterHeight) != null ? _p : [0, 1];
+  const intensity = (_q = props.intensity) != null ? _q : 1;
+  const position = (_r = props.position) != null ? _r : [0, 0, 0];
+  const autoStart = (_s = props.autoStart) != null ? _s : true;
+  const delay = (_t = props.delay) != null ? _t : 0;
+  const emitCount = (_u = props.emitCount) != null ? _u : 1;
+  const emitterShape = (_v = props.emitterShape) != null ? _v : EmitterShape.BOX;
+  const emitterAngle = (_w = props.emitterAngle) != null ? _w : Math.PI / 4;
+  const emitterSurfaceOnly = (_x = props.emitterSurfaceOnly) != null ? _x : false;
+  const emitterDirection = (_y = props.emitterDirection) != null ? _y : [0, 1, 0];
+  const turbulence = (_z = props.turbulence) != null ? _z : null;
+  const attractors = (_A = props.attractors) != null ? _A : null;
+  const attractToCenter = (_B = props.attractToCenter) != null ? _B : false;
+  const startPositionAsDirection = (_C = props.startPositionAsDirection) != null ? _C : false;
+  const softParticles = (_D = props.softParticles) != null ? _D : false;
+  const softDistance = (_E = props.softDistance) != null ? _E : 0.5;
+  const collision = (_F = props.collision) != null ? _F : null;
+  const appearance = (_G = props.appearance) != null ? _G : Appearance.GRADIENT;
+  const alphaMap = (_H = props.alphaMap) != null ? _H : null;
+  const flipbook = (_I = props.flipbook) != null ? _I : null;
+  const geometry = (_J = props.geometry) != null ? _J : null;
+  const orientToDirection = (_K = props.orientToDirection) != null ? _K : false;
+  const orientAxis = (_L = props.orientAxis) != null ? _L : "z";
+  const stretchBySpeed = (_M = props.stretchBySpeed) != null ? _M : null;
+  const lighting = (_N = props.lighting) != null ? _N : Lighting.STANDARD;
+  const shadow = (_O = props.shadow) != null ? _O : false;
+  const blending = (_P = props.blending) != null ? _P : Blending.NORMAL;
+  const sizeRange = toRange(size, [0.1, 0.3]);
+  const speedRange = toRange(speed, [0.1, 0.1]);
+  const fadeSizeRange = toRange(fadeSize, [1, 0]);
+  const fadeOpacityRange = toRange(fadeOpacity, [1, 0]);
+  const lifetimeRange = toRange(lifetime, [1, 2]);
+  const direction3D = toRotation3D(direction);
+  const startPosition3D = toRotation3D(startPosition);
+  const rotation3D = toRotation3D(rotation);
+  const rotationSpeed3D = toRotation3D(rotationSpeed);
+  const emitterRadiusRange = toRange(emitterRadius, [0, 1]);
+  const emitterHeightRange = toRange(emitterHeight, [0, 1]);
+  const frictionIntensityRange = typeof friction === "object" && friction !== null && "intensity" in friction ? toRange(friction.intensity, [0, 0]) : [0, 0];
+  const frictionEasingType = typeof friction === "object" && friction !== null && "easing" in friction ? easingToType((_Q = friction.easing) != null ? _Q : "linear") : 0;
+  const startColors = colorStart.slice(0, 8).map(hexToRgb);
+  while (startColors.length < 8)
+    startColors.push(startColors[startColors.length - 1] || [1, 1, 1]);
+  const effectiveColorEnd = colorEnd != null ? colorEnd : colorStart;
+  const endColors = effectiveColorEnd.slice(0, 8).map(hexToRgb);
+  while (endColors.length < 8)
+    endColors.push(endColors[endColors.length - 1] || [1, 1, 1]);
+  return {
+    maxParticles,
+    sizeRange,
+    speedRange,
+    fadeSizeRange,
+    fadeOpacityRange,
+    lifetimeRange,
+    gravity,
+    direction3D,
+    startPosition3D,
+    rotation3D,
+    rotationSpeed3D,
+    frictionIntensityRange,
+    frictionEasingType,
+    startColors,
+    endColors,
+    colorStartCount: colorStart.length,
+    colorEndCount: effectiveColorEnd.length,
+    emitterRadiusRange,
+    emitterHeightRange,
+    intensity,
+    position,
+    autoStart,
+    delay,
+    emitCount,
+    emitterShape,
+    emitterAngle,
+    emitterSurfaceOnly,
+    emitterDirection,
+    turbulence,
+    attractors,
+    attractToCenter,
+    startPositionAsDirection,
+    softParticles,
+    softDistance,
+    collision,
+    appearance,
+    alphaMap,
+    flipbook,
+    rotation,
+    rotationSpeed,
+    geometry,
+    orientToDirection,
+    orientAxis,
+    stretchBySpeed,
+    lighting,
+    shadow,
+    blending,
+    depthTest: true,
+    renderOrder: 0,
+    colorStart,
+    colorEnd,
+    // Keep raw values
+    size,
+    speed,
+    fadeSize,
+    fadeOpacity,
+    lifetime,
+    direction,
+    startPosition,
+    friction,
+    emitterRadius,
+    emitterHeight
+  };
+};
 
 // src/curves.ts
 import * as THREE2 from "three/webgpu";
@@ -511,6 +665,68 @@ var loadCurveTextureFromPath = async (path) => {
   tex.needsUpdate = true;
   return { texture: tex, activeChannels };
 };
+var resolveCurveTexture = async (options) => {
+  const {
+    fadeSizeCurve = null,
+    fadeOpacityCurve = null,
+    velocityCurve = null,
+    rotationSpeedCurve = null,
+    curveTexturePath = null
+  } = options;
+  const hasAnyCurve = fadeSizeCurve || fadeOpacityCurve || velocityCurve || rotationSpeedCurve;
+  if (curveTexturePath) {
+    try {
+      const result = await loadCurveTextureFromPath(curveTexturePath);
+      return {
+        texture: result.texture,
+        sizeEnabled: !!(result.activeChannels & CurveChannel.SIZE),
+        opacityEnabled: !!(result.activeChannels & CurveChannel.OPACITY),
+        velocityEnabled: !!(result.activeChannels & CurveChannel.VELOCITY),
+        rotationSpeedEnabled: !!(result.activeChannels & CurveChannel.ROTATION_SPEED)
+      };
+    } catch (err) {
+      console.warn(
+        `Failed to load curve texture: ${curveTexturePath}, falling back to baking`,
+        err
+      );
+      if (hasAnyCurve) {
+        return {
+          texture: createCombinedCurveTexture(
+            fadeSizeCurve,
+            fadeOpacityCurve,
+            velocityCurve,
+            rotationSpeedCurve
+          ),
+          sizeEnabled: !!fadeSizeCurve,
+          opacityEnabled: !!fadeOpacityCurve,
+          velocityEnabled: !!velocityCurve,
+          rotationSpeedEnabled: !!rotationSpeedCurve
+        };
+      }
+    }
+  }
+  if (hasAnyCurve) {
+    return {
+      texture: createCombinedCurveTexture(
+        fadeSizeCurve,
+        fadeOpacityCurve,
+        velocityCurve,
+        rotationSpeedCurve
+      ),
+      sizeEnabled: !!fadeSizeCurve,
+      opacityEnabled: !!fadeOpacityCurve,
+      velocityEnabled: !!velocityCurve,
+      rotationSpeedEnabled: !!rotationSpeedCurve
+    };
+  }
+  return {
+    texture: createDefaultCurveTexture(),
+    sizeEnabled: false,
+    opacityEnabled: false,
+    velocityEnabled: false,
+    rotationSpeedEnabled: false
+  };
+};
 
 // src/shaders/helpers.ts
 var selectColor = (idx, c0, c1, c2, c3, c4, c5, c6, c7) => {
@@ -816,7 +1032,9 @@ var DEFAULT_FEATURES = {
   attractors: true,
   collision: true,
   rotation: true,
-  perParticleColor: true
+  perParticleColor: true,
+  needsPerParticleColor: true,
+  needsRotation: true
 };
 var createUpdateCompute = (storage, uniforms, curveTexture, maxParticles, features = {}) => {
   const f = __spreadValues(__spreadValues({}, DEFAULT_FEATURES), features);
@@ -1277,6 +1495,957 @@ var createParticleMaterial = (storage, uniforms, curveTexture, options) => {
     return mat;
   }
 };
+
+// src/uniforms.ts
+import * as THREE4 from "three/webgpu";
+import { uniform } from "three/tsl";
+function createUniforms(props) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+  return {
+    sizeMin: uniform(props.sizeRange[0]),
+    sizeMax: uniform(props.sizeRange[1]),
+    fadeSizeStart: uniform(props.fadeSizeRange[0]),
+    fadeSizeEnd: uniform(props.fadeSizeRange[1]),
+    fadeOpacityStart: uniform(props.fadeOpacityRange[0]),
+    fadeOpacityEnd: uniform(props.fadeOpacityRange[1]),
+    gravity: uniform(new THREE4.Vector3(...props.gravity)),
+    frictionIntensityStart: uniform(props.frictionIntensityRange[0]),
+    frictionIntensityEnd: uniform(props.frictionIntensityRange[1]),
+    frictionEasingType: uniform(props.frictionEasingType),
+    speedMin: uniform(props.speedRange[0]),
+    speedMax: uniform(props.speedRange[1]),
+    lifetimeMin: uniform(lifetimeToFadeRate(props.lifetimeRange[1])),
+    lifetimeMax: uniform(lifetimeToFadeRate(props.lifetimeRange[0])),
+    deltaTime: uniform(0.016),
+    // 3D direction ranges
+    dirMinX: uniform(props.direction3D[0][0]),
+    dirMaxX: uniform(props.direction3D[0][1]),
+    dirMinY: uniform(props.direction3D[1][0]),
+    dirMaxY: uniform(props.direction3D[1][1]),
+    dirMinZ: uniform(props.direction3D[2][0]),
+    dirMaxZ: uniform(props.direction3D[2][1]),
+    // 3D start position offset ranges
+    startPosMinX: uniform(props.startPosition3D[0][0]),
+    startPosMaxX: uniform(props.startPosition3D[0][1]),
+    startPosMinY: uniform(props.startPosition3D[1][0]),
+    startPosMaxY: uniform(props.startPosition3D[1][1]),
+    startPosMinZ: uniform(props.startPosition3D[2][0]),
+    startPosMaxZ: uniform(props.startPosition3D[2][1]),
+    spawnPosition: uniform(new THREE4.Vector3(...props.position)),
+    spawnIndexStart: uniform(0),
+    spawnIndexEnd: uniform(0),
+    spawnSeed: uniform(0),
+    intensity: uniform(props.intensity),
+    // 3D rotation ranges
+    rotationMinX: uniform(props.rotation3D[0][0]),
+    rotationMaxX: uniform(props.rotation3D[0][1]),
+    rotationMinY: uniform(props.rotation3D[1][0]),
+    rotationMaxY: uniform(props.rotation3D[1][1]),
+    rotationMinZ: uniform(props.rotation3D[2][0]),
+    rotationMaxZ: uniform(props.rotation3D[2][1]),
+    // 3D rotation speed ranges
+    rotationSpeedMinX: uniform(props.rotationSpeed3D[0][0]),
+    rotationSpeedMaxX: uniform(props.rotationSpeed3D[0][1]),
+    rotationSpeedMinY: uniform(props.rotationSpeed3D[1][0]),
+    rotationSpeedMaxY: uniform(props.rotationSpeed3D[1][1]),
+    rotationSpeedMinZ: uniform(props.rotationSpeed3D[2][0]),
+    rotationSpeedMaxZ: uniform(props.rotationSpeed3D[2][1]),
+    // Color arrays (8 colors max each)
+    colorStartCount: uniform(props.colorStartCount),
+    colorEndCount: uniform(props.colorEndCount),
+    colorStart0: uniform(new THREE4.Color(...props.startColors[0])),
+    colorStart1: uniform(new THREE4.Color(...props.startColors[1])),
+    colorStart2: uniform(new THREE4.Color(...props.startColors[2])),
+    colorStart3: uniform(new THREE4.Color(...props.startColors[3])),
+    colorStart4: uniform(new THREE4.Color(...props.startColors[4])),
+    colorStart5: uniform(new THREE4.Color(...props.startColors[5])),
+    colorStart6: uniform(new THREE4.Color(...props.startColors[6])),
+    colorStart7: uniform(new THREE4.Color(...props.startColors[7])),
+    colorEnd0: uniform(new THREE4.Color(...props.endColors[0])),
+    colorEnd1: uniform(new THREE4.Color(...props.endColors[1])),
+    colorEnd2: uniform(new THREE4.Color(...props.endColors[2])),
+    colorEnd3: uniform(new THREE4.Color(...props.endColors[3])),
+    colorEnd4: uniform(new THREE4.Color(...props.endColors[4])),
+    colorEnd5: uniform(new THREE4.Color(...props.endColors[5])),
+    colorEnd6: uniform(new THREE4.Color(...props.endColors[6])),
+    colorEnd7: uniform(new THREE4.Color(...props.endColors[7])),
+    // Emitter shape uniforms
+    emitterShapeType: uniform(props.emitterShape),
+    emitterRadiusInner: uniform(props.emitterRadiusRange[0]),
+    emitterRadiusOuter: uniform(props.emitterRadiusRange[1]),
+    emitterAngle: uniform(props.emitterAngle),
+    emitterHeightMin: uniform(props.emitterHeightRange[0]),
+    emitterHeightMax: uniform(props.emitterHeightRange[1]),
+    emitterSurfaceOnly: uniform(props.emitterSurfaceOnly ? 1 : 0),
+    emitterDir: uniform(
+      new THREE4.Vector3(...props.emitterDirection).normalize()
+    ),
+    // Turbulence uniforms
+    turbulenceIntensity: uniform((_b = (_a = props.turbulence) == null ? void 0 : _a.intensity) != null ? _b : 0),
+    turbulenceFrequency: uniform((_d = (_c = props.turbulence) == null ? void 0 : _c.frequency) != null ? _d : 1),
+    turbulenceSpeed: uniform((_f = (_e = props.turbulence) == null ? void 0 : _e.speed) != null ? _f : 1),
+    turbulenceTime: uniform(0),
+    // Attractor uniforms (up to 4)
+    attractorCount: uniform(0),
+    attractor0Pos: uniform(new THREE4.Vector3(0, 0, 0)),
+    attractor0Strength: uniform(0),
+    attractor0Radius: uniform(1),
+    attractor0Type: uniform(0),
+    attractor0Axis: uniform(new THREE4.Vector3(0, 1, 0)),
+    attractor1Pos: uniform(new THREE4.Vector3(0, 0, 0)),
+    attractor1Strength: uniform(0),
+    attractor1Radius: uniform(1),
+    attractor1Type: uniform(0),
+    attractor1Axis: uniform(new THREE4.Vector3(0, 1, 0)),
+    attractor2Pos: uniform(new THREE4.Vector3(0, 0, 0)),
+    attractor2Strength: uniform(0),
+    attractor2Radius: uniform(1),
+    attractor2Type: uniform(0),
+    attractor2Axis: uniform(new THREE4.Vector3(0, 1, 0)),
+    attractor3Pos: uniform(new THREE4.Vector3(0, 0, 0)),
+    attractor3Strength: uniform(0),
+    attractor3Radius: uniform(1),
+    attractor3Type: uniform(0),
+    attractor3Axis: uniform(new THREE4.Vector3(0, 1, 0)),
+    // Simple attract to center
+    attractToCenter: uniform(props.attractToCenter ? 1 : 0),
+    // Use start position as direction
+    startPositionAsDirection: uniform(props.startPositionAsDirection ? 1 : 0),
+    // Soft particles
+    softParticlesEnabled: uniform(props.softParticles ? 1 : 0),
+    softDistance: uniform(props.softDistance),
+    // Curve enabled flags
+    velocityCurveEnabled: uniform(0),
+    rotationSpeedCurveEnabled: uniform(0),
+    fadeSizeCurveEnabled: uniform(0),
+    fadeOpacityCurveEnabled: uniform(0),
+    // Orient axis
+    orientAxisType: uniform(axisToNumber(props.orientAxis)),
+    // Stretch by speed
+    stretchEnabled: uniform(props.stretchBySpeed ? 1 : 0),
+    stretchFactor: uniform((_h = (_g = props.stretchBySpeed) == null ? void 0 : _g.factor) != null ? _h : 1),
+    stretchMax: uniform((_j = (_i = props.stretchBySpeed) == null ? void 0 : _i.maxStretch) != null ? _j : 5),
+    // Collision uniforms
+    collisionEnabled: uniform(props.collision ? 1 : 0),
+    collisionPlaneY: uniform((_m = (_l = (_k = props.collision) == null ? void 0 : _k.plane) == null ? void 0 : _l.y) != null ? _m : 0),
+    collisionBounce: uniform((_o = (_n = props.collision) == null ? void 0 : _n.bounce) != null ? _o : 0.3),
+    collisionFriction: uniform((_q = (_p = props.collision) == null ? void 0 : _p.friction) != null ? _q : 0.8),
+    collisionDie: uniform(((_r = props.collision) == null ? void 0 : _r.die) ? 1 : 0),
+    sizeBasedGravity: uniform((_t = (_s = props.collision) == null ? void 0 : _s.sizeBasedGravity) != null ? _t : 0)
+  };
+}
+function updateUniforms(uniforms, props) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+  const u = uniforms;
+  u.sizeMin.value = props.sizeRange[0];
+  u.sizeMax.value = props.sizeRange[1];
+  u.fadeSizeStart.value = props.fadeSizeRange[0];
+  u.fadeSizeEnd.value = props.fadeSizeRange[1];
+  u.fadeOpacityStart.value = props.fadeOpacityRange[0];
+  u.fadeOpacityEnd.value = props.fadeOpacityRange[1];
+  u.gravity.value.set(...props.gravity);
+  u.frictionIntensityStart.value = props.frictionIntensityRange[0];
+  u.frictionIntensityEnd.value = props.frictionIntensityRange[1];
+  u.frictionEasingType.value = props.frictionEasingType;
+  u.speedMin.value = props.speedRange[0];
+  u.speedMax.value = props.speedRange[1];
+  u.lifetimeMin.value = lifetimeToFadeRate(props.lifetimeRange[1]);
+  u.lifetimeMax.value = lifetimeToFadeRate(props.lifetimeRange[0]);
+  u.dirMinX.value = props.direction3D[0][0];
+  u.dirMaxX.value = props.direction3D[0][1];
+  u.dirMinY.value = props.direction3D[1][0];
+  u.dirMaxY.value = props.direction3D[1][1];
+  u.dirMinZ.value = props.direction3D[2][0];
+  u.dirMaxZ.value = props.direction3D[2][1];
+  u.startPosMinX.value = props.startPosition3D[0][0];
+  u.startPosMaxX.value = props.startPosition3D[0][1];
+  u.startPosMinY.value = props.startPosition3D[1][0];
+  u.startPosMaxY.value = props.startPosition3D[1][1];
+  u.startPosMinZ.value = props.startPosition3D[2][0];
+  u.startPosMaxZ.value = props.startPosition3D[2][1];
+  u.rotationMinX.value = props.rotation3D[0][0];
+  u.rotationMaxX.value = props.rotation3D[0][1];
+  u.rotationMinY.value = props.rotation3D[1][0];
+  u.rotationMaxY.value = props.rotation3D[1][1];
+  u.rotationMinZ.value = props.rotation3D[2][0];
+  u.rotationMaxZ.value = props.rotation3D[2][1];
+  u.rotationSpeedMinX.value = props.rotationSpeed3D[0][0];
+  u.rotationSpeedMaxX.value = props.rotationSpeed3D[0][1];
+  u.rotationSpeedMinY.value = props.rotationSpeed3D[1][0];
+  u.rotationSpeedMaxY.value = props.rotationSpeed3D[1][1];
+  u.rotationSpeedMinZ.value = props.rotationSpeed3D[2][0];
+  u.rotationSpeedMaxZ.value = props.rotationSpeed3D[2][1];
+  u.intensity.value = props.intensity;
+  u.colorStartCount.value = props.colorStartCount;
+  u.colorEndCount.value = props.colorEndCount;
+  props.startColors.forEach((c, i) => {
+    var _a2;
+    (_a2 = u[`colorStart${i}`]) == null ? void 0 : _a2.value.setRGB(...c);
+  });
+  props.endColors.forEach((c, i) => {
+    var _a2;
+    (_a2 = u[`colorEnd${i}`]) == null ? void 0 : _a2.value.setRGB(...c);
+  });
+  u.emitterShapeType.value = props.emitterShape;
+  u.emitterRadiusInner.value = props.emitterRadiusRange[0];
+  u.emitterRadiusOuter.value = props.emitterRadiusRange[1];
+  u.emitterAngle.value = props.emitterAngle;
+  u.emitterHeightMin.value = props.emitterHeightRange[0];
+  u.emitterHeightMax.value = props.emitterHeightRange[1];
+  u.emitterSurfaceOnly.value = props.emitterSurfaceOnly ? 1 : 0;
+  u.emitterDir.value.set(...props.emitterDirection).normalize();
+  u.turbulenceIntensity.value = (_b = (_a = props.turbulence) == null ? void 0 : _a.intensity) != null ? _b : 0;
+  u.turbulenceFrequency.value = (_d = (_c = props.turbulence) == null ? void 0 : _c.frequency) != null ? _d : 1;
+  u.turbulenceSpeed.value = (_f = (_e = props.turbulence) == null ? void 0 : _e.speed) != null ? _f : 1;
+  const attractorList = (_g = props.attractors) != null ? _g : [];
+  u.attractorCount.value = Math.min(attractorList.length, MAX_ATTRACTORS);
+  for (let i = 0; i < MAX_ATTRACTORS; i++) {
+    const a = attractorList[i];
+    if (a) {
+      ;
+      u[`attractor${i}Pos`].value.set(
+        ...(_h = a.position) != null ? _h : [0, 0, 0]
+      );
+      u[`attractor${i}Strength`].value = (_i = a.strength) != null ? _i : 1;
+      u[`attractor${i}Radius`].value = (_j = a.radius) != null ? _j : 0;
+      u[`attractor${i}Type`].value = a.type === "vortex" ? 1 : 0;
+      u[`attractor${i}Axis`].value.set(...(_k = a.axis) != null ? _k : [0, 1, 0]).normalize();
+    } else {
+      u[`attractor${i}Strength`].value = 0;
+    }
+  }
+  u.attractToCenter.value = props.attractToCenter ? 1 : 0;
+  u.startPositionAsDirection.value = props.startPositionAsDirection ? 1 : 0;
+  u.softParticlesEnabled.value = props.softParticles ? 1 : 0;
+  u.softDistance.value = props.softDistance;
+  u.orientAxisType.value = axisToNumber(props.orientAxis);
+  u.stretchEnabled.value = props.stretchBySpeed ? 1 : 0;
+  u.stretchFactor.value = (_m = (_l = props.stretchBySpeed) == null ? void 0 : _l.factor) != null ? _m : 1;
+  u.stretchMax.value = (_o = (_n = props.stretchBySpeed) == null ? void 0 : _n.maxStretch) != null ? _o : 5;
+  u.collisionEnabled.value = props.collision ? 1 : 0;
+  u.collisionPlaneY.value = (_r = (_q = (_p = props.collision) == null ? void 0 : _p.plane) == null ? void 0 : _q.y) != null ? _r : 0;
+  u.collisionBounce.value = (_t = (_s = props.collision) == null ? void 0 : _s.bounce) != null ? _t : 0.3;
+  u.collisionFriction.value = (_v = (_u = props.collision) == null ? void 0 : _u.friction) != null ? _v : 0.8;
+  u.collisionDie.value = ((_w = props.collision) == null ? void 0 : _w.die) ? 1 : 0;
+  u.sizeBasedGravity.value = (_y = (_x = props.collision) == null ? void 0 : _x.sizeBasedGravity) != null ? _y : 0;
+}
+function updateUniformsPartial(uniforms, rawProps) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C;
+  const u = uniforms;
+  if ("size" in rawProps) {
+    const sizeR = toRange(rawProps.size, [0.1, 0.3]);
+    u.sizeMin.value = sizeR[0];
+    u.sizeMax.value = sizeR[1];
+  }
+  if ("fadeSize" in rawProps) {
+    const fadeSizeR = toRange(rawProps.fadeSize, [1, 0]);
+    u.fadeSizeStart.value = fadeSizeR[0];
+    u.fadeSizeEnd.value = fadeSizeR[1];
+  }
+  if ("fadeOpacity" in rawProps) {
+    const fadeOpacityR = toRange(rawProps.fadeOpacity, [1, 0]);
+    u.fadeOpacityStart.value = fadeOpacityR[0];
+    u.fadeOpacityEnd.value = fadeOpacityR[1];
+  }
+  if ("fadeSizeCurve" in rawProps) {
+    u.fadeSizeCurveEnabled.value = rawProps.fadeSizeCurve ? 1 : 0;
+  }
+  if ("fadeOpacityCurve" in rawProps) {
+    u.fadeOpacityCurveEnabled.value = rawProps.fadeOpacityCurve ? 1 : 0;
+  }
+  if ("velocityCurve" in rawProps) {
+    u.velocityCurveEnabled.value = rawProps.velocityCurve ? 1 : 0;
+  }
+  if ("rotationSpeedCurve" in rawProps) {
+    u.rotationSpeedCurveEnabled.value = rawProps.rotationSpeedCurve ? 1 : 0;
+  }
+  if ("orientAxis" in rawProps) {
+    u.orientAxisType.value = axisToNumber(rawProps.orientAxis);
+  }
+  if ("stretchBySpeed" in rawProps) {
+    u.stretchEnabled.value = rawProps.stretchBySpeed ? 1 : 0;
+    u.stretchFactor.value = (_b = (_a = rawProps.stretchBySpeed) == null ? void 0 : _a.factor) != null ? _b : 1;
+    u.stretchMax.value = (_d = (_c = rawProps.stretchBySpeed) == null ? void 0 : _c.maxStretch) != null ? _d : 5;
+  }
+  if ("gravity" in rawProps && rawProps.gravity && Array.isArray(rawProps.gravity)) {
+    u.gravity.value.set(...rawProps.gravity);
+  }
+  if ("speed" in rawProps) {
+    const speedR = toRange(rawProps.speed, [0.1, 0.1]);
+    u.speedMin.value = speedR[0];
+    u.speedMax.value = speedR[1];
+  }
+  if ("lifetime" in rawProps) {
+    const lifetimeR = toRange(rawProps.lifetime, [1, 2]);
+    u.lifetimeMin.value = 1 / lifetimeR[1];
+    u.lifetimeMax.value = 1 / lifetimeR[0];
+  }
+  if ("friction" in rawProps && rawProps.friction) {
+    const frictionR = toRange(rawProps.friction.intensity, [0, 0]);
+    u.frictionIntensityStart.value = frictionR[0];
+    u.frictionIntensityEnd.value = frictionR[1];
+    u.frictionEasingType.value = easingToType(rawProps.friction.easing);
+  }
+  if ("direction" in rawProps) {
+    const dir3D = toRotation3D(rawProps.direction);
+    u.dirMinX.value = dir3D[0][0];
+    u.dirMaxX.value = dir3D[0][1];
+    u.dirMinY.value = dir3D[1][0];
+    u.dirMaxY.value = dir3D[1][1];
+    u.dirMinZ.value = dir3D[2][0];
+    u.dirMaxZ.value = dir3D[2][1];
+  }
+  if ("startPosition" in rawProps) {
+    const startPos3D = toRotation3D(rawProps.startPosition);
+    u.startPosMinX.value = startPos3D[0][0];
+    u.startPosMaxX.value = startPos3D[0][1];
+    u.startPosMinY.value = startPos3D[1][0];
+    u.startPosMaxY.value = startPos3D[1][1];
+    u.startPosMinZ.value = startPos3D[2][0];
+    u.startPosMaxZ.value = startPos3D[2][1];
+  }
+  if ("rotation" in rawProps) {
+    const rot3D = toRotation3D(rawProps.rotation);
+    u.rotationMinX.value = rot3D[0][0];
+    u.rotationMaxX.value = rot3D[0][1];
+    u.rotationMinY.value = rot3D[1][0];
+    u.rotationMaxY.value = rot3D[1][1];
+    u.rotationMinZ.value = rot3D[2][0];
+    u.rotationMaxZ.value = rot3D[2][1];
+  }
+  if ("rotationSpeed" in rawProps) {
+    const rotSpeed3D = toRotation3D(rawProps.rotationSpeed);
+    u.rotationSpeedMinX.value = rotSpeed3D[0][0];
+    u.rotationSpeedMaxX.value = rotSpeed3D[0][1];
+    u.rotationSpeedMinY.value = rotSpeed3D[1][0];
+    u.rotationSpeedMaxY.value = rotSpeed3D[1][1];
+    u.rotationSpeedMinZ.value = rotSpeed3D[2][0];
+    u.rotationSpeedMaxZ.value = rotSpeed3D[2][1];
+  }
+  if ("intensity" in rawProps) {
+    u.intensity.value = (_e = rawProps.intensity) != null ? _e : 1;
+  }
+  if ("colorStart" in rawProps && rawProps.colorStart) {
+    const sColors = rawProps.colorStart.slice(0, 8).map(hexToRgb);
+    while (sColors.length < 8)
+      sColors.push(sColors[sColors.length - 1] || [1, 1, 1]);
+    u.colorStartCount.value = rawProps.colorStart.length;
+    sColors.forEach((c, i) => {
+      if (u[`colorStart${i}`]) u[`colorStart${i}`].value.setRGB(...c);
+    });
+  }
+  if ("colorEnd" in rawProps) {
+    const effectiveEndColors = rawProps.colorEnd || rawProps.colorStart || ["#ffffff"];
+    const eColors = effectiveEndColors.slice(0, 8).map(hexToRgb);
+    while (eColors.length < 8)
+      eColors.push(eColors[eColors.length - 1] || [1, 1, 1]);
+    u.colorEndCount.value = effectiveEndColors.length;
+    eColors.forEach((c, i) => {
+      if (u[`colorEnd${i}`]) u[`colorEnd${i}`].value.setRGB(...c);
+    });
+  }
+  if ("emitterShape" in rawProps) {
+    u.emitterShapeType.value = (_f = rawProps.emitterShape) != null ? _f : 0;
+  }
+  if ("emitterRadius" in rawProps) {
+    const emitterRadiusR = toRange(rawProps.emitterRadius, [0, 1]);
+    u.emitterRadiusInner.value = emitterRadiusR[0];
+    u.emitterRadiusOuter.value = emitterRadiusR[1];
+  }
+  if ("emitterAngle" in rawProps) {
+    u.emitterAngle.value = (_g = rawProps.emitterAngle) != null ? _g : Math.PI / 4;
+  }
+  if ("emitterHeight" in rawProps) {
+    const emitterHeightR = toRange(rawProps.emitterHeight, [0, 1]);
+    u.emitterHeightMin.value = emitterHeightR[0];
+    u.emitterHeightMax.value = emitterHeightR[1];
+  }
+  if ("emitterSurfaceOnly" in rawProps) {
+    u.emitterSurfaceOnly.value = rawProps.emitterSurfaceOnly ? 1 : 0;
+  }
+  if ("emitterDirection" in rawProps && rawProps.emitterDirection && Array.isArray(rawProps.emitterDirection)) {
+    const dir = new THREE4.Vector3(
+      ...rawProps.emitterDirection
+    ).normalize();
+    u.emitterDir.value.x = dir.x;
+    u.emitterDir.value.y = dir.y;
+    u.emitterDir.value.z = dir.z;
+  }
+  if ("turbulence" in rawProps) {
+    u.turbulenceIntensity.value = (_i = (_h = rawProps.turbulence) == null ? void 0 : _h.intensity) != null ? _i : 0;
+    u.turbulenceFrequency.value = (_k = (_j = rawProps.turbulence) == null ? void 0 : _j.frequency) != null ? _k : 1;
+    u.turbulenceSpeed.value = (_m = (_l = rawProps.turbulence) == null ? void 0 : _l.speed) != null ? _m : 1;
+  }
+  if ("attractors" in rawProps) {
+    const attractorList = (_n = rawProps.attractors) != null ? _n : [];
+    u.attractorCount.value = Math.min(attractorList.length, MAX_ATTRACTORS);
+    for (let i = 0; i < MAX_ATTRACTORS; i++) {
+      const a = attractorList[i];
+      if (a) {
+        ;
+        u[`attractor${i}Pos`].value.set(
+          ...(_o = a.position) != null ? _o : [0, 0, 0]
+        );
+        u[`attractor${i}Strength`].value = (_p = a.strength) != null ? _p : 1;
+        u[`attractor${i}Radius`].value = (_q = a.radius) != null ? _q : 0;
+        u[`attractor${i}Type`].value = a.type === "vortex" ? 1 : 0;
+        u[`attractor${i}Axis`].value.set(...(_r = a.axis) != null ? _r : [0, 1, 0]).normalize();
+      } else {
+        u[`attractor${i}Strength`].value = 0;
+      }
+    }
+  }
+  if ("attractToCenter" in rawProps) {
+    u.attractToCenter.value = rawProps.attractToCenter ? 1 : 0;
+  }
+  if ("startPositionAsDirection" in rawProps) {
+    u.startPositionAsDirection.value = rawProps.startPositionAsDirection ? 1 : 0;
+  }
+  if ("softParticles" in rawProps) {
+    u.softParticlesEnabled.value = rawProps.softParticles ? 1 : 0;
+  }
+  if ("softDistance" in rawProps) {
+    u.softDistance.value = (_s = rawProps.softDistance) != null ? _s : 0.5;
+  }
+  if ("collision" in rawProps) {
+    u.collisionEnabled.value = rawProps.collision ? 1 : 0;
+    u.collisionPlaneY.value = (_v = (_u = (_t = rawProps.collision) == null ? void 0 : _t.plane) == null ? void 0 : _u.y) != null ? _v : 0;
+    u.collisionBounce.value = (_x = (_w = rawProps.collision) == null ? void 0 : _w.bounce) != null ? _x : 0.3;
+    u.collisionFriction.value = (_z = (_y = rawProps.collision) == null ? void 0 : _y.friction) != null ? _z : 0.8;
+    u.collisionDie.value = ((_A = rawProps.collision) == null ? void 0 : _A.die) ? 1 : 0;
+    u.sizeBasedGravity.value = (_C = (_B = rawProps.collision) == null ? void 0 : _B.sizeBasedGravity) != null ? _C : 0;
+  }
+}
+function updateUniformsCurveFlags(uniforms, flags) {
+  const u = uniforms;
+  u.fadeSizeCurveEnabled.value = flags.fadeSizeCurveEnabled ? 1 : 0;
+  u.fadeOpacityCurveEnabled.value = flags.fadeOpacityCurveEnabled ? 1 : 0;
+  u.velocityCurveEnabled.value = flags.velocityCurveEnabled ? 1 : 0;
+  u.rotationSpeedCurveEnabled.value = flags.rotationSpeedCurveEnabled ? 1 : 0;
+}
+function applySpawnOverrides(uniforms, overrides) {
+  if (!overrides) return null;
+  const u = uniforms;
+  const saved = {};
+  const setUniform = (key, value) => {
+    if (u[key]) {
+      saved[key] = u[key].value;
+      u[key].value = value;
+    }
+  };
+  if (overrides.size !== void 0) {
+    const range = toRange(overrides.size, [0.1, 0.3]);
+    setUniform("sizeMin", range[0]);
+    setUniform("sizeMax", range[1]);
+  }
+  if (overrides.speed !== void 0) {
+    const range = toRange(overrides.speed, [0.1, 0.1]);
+    setUniform("speedMin", range[0]);
+    setUniform("speedMax", range[1]);
+  }
+  if (overrides.lifetime !== void 0) {
+    const range = toRange(overrides.lifetime, [1, 2]);
+    setUniform("lifetimeMin", 1 / range[1]);
+    setUniform("lifetimeMax", 1 / range[0]);
+  }
+  if (overrides.direction !== void 0) {
+    const dir3D = toRotation3D(overrides.direction);
+    setUniform("dirMinX", dir3D[0][0]);
+    setUniform("dirMaxX", dir3D[0][1]);
+    setUniform("dirMinY", dir3D[1][0]);
+    setUniform("dirMaxY", dir3D[1][1]);
+    setUniform("dirMinZ", dir3D[2][0]);
+    setUniform("dirMaxZ", dir3D[2][1]);
+  }
+  if (overrides.startPosition !== void 0) {
+    const pos3D = toRotation3D(overrides.startPosition);
+    setUniform("startPosMinX", pos3D[0][0]);
+    setUniform("startPosMaxX", pos3D[0][1]);
+    setUniform("startPosMinY", pos3D[1][0]);
+    setUniform("startPosMaxY", pos3D[1][1]);
+    setUniform("startPosMinZ", pos3D[2][0]);
+    setUniform("startPosMaxZ", pos3D[2][1]);
+  }
+  if (overrides.gravity !== void 0) {
+    saved.gravity = u.gravity.value.clone();
+    u.gravity.value.set(...overrides.gravity);
+  }
+  if (overrides.colorStart !== void 0) {
+    const colors = overrides.colorStart.slice(0, 8).map(hexToRgb);
+    while (colors.length < 8)
+      colors.push(colors[colors.length - 1] || [1, 1, 1]);
+    setUniform("colorStartCount", overrides.colorStart.length);
+    colors.forEach((c, i) => {
+      if (u[`colorStart${i}`]) {
+        saved[`colorStart${i}`] = u[`colorStart${i}`].value.clone();
+        u[`colorStart${i}`].value.setRGB(...c);
+      }
+    });
+  }
+  if (overrides.colorEnd !== void 0) {
+    const colors = overrides.colorEnd.slice(0, 8).map(hexToRgb);
+    while (colors.length < 8)
+      colors.push(colors[colors.length - 1] || [1, 1, 1]);
+    setUniform("colorEndCount", overrides.colorEnd.length);
+    colors.forEach((c, i) => {
+      if (u[`colorEnd${i}`]) {
+        saved[`colorEnd${i}`] = u[`colorEnd${i}`].value.clone();
+        u[`colorEnd${i}`].value.setRGB(...c);
+      }
+    });
+  }
+  if (overrides.rotation !== void 0) {
+    const rot3D = toRotation3D(overrides.rotation);
+    setUniform("rotationMinX", rot3D[0][0]);
+    setUniform("rotationMaxX", rot3D[0][1]);
+    setUniform("rotationMinY", rot3D[1][0]);
+    setUniform("rotationMaxY", rot3D[1][1]);
+    setUniform("rotationMinZ", rot3D[2][0]);
+    setUniform("rotationMaxZ", rot3D[2][1]);
+  }
+  if (overrides.emitterShape !== void 0) {
+    setUniform("emitterShapeType", overrides.emitterShape);
+  }
+  if (overrides.emitterRadius !== void 0) {
+    const range = toRange(overrides.emitterRadius, [0, 1]);
+    setUniform("emitterRadiusInner", range[0]);
+    setUniform("emitterRadiusOuter", range[1]);
+  }
+  if (overrides.emitterAngle !== void 0) {
+    setUniform("emitterAngle", overrides.emitterAngle);
+  }
+  if (overrides.emitterHeight !== void 0) {
+    const range = toRange(overrides.emitterHeight, [0, 1]);
+    setUniform("emitterHeightMin", range[0]);
+    setUniform("emitterHeightMax", range[1]);
+  }
+  if (overrides.emitterSurfaceOnly !== void 0) {
+    setUniform("emitterSurfaceOnly", overrides.emitterSurfaceOnly ? 1 : 0);
+  }
+  if (overrides.emitterDirection !== void 0) {
+    saved.emitterDir = u.emitterDir.value.clone();
+    u.emitterDir.value.set(...overrides.emitterDirection).normalize();
+  }
+  return () => {
+    Object.entries(saved).forEach(([key, value]) => {
+      if (u[key]) {
+        u[key].value = value;
+      }
+    });
+  };
+}
+
+// src/storage.ts
+import * as THREE5 from "three/webgpu";
+import { instancedArray } from "three/tsl";
+var STRUCTURAL_KEYS = [
+  "maxParticles",
+  "lighting",
+  "appearance",
+  "shadow",
+  "orientToDirection"
+];
+function resolveFeatures(props) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const colorStart = (_a = props.colorStart) != null ? _a : ["#ffffff"];
+  const colorEnd = (_b = props.colorEnd) != null ? _b : null;
+  const rotation = (_c = props.rotation) != null ? _c : [0, 0];
+  const rotationSpeed = (_d = props.rotationSpeed) != null ? _d : [0, 0];
+  const turbulence = (_e = props.turbulence) != null ? _e : null;
+  const attractors = (_f = props.attractors) != null ? _f : null;
+  const collision = (_g = props.collision) != null ? _g : null;
+  const needsPerParticleColor = colorStart.length > 1 || colorEnd !== null;
+  const needsRotation = isNonDefaultRotation(rotation) || isNonDefaultRotation(rotationSpeed);
+  const hasTurbulence = turbulence !== null && ((_h = turbulence == null ? void 0 : turbulence.intensity) != null ? _h : 0) > 0;
+  const hasAttractors = attractors !== null && attractors.length > 0;
+  const hasCollision = collision !== null;
+  return {
+    needsPerParticleColor,
+    needsRotation,
+    turbulence: hasTurbulence,
+    attractors: hasAttractors,
+    collision: hasCollision,
+    rotation: needsRotation,
+    perParticleColor: needsPerParticleColor
+  };
+}
+function needsRecreation(currentFeatures, changedProps, mergedConfig) {
+  if (STRUCTURAL_KEYS.some((key) => key in changedProps)) return true;
+  const newFeatures = resolveFeatures(mergedConfig);
+  if (newFeatures.turbulence !== currentFeatures.turbulence) return true;
+  if (newFeatures.attractors !== currentFeatures.attractors) return true;
+  if (newFeatures.collision !== currentFeatures.collision) return true;
+  if (newFeatures.needsRotation !== currentFeatures.needsRotation) return true;
+  if (newFeatures.needsPerParticleColor !== currentFeatures.needsPerParticleColor)
+    return true;
+  return false;
+}
+function createStorageArrays(maxParticles, features) {
+  const arrays = {
+    positions: instancedArray(maxParticles, "vec3"),
+    velocities: instancedArray(maxParticles, "vec3"),
+    lifetimes: instancedArray(maxParticles, "float"),
+    fadeRates: instancedArray(maxParticles, "float"),
+    particleSizes: instancedArray(maxParticles, "float"),
+    particleRotations: null,
+    particleColorStarts: null,
+    particleColorEnds: null
+  };
+  if (features.needsRotation) {
+    arrays.particleRotations = instancedArray(maxParticles, "vec3");
+  }
+  if (features.needsPerParticleColor) {
+    arrays.particleColorStarts = instancedArray(maxParticles, "vec3");
+    arrays.particleColorEnds = instancedArray(maxParticles, "vec3");
+  }
+  return arrays;
+}
+function createRenderObject(geometry, material, maxParticles, shadow) {
+  if (geometry) {
+    const mesh = new THREE5.InstancedMesh(geometry, material, maxParticles);
+    mesh.frustumCulled = false;
+    mesh.castShadow = shadow;
+    mesh.receiveShadow = shadow;
+    return mesh;
+  } else {
+    const s = new THREE5.Sprite(material);
+    s.count = maxParticles;
+    s.frustumCulled = false;
+    return s;
+  }
+}
+
+// src/particle-system.ts
+var VFXParticleSystem = class {
+  constructor(renderer, options) {
+    this.nextIndex = 0;
+    this.initialized = false;
+    this.emitAccumulator = 0;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    this.renderer = renderer;
+    this.options = options;
+    this.normalizedProps = normalizeProps(options);
+    if (options.depthTest !== void 0) {
+      this.normalizedProps.depthTest = options.depthTest;
+    }
+    if (options.renderOrder !== void 0) {
+      this.normalizedProps.renderOrder = options.renderOrder;
+    }
+    const np = this.normalizedProps;
+    this.features = resolveFeatures(options);
+    this.uniforms = createUniforms(np);
+    this.storage = createStorageArrays(np.maxParticles, this.features);
+    if (options.fadeSizeCurve || options.fadeOpacityCurve || options.velocityCurve || options.rotationSpeedCurve) {
+      this.curveTexture = createCombinedCurveTexture(
+        (_a = options.fadeSizeCurve) != null ? _a : null,
+        (_b = options.fadeOpacityCurve) != null ? _b : null,
+        (_c = options.velocityCurve) != null ? _c : null,
+        (_d = options.rotationSpeedCurve) != null ? _d : null
+      );
+    } else {
+      this.curveTexture = createDefaultCurveTexture();
+    }
+    const u = this.uniforms;
+    u.fadeSizeCurveEnabled.value = options.fadeSizeCurve ? 1 : 0;
+    u.fadeOpacityCurveEnabled.value = options.fadeOpacityCurve ? 1 : 0;
+    u.velocityCurveEnabled.value = options.velocityCurve ? 1 : 0;
+    u.rotationSpeedCurveEnabled.value = options.rotationSpeedCurve ? 1 : 0;
+    this.computeInit = createInitCompute(this.storage, np.maxParticles);
+    this.computeSpawn = createSpawnCompute(
+      this.storage,
+      this.uniforms,
+      np.maxParticles
+    );
+    this.computeUpdate = createUpdateCompute(
+      this.storage,
+      this.uniforms,
+      this.curveTexture,
+      np.maxParticles,
+      {
+        turbulence: this.features.turbulence,
+        attractors: this.features.attractors,
+        collision: this.features.collision,
+        rotation: this.features.rotation,
+        perParticleColor: this.features.perParticleColor
+      }
+    );
+    this.material = createParticleMaterial(
+      this.storage,
+      this.uniforms,
+      this.curveTexture,
+      {
+        alphaMap: np.alphaMap,
+        flipbook: np.flipbook,
+        appearance: np.appearance,
+        lighting: np.lighting,
+        softParticles: np.softParticles,
+        geometry: np.geometry,
+        orientToDirection: np.orientToDirection,
+        shadow: np.shadow,
+        blending: np.blending,
+        opacityNode: (_e = options.opacityNode) != null ? _e : null,
+        colorNode: (_f = options.colorNode) != null ? _f : null,
+        backdropNode: (_g = options.backdropNode) != null ? _g : null,
+        alphaTestNode: (_h = options.alphaTestNode) != null ? _h : null,
+        castShadowNode: (_i = options.castShadowNode) != null ? _i : null
+      }
+    );
+    this.renderObject = createRenderObject(
+      np.geometry,
+      this.material,
+      np.maxParticles,
+      np.shadow
+    );
+    this.isEmitting = np.autoStart;
+    this.turbulenceSpeed = (_k = (_j = np.turbulence) == null ? void 0 : _j.speed) != null ? _k : 1;
+    this.position = [...np.position];
+  }
+  async init() {
+    if (this.initialized) return;
+    await this.renderer.computeAsync(this.computeInit);
+    if (this.options.curveTexturePath) {
+      try {
+        const result = await loadCurveTextureFromPath(
+          this.options.curveTexturePath
+        );
+        const src = result.texture.image.data;
+        const dst = this.curveTexture.image.data;
+        dst.set(src);
+        this.curveTexture.needsUpdate = true;
+        result.texture.dispose();
+        const u = this.uniforms;
+        u.fadeSizeCurveEnabled.value = result.activeChannels & CurveChannel.SIZE ? 1 : 0;
+        u.fadeOpacityCurveEnabled.value = result.activeChannels & CurveChannel.OPACITY ? 1 : 0;
+        u.velocityCurveEnabled.value = result.activeChannels & CurveChannel.VELOCITY ? 1 : 0;
+        u.rotationSpeedCurveEnabled.value = result.activeChannels & CurveChannel.ROTATION_SPEED ? 1 : 0;
+      } catch (err) {
+        console.warn(
+          `Failed to load curve texture: ${this.options.curveTexturePath}, using baked/default`,
+          err
+        );
+      }
+    }
+    this.initialized = true;
+  }
+  dispose() {
+    if (this.material) {
+      this.material.dispose();
+    }
+    if (this.renderObject) {
+      if (this.renderObject.geometry && !this.normalizedProps.geometry) {
+        this.renderObject.geometry.dispose();
+      }
+    }
+    this.initialized = false;
+    this.nextIndex = 0;
+  }
+  spawn(x, y, z, count = 20, overrides = null) {
+    if (!this.initialized || !this.renderer) return;
+    const restore = applySpawnOverrides(this.uniforms, overrides);
+    const u = this.uniforms;
+    const startIdx = this.nextIndex;
+    const endIdx = (startIdx + count) % this.normalizedProps.maxParticles;
+    u.spawnPosition.value.set(x, y, z);
+    u.spawnIndexStart.value = startIdx;
+    u.spawnIndexEnd.value = endIdx;
+    u.spawnSeed.value = Math.random() * 1e4;
+    this.nextIndex = endIdx;
+    this.renderer.computeAsync(this.computeSpawn);
+    if (restore) restore();
+  }
+  async update(delta) {
+    if (!this.initialized || !this.renderer) return;
+    const u = this.uniforms;
+    u.deltaTime.value = delta;
+    u.turbulenceTime.value += delta * this.turbulenceSpeed;
+    await this.renderer.computeAsync(this.computeUpdate);
+  }
+  autoEmit(delta) {
+    if (!this.isEmitting) return;
+    const [px, py, pz] = this.position;
+    const currentDelay = this.normalizedProps.delay;
+    const currentEmitCount = this.normalizedProps.emitCount;
+    if (!currentDelay) {
+      this.spawn(px, py, pz, currentEmitCount);
+    } else {
+      this.emitAccumulator += delta;
+      if (this.emitAccumulator >= currentDelay) {
+        this.emitAccumulator -= currentDelay;
+        this.spawn(px, py, pz, currentEmitCount);
+      }
+    }
+  }
+  start() {
+    this.isEmitting = true;
+    this.emitAccumulator = 0;
+  }
+  stop() {
+    this.isEmitting = false;
+  }
+  clear() {
+    ;
+    this.renderer.computeAsync(this.computeInit);
+    this.nextIndex = 0;
+  }
+  updateProps(props) {
+    const np = normalizeProps(__spreadValues(__spreadValues({}, this.options), props));
+    updateUniforms(this.uniforms, np);
+  }
+  setPosition(position) {
+    this.position = [...position];
+  }
+  setDelay(delay) {
+    this.normalizedProps.delay = delay;
+  }
+  setEmitCount(emitCount) {
+    this.normalizedProps.emitCount = emitCount;
+  }
+  setTurbulenceSpeed(speed) {
+    this.turbulenceSpeed = speed;
+  }
+  setCurveTexture(texture3) {
+    this.curveTexture = texture3;
+  }
+};
+
+// src/emitter.ts
+import { Vector3 as Vector32 } from "three/webgpu";
+var tempVec = new Vector32();
+var EmitterController = class {
+  constructor(options) {
+    this.system = null;
+    this.emitAccumulator = 0;
+    this.hasEmittedOnce = false;
+    var _a;
+    this.options = __spreadValues({}, options);
+    this.isEmitting = (_a = options.autoStart) != null ? _a : true;
+  }
+  setSystem(system) {
+    this.system = system;
+  }
+  getSystem() {
+    return this.system;
+  }
+  updateOptions(options) {
+    this.options = __spreadValues(__spreadValues({}, this.options), options);
+    if (options.autoStart !== void 0) {
+      this.isEmitting = options.autoStart;
+      if (options.autoStart) {
+        this.hasEmittedOnce = false;
+        this.emitAccumulator = 0;
+      }
+    }
+  }
+  // Transform a direction range by quaternion
+  transformDirectionByQuat(dirRange, quat) {
+    const minDir = tempVec.set(dirRange[0][0], dirRange[1][0], dirRange[2][0]);
+    minDir.applyQuaternion(quat);
+    const maxDir = new Vector32(dirRange[0][1], dirRange[1][1], dirRange[2][1]);
+    maxDir.applyQuaternion(quat);
+    return [
+      [Math.min(minDir.x, maxDir.x), Math.max(minDir.x, maxDir.x)],
+      [Math.min(minDir.y, maxDir.y), Math.max(minDir.y, maxDir.y)],
+      [Math.min(minDir.z, maxDir.z), Math.max(minDir.z, maxDir.z)]
+    ];
+  }
+  update(delta, worldPosition, worldQuaternion) {
+    var _a, _b;
+    if (!this.isEmitting) return;
+    const loop = (_a = this.options.loop) != null ? _a : true;
+    if (!loop && this.hasEmittedOnce) return;
+    const delay = (_b = this.options.delay) != null ? _b : 0;
+    if (delay <= 0) {
+      const success = this.emitAtPosition(worldPosition, worldQuaternion);
+      if (success) this.hasEmittedOnce = true;
+    } else {
+      this.emitAccumulator += delta;
+      if (this.emitAccumulator >= delay) {
+        this.emitAccumulator -= delay;
+        const success = this.emitAtPosition(worldPosition, worldQuaternion);
+        if (success) this.hasEmittedOnce = true;
+      }
+    }
+  }
+  emit(emitOverrides = null) {
+    var _a;
+    if (!((_a = this.system) == null ? void 0 : _a.spawn)) return false;
+    return this.doEmit({ x: 0, y: 0, z: 0 }, void 0, emitOverrides);
+  }
+  emitAtPosition(worldPosition, worldQuaternion, emitOverrides = null) {
+    return this.doEmit(worldPosition, worldQuaternion, emitOverrides);
+  }
+  burst(count, worldPosition, worldQuaternion) {
+    var _a, _b, _c;
+    if (!((_a = this.system) == null ? void 0 : _a.spawn)) return false;
+    const direction = this.options.direction;
+    let emitDir = direction;
+    if (this.options.localDirection && direction && worldQuaternion) {
+      emitDir = this.transformDirectionByQuat(direction, worldQuaternion);
+    }
+    const finalOverrides = emitDir ? __spreadProps(__spreadValues({}, this.options.overrides), { direction: emitDir }) : this.options.overrides;
+    this.system.spawn(
+      worldPosition.x,
+      worldPosition.y,
+      worldPosition.z,
+      (_b = count != null ? count : this.options.emitCount) != null ? _b : 10,
+      finalOverrides
+    );
+    if (this.options.onEmit) {
+      this.options.onEmit({
+        position: [worldPosition.x, worldPosition.y, worldPosition.z],
+        count: (_c = count != null ? count : this.options.emitCount) != null ? _c : 10,
+        direction: emitDir
+      });
+    }
+    return true;
+  }
+  start() {
+    this.isEmitting = true;
+    this.hasEmittedOnce = false;
+    this.emitAccumulator = 0;
+  }
+  stop() {
+    this.isEmitting = false;
+  }
+  doEmit(worldPosition, worldQuaternion, emitOverrides = null) {
+    var _a, _c;
+    if (!((_a = this.system) == null ? void 0 : _a.spawn)) return false;
+    const direction = this.options.direction;
+    let emitDir = direction;
+    if (this.options.localDirection && direction && worldQuaternion) {
+      emitDir = this.transformDirectionByQuat(direction, worldQuaternion);
+    }
+    const emitTimeDirection = emitOverrides == null ? void 0 : emitOverrides.direction;
+    let finalDir = emitDir;
+    if (emitTimeDirection && this.options.localDirection && worldQuaternion) {
+      finalDir = this.transformDirectionByQuat(
+        emitTimeDirection,
+        worldQuaternion
+      );
+    } else if (emitTimeDirection) {
+      finalDir = emitTimeDirection;
+    }
+    const _b = emitOverrides || {}, { direction: _ } = _b, emitOverridesWithoutDir = __objRest(_b, ["direction"]);
+    const mergedOverrides = __spreadValues(__spreadValues({}, this.options.overrides), emitOverridesWithoutDir);
+    const finalOverrides = finalDir ? __spreadProps(__spreadValues({}, mergedOverrides), { direction: finalDir }) : mergedOverrides;
+    const emitCount = (_c = this.options.emitCount) != null ? _c : 10;
+    this.system.spawn(
+      worldPosition.x,
+      worldPosition.y,
+      worldPosition.z,
+      emitCount,
+      finalOverrides
+    );
+    if (this.options.onEmit) {
+      this.options.onEmit({
+        position: [worldPosition.x, worldPosition.y, worldPosition.z],
+        count: emitCount,
+        direction: finalDir
+      });
+    }
+    return true;
+  }
+};
 export {
   Appearance,
   AttractorType,
@@ -1285,9 +2454,13 @@ export {
   CurveChannel,
   DEFAULT_LINEAR_CURVE,
   Easing,
+  EmitterController,
   EmitterShape,
   Lighting,
   MAX_ATTRACTORS,
+  STRUCTURAL_KEYS,
+  VFXParticleSystem,
+  applySpawnOverrides,
   axisToNumber,
   bakeCurveToArray,
   buildCurveTextureBin,
@@ -1296,15 +2469,27 @@ export {
   createDefaultCurveTexture,
   createInitCompute,
   createParticleMaterial,
+  createRenderObject,
   createSpawnCompute,
+  createStorageArrays,
+  createUniforms,
   createUpdateCompute,
   easingToType,
   evaluateBezierSegment,
   hexToRgb,
+  isNonDefaultRotation,
+  isWebGPUBackend,
   lifetimeToFadeRate,
   loadCurveTextureFromPath,
+  needsRecreation,
+  normalizeProps,
+  resolveCurveTexture,
+  resolveFeatures,
   sampleCurveAtX,
   selectColor,
   toRange,
-  toRotation3D
+  toRotation3D,
+  updateUniforms,
+  updateUniformsCurveFlags,
+  updateUniformsPartial
 };