r3f-vfx 0.0.9 → 0.1.1

package/dist/index.js

@@ -18,6 +18,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -45,6 +57,117 @@ var init_react_store = __esm({
   }
 });
 
+// src/useCurveTextureAsync.ts
+import { useRef, useEffect } from "react";
+import {
+  createDefaultCurveTexture,
+  loadCurveTextureFromPath
+} from "core-vfx";
+var import_meta, curveWorker, curveWorkerCallbacks, curveWorkerIdCounter, getCurveWorker, bakeCurvesAsync, useCurveTextureAsync;
+var init_useCurveTextureAsync = __esm({
+  "src/useCurveTextureAsync.ts"() {
+    "use strict";
+    import_meta = {};
+    curveWorker = null;
+    curveWorkerCallbacks = /* @__PURE__ */ new Map();
+    curveWorkerIdCounter = 0;
+    getCurveWorker = () => {
+      if (!curveWorker) {
+        curveWorker = new Worker(new URL("./curveWorker.js", import_meta.url), {
+          type: "module"
+        });
+        curveWorker.onmessage = (e) => {
+          const { id, rgba } = e.data;
+          const callback = curveWorkerCallbacks.get(id);
+          if (callback) {
+            callback(rgba);
+            curveWorkerCallbacks.delete(id);
+          }
+        };
+      }
+      return curveWorker;
+    };
+    bakeCurvesAsync = (sizeCurve, opacityCurve, velocityCurve, rotationSpeedCurve) => {
+      return new Promise((resolve) => {
+        const worker = getCurveWorker();
+        const id = curveWorkerIdCounter++;
+        curveWorkerCallbacks.set(id, resolve);
+        worker.postMessage({
+          id,
+          sizeCurve,
+          opacityCurve,
+          velocityCurve,
+          rotationSpeedCurve
+        });
+      });
+    };
+    useCurveTextureAsync = (sizeCurve, opacityCurve, velocityCurve, rotationSpeedCurve, curveTexturePath = null) => {
+      const textureRef = useRef(null);
+      const pendingRef = useRef(null);
+      if (!textureRef.current) {
+        textureRef.current = createDefaultCurveTexture();
+      }
+      useEffect(() => {
+        const requestId = {};
+        pendingRef.current = requestId;
+        const hasAnyCurve = sizeCurve || opacityCurve || velocityCurve || rotationSpeedCurve;
+        if (curveTexturePath) {
+          loadCurveTextureFromPath(curveTexturePath, textureRef.current).catch(
+            (err) => {
+              console.warn(
+                `Failed to load curve texture: ${curveTexturePath}, falling back to baking`,
+                err
+              );
+              return bakeCurvesAsync(
+                sizeCurve,
+                opacityCurve,
+                velocityCurve,
+                rotationSpeedCurve
+              ).then((rgba) => {
+                var _a;
+                if (pendingRef.current === requestId && ((_a = textureRef.current) == null ? void 0 : _a.image.data)) {
+                  textureRef.current.image.data.set(rgba);
+                  textureRef.current.needsUpdate = true;
+                }
+              });
+            }
+          );
+        } else if (hasAnyCurve) {
+          bakeCurvesAsync(
+            sizeCurve,
+            opacityCurve,
+            velocityCurve,
+            rotationSpeedCurve
+          ).then((rgba) => {
+            var _a;
+            if (pendingRef.current === requestId && ((_a = textureRef.current) == null ? void 0 : _a.image.data)) {
+              textureRef.current.image.data.set(rgba);
+              textureRef.current.needsUpdate = true;
+            }
+          });
+        }
+        return () => {
+          pendingRef.current = null;
+        };
+      }, [
+        sizeCurve,
+        opacityCurve,
+        velocityCurve,
+        rotationSpeedCurve,
+        curveTexturePath
+      ]);
+      useEffect(() => {
+        return () => {
+          var _a;
+          (_a = textureRef.current) == null ? void 0 : _a.dispose();
+          textureRef.current = null;
+        };
+      }, []);
+      return textureRef.current;
+    };
+  }
+});
+
 // src/VFXParticlesDebugPanel.jsx
 var VFXParticlesDebugPanel_exports = {};
 __export(VFXParticlesDebugPanel_exports, {
@@ -57,7 +180,7 @@ __export(VFXParticlesDebugPanel_exports, {
   updateDebugPanel: () => updateDebugPanel
 });
 import { createRoot } from "react-dom/client";
-import { useState, useCallback, useRef, useEffect } from "react";
+import { useState, useCallback, useRef as useRef2, useEffect as useEffect2 } from "react";
 import * as THREE from "three";
 import { create } from "zustand";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -74,7 +197,7 @@ function renderDebugPanel(values, onChange) {
       style.id = styleId;
       style.textContent = `
         @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap');
-        
+
         @keyframes dotPulse {
           0%, 100% {
             box-shadow: 0 0 4px rgba(249, 115, 22, 0.4), 0 0 8px rgba(249, 115, 22, 0.2);
@@ -85,12 +208,12 @@ function renderDebugPanel(values, onChange) {
             transform: scale(1.1);
           }
         }
-        
+
         @keyframes spin {
           from { transform: rotate(0deg); }
           to { transform: rotate(360deg); }
         }
-        
+
         #vfx-debug-panel-root *::-webkit-scrollbar {
           width: 6px;
           height: 6px;
@@ -225,7 +348,7 @@ function destroyDebugPanel() {
   currentValues = null;
   currentOnChange = null;
 }
-var useDebugPanelStore, getFlushChanges, setFlushChanges, GeometryType, geometryDefaults, DEFAULT_VALUES, createGeometry, debugRoot, debugContainer, currentValues, currentOnChange, wrapped, formatJSXValue, geometryTypeToJSX, generateVFXParticlesJSX, styles, parseRange, parse3D, Section, useScrubber, ScrubInput, NumberInput, RangeInput, Vec3Input, Range3DInput, SelectInput, CheckboxInput, CustomColorPicker, ColorArrayInput, EasingCurveEditor, LoadingSpinner, DebugPanelContent, VFXParticlesDebugPanel_default;
+var useDebugPanelStore, getFlushChanges, setFlushChanges, GeometryType, geometryDefaults, DEFAULT_VALUES, createGeometry, debugRoot, debugContainer, currentValues, currentOnChange, wrapped, formatJSXValue, geometryTypeToJSX, arraysEqual, isDefaultFriction, isDefaultTurbulence, generateVFXParticlesJSX, styles, parseRange, parse3D, Section, useScrubber, ScrubInput, NumberInput, RangeInput, Vec3Input, Range3DInput, SelectInput, CheckboxInput, CustomColorPicker, ColorArrayInput, EasingCurveEditor, LoadingSpinner, DebugPanelContent, VFXParticlesDebugPanel_default;
 var init_VFXParticlesDebugPanel = __esm({
   "src/VFXParticlesDebugPanel.jsx"() {
     "use strict";
@@ -432,17 +555,11 @@ var init_VFXParticlesDebugPanel = __esm({
             mergedArgs.detail
           );
         case GeometryType.ICOSAHEDRON:
-          return new THREE.IcosahedronGeometry(
-            mergedArgs.radius,
-            mergedArgs.detail
-          );
+          return new THREE.IcosahedronGeometry(mergedArgs.radius, mergedArgs.detail);
         case GeometryType.OCTAHEDRON:
           return new THREE.OctahedronGeometry(mergedArgs.radius, mergedArgs.detail);
         case GeometryType.TETRAHEDRON:
-          return new THREE.TetrahedronGeometry(
-            mergedArgs.radius,
-            mergedArgs.detail
-          );
+          return new THREE.TetrahedronGeometry(mergedArgs.radius, mergedArgs.detail);
         case GeometryType.CAPSULE:
           return new THREE.CapsuleGeometry(
             mergedArgs.radius,
@@ -584,9 +701,31 @@ ${" ".repeat(indent - 2)}}`;
           return null;
       }
     };
+    arraysEqual = (a, b) => {
+      if (!Array.isArray(a) || !Array.isArray(b)) return false;
+      if (a.length !== b.length) return false;
+      return a.every((v, i) => {
+        if (Array.isArray(v) && Array.isArray(b[i])) return arraysEqual(v, b[i]);
+        return v === b[i];
+      });
+    };
+    isDefaultFriction = (f) => {
+      if (!f) return true;
+      const intensity = f.intensity;
+      if (Array.isArray(intensity)) {
+        return intensity[0] === 0 && intensity[1] === 0;
+      }
+      return intensity === 0 || intensity === void 0;
+    };
+    isDefaultTurbulence = (t) => {
+      if (!t) return true;
+      return t.intensity === 0 || t.intensity === void 0;
+    };
     generateVFXParticlesJSX = (values) => {
       const props = [];
       const propOrder = [
+        "name",
+        "curveTexturePath",
         "maxParticles",
         "position",
         "autoStart",
@@ -639,24 +778,61 @@ ${" ".repeat(indent - 2)}}`;
       for (const key of propOrder) {
         const value = values[key];
         if (value === void 0 || value === null) continue;
+        if (key === "name" && !value) continue;
+        if (key === "curveTexturePath" && !value) continue;
         if (key === "maxParticles" && value === 1e4) continue;
+        if (key === "position" && arraysEqual(value, [0, 0, 0])) continue;
         if (key === "autoStart" && value === true) continue;
         if (key === "emitCount" && value === 1) continue;
         if (key === "delay" && value === 0) continue;
         if (key === "intensity" && value === 1) continue;
+        if (key === "size" && arraysEqual(value, [0.1, 0.3])) continue;
+        if (key === "speed" && arraysEqual(value, [0.1, 0.1])) continue;
+        if (key === "lifetime" && arraysEqual(value, [1, 2])) continue;
+        if (key === "fadeSize" && arraysEqual(value, [1, 0])) continue;
+        if (key === "fadeOpacity" && arraysEqual(value, [1, 0])) continue;
+        if (key === "colorStart" && arraysEqual(value, ["#ffffff"])) continue;
+        if (key === "gravity" && arraysEqual(value, [0, 0, 0])) continue;
+        if (key === "friction" && isDefaultFriction(value)) continue;
+        if (key === "friction" && values.velocityCurve) continue;
+        if (key === "direction" && arraysEqual(value, [
+          [-1, 1],
+          [0, 1],
+          [-1, 1]
+        ]))
+          continue;
+        if (key === "direction" && values.startPositionAsDirection) continue;
+        if (key === "startPosition" && arraysEqual(value, [
+          [0, 0],
+          [0, 0],
+          [0, 0]
+        ]))
+          continue;
+        if (key === "startPositionAsDirection" && value === false) continue;
+        if (key === "rotation" && arraysEqual(value, [0, 0])) continue;
+        if (key === "rotationSpeed" && arraysEqual(value, [0, 0])) continue;
+        if (key === "appearance" && value === 0) continue;
+        if (key === "blending" && value === 1) continue;
+        if (key === "lighting" && value === 1) continue;
         if (key === "shadow" && value === false) continue;
         if (key === "orientToDirection" && value === false) continue;
         if (key === "orientAxis") {
           const axisNeeded = values.orientToDirection || values.stretchBySpeed;
           if (!axisNeeded || value === "z" || value === "+z") continue;
         }
-        if (key === "softParticles" && value === false) continue;
-        if (key === "attractToCenter" && value === false) continue;
-        if (key === "startPositionAsDirection" && value === false) continue;
-        if (key === "direction" && values.startPositionAsDirection) continue;
+        if (key === "stretchBySpeed" && !value) continue;
+        if (key === "emitterShape" && value === 0) continue;
+        if (key === "emitterRadius" && arraysEqual(value, [0, 1])) continue;
+        if (key === "emitterAngle" && Math.abs(value - Math.PI / 4) < 1e-3)
+          continue;
+        if (key === "emitterHeight" && arraysEqual(value, [0, 1])) continue;
+        if (key === "emitterDirection" && arraysEqual(value, [0, 1, 0])) continue;
         if (key === "emitterSurfaceOnly" && value === false) continue;
+        if (key === "turbulence" && isDefaultTurbulence(value)) continue;
+        if (key === "collision" && !value) continue;
+        if (key === "softParticles" && value === false) continue;
         if (key === "softDistance" && !values.softParticles) continue;
-        if (key === "friction" && values.velocityCurve) continue;
+        if (key === "attractToCenter" && value === false) continue;
         const formatted = formatJSXValue(key, value);
         if (formatted) props.push(formatted);
       }
@@ -1070,9 +1246,9 @@ ${" ".repeat(indent - 2)}}`;
     }) => {
       const [isOpen, setIsOpen] = useState(defaultOpen);
       const [isHovered, setIsHovered] = useState(false);
-      const contentRef = useRef(null);
+      const contentRef = useRef2(null);
       const [contentHeight, setContentHeight] = useState(defaultOpen ? "auto" : 0);
-      useEffect(() => {
+      useEffect2(() => {
         if (contentRef.current) {
           if (isOpen) {
             const height = contentRef.current.scrollHeight;
@@ -1149,10 +1325,10 @@ ${" ".repeat(indent - 2)}}`;
       );
     };
     useScrubber = (value, onChange, step = 0.01, min, max) => {
-      const isDraggingRef = useRef(false);
-      const hasMoved = useRef(false);
-      const startX = useRef(0);
-      const startValue = useRef(0);
+      const isDraggingRef = useRef2(false);
+      const hasMoved = useRef2(false);
+      const startX = useRef2(0);
+      const startValue = useRef2(0);
       const [isDragging, setIsDragging] = useState(false);
       const handleMouseDown = useCallback(
         (e) => {
@@ -1210,7 +1386,7 @@ ${" ".repeat(indent - 2)}}`;
       style,
       placeholder
     }) => {
-      const inputRef = useRef(null);
+      const inputRef = useRef2(null);
       const [localValue, setLocalValue] = useState(String(value));
       const [isFocused, setIsFocused] = useState(false);
       const { handleMouseDown, hasMoved, isDragging } = useScrubber(
@@ -1220,7 +1396,7 @@ ${" ".repeat(indent - 2)}}`;
         min,
         max
       );
-      useEffect(() => {
+      useEffect2(() => {
         if (!isFocused) {
           setLocalValue(String(value));
         }
@@ -1592,10 +1768,10 @@ ${" ".repeat(indent - 2)}}`;
     CustomColorPicker = ({ color, onChange }) => {
       const [isOpen, setIsOpen] = useState(false);
       const [hexInput, setHexInput] = useState(color);
-      const pickerRef = useRef(null);
-      const gradientRef = useRef(null);
-      const isDraggingGradient = useRef(false);
-      const isDraggingHue = useRef(false);
+      const pickerRef = useRef2(null);
+      const gradientRef = useRef2(null);
+      const isDraggingGradient = useRef2(false);
+      const isDraggingHue = useRef2(false);
       const presets = [
         "#ffffff",
         "#f97316",
@@ -1688,13 +1864,13 @@ ${" ".repeat(indent - 2)}}`;
         return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
       };
       const [hsv, setHsv] = useState(() => hexToHsv(color));
-      useEffect(() => {
+      useEffect2(() => {
         if (!isOpen) {
           setHsv(hexToHsv(color));
           setHexInput(color);
         }
       }, [color, isOpen]);
-      useEffect(() => {
+      useEffect2(() => {
         if (!isOpen) return;
         const handleClickOutside = (e) => {
           if (pickerRef.current && !pickerRef.current.contains(e.target)) {
@@ -2024,21 +2200,21 @@ ${" ".repeat(indent - 2)}}`;
           { pos: [1, 0], handleIn: [-0.3, 0] }
         ]
       };
-      const canvasRef = useRef(null);
-      const containerRef = useRef(null);
-      const draggingRef = useRef(null);
-      const localDataRef = useRef((value == null ? void 0 : value.points) || defaultValue.points);
+      const canvasRef = useRef2(null);
+      const containerRef = useRef2(null);
+      const draggingRef = useRef2(null);
+      const localDataRef = useRef2((value == null ? void 0 : value.points) || defaultValue.points);
       const [, forceUpdate] = useState(0);
       const [hoverItem, setHoverItem] = useState(null);
       const [selectedPoint, setSelectedPoint] = useState(null);
       const [isScaling, setIsScaling] = useState(false);
-      const scaleStartRef = useRef(null);
+      const scaleStartRef = useRef2(null);
       const [isRotating, setIsRotating] = useState(false);
-      const rotateStartRef = useRef(null);
+      const rotateStartRef = useRef2(null);
       const SIZE = 260;
       const PADDING = 30;
       const GRAPH_SIZE = SIZE - 2 * PADDING;
-      useEffect(() => {
+      useEffect2(() => {
         if (value == null ? void 0 : value.points) {
           localDataRef.current = value.points;
           forceUpdate((n) => n + 1);
@@ -2229,7 +2405,7 @@ ${" ".repeat(indent - 2)}}`;
         ctx.fillText("value \u2192", 0, 0);
         ctx.restore();
       }, [toCanvas, hoverItem, GRAPH_SIZE, selectedPoint, isScaling, isRotating]);
-      useEffect(() => {
+      useEffect2(() => {
         draw();
       }, [draw]);
       const hitTest = useCallback(
@@ -2266,7 +2442,7 @@ ${" ".repeat(indent - 2)}}`;
         },
         [toCanvas]
       );
-      useEffect(() => {
+      useEffect2(() => {
         const handleMouseMove = (e) => {
           if (!canvasRef.current) return;
           const rect = canvasRef.current.getBoundingClientRect();
@@ -3376,22 +3552,23 @@ ${" ".repeat(indent - 2)}}`;
       const [isMinimized, setIsMinimized] = useState(false);
       const [panelSize, setPanelSize] = useState({ width: 380, height: null });
       const [copySuccess, setCopySuccess] = useState(false);
+      const [bakeSuccess, setBakeSuccess] = useState(false);
       const [hasPendingChanges, setHasPendingChanges] = useState(false);
-      const valuesRef = useRef(initialValues);
-      const dirtyKeysRef = useRef(/* @__PURE__ */ new Set());
+      const valuesRef = useRef2(initialValues);
+      const dirtyKeysRef = useRef2(/* @__PURE__ */ new Set());
       const [, forceUpdate] = useState(0);
-      const isResizing = useRef(false);
-      const resizeType = useRef(null);
-      const debounceTimerRef = useRef(null);
+      const isResizing = useRef2(false);
+      const resizeType = useRef2(null);
+      const debounceTimerRef = useRef2(null);
       const DEBOUNCE_DELAY = 500;
       const [searchQuery, setSearchQuery] = useState("");
-      const historyRef = useRef([JSON.parse(JSON.stringify(initialValues))]);
+      const historyRef = useRef2([JSON.parse(JSON.stringify(initialValues))]);
       const [historyIndex, setHistoryIndex] = useState(0);
       const [historyLength, setHistoryLength] = useState(1);
       const MAX_HISTORY = 50;
-      const isUndoingRef = useRef(false);
-      const prevInitialValuesRef = useRef(initialValues);
-      useEffect(() => {
+      const isUndoingRef = useRef2(false);
+      const prevInitialValuesRef = useRef2(initialValues);
+      useEffect2(() => {
         if (initialValues !== prevInitialValuesRef.current) {
           const merged = __spreadValues({}, valuesRef.current);
           for (const key in initialValues) {
@@ -3428,7 +3605,7 @@ ${" ".repeat(indent - 2)}}`;
           flushChanges();
         }, DEBOUNCE_DELAY);
       }, [flushChanges]);
-      useEffect(() => {
+      useEffect2(() => {
         return () => {
           if (debounceTimerRef.current) {
             clearTimeout(debounceTimerRef.current);
@@ -3448,7 +3625,118 @@ ${" ".repeat(indent - 2)}}`;
           console.error("Failed to copy:", err);
         }
       }, [hasPendingChanges, flushChanges]);
-      const recordHistoryTimeoutRef = useRef(null);
+      const handleBakeCurves = useCallback(async () => {
+        if (hasPendingChanges) {
+          flushChanges();
+        }
+        const values2 = valuesRef.current;
+        const CURVE_RESOLUTION2 = 256;
+        const 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 cp3 = p1;
+          const mt = 1 - t;
+          const mt2 = mt * mt;
+          const mt3 = mt2 * mt;
+          const t2 = t * t;
+          const t3 = t2 * t;
+          return [
+            mt3 * cp0[0] + 3 * mt2 * t * cp1[0] + 3 * mt * t2 * cp2[0] + t3 * cp3[0],
+            mt3 * cp0[1] + 3 * mt2 * t * cp1[1] + 3 * mt * t2 * cp2[1] + t3 * cp3[1]
+          ];
+        };
+        const sampleCurveAtX = (x, points) => {
+          var _a2, _b2, _c2, _d2;
+          if (!points || points.length < 2) return x;
+          if (!((_a2 = points[0]) == null ? void 0 : _a2.pos) || !((_b2 = points[points.length - 1]) == null ? void 0 : _b2.pos)) return x;
+          let segmentIdx = 0;
+          for (let i = 0; i < points.length - 1; i++) {
+            if (((_c2 = points[i]) == null ? void 0 : _c2.pos) && ((_d2 = points[i + 1]) == null ? void 0 : _d2.pos) && x >= points[i].pos[0] && x <= points[i + 1].pos[0]) {
+              segmentIdx = i;
+              break;
+            }
+          }
+          const p0 = points[segmentIdx];
+          const p1 = points[segmentIdx + 1];
+          if (!(p0 == null ? void 0 : p0.pos) || !(p1 == null ? void 0 : p1.pos)) return x;
+          let tLow = 0, tHigh = 1, t = 0.5;
+          for (let iter = 0; iter < 20; iter++) {
+            const [px] = evaluateBezierSegment(
+              t,
+              p0.pos,
+              p1.pos,
+              p0.handleOut,
+              p1.handleIn
+            );
+            if (Math.abs(px - x) < 1e-4) break;
+            if (px < x) {
+              tLow = t;
+            } else {
+              tHigh = t;
+            }
+            t = (tLow + tHigh) / 2;
+          }
+          const [, py] = evaluateBezierSegment(
+            t,
+            p0.pos,
+            p1.pos,
+            p0.handleOut,
+            p1.handleIn
+          );
+          return Math.max(-0.5, Math.min(1.5, py));
+        };
+        const bakeCurveToArray2 = (curveData) => {
+          const data = new Float32Array(CURVE_RESOLUTION2);
+          if (!(curveData == null ? void 0 : curveData.points) || !Array.isArray(curveData.points) || curveData.points.length < 2) {
+            for (let i = 0; i < CURVE_RESOLUTION2; i++) {
+              data[i] = 1 - i / (CURVE_RESOLUTION2 - 1);
+            }
+            return data;
+          }
+          const firstPoint = curveData.points[0];
+          const lastPoint = curveData.points[curveData.points.length - 1];
+          if (!(firstPoint == null ? void 0 : firstPoint.pos) || !(lastPoint == null ? void 0 : lastPoint.pos) || !Array.isArray(firstPoint.pos) || !Array.isArray(lastPoint.pos)) {
+            for (let i = 0; i < CURVE_RESOLUTION2; i++) {
+              data[i] = 1 - i / (CURVE_RESOLUTION2 - 1);
+            }
+            return data;
+          }
+          for (let i = 0; i < CURVE_RESOLUTION2; i++) {
+            const x = i / (CURVE_RESOLUTION2 - 1);
+            data[i] = sampleCurveAtX(x, curveData.points);
+          }
+          return data;
+        };
+        const sizeData = bakeCurveToArray2(values2.fadeSizeCurve);
+        const opacityData = bakeCurveToArray2(values2.fadeOpacityCurve);
+        const velocityData = bakeCurveToArray2(values2.velocityCurve);
+        const rotationSpeedData = bakeCurveToArray2(values2.rotationSpeedCurve);
+        const rgba = new Float32Array(CURVE_RESOLUTION2 * 4);
+        for (let i = 0; i < CURVE_RESOLUTION2; i++) {
+          rgba[i * 4] = sizeData[i];
+          rgba[i * 4 + 1] = opacityData[i];
+          rgba[i * 4 + 2] = velocityData[i];
+          rgba[i * 4 + 3] = rotationSpeedData[i];
+        }
+        const vfxName = values2.name || `vfx-curves-${Date.now()}`;
+        const filename = `${vfxName.replace(/[^a-zA-Z0-9-_]/g, "-")}.bin`;
+        const blob = new Blob([rgba.buffer], { type: "application/octet-stream" });
+        const link = document.createElement("a");
+        link.download = filename;
+        link.href = URL.createObjectURL(blob);
+        link.click();
+        URL.revokeObjectURL(link.href);
+        setBakeSuccess(true);
+        setTimeout(() => setBakeSuccess(false), 2e3);
+        const texturePath = `/vfx/curves/${filename}`;
+        try {
+          await navigator.clipboard.writeText(`curveTexturePath="${texturePath}"`);
+        } catch (err) {
+          console.error("Failed to copy texture path:", err);
+        }
+      }, [hasPendingChanges, flushChanges]);
+      const recordHistoryTimeoutRef = useRef2(null);
       const recordHistory = useCallback(() => {
         if (isUndoingRef.current) return;
         if (recordHistoryTimeoutRef.current) {
@@ -3497,9 +3785,7 @@ ${" ".repeat(indent - 2)}}`;
           isUndoingRef.current = true;
           const newIndex = historyIndex + 1;
           setHistoryIndex(newIndex);
-          const nextState = JSON.parse(
-            JSON.stringify(historyRef.current[newIndex])
-          );
+          const nextState = JSON.parse(JSON.stringify(historyRef.current[newIndex]));
           valuesRef.current = nextState;
           for (const key in nextState) {
             dirtyKeysRef.current.add(key);
@@ -3538,7 +3824,7 @@ ${" ".repeat(indent - 2)}}`;
           isUndoingRef.current = false;
         }, 50);
       }, [flushChanges, historyIndex]);
-      useEffect(() => {
+      useEffect2(() => {
         const handleKeyDown = (e) => {
           if (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA")
             return;
@@ -3593,7 +3879,7 @@ ${" ".repeat(indent - 2)}}`;
         },
         [scheduleUpdate, recordHistory]
       );
-      useEffect(() => {
+      useEffect2(() => {
         setFlushChanges(flushChanges);
         return () => setFlushChanges(null);
       }, [flushChanges]);
@@ -3835,6 +4121,16 @@ ${" ".repeat(indent - 2)}}`;
                 children: copySuccess ? "\u2713 copied" : "copy jsx"
               }
             ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                style: __spreadProps(__spreadValues(__spreadValues({}, styles.copyBtn), bakeSuccess ? styles.copyBtnSuccess : {}), {
+                  marginLeft: "4px"
+                }),
+                onClick: handleBakeCurves,
+                children: bakeSuccess ? "\u2713 exported" : "bake curves"
+              }
+            ),
             /* @__PURE__ */ jsx(
               "button",
               {
@@ -5128,8 +5424,8 @@ ${" ".repeat(indent - 2)}}`;
 import {
   forwardRef,
   useImperativeHandle,
-  useEffect as useEffect2,
-  useRef as useRef2,
+  useEffect as useEffect3,
+  useRef as useRef3,
   useMemo,
   useCallback as useCallback2,
   useState as useState2
@@ -5149,7 +5445,6 @@ import {
   axisToNumber,
   toRotation3D,
   lifetimeToFadeRate,
-  createCombinedCurveTexture,
   createInitCompute,
   createSpawnCompute,
   createUpdateCompute,
@@ -5171,1286 +5466,1433 @@ var init_VFXParticles = __esm({
   "src/VFXParticles.tsx"() {
     "use strict";
     init_react_store();
-    VFXParticles = forwardRef(function VFXParticles2({
-      name,
-      // Optional name for registering with useVFXStore (enables VFXEmitter linking)
-      maxParticles = 1e4,
-      size = [0.1, 0.3],
-      colorStart = ["#ffffff"],
-      colorEnd = null,
-      // If null, uses colorStart (no color transition)
-      fadeSize = [1, 0],
-      fadeSizeCurve = null,
-      // Curve data { points: [...] } - controls fadeSize over lifetime (overrides fadeSize if set)
-      fadeOpacity = [1, 0],
-      fadeOpacityCurve = null,
-      // Curve data { points: [...] } - controls fadeOpacity over lifetime (overrides fadeOpacity if set)
-      velocityCurve = null,
-      // Curve data { points: [...] } - controls velocity/speed over lifetime (overrides friction if set)
-      gravity = [0, 0, 0],
-      lifetime = [1, 2],
-      direction = [
-        [-1, 1],
-        [0, 1],
-        [-1, 1]
-      ],
-      // [[minX, maxX], [minY, maxY], [minZ, maxZ]] or [min, max] for all axes
-      startPosition = [
-        [0, 0],
-        [0, 0],
-        [0, 0]
-      ],
-      // [[minX, maxX], [minY, maxY], [minZ, maxZ]] offset from spawn position
-      speed = [0.1, 0.1],
-      friction = { intensity: 0, easing: "linear" },
-      // { intensity: [start, end] or single value, easing: string }
-      // intensity: 1 = max friction (almost stopped), 0 = no friction (normal), negative = boost/acceleration
-      appearance = Appearance2.GRADIENT,
-      alphaMap = null,
-      flipbook = null,
-      // { rows: 4, columns: 8 }
-      rotation = [0, 0],
-      // [min, max] in radians
-      rotationSpeed = [0, 0],
-      // [min, max] rotation speed in radians/second
-      rotationSpeedCurve = null,
-      // Curve data { points: [...] } - controls rotation speed over lifetime
-      geometry = null,
-      // Custom geometry (e.g. new THREE.SphereGeometry(0.5, 8, 8))
-      orientToDirection = false,
-      // Rotate geometry to face velocity direction (geometry mode only)
-      orientAxis = "z",
-      // Which local axis aligns with velocity: "x", "y", "z", "-x", "-y", "-z"
-      stretchBySpeed = null,
-      // { factor: 2, maxStretch: 5 } - stretch particles in velocity direction based on effective speed
-      lighting = Lighting2.STANDARD,
-      // 'basic' | 'standard' | 'physical' - material type for geometry mode
-      shadow = false,
-      // Enable both castShadow and receiveShadow on geometry instances
-      blending = Blending2.NORMAL,
-      intensity = 1,
-      position = [0, 0, 0],
-      autoStart = true,
-      delay = 0,
-      backdropNode = null,
-      // TSL node or function for backdrop sampling
-      opacityNode = null,
-      // TSL node or function for custom opacity control
-      colorNode = null,
-      // TSL node or function to override color (receives particleData, should return vec4)
-      alphaTestNode = null,
-      // TSL node or function for custom alpha test/discard (return true to discard fragment)
-      castShadowNode = null,
-      // TSL node or function for shadow map output (what shadow the particle casts)
-      emitCount = 1,
-      // Emitter shape props
-      emitterShape = EmitterShape2.BOX,
-      // Emission shape type
-      emitterRadius = [0, 1],
-      // [inner, outer] radius for sphere/cone/disk (inner=0 for solid)
-      emitterAngle = Math.PI / 4,
-      // Cone angle in radians (0 = line, PI/2 = hemisphere)
-      emitterHeight = [0, 1],
-      // [min, max] height for cone
-      emitterSurfaceOnly = false,
-      // Emit from surface only (sphere/disk)
-      emitterDirection = [0, 1, 0],
-      // Direction for cone/disk normal
-      // Turbulence (curl noise)
-      turbulence = null,
-      // { intensity: 0.5, frequency: 1, speed: 1 }
-      // Attractors - array of up to 4 attractors
-      // { position: [x,y,z], strength: 1, radius: 3, type: 'point'|'vortex', axis?: [x,y,z] }
-      attractors = null,
-      // Simple attract to center - particles move from spawn position to center over lifetime
-      // Overrides speed/direction - lifetime controls how long it takes to reach center
-      attractToCenter = false,
-      // Use start position offset as direction - particles move in the direction of their spawn offset
-      startPositionAsDirection = false,
-      // Soft particles - fade when intersecting scene geometry
-      softParticles = false,
-      softDistance = 0.5,
-      // Distance in world units over which to fade
-      // Plane collision - particles bounce or die when hitting a plane
-      // { plane: { y: 0 }, bounce: 0.3, friction: 0.8, die: false, sizeBasedGravity: 0 }
-      collision = null,
-      // Debug mode - shows tweakable control panel
-      debug = false
-    }, ref) {
-      const { gl: renderer } = useThree();
-      const spriteRef = useRef2(null);
-      const initialized = useRef2(false);
-      const nextIndex = useRef2(0);
-      const [emitting, setEmitting] = useState2(autoStart);
-      const emitAccumulator = useRef2(0);
-      const delayRef = useRef2(delay);
-      const emitCountRef = useRef2(emitCount);
-      const turbulenceRef = useRef2(turbulence);
-      const [activeMaxParticles, setActiveMaxParticles] = useState2(maxParticles);
-      const [activeLighting, setActiveLighting] = useState2(lighting);
-      const [activeAppearance, setActiveAppearance] = useState2(appearance);
-      const [activeOrientToDirection, setActiveOrientToDirection] = useState2(orientToDirection);
-      const [activeGeometry, setActiveGeometry] = useState2(geometry);
-      const [activeShadow, setActiveShadow] = useState2(shadow);
-      const [activeFadeSizeCurve, setActiveFadeSizeCurve] = useState2(fadeSizeCurve);
-      const [activeFadeOpacityCurve, setActiveFadeOpacityCurve] = useState2(fadeOpacityCurve);
-      const [activeVelocityCurve, setActiveVelocityCurve] = useState2(velocityCurve);
-      const [activeRotationSpeedCurve, setActiveRotationSpeedCurve] = useState2(rotationSpeedCurve);
-      useEffect2(() => {
-        delayRef.current = delay;
-        emitCountRef.current = emitCount;
-        turbulenceRef.current = turbulence;
-      }, [delay, emitCount, turbulence]);
-      useEffect2(() => {
-        if (!debug) {
-          setActiveMaxParticles(maxParticles);
-          setActiveLighting(lighting);
-          setActiveAppearance(appearance);
-          setActiveOrientToDirection(orientToDirection);
-          setActiveGeometry(geometry);
-          setActiveShadow(shadow);
-          setActiveFadeSizeCurve(fadeSizeCurve);
-          setActiveFadeOpacityCurve(fadeOpacityCurve);
-          setActiveVelocityCurve(velocityCurve);
-          setActiveRotationSpeedCurve(rotationSpeedCurve);
-        }
-      }, [
-        debug,
-        maxParticles,
-        lighting,
-        appearance,
-        orientToDirection,
-        geometry,
-        shadow,
-        fadeSizeCurve,
-        fadeOpacityCurve,
-        velocityCurve,
-        rotationSpeedCurve
-      ]);
-      const sizeRange = useMemo(() => toRange(size, [0.1, 0.3]), [size]);
-      const speedRange = useMemo(() => toRange(speed, [0.1, 0.1]), [speed]);
-      const fadeSizeRange = useMemo(() => toRange(fadeSize, [1, 0]), [fadeSize]);
-      const fadeOpacityRange = useMemo(
-        () => toRange(fadeOpacity, [1, 0]),
-        [fadeOpacity]
-      );
-      const curveTexture = useMemo(() => {
-        return createCombinedCurveTexture(
+    init_useCurveTextureAsync();
+    VFXParticles = forwardRef(
+      function VFXParticles2({
+        name,
+        // Optional name for registering with useVFXStore (enables VFXEmitter linking)
+        maxParticles = 1e4,
+        size = [0.1, 0.3],
+        colorStart = ["#ffffff"],
+        colorEnd = null,
+        // If null, uses colorStart (no color transition)
+        fadeSize = [1, 0],
+        fadeSizeCurve = null,
+        // Curve data { points: [...] } - controls fadeSize over lifetime (overrides fadeSize if set)
+        fadeOpacity = [1, 0],
+        fadeOpacityCurve = null,
+        // Curve data { points: [...] } - controls fadeOpacity over lifetime (overrides fadeOpacity if set)
+        velocityCurve = null,
+        // Curve data { points: [...] } - controls velocity/speed over lifetime (overrides friction if set)
+        gravity = [0, 0, 0],
+        lifetime = [1, 2],
+        direction = [
+          [-1, 1],
+          [0, 1],
+          [-1, 1]
+        ],
+        // [[minX, maxX], [minY, maxY], [minZ, maxZ]] or [min, max] for all axes
+        startPosition = [
+          [0, 0],
+          [0, 0],
+          [0, 0]
+        ],
+        // [[minX, maxX], [minY, maxY], [minZ, maxZ]] offset from spawn position
+        speed = [0.1, 0.1],
+        friction = { intensity: 0, easing: "linear" },
+        // { intensity: [start, end] or single value, easing: string }
+        // intensity: 1 = max friction (almost stopped), 0 = no friction (normal), negative = boost/acceleration
+        appearance = Appearance2.GRADIENT,
+        alphaMap = null,
+        flipbook = null,
+        // { rows: 4, columns: 8 }
+        rotation = [0, 0],
+        // [min, max] in radians
+        rotationSpeed = [0, 0],
+        // [min, max] rotation speed in radians/second
+        rotationSpeedCurve = null,
+        // Curve data { points: [...] } - controls rotation speed over lifetime
+        geometry = null,
+        // Custom geometry (e.g. new THREE.SphereGeometry(0.5, 8, 8))
+        orientToDirection = false,
+        // Rotate geometry to face velocity direction (geometry mode only)
+        orientAxis = "z",
+        // Which local axis aligns with velocity: "x", "y", "z", "-x", "-y", "-z"
+        stretchBySpeed = null,
+        // { factor: 2, maxStretch: 5 } - stretch particles in velocity direction based on effective speed
+        lighting = Lighting2.STANDARD,
+        // 'basic' | 'standard' | 'physical' - material type for geometry mode
+        shadow = false,
+        // Enable both castShadow and receiveShadow on geometry instances
+        blending = Blending2.NORMAL,
+        intensity = 1,
+        position = [0, 0, 0],
+        autoStart = true,
+        delay = 0,
+        backdropNode = null,
+        // TSL node or function for backdrop sampling
+        opacityNode = null,
+        // TSL node or function for custom opacity control
+        colorNode = null,
+        // TSL node or function to override color (receives particleData, should return vec4)
+        alphaTestNode = null,
+        // TSL node or function for custom alpha test/discard (return true to discard fragment)
+        castShadowNode = null,
+        // TSL node or function for shadow map output (what shadow the particle casts)
+        emitCount = 1,
+        // Emitter shape props
+        emitterShape = EmitterShape2.BOX,
+        // Emission shape type
+        emitterRadius = [0, 1],
+        // [inner, outer] radius for sphere/cone/disk (inner=0 for solid)
+        emitterAngle = Math.PI / 4,
+        // Cone angle in radians (0 = line, PI/2 = hemisphere)
+        emitterHeight = [0, 1],
+        // [min, max] height for cone
+        emitterSurfaceOnly = false,
+        // Emit from surface only (sphere/disk)
+        emitterDirection = [0, 1, 0],
+        // Direction for cone/disk normal
+        // Turbulence (curl noise)
+        turbulence = null,
+        // { intensity: 0.5, frequency: 1, speed: 1 }
+        // Attractors - array of up to 4 attractors
+        // { position: [x,y,z], strength: 1, radius: 3, type: 'point'|'vortex', axis?: [x,y,z] }
+        attractors = null,
+        // Simple attract to center - particles move from spawn position to center over lifetime
+        // Overrides speed/direction - lifetime controls how long it takes to reach center
+        attractToCenter = false,
+        // Use start position offset as direction - particles move in the direction of their spawn offset
+        startPositionAsDirection = false,
+        // Soft particles - fade when intersecting scene geometry
+        softParticles = false,
+        softDistance = 0.5,
+        // Distance in world units over which to fade
+        // Plane collision - particles bounce or die when hitting a plane
+        // { plane: { y: 0 }, bounce: 0.3, friction: 0.8, die: false, sizeBasedGravity: 0 }
+        collision = null,
+        // Debug mode - shows tweakable control panel
+        debug = false,
+        // Path to pre-baked curve texture (skips runtime baking for faster load)
+        curveTexturePath = null,
+        // Depth test
+        depthTest = true,
+        // Render order
+        renderOrder = 0
+      }, ref) {
+        var _a;
+        const { gl: renderer } = useThree();
+        const spriteRef = useRef3(null);
+        const initialized = useRef3(false);
+        const nextIndex = useRef3(0);
+        const [emitting, setEmitting] = useState2(autoStart);
+        const emitAccumulator = useRef3(0);
+        const delayRef = useRef3(delay);
+        const emitCountRef = useRef3(emitCount);
+        const turbulenceRef = useRef3(turbulence);
+        const [activeMaxParticles, setActiveMaxParticles] = useState2(maxParticles);
+        const [activeLighting, setActiveLighting] = useState2(lighting);
+        const [activeAppearance, setActiveAppearance] = useState2(appearance);
+        const [activeOrientToDirection, setActiveOrientToDirection] = useState2(orientToDirection);
+        const [activeGeometry, setActiveGeometry] = useState2(geometry);
+        const [activeShadow, setActiveShadow] = useState2(shadow);
+        const [activeFadeSizeCurve, setActiveFadeSizeCurve] = useState2(fadeSizeCurve);
+        const [activeFadeOpacityCurve, setActiveFadeOpacityCurve] = useState2(fadeOpacityCurve);
+        const [activeVelocityCurve, setActiveVelocityCurve] = useState2(velocityCurve);
+        const [activeRotationSpeedCurve, setActiveRotationSpeedCurve] = useState2(rotationSpeedCurve);
+        const [activeTurbulence, setActiveTurbulence] = useState2(
+          turbulence !== null && ((_a = turbulence == null ? void 0 : turbulence.intensity) != null ? _a : 0) > 0
+        );
+        const [activeAttractors, setActiveAttractors] = useState2(
+          attractors !== null && attractors.length > 0
+        );
+        const [activeCollision, setActiveCollision] = useState2(collision !== null);
+        const [activeNeedsPerParticleColor, setActiveNeedsPerParticleColor] = useState2(colorStart.length > 1 || colorEnd !== null);
+        const isNonDefaultRotation = (r) => {
+          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;
+        };
+        const [activeNeedsRotation, setActiveNeedsRotation] = useState2(
+          isNonDefaultRotation(rotation) || isNonDefaultRotation(rotationSpeed)
+        );
+        useEffect3(() => {
+          delayRef.current = delay;
+          emitCountRef.current = emitCount;
+          turbulenceRef.current = turbulence;
+        }, [delay, emitCount, turbulence]);
+        useEffect3(() => {
+          var _a2;
+          if (!debug) {
+            setActiveMaxParticles(maxParticles);
+            setActiveLighting(lighting);
+            setActiveAppearance(appearance);
+            setActiveOrientToDirection(orientToDirection);
+            setActiveGeometry(geometry);
+            setActiveShadow(shadow);
+            setActiveFadeSizeCurve(fadeSizeCurve);
+            setActiveFadeOpacityCurve(fadeOpacityCurve);
+            setActiveVelocityCurve(velocityCurve);
+            setActiveRotationSpeedCurve(rotationSpeedCurve);
+            setActiveNeedsPerParticleColor(
+              colorStart.length > 1 || colorEnd !== null
+            );
+            setActiveNeedsRotation(
+              isNonDefaultRotation(rotation) || isNonDefaultRotation(rotationSpeed)
+            );
+            setActiveTurbulence(
+              turbulence !== null && ((_a2 = turbulence == null ? void 0 : turbulence.intensity) != null ? _a2 : 0) > 0
+            );
+            setActiveAttractors(attractors !== null && attractors.length > 0);
+            setActiveCollision(collision !== null);
+          }
+        }, [
+          debug,
+          maxParticles,
+          lighting,
+          appearance,
+          orientToDirection,
+          geometry,
+          colorStart.length,
+          colorEnd,
+          shadow,
+          fadeSizeCurve,
+          fadeOpacityCurve,
+          velocityCurve,
+          rotationSpeedCurve,
+          rotation,
+          rotationSpeed,
+          turbulence,
+          attractors,
+          collision
+        ]);
+        const sizeRange = useMemo(() => toRange(size, [0.1, 0.3]), [size]);
+        const speedRange = useMemo(() => toRange(speed, [0.1, 0.1]), [speed]);
+        const fadeSizeRange = useMemo(() => toRange(fadeSize, [1, 0]), [fadeSize]);
+        const fadeOpacityRange = useMemo(
+          () => toRange(fadeOpacity, [1, 0]),
+          [fadeOpacity]
+        );
+        const curveTexture = useCurveTextureAsync(
           activeFadeSizeCurve,
           activeFadeOpacityCurve,
           activeVelocityCurve,
-          activeRotationSpeedCurve
+          activeRotationSpeedCurve,
+          curveTexturePath
         );
-      }, [
-        activeFadeSizeCurve,
-        activeFadeOpacityCurve,
-        activeVelocityCurve,
-        activeRotationSpeedCurve
-      ]);
-      const prevCurveTextureRef = useRef2(null);
-      useEffect2(() => {
-        if (prevCurveTextureRef.current && prevCurveTextureRef.current !== curveTexture) {
-          prevCurveTextureRef.current.dispose();
-        }
-        prevCurveTextureRef.current = curveTexture;
-        return () => {
-          if (curveTexture) {
-            curveTexture.dispose();
-          }
-        };
-      }, [curveTexture]);
-      const lifetimeRange = useMemo(() => toRange(lifetime, [1, 2]), [lifetime]);
-      const rotation3D = useMemo(() => toRotation3D(rotation), [rotation]);
-      const rotationSpeed3D = useMemo(
-        () => toRotation3D(rotationSpeed),
-        [rotationSpeed]
-      );
-      const direction3D = useMemo(() => toRotation3D(direction), [direction]);
-      const startPosition3D = useMemo(
-        () => toRotation3D(startPosition),
-        [startPosition]
-      );
-      const emitterRadiusRange = useMemo(
-        () => toRange(emitterRadius, [0, 1]),
-        [emitterRadius]
-      );
-      const emitterHeightRange = useMemo(
-        () => toRange(emitterHeight, [0, 1]),
-        [emitterHeight]
-      );
-      const frictionIntensityRange = useMemo(() => {
-        if (typeof friction === "object" && friction !== null && "intensity" in friction) {
-          return toRange(friction.intensity, [0, 0]);
-        }
-        return [0, 0];
-      }, [friction]);
-      const frictionEasingType = useMemo(() => {
-        var _a;
-        if (typeof friction === "object" && friction !== null && "easing" in friction) {
-          return easingToType((_a = friction.easing) != null ? _a : "linear");
-        }
-        return 0;
-      }, [friction]);
-      const startColors = useMemo(() => {
-        const colors = colorStart.slice(0, 8).map(hexToRgb);
-        while (colors.length < 8)
-          colors.push(colors[colors.length - 1] || [1, 1, 1]);
-        return colors;
-      }, [colorStart]);
-      const effectiveColorEnd = colorEnd != null ? colorEnd : colorStart;
-      const endColors = useMemo(() => {
-        const colors = effectiveColorEnd.slice(0, 8).map(hexToRgb);
-        while (colors.length < 8)
-          colors.push(colors[colors.length - 1] || [1, 1, 1]);
-        return colors;
-      }, [effectiveColorEnd]);
-      const uniforms = useMemo(
-        () => {
-          var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-          return {
-            sizeMin: uniform(sizeRange[0]),
-            sizeMax: uniform(sizeRange[1]),
-            fadeSizeStart: uniform(fadeSizeRange[0]),
-            fadeSizeEnd: uniform(fadeSizeRange[1]),
-            fadeOpacityStart: uniform(fadeOpacityRange[0]),
-            fadeOpacityEnd: uniform(fadeOpacityRange[1]),
-            gravity: uniform(new THREE2.Vector3(...gravity)),
-            frictionIntensityStart: uniform(frictionIntensityRange[0]),
-            frictionIntensityEnd: uniform(frictionIntensityRange[1]),
-            frictionEasingType: uniform(frictionEasingType),
-            speedMin: uniform(speedRange[0]),
-            speedMax: uniform(speedRange[1]),
-            lifetimeMin: uniform(lifetimeToFadeRate(lifetimeRange[1])),
-            lifetimeMax: uniform(lifetimeToFadeRate(lifetimeRange[0])),
-            deltaTime: uniform(0.016),
-            // Will be updated each frame
-            // 3D direction ranges
-            dirMinX: uniform(direction3D[0][0]),
-            dirMaxX: uniform(direction3D[0][1]),
-            dirMinY: uniform(direction3D[1][0]),
-            dirMaxY: uniform(direction3D[1][1]),
-            dirMinZ: uniform(direction3D[2][0]),
-            dirMaxZ: uniform(direction3D[2][1]),
-            // 3D start position offset ranges
-            startPosMinX: uniform(startPosition3D[0][0]),
-            startPosMaxX: uniform(startPosition3D[0][1]),
-            startPosMinY: uniform(startPosition3D[1][0]),
-            startPosMaxY: uniform(startPosition3D[1][1]),
-            startPosMinZ: uniform(startPosition3D[2][0]),
-            startPosMaxZ: uniform(startPosition3D[2][1]),
-            spawnPosition: uniform(new THREE2.Vector3(...position)),
-            spawnIndexStart: uniform(0),
-            spawnIndexEnd: uniform(0),
-            spawnSeed: uniform(0),
-            intensity: uniform(intensity),
-            // 3D rotation ranges
-            rotationMinX: uniform(rotation3D[0][0]),
-            rotationMaxX: uniform(rotation3D[0][1]),
-            rotationMinY: uniform(rotation3D[1][0]),
-            rotationMaxY: uniform(rotation3D[1][1]),
-            rotationMinZ: uniform(rotation3D[2][0]),
-            rotationMaxZ: uniform(rotation3D[2][1]),
-            // 3D rotation speed ranges (radians/second)
-            rotationSpeedMinX: uniform(rotationSpeed3D[0][0]),
-            rotationSpeedMaxX: uniform(rotationSpeed3D[0][1]),
-            rotationSpeedMinY: uniform(rotationSpeed3D[1][0]),
-            rotationSpeedMaxY: uniform(rotationSpeed3D[1][1]),
-            rotationSpeedMinZ: uniform(rotationSpeed3D[2][0]),
-            rotationSpeedMaxZ: uniform(rotationSpeed3D[2][1]),
-            // Color arrays (8 colors max each)
-            colorStartCount: uniform(colorStart.length),
-            colorEndCount: uniform(effectiveColorEnd.length),
-            colorStart0: uniform(new THREE2.Color(...startColors[0])),
-            colorStart1: uniform(new THREE2.Color(...startColors[1])),
-            colorStart2: uniform(new THREE2.Color(...startColors[2])),
-            colorStart3: uniform(new THREE2.Color(...startColors[3])),
-            colorStart4: uniform(new THREE2.Color(...startColors[4])),
-            colorStart5: uniform(new THREE2.Color(...startColors[5])),
-            colorStart6: uniform(new THREE2.Color(...startColors[6])),
-            colorStart7: uniform(new THREE2.Color(...startColors[7])),
-            colorEnd0: uniform(new THREE2.Color(...endColors[0])),
-            colorEnd1: uniform(new THREE2.Color(...endColors[1])),
-            colorEnd2: uniform(new THREE2.Color(...endColors[2])),
-            colorEnd3: uniform(new THREE2.Color(...endColors[3])),
-            colorEnd4: uniform(new THREE2.Color(...endColors[4])),
-            colorEnd5: uniform(new THREE2.Color(...endColors[5])),
-            colorEnd6: uniform(new THREE2.Color(...endColors[6])),
-            colorEnd7: uniform(new THREE2.Color(...endColors[7])),
-            // Emitter shape uniforms
-            emitterShapeType: uniform(emitterShape),
-            emitterRadiusInner: uniform(emitterRadiusRange[0]),
-            emitterRadiusOuter: uniform(emitterRadiusRange[1]),
-            emitterAngle: uniform(emitterAngle),
-            emitterHeightMin: uniform(emitterHeightRange[0]),
-            emitterHeightMax: uniform(emitterHeightRange[1]),
-            emitterSurfaceOnly: uniform(emitterSurfaceOnly ? 1 : 0),
-            emitterDir: uniform(new THREE2.Vector3(...emitterDirection).normalize()),
-            // Turbulence uniforms
-            turbulenceIntensity: uniform((_a = turbulence == null ? void 0 : turbulence.intensity) != null ? _a : 0),
-            turbulenceFrequency: uniform((_b = turbulence == null ? void 0 : turbulence.frequency) != null ? _b : 1),
-            turbulenceSpeed: uniform((_c = turbulence == null ? void 0 : turbulence.speed) != null ? _c : 1),
-            turbulenceTime: uniform(0),
-            // Updated each frame
-            // Attractor uniforms (up to 4)
-            attractorCount: uniform(0),
-            attractor0Pos: uniform(new THREE2.Vector3(0, 0, 0)),
-            attractor0Strength: uniform(0),
-            attractor0Radius: uniform(1),
-            attractor0Type: uniform(0),
-            attractor0Axis: uniform(new THREE2.Vector3(0, 1, 0)),
-            attractor1Pos: uniform(new THREE2.Vector3(0, 0, 0)),
-            attractor1Strength: uniform(0),
-            attractor1Radius: uniform(1),
-            attractor1Type: uniform(0),
-            attractor1Axis: uniform(new THREE2.Vector3(0, 1, 0)),
-            attractor2Pos: uniform(new THREE2.Vector3(0, 0, 0)),
-            attractor2Strength: uniform(0),
-            attractor2Radius: uniform(1),
-            attractor2Type: uniform(0),
-            attractor2Axis: uniform(new THREE2.Vector3(0, 1, 0)),
-            attractor3Pos: uniform(new THREE2.Vector3(0, 0, 0)),
-            attractor3Strength: uniform(0),
-            attractor3Radius: uniform(1),
-            attractor3Type: uniform(0),
-            attractor3Axis: uniform(new THREE2.Vector3(0, 1, 0)),
-            // Simple attract to center
-            attractToCenter: uniform(attractToCenter ? 1 : 0),
-            // Use start position as direction
-            startPositionAsDirection: uniform(startPositionAsDirection ? 1 : 0),
-            // Soft particles
-            softParticlesEnabled: uniform(softParticles ? 1 : 0),
-            softDistance: uniform(softDistance),
-            // Velocity curve (replaces friction when enabled)
-            velocityCurveEnabled: uniform(velocityCurve ? 1 : 0),
-            // Rotation speed curve (modulates rotation speed over lifetime)
-            rotationSpeedCurveEnabled: uniform(rotationSpeedCurve ? 1 : 0),
-            // Fade size curve (when disabled, uses fadeSize prop interpolation)
-            fadeSizeCurveEnabled: uniform(fadeSizeCurve ? 1 : 0),
-            // Fade opacity curve (when disabled, uses fadeOpacity prop interpolation)
-            fadeOpacityCurveEnabled: uniform(fadeOpacityCurve ? 1 : 0),
-            // Orient axis: 0=+X, 1=+Y, 2=+Z, 3=-X, 4=-Y, 5=-Z
-            orientAxisType: uniform(axisToNumber(orientAxis)),
-            // Stretch by speed (uses effective velocity after curve modifier)
-            stretchEnabled: uniform(stretchBySpeed ? 1 : 0),
-            stretchFactor: uniform((_d = stretchBySpeed == null ? void 0 : stretchBySpeed.factor) != null ? _d : 1),
-            stretchMax: uniform((_e = stretchBySpeed == null ? void 0 : stretchBySpeed.maxStretch) != null ? _e : 5),
-            // Collision uniforms
-            collisionEnabled: uniform(collision ? 1 : 0),
-            collisionPlaneY: uniform((_g = (_f = collision == null ? void 0 : collision.plane) == null ? void 0 : _f.y) != null ? _g : 0),
-            collisionBounce: uniform((_h = collision == null ? void 0 : collision.bounce) != null ? _h : 0.3),
-            collisionFriction: uniform((_i = collision == null ? void 0 : collision.friction) != null ? _i : 0.8),
-            collisionDie: uniform((collision == null ? void 0 : collision.die) ? 1 : 0),
-            // Size-based gravity (inside collision object)
-            sizeBasedGravity: uniform((_j = collision == null ? void 0 : collision.sizeBasedGravity) != null ? _j : 0)
+        const prevCurveTextureRef = useRef3(null);
+        useEffect3(() => {
+          prevCurveTextureRef.current = curveTexture;
+          return () => {
+            if (curveTexture) {
+              curveTexture.dispose();
+            }
           };
-        },
-        []
-      );
-      const positionRef = useRef2(position);
-      useEffect2(() => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-        if (debug) return;
-        positionRef.current = position;
-        uniforms.sizeMin.value = sizeRange[0];
-        uniforms.sizeMax.value = sizeRange[1];
-        uniforms.fadeSizeStart.value = fadeSizeRange[0];
-        uniforms.fadeSizeEnd.value = fadeSizeRange[1];
-        uniforms.fadeOpacityStart.value = fadeOpacityRange[0];
-        uniforms.fadeOpacityEnd.value = fadeOpacityRange[1];
-        uniforms.gravity.value.set(...gravity);
-        uniforms.frictionIntensityStart.value = frictionIntensityRange[0];
-        uniforms.frictionIntensityEnd.value = frictionIntensityRange[1];
-        uniforms.frictionEasingType.value = frictionEasingType;
-        uniforms.speedMin.value = speedRange[0];
-        uniforms.speedMax.value = speedRange[1];
-        uniforms.lifetimeMin.value = lifetimeToFadeRate(lifetimeRange[1]);
-        uniforms.lifetimeMax.value = lifetimeToFadeRate(lifetimeRange[0]);
-        uniforms.dirMinX.value = direction3D[0][0];
-        uniforms.dirMaxX.value = direction3D[0][1];
-        uniforms.dirMinY.value = direction3D[1][0];
-        uniforms.dirMaxY.value = direction3D[1][1];
-        uniforms.dirMinZ.value = direction3D[2][0];
-        uniforms.dirMaxZ.value = direction3D[2][1];
-        uniforms.startPosMinX.value = startPosition3D[0][0];
-        uniforms.startPosMaxX.value = startPosition3D[0][1];
-        uniforms.startPosMinY.value = startPosition3D[1][0];
-        uniforms.startPosMaxY.value = startPosition3D[1][1];
-        uniforms.startPosMinZ.value = startPosition3D[2][0];
-        uniforms.startPosMaxZ.value = startPosition3D[2][1];
-        uniforms.rotationMinX.value = rotation3D[0][0];
-        uniforms.rotationMaxX.value = rotation3D[0][1];
-        uniforms.rotationMinY.value = rotation3D[1][0];
-        uniforms.rotationMaxY.value = rotation3D[1][1];
-        uniforms.rotationMinZ.value = rotation3D[2][0];
-        uniforms.rotationMaxZ.value = rotation3D[2][1];
-        uniforms.rotationSpeedMinX.value = rotationSpeed3D[0][0];
-        uniforms.rotationSpeedMaxX.value = rotationSpeed3D[0][1];
-        uniforms.rotationSpeedMinY.value = rotationSpeed3D[1][0];
-        uniforms.rotationSpeedMaxY.value = rotationSpeed3D[1][1];
-        uniforms.rotationSpeedMinZ.value = rotationSpeed3D[2][0];
-        uniforms.rotationSpeedMaxZ.value = rotationSpeed3D[2][1];
-        uniforms.intensity.value = intensity;
-        uniforms.colorStartCount.value = colorStart.length;
-        uniforms.colorEndCount.value = effectiveColorEnd.length;
-        startColors.forEach((c, i) => {
-          var _a2;
-          (_a2 = uniforms[`colorStart${i}`]) == null ? void 0 : _a2.value.setRGB(...c);
-        });
-        endColors.forEach((c, i) => {
+        }, [curveTexture]);
+        const lifetimeRange = useMemo(() => toRange(lifetime, [1, 2]), [lifetime]);
+        const rotation3D = useMemo(() => toRotation3D(rotation), [rotation]);
+        const rotationSpeed3D = useMemo(
+          () => toRotation3D(rotationSpeed),
+          [rotationSpeed]
+        );
+        const direction3D = useMemo(() => toRotation3D(direction), [direction]);
+        const startPosition3D = useMemo(
+          () => toRotation3D(startPosition),
+          [startPosition]
+        );
+        const emitterRadiusRange = useMemo(
+          () => toRange(emitterRadius, [0, 1]),
+          [emitterRadius]
+        );
+        const emitterHeightRange = useMemo(
+          () => toRange(emitterHeight, [0, 1]),
+          [emitterHeight]
+        );
+        const activeFeatures = useMemo(
+          () => ({
+            // Storage array features
+            needsPerParticleColor: activeNeedsPerParticleColor,
+            needsRotation: activeNeedsRotation,
+            // Shader features (skip code entirely when disabled)
+            turbulence: activeTurbulence,
+            attractors: activeAttractors,
+            collision: activeCollision,
+            rotation: activeNeedsRotation,
+            perParticleColor: activeNeedsPerParticleColor
+          }),
+          [
+            activeNeedsPerParticleColor,
+            activeNeedsRotation,
+            activeTurbulence,
+            activeAttractors,
+            activeCollision
+          ]
+        );
+        const frictionIntensityRange = useMemo(() => {
+          if (typeof friction === "object" && friction !== null && "intensity" in friction) {
+            return toRange(friction.intensity, [0, 0]);
+          }
+          return [0, 0];
+        }, [friction]);
+        const frictionEasingType = useMemo(() => {
           var _a2;
-          (_a2 = uniforms[`colorEnd${i}`]) == null ? void 0 : _a2.value.setRGB(...c);
-        });
-        uniforms.emitterShapeType.value = emitterShape;
-        uniforms.emitterRadiusInner.value = emitterRadiusRange[0];
-        uniforms.emitterRadiusOuter.value = emitterRadiusRange[1];
-        uniforms.emitterAngle.value = emitterAngle;
-        uniforms.emitterHeightMin.value = emitterHeightRange[0];
-        uniforms.emitterHeightMax.value = emitterHeightRange[1];
-        uniforms.emitterSurfaceOnly.value = emitterSurfaceOnly ? 1 : 0;
-        uniforms.emitterDir.value.set(...emitterDirection).normalize();
-        uniforms.turbulenceIntensity.value = (_a = turbulence == null ? void 0 : turbulence.intensity) != null ? _a : 0;
-        uniforms.turbulenceFrequency.value = (_b = turbulence == null ? void 0 : turbulence.frequency) != null ? _b : 1;
-        uniforms.turbulenceSpeed.value = (_c = turbulence == null ? void 0 : turbulence.speed) != null ? _c : 1;
-        const attractorList = attractors != null ? attractors : [];
-        uniforms.attractorCount.value = Math.min(
-          attractorList.length,
-          MAX_ATTRACTORS
+          if (typeof friction === "object" && friction !== null && "easing" in friction) {
+            return easingToType((_a2 = friction.easing) != null ? _a2 : "linear");
+          }
+          return 0;
+        }, [friction]);
+        const startColors = useMemo(() => {
+          const colors = colorStart.slice(0, 8).map(hexToRgb);
+          while (colors.length < 8)
+            colors.push(colors[colors.length - 1] || [1, 1, 1]);
+          return colors;
+        }, [colorStart]);
+        const effectiveColorEnd = colorEnd != null ? colorEnd : colorStart;
+        const endColors = useMemo(() => {
+          const colors = effectiveColorEnd.slice(0, 8).map(hexToRgb);
+          while (colors.length < 8)
+            colors.push(colors[colors.length - 1] || [1, 1, 1]);
+          return colors;
+        }, [effectiveColorEnd]);
+        const uniforms = useMemo(
+          () => {
+            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+            return {
+              sizeMin: uniform(sizeRange[0]),
+              sizeMax: uniform(sizeRange[1]),
+              fadeSizeStart: uniform(fadeSizeRange[0]),
+              fadeSizeEnd: uniform(fadeSizeRange[1]),
+              fadeOpacityStart: uniform(fadeOpacityRange[0]),
+              fadeOpacityEnd: uniform(fadeOpacityRange[1]),
+              gravity: uniform(new THREE2.Vector3(...gravity)),
+              frictionIntensityStart: uniform(frictionIntensityRange[0]),
+              frictionIntensityEnd: uniform(frictionIntensityRange[1]),
+              frictionEasingType: uniform(frictionEasingType),
+              speedMin: uniform(speedRange[0]),
+              speedMax: uniform(speedRange[1]),
+              lifetimeMin: uniform(lifetimeToFadeRate(lifetimeRange[1])),
+              lifetimeMax: uniform(lifetimeToFadeRate(lifetimeRange[0])),
+              deltaTime: uniform(0.016),
+              // Will be updated each frame
+              // 3D direction ranges
+              dirMinX: uniform(direction3D[0][0]),
+              dirMaxX: uniform(direction3D[0][1]),
+              dirMinY: uniform(direction3D[1][0]),
+              dirMaxY: uniform(direction3D[1][1]),
+              dirMinZ: uniform(direction3D[2][0]),
+              dirMaxZ: uniform(direction3D[2][1]),
+              // 3D start position offset ranges
+              startPosMinX: uniform(startPosition3D[0][0]),
+              startPosMaxX: uniform(startPosition3D[0][1]),
+              startPosMinY: uniform(startPosition3D[1][0]),
+              startPosMaxY: uniform(startPosition3D[1][1]),
+              startPosMinZ: uniform(startPosition3D[2][0]),
+              startPosMaxZ: uniform(startPosition3D[2][1]),
+              spawnPosition: uniform(new THREE2.Vector3(...position)),
+              spawnIndexStart: uniform(0),
+              spawnIndexEnd: uniform(0),
+              spawnSeed: uniform(0),
+              intensity: uniform(intensity),
+              // 3D rotation ranges
+              rotationMinX: uniform(rotation3D[0][0]),
+              rotationMaxX: uniform(rotation3D[0][1]),
+              rotationMinY: uniform(rotation3D[1][0]),
+              rotationMaxY: uniform(rotation3D[1][1]),
+              rotationMinZ: uniform(rotation3D[2][0]),
+              rotationMaxZ: uniform(rotation3D[2][1]),
+              // 3D rotation speed ranges (radians/second)
+              rotationSpeedMinX: uniform(rotationSpeed3D[0][0]),
+              rotationSpeedMaxX: uniform(rotationSpeed3D[0][1]),
+              rotationSpeedMinY: uniform(rotationSpeed3D[1][0]),
+              rotationSpeedMaxY: uniform(rotationSpeed3D[1][1]),
+              rotationSpeedMinZ: uniform(rotationSpeed3D[2][0]),
+              rotationSpeedMaxZ: uniform(rotationSpeed3D[2][1]),
+              // Color arrays (8 colors max each)
+              colorStartCount: uniform(colorStart.length),
+              colorEndCount: uniform(effectiveColorEnd.length),
+              colorStart0: uniform(new THREE2.Color(...startColors[0])),
+              colorStart1: uniform(new THREE2.Color(...startColors[1])),
+              colorStart2: uniform(new THREE2.Color(...startColors[2])),
+              colorStart3: uniform(new THREE2.Color(...startColors[3])),
+              colorStart4: uniform(new THREE2.Color(...startColors[4])),
+              colorStart5: uniform(new THREE2.Color(...startColors[5])),
+              colorStart6: uniform(new THREE2.Color(...startColors[6])),
+              colorStart7: uniform(new THREE2.Color(...startColors[7])),
+              colorEnd0: uniform(new THREE2.Color(...endColors[0])),
+              colorEnd1: uniform(new THREE2.Color(...endColors[1])),
+              colorEnd2: uniform(new THREE2.Color(...endColors[2])),
+              colorEnd3: uniform(new THREE2.Color(...endColors[3])),
+              colorEnd4: uniform(new THREE2.Color(...endColors[4])),
+              colorEnd5: uniform(new THREE2.Color(...endColors[5])),
+              colorEnd6: uniform(new THREE2.Color(...endColors[6])),
+              colorEnd7: uniform(new THREE2.Color(...endColors[7])),
+              // Emitter shape uniforms
+              emitterShapeType: uniform(emitterShape),
+              emitterRadiusInner: uniform(emitterRadiusRange[0]),
+              emitterRadiusOuter: uniform(emitterRadiusRange[1]),
+              emitterAngle: uniform(emitterAngle),
+              emitterHeightMin: uniform(emitterHeightRange[0]),
+              emitterHeightMax: uniform(emitterHeightRange[1]),
+              emitterSurfaceOnly: uniform(emitterSurfaceOnly ? 1 : 0),
+              emitterDir: uniform(new THREE2.Vector3(...emitterDirection).normalize()),
+              // Turbulence uniforms
+              turbulenceIntensity: uniform((_a2 = turbulence == null ? void 0 : turbulence.intensity) != null ? _a2 : 0),
+              turbulenceFrequency: uniform((_b = turbulence == null ? void 0 : turbulence.frequency) != null ? _b : 1),
+              turbulenceSpeed: uniform((_c = turbulence == null ? void 0 : turbulence.speed) != null ? _c : 1),
+              turbulenceTime: uniform(0),
+              // Updated each frame
+              // Attractor uniforms (up to 4)
+              attractorCount: uniform(0),
+              attractor0Pos: uniform(new THREE2.Vector3(0, 0, 0)),
+              attractor0Strength: uniform(0),
+              attractor0Radius: uniform(1),
+              attractor0Type: uniform(0),
+              attractor0Axis: uniform(new THREE2.Vector3(0, 1, 0)),
+              attractor1Pos: uniform(new THREE2.Vector3(0, 0, 0)),
+              attractor1Strength: uniform(0),
+              attractor1Radius: uniform(1),
+              attractor1Type: uniform(0),
+              attractor1Axis: uniform(new THREE2.Vector3(0, 1, 0)),
+              attractor2Pos: uniform(new THREE2.Vector3(0, 0, 0)),
+              attractor2Strength: uniform(0),
+              attractor2Radius: uniform(1),
+              attractor2Type: uniform(0),
+              attractor2Axis: uniform(new THREE2.Vector3(0, 1, 0)),
+              attractor3Pos: uniform(new THREE2.Vector3(0, 0, 0)),
+              attractor3Strength: uniform(0),
+              attractor3Radius: uniform(1),
+              attractor3Type: uniform(0),
+              attractor3Axis: uniform(new THREE2.Vector3(0, 1, 0)),
+              // Simple attract to center
+              attractToCenter: uniform(attractToCenter ? 1 : 0),
+              // Use start position as direction
+              startPositionAsDirection: uniform(startPositionAsDirection ? 1 : 0),
+              // Soft particles
+              softParticlesEnabled: uniform(softParticles ? 1 : 0),
+              softDistance: uniform(softDistance),
+              // Velocity curve (replaces friction when enabled)
+              // Enable if velocityCurve prop is set OR curveTexturePath is provided
+              velocityCurveEnabled: uniform(
+                velocityCurve || curveTexturePath ? 1 : 0
+              ),
+              // Rotation speed curve (modulates rotation speed over lifetime)
+              rotationSpeedCurveEnabled: uniform(
+                rotationSpeedCurve || curveTexturePath ? 1 : 0
+              ),
+              // Fade size curve (when disabled, uses fadeSize prop interpolation)
+              fadeSizeCurveEnabled: uniform(
+                fadeSizeCurve || curveTexturePath ? 1 : 0
+              ),
+              // Fade opacity curve (when disabled, uses fadeOpacity prop interpolation)
+              fadeOpacityCurveEnabled: uniform(
+                fadeOpacityCurve || curveTexturePath ? 1 : 0
+              ),
+              // Orient axis: 0=+X, 1=+Y, 2=+Z, 3=-X, 4=-Y, 5=-Z
+              orientAxisType: uniform(axisToNumber(orientAxis)),
+              // Stretch by speed (uses effective velocity after curve modifier)
+              stretchEnabled: uniform(stretchBySpeed ? 1 : 0),
+              stretchFactor: uniform((_d = stretchBySpeed == null ? void 0 : stretchBySpeed.factor) != null ? _d : 1),
+              stretchMax: uniform((_e = stretchBySpeed == null ? void 0 : stretchBySpeed.maxStretch) != null ? _e : 5),
+              // Collision uniforms
+              collisionEnabled: uniform(collision ? 1 : 0),
+              collisionPlaneY: uniform((_g = (_f = collision == null ? void 0 : collision.plane) == null ? void 0 : _f.y) != null ? _g : 0),
+              collisionBounce: uniform((_h = collision == null ? void 0 : collision.bounce) != null ? _h : 0.3),
+              collisionFriction: uniform((_i = collision == null ? void 0 : collision.friction) != null ? _i : 0.8),
+              collisionDie: uniform((collision == null ? void 0 : collision.die) ? 1 : 0),
+              // Size-based gravity (inside collision object)
+              sizeBasedGravity: uniform((_j = collision == null ? void 0 : collision.sizeBasedGravity) != null ? _j : 0)
+            };
+          },
+          []
         );
-        for (let i = 0; i < MAX_ATTRACTORS; i++) {
-          const a = attractorList[i];
-          const u = uniforms;
-          if (a) {
-            u[`attractor${i}Pos`].value.set(...(_d = a.position) != null ? _d : [0, 0, 0]);
-            u[`attractor${i}Strength`].value = (_e = a.strength) != null ? _e : 1;
-            u[`attractor${i}Radius`].value = (_f = a.radius) != null ? _f : 0;
-            u[`attractor${i}Type`].value = a.type === "vortex" ? 1 : 0;
-            u[`attractor${i}Axis`].value.set(...(_g = a.axis) != null ? _g : [0, 1, 0]).normalize();
-          } else {
-            u[`attractor${i}Strength`].value = 0;
+        const positionRef = useRef3(position);
+        useEffect3(() => {
+          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+          if (debug) return;
+          positionRef.current = position;
+          uniforms.sizeMin.value = sizeRange[0];
+          uniforms.sizeMax.value = sizeRange[1];
+          uniforms.fadeSizeStart.value = fadeSizeRange[0];
+          uniforms.fadeSizeEnd.value = fadeSizeRange[1];
+          uniforms.fadeOpacityStart.value = fadeOpacityRange[0];
+          uniforms.fadeOpacityEnd.value = fadeOpacityRange[1];
+          uniforms.gravity.value.set(...gravity);
+          uniforms.frictionIntensityStart.value = frictionIntensityRange[0];
+          uniforms.frictionIntensityEnd.value = frictionIntensityRange[1];
+          uniforms.frictionEasingType.value = frictionEasingType;
+          uniforms.speedMin.value = speedRange[0];
+          uniforms.speedMax.value = speedRange[1];
+          uniforms.lifetimeMin.value = lifetimeToFadeRate(lifetimeRange[1]);
+          uniforms.lifetimeMax.value = lifetimeToFadeRate(lifetimeRange[0]);
+          uniforms.dirMinX.value = direction3D[0][0];
+          uniforms.dirMaxX.value = direction3D[0][1];
+          uniforms.dirMinY.value = direction3D[1][0];
+          uniforms.dirMaxY.value = direction3D[1][1];
+          uniforms.dirMinZ.value = direction3D[2][0];
+          uniforms.dirMaxZ.value = direction3D[2][1];
+          uniforms.startPosMinX.value = startPosition3D[0][0];
+          uniforms.startPosMaxX.value = startPosition3D[0][1];
+          uniforms.startPosMinY.value = startPosition3D[1][0];
+          uniforms.startPosMaxY.value = startPosition3D[1][1];
+          uniforms.startPosMinZ.value = startPosition3D[2][0];
+          uniforms.startPosMaxZ.value = startPosition3D[2][1];
+          uniforms.rotationMinX.value = rotation3D[0][0];
+          uniforms.rotationMaxX.value = rotation3D[0][1];
+          uniforms.rotationMinY.value = rotation3D[1][0];
+          uniforms.rotationMaxY.value = rotation3D[1][1];
+          uniforms.rotationMinZ.value = rotation3D[2][0];
+          uniforms.rotationMaxZ.value = rotation3D[2][1];
+          uniforms.rotationSpeedMinX.value = rotationSpeed3D[0][0];
+          uniforms.rotationSpeedMaxX.value = rotationSpeed3D[0][1];
+          uniforms.rotationSpeedMinY.value = rotationSpeed3D[1][0];
+          uniforms.rotationSpeedMaxY.value = rotationSpeed3D[1][1];
+          uniforms.rotationSpeedMinZ.value = rotationSpeed3D[2][0];
+          uniforms.rotationSpeedMaxZ.value = rotationSpeed3D[2][1];
+          uniforms.intensity.value = intensity;
+          uniforms.colorStartCount.value = colorStart.length;
+          uniforms.colorEndCount.value = effectiveColorEnd.length;
+          startColors.forEach((c, i) => {
+            var _a3;
+            ;
+            (_a3 = uniforms[`colorStart${i}`]) == null ? void 0 : _a3.value.setRGB(...c);
+          });
+          endColors.forEach((c, i) => {
+            var _a3;
+            ;
+            (_a3 = uniforms[`colorEnd${i}`]) == null ? void 0 : _a3.value.setRGB(...c);
+          });
+          uniforms.emitterShapeType.value = emitterShape;
+          uniforms.emitterRadiusInner.value = emitterRadiusRange[0];
+          uniforms.emitterRadiusOuter.value = emitterRadiusRange[1];
+          uniforms.emitterAngle.value = emitterAngle;
+          uniforms.emitterHeightMin.value = emitterHeightRange[0];
+          uniforms.emitterHeightMax.value = emitterHeightRange[1];
+          uniforms.emitterSurfaceOnly.value = emitterSurfaceOnly ? 1 : 0;
+          uniforms.emitterDir.value.set(...emitterDirection).normalize();
+          uniforms.turbulenceIntensity.value = (_a2 = turbulence == null ? void 0 : turbulence.intensity) != null ? _a2 : 0;
+          uniforms.turbulenceFrequency.value = (_b = turbulence == null ? void 0 : turbulence.frequency) != null ? _b : 1;
+          uniforms.turbulenceSpeed.value = (_c = turbulence == null ? void 0 : turbulence.speed) != null ? _c : 1;
+          const attractorList = attractors != null ? attractors : [];
+          uniforms.attractorCount.value = Math.min(
+            attractorList.length,
+            MAX_ATTRACTORS
+          );
+          for (let i = 0; i < MAX_ATTRACTORS; i++) {
+            const a = attractorList[i];
+            const u = uniforms;
+            if (a) {
+              ;
+              u[`attractor${i}Pos`].value.set(
+                ...(_d = a.position) != null ? _d : [0, 0, 0]
+              );
+              u[`attractor${i}Strength`].value = (_e = a.strength) != null ? _e : 1;
+              u[`attractor${i}Radius`].value = (_f = a.radius) != null ? _f : 0;
+              u[`attractor${i}Type`].value = a.type === "vortex" ? 1 : 0;
+              u[`attractor${i}Axis`].value.set(...(_g = a.axis) != null ? _g : [0, 1, 0]).normalize();
+            } else {
+              u[`attractor${i}Strength`].value = 0;
+            }
           }
-        }
-        uniforms.attractToCenter.value = attractToCenter ? 1 : 0;
-        uniforms.startPositionAsDirection.value = startPositionAsDirection ? 1 : 0;
-        uniforms.softParticlesEnabled.value = softParticles ? 1 : 0;
-        uniforms.softDistance.value = softDistance;
-        uniforms.velocityCurveEnabled.value = velocityCurve ? 1 : 0;
-        uniforms.rotationSpeedCurveEnabled.value = rotationSpeedCurve ? 1 : 0;
-        uniforms.fadeSizeCurveEnabled.value = fadeSizeCurve ? 1 : 0;
-        uniforms.fadeOpacityCurveEnabled.value = fadeOpacityCurve ? 1 : 0;
-        uniforms.orientAxisType.value = axisToNumber(orientAxis);
-        uniforms.stretchEnabled.value = stretchBySpeed ? 1 : 0;
-        uniforms.stretchFactor.value = (_h = stretchBySpeed == null ? void 0 : stretchBySpeed.factor) != null ? _h : 1;
-        uniforms.stretchMax.value = (_i = stretchBySpeed == null ? void 0 : stretchBySpeed.maxStretch) != null ? _i : 5;
-        uniforms.collisionEnabled.value = collision ? 1 : 0;
-        uniforms.collisionPlaneY.value = (_k = (_j = collision == null ? void 0 : collision.plane) == null ? void 0 : _j.y) != null ? _k : 0;
-        uniforms.collisionBounce.value = (_l = collision == null ? void 0 : collision.bounce) != null ? _l : 0.3;
-        uniforms.collisionFriction.value = (_m = collision == null ? void 0 : collision.friction) != null ? _m : 0.8;
-        uniforms.collisionDie.value = (collision == null ? void 0 : collision.die) ? 1 : 0;
-        uniforms.sizeBasedGravity.value = (_n = collision == null ? void 0 : collision.sizeBasedGravity) != null ? _n : 0;
-      }, [
-        debug,
-        position,
-        sizeRange,
-        fadeSizeRange,
-        fadeOpacityRange,
-        gravity,
-        frictionIntensityRange,
-        frictionEasingType,
-        speedRange,
-        lifetimeRange,
-        direction3D,
-        rotation3D,
-        rotationSpeed3D,
-        intensity,
-        colorStart,
-        effectiveColorEnd,
-        startColors,
-        endColors,
-        uniforms,
-        collision,
-        emitterShape,
-        emitterRadiusRange,
-        emitterAngle,
-        emitterHeightRange,
-        emitterSurfaceOnly,
-        emitterDirection,
-        turbulence,
-        startPosition3D,
-        attractors,
-        attractToCenter,
-        startPositionAsDirection,
-        softParticles,
-        softDistance,
-        velocityCurve,
-        rotationSpeedCurve,
-        fadeSizeCurve,
-        fadeOpacityCurve,
-        orientAxis,
-        stretchBySpeed
-      ]);
-      const storage = useMemo(
-        () => ({
-          positions: instancedArray(activeMaxParticles, "vec3"),
-          velocities: instancedArray(activeMaxParticles, "vec3"),
-          lifetimes: instancedArray(activeMaxParticles, "float"),
-          fadeRates: instancedArray(activeMaxParticles, "float"),
-          particleSizes: instancedArray(activeMaxParticles, "float"),
-          particleRotations: instancedArray(activeMaxParticles, "vec3"),
-          particleColorStarts: instancedArray(activeMaxParticles, "vec3"),
-          particleColorEnds: instancedArray(activeMaxParticles, "vec3")
-        }),
-        [activeMaxParticles]
-      );
-      const computeInit = useMemo(
-        () => createInitCompute(storage, activeMaxParticles),
-        [storage, activeMaxParticles]
-      );
-      const computeSpawn = useMemo(
-        () => createSpawnCompute(storage, uniforms, activeMaxParticles),
-        [storage, uniforms, activeMaxParticles]
-      );
-      const computeUpdate = useMemo(
-        () => createUpdateCompute(storage, uniforms, curveTexture, activeMaxParticles),
-        [storage, uniforms, curveTexture, activeMaxParticles]
-      );
-      const material = useMemo(
-        () => createParticleMaterial(storage, uniforms, curveTexture, {
-          alphaMap,
-          flipbook,
-          appearance: activeAppearance,
-          lighting: activeLighting,
-          softParticles,
-          geometry: activeGeometry,
-          orientToDirection: activeOrientToDirection,
-          shadow: activeShadow,
-          blending,
-          opacityNode,
-          colorNode,
-          backdropNode,
-          alphaTestNode,
-          castShadowNode
-        }),
-        [
-          storage,
+          uniforms.attractToCenter.value = attractToCenter ? 1 : 0;
+          uniforms.startPositionAsDirection.value = startPositionAsDirection ? 1 : 0;
+          uniforms.softParticlesEnabled.value = softParticles ? 1 : 0;
+          uniforms.softDistance.value = softDistance;
+          uniforms.velocityCurveEnabled.value = velocityCurve || curveTexturePath ? 1 : 0;
+          uniforms.rotationSpeedCurveEnabled.value = rotationSpeedCurve || curveTexturePath ? 1 : 0;
+          uniforms.fadeSizeCurveEnabled.value = fadeSizeCurve || curveTexturePath ? 1 : 0;
+          uniforms.fadeOpacityCurveEnabled.value = fadeOpacityCurve || curveTexturePath ? 1 : 0;
+          uniforms.orientAxisType.value = axisToNumber(orientAxis);
+          uniforms.stretchEnabled.value = stretchBySpeed ? 1 : 0;
+          uniforms.stretchFactor.value = (_h = stretchBySpeed == null ? void 0 : stretchBySpeed.factor) != null ? _h : 1;
+          uniforms.stretchMax.value = (_i = stretchBySpeed == null ? void 0 : stretchBySpeed.maxStretch) != null ? _i : 5;
+          uniforms.collisionEnabled.value = collision ? 1 : 0;
+          uniforms.collisionPlaneY.value = (_k = (_j = collision == null ? void 0 : collision.plane) == null ? void 0 : _j.y) != null ? _k : 0;
+          uniforms.collisionBounce.value = (_l = collision == null ? void 0 : collision.bounce) != null ? _l : 0.3;
+          uniforms.collisionFriction.value = (_m = collision == null ? void 0 : collision.friction) != null ? _m : 0.8;
+          uniforms.collisionDie.value = (collision == null ? void 0 : collision.die) ? 1 : 0;
+          uniforms.sizeBasedGravity.value = (_n = collision == null ? void 0 : collision.sizeBasedGravity) != null ? _n : 0;
+        }, [
+          debug,
+          position,
+          sizeRange,
+          fadeSizeRange,
+          fadeOpacityRange,
+          gravity,
+          frictionIntensityRange,
+          frictionEasingType,
+          speedRange,
+          lifetimeRange,
+          direction3D,
+          rotation3D,
+          rotationSpeed3D,
+          intensity,
+          colorStart,
+          effectiveColorEnd,
+          startColors,
+          endColors,
           uniforms,
-          curveTexture,
-          activeAppearance,
-          alphaMap,
-          flipbook,
-          blending,
-          activeGeometry,
-          activeOrientToDirection,
-          activeLighting,
-          backdropNode,
-          opacityNode,
-          colorNode,
-          alphaTestNode,
-          castShadowNode,
+          collision,
+          emitterShape,
+          emitterRadiusRange,
+          emitterAngle,
+          emitterHeightRange,
+          emitterSurfaceOnly,
+          emitterDirection,
+          turbulence,
+          startPosition3D,
+          attractors,
+          attractToCenter,
+          startPositionAsDirection,
           softParticles,
-          activeShadow
-        ]
-      );
-      const renderObject = useMemo(() => {
-        if (activeGeometry) {
-          const mesh = new THREE2.InstancedMesh(
-            activeGeometry,
-            material,
-            activeMaxParticles
-          );
-          mesh.frustumCulled = false;
-          mesh.castShadow = activeShadow;
-          mesh.receiveShadow = activeShadow;
-          return mesh;
-        } else {
-          const s = new THREE2.Sprite(material);
-          s.count = activeMaxParticles;
-          s.frustumCulled = false;
-          return s;
-        }
-      }, [material, activeMaxParticles, activeGeometry, activeShadow]);
-      useEffect2(() => {
-        if (!renderer || initialized.current) return;
-        renderer.computeAsync(computeInit).then(() => {
-          initialized.current = true;
-        });
-      }, [renderer, computeInit]);
-      const applySpawnOverrides = useCallback2(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (overrides) => {
-          if (!overrides) return null;
-          const saved = {};
-          const setUniform = (key, value) => {
-            if (uniforms[key]) {
-              saved[key] = uniforms[key].value;
-              uniforms[key].value = value;
-            }
+          softDistance,
+          velocityCurve,
+          rotationSpeedCurve,
+          fadeSizeCurve,
+          fadeOpacityCurve,
+          curveTexturePath,
+          orientAxis,
+          stretchBySpeed
+        ]);
+        const storage = useMemo(() => {
+          const arrays = {
+            positions: instancedArray(activeMaxParticles, "vec3"),
+            velocities: instancedArray(activeMaxParticles, "vec3"),
+            lifetimes: instancedArray(activeMaxParticles, "float"),
+            fadeRates: instancedArray(activeMaxParticles, "float"),
+            particleSizes: instancedArray(activeMaxParticles, "float"),
+            // Optional arrays - null when feature unused (saves GPU memory)
+            particleRotations: null,
+            particleColorStarts: null,
+            particleColorEnds: null
           };
-          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 (activeFeatures.needsRotation) {
+            arrays.particleRotations = instancedArray(activeMaxParticles, "vec3");
           }
-          if (overrides.lifetime !== void 0) {
-            const range = toRange(overrides.lifetime, [1, 2]);
-            setUniform("lifetimeMin", 1 / range[1]);
-            setUniform("lifetimeMax", 1 / range[0]);
+          if (activeFeatures.needsPerParticleColor) {
+            arrays.particleColorStarts = instancedArray(activeMaxParticles, "vec3");
+            arrays.particleColorEnds = instancedArray(activeMaxParticles, "vec3");
           }
-          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 = uniforms.gravity.value.clone();
-            uniforms.gravity.value.set(...overrides.gravity);
-          }
-          const u = uniforms;
-          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]);
+          return arrays;
+        }, [
+          activeMaxParticles,
+          activeFeatures.needsRotation,
+          activeFeatures.needsPerParticleColor
+        ]);
+        const computeInit = useMemo(
+          () => createInitCompute(storage, activeMaxParticles),
+          [storage, activeMaxParticles]
+        );
+        const computeSpawn = useMemo(
+          () => createSpawnCompute(storage, uniforms, activeMaxParticles),
+          [storage, uniforms, activeMaxParticles]
+        );
+        const computeUpdate = useMemo(
+          () => createUpdateCompute(
+            storage,
+            uniforms,
+            curveTexture,
+            activeMaxParticles,
+            {
+              turbulence: activeFeatures.turbulence,
+              attractors: activeFeatures.attractors,
+              collision: activeFeatures.collision,
+              rotation: activeFeatures.rotation,
+              perParticleColor: activeFeatures.perParticleColor
+            }
+          ),
+          [storage, uniforms, curveTexture, activeMaxParticles, activeFeatures]
+        );
+        const material = useMemo(
+          () => createParticleMaterial(storage, uniforms, curveTexture, {
+            alphaMap,
+            flipbook,
+            appearance: activeAppearance,
+            lighting: activeLighting,
+            softParticles,
+            geometry: activeGeometry,
+            orientToDirection: activeOrientToDirection,
+            shadow: activeShadow,
+            blending,
+            opacityNode,
+            colorNode,
+            backdropNode,
+            alphaTestNode,
+            castShadowNode
+          }),
+          [
+            storage,
+            uniforms,
+            curveTexture,
+            activeAppearance,
+            alphaMap,
+            flipbook,
+            blending,
+            activeGeometry,
+            activeOrientToDirection,
+            activeLighting,
+            backdropNode,
+            opacityNode,
+            colorNode,
+            alphaTestNode,
+            castShadowNode,
+            softParticles,
+            activeShadow
+          ]
+        );
+        const renderObject = useMemo(() => {
+          if (activeGeometry) {
+            const mesh = new THREE2.InstancedMesh(
+              activeGeometry,
+              material,
+              activeMaxParticles
+            );
+            mesh.frustumCulled = false;
+            mesh.castShadow = activeShadow;
+            mesh.receiveShadow = activeShadow;
+            return mesh;
+          } else {
+            const s = new THREE2.Sprite(material);
+            s.count = activeMaxParticles;
+            s.frustumCulled = false;
+            return s;
           }
-          return () => {
-            Object.entries(saved).forEach(([key, value]) => {
+        }, [material, activeMaxParticles, activeGeometry, activeShadow]);
+        useEffect3(() => {
+          if (!renderer || initialized.current) return;
+          renderer.computeAsync(computeInit).then(() => {
+            initialized.current = true;
+          });
+        }, [renderer, computeInit]);
+        const applySpawnOverrides = useCallback2(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (overrides) => {
+            if (!overrides) return null;
+            const saved = {};
+            const setUniform = (key, value) => {
               if (uniforms[key]) {
+                saved[key] = uniforms[key].value;
                 uniforms[key].value = value;
               }
-            });
-          };
-        },
-        [uniforms]
-      );
-      const spawnInternal = useCallback2(
-        (x, y, z, count = 20, overrides = null) => {
+            };
+            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 = uniforms.gravity.value.clone();
+              uniforms.gravity.value.set(
+                ...overrides.gravity
+              );
+            }
+            const u = uniforms;
+            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]);
+            }
+            return () => {
+              Object.entries(saved).forEach(([key, value]) => {
+                if (uniforms[key]) {
+                  uniforms[key].value = value;
+                }
+              });
+            };
+          },
+          [uniforms]
+        );
+        const spawnInternal = useCallback2(
+          (x, y, z, count = 20, overrides = null) => {
+            if (!initialized.current || !renderer) return;
+            const restore = applySpawnOverrides(overrides);
+            const startIdx = nextIndex.current;
+            const endIdx = (startIdx + count) % activeMaxParticles;
+            uniforms.spawnPosition.value.set(x, y, z);
+            uniforms.spawnIndexStart.value = startIdx;
+            uniforms.spawnIndexEnd.value = endIdx;
+            uniforms.spawnSeed.value = Math.random() * 1e4;
+            nextIndex.current = endIdx;
+            renderer.computeAsync(computeSpawn);
+            if (restore) restore();
+          },
+          [
+            renderer,
+            computeSpawn,
+            uniforms,
+            activeMaxParticles,
+            applySpawnOverrides
+          ]
+        );
+        const spawn = useCallback2(
+          (x = 0, y = 0, z = 0, count = 20, overrides = null) => {
+            var _a2;
+            const [px, py, pz] = (_a2 = positionRef.current) != null ? _a2 : [0, 0, 0];
+            spawnInternal(px + x, py + y, pz + z, count, overrides);
+          },
+          [spawnInternal]
+        );
+        const computeUpdateRef = useRef3(computeUpdate);
+        useEffect3(() => {
+          computeUpdateRef.current = computeUpdate;
+        }, [computeUpdate]);
+        useFrame(async (state, delta) => {
+          var _a2, _b;
           if (!initialized.current || !renderer) return;
-          const restore = applySpawnOverrides(overrides);
-          const startIdx = nextIndex.current;
-          const endIdx = (startIdx + count) % activeMaxParticles;
-          uniforms.spawnPosition.value.set(x, y, z);
-          uniforms.spawnIndexStart.value = startIdx;
-          uniforms.spawnIndexEnd.value = endIdx;
-          uniforms.spawnSeed.value = Math.random() * 1e4;
-          nextIndex.current = endIdx;
-          renderer.computeAsync(computeSpawn);
-          if (restore) restore();
-        },
-        [renderer, computeSpawn, uniforms, activeMaxParticles, applySpawnOverrides]
-      );
-      const spawn = useCallback2(
-        (x = 0, y = 0, z = 0, count = 20, overrides = null) => {
-          var _a;
-          const [px, py, pz] = (_a = positionRef.current) != null ? _a : [0, 0, 0];
-          spawnInternal(px + x, py + y, pz + z, count, overrides);
-        },
-        [spawnInternal]
-      );
-      const computeUpdateRef = useRef2(computeUpdate);
-      useEffect2(() => {
-        computeUpdateRef.current = computeUpdate;
-      }, [computeUpdate]);
-      useFrame(async (state, delta) => {
-        var _a, _b;
-        if (!initialized.current || !renderer) return;
-        uniforms.deltaTime.value = delta;
-        const turbSpeed = (_b = (_a = turbulenceRef.current) == null ? void 0 : _a.speed) != null ? _b : 1;
-        uniforms.turbulenceTime.value += delta * turbSpeed;
-        await renderer.computeAsync(computeUpdateRef.current);
-        if (emitting) {
-          const [px, py, pz] = positionRef.current;
-          const currentDelay = delayRef.current;
-          const currentEmitCount = emitCountRef.current;
-          if (!currentDelay) {
-            spawnInternal(px, py, pz, currentEmitCount);
-          } else {
-            emitAccumulator.current += delta;
-            if (emitAccumulator.current >= currentDelay) {
-              emitAccumulator.current -= currentDelay;
+          uniforms.deltaTime.value = delta;
+          const turbSpeed = (_b = (_a2 = turbulenceRef.current) == null ? void 0 : _a2.speed) != null ? _b : 1;
+          uniforms.turbulenceTime.value += delta * turbSpeed;
+          await renderer.computeAsync(computeUpdateRef.current);
+          if (emitting) {
+            const [px, py, pz] = positionRef.current;
+            const currentDelay = delayRef.current;
+            const currentEmitCount = emitCountRef.current;
+            if (!currentDelay) {
               spawnInternal(px, py, pz, currentEmitCount);
+            } else {
+              emitAccumulator.current += delta;
+              if (emitAccumulator.current >= currentDelay) {
+                emitAccumulator.current -= currentDelay;
+                spawnInternal(px, py, pz, currentEmitCount);
+              }
             }
           }
-        }
-      });
-      const start = useCallback2(() => {
-        setEmitting(true);
-        emitAccumulator.current = 0;
-      }, []);
-      const stop = useCallback2(() => {
-        setEmitting(false);
-      }, []);
-      const prevMaterialRef = useRef2(null);
-      const prevRenderObjectRef = useRef2(null);
-      useEffect2(() => {
-        if (prevMaterialRef.current && prevMaterialRef.current !== material) {
-          prevMaterialRef.current.dispose();
-        }
-        prevMaterialRef.current = material;
-        if (prevRenderObjectRef.current && prevRenderObjectRef.current !== renderObject) {
-          if (prevRenderObjectRef.current.material) {
-            prevRenderObjectRef.current.material.dispose();
+        });
+        const start = useCallback2(() => {
+          setEmitting(true);
+          emitAccumulator.current = 0;
+        }, []);
+        const stop = useCallback2(() => {
+          setEmitting(false);
+        }, []);
+        const prevMaterialRef = useRef3(null);
+        const prevRenderObjectRef = useRef3(null);
+        useEffect3(() => {
+          if (prevMaterialRef.current && prevMaterialRef.current !== material) {
+            prevMaterialRef.current.dispose();
           }
-        }
-        prevRenderObjectRef.current = renderObject;
-      }, [material, renderObject]);
-      useEffect2(() => {
-        return () => {
-          if (material) {
-            material.dispose();
+          prevMaterialRef.current = material;
+          if (prevRenderObjectRef.current && prevRenderObjectRef.current !== renderObject) {
+            if (prevRenderObjectRef.current.material) {
+              prevRenderObjectRef.current.material.dispose();
+            }
           }
-          if (renderObject) {
-            if (renderObject.geometry && !geometry) {
-              renderObject.geometry.dispose();
+          prevRenderObjectRef.current = renderObject;
+        }, [material, renderObject]);
+        useEffect3(() => {
+          return () => {
+            if (material) {
+              material.dispose();
             }
-            if (renderObject.material) {
-              renderObject.material.dispose();
+            if (renderObject) {
+              if (renderObject.geometry && !geometry) {
+                renderObject.geometry.dispose();
+              }
+              if (renderObject.material) {
+                renderObject.material.dispose();
+              }
             }
-          }
-          initialized.current = false;
-          nextIndex.current = 0;
-        };
-      }, []);
-      const particleAPI = useMemo(
-        () => ({
-          spawn,
-          start,
-          stop,
-          get isEmitting() {
-            return emitting;
-          },
-          clear() {
-            renderer.computeAsync(computeInit);
+            initialized.current = false;
             nextIndex.current = 0;
-          },
-          uniforms
-        }),
-        [spawn, start, stop, emitting, renderer, computeInit, uniforms]
-      );
-      useImperativeHandle(ref, () => particleAPI, [particleAPI]);
-      const registerParticles = useVFXStore((s) => s.registerParticles);
-      const unregisterParticles = useVFXStore((s) => s.unregisterParticles);
-      useEffect2(() => {
-        if (!name) return;
-        registerParticles(name, particleAPI);
-        return () => {
-          unregisterParticles(name);
-        };
-      }, [name, particleAPI, registerParticles, unregisterParticles]);
-      const debugValuesRef = useRef2(null);
-      const prevGeometryTypeRef = useRef2(null);
-      const prevGeometryArgsRef = useRef2(null);
-      const handleDebugUpdate = useCallback2(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (newValues) => {
-          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;
-          debugValuesRef.current = __spreadValues(__spreadValues({}, debugValuesRef.current), newValues);
-          if ("size" in newValues) {
-            const sizeR = toRange(newValues.size, [0.1, 0.3]);
-            uniforms.sizeMin.value = sizeR[0];
-            uniforms.sizeMax.value = sizeR[1];
-          }
-          if ("fadeSize" in newValues) {
-            const fadeSizeR = toRange(newValues.fadeSize, [1, 0]);
-            uniforms.fadeSizeStart.value = fadeSizeR[0];
-            uniforms.fadeSizeEnd.value = fadeSizeR[1];
-          }
-          if ("fadeOpacity" in newValues) {
-            const fadeOpacityR = toRange(newValues.fadeOpacity, [1, 0]);
-            uniforms.fadeOpacityStart.value = fadeOpacityR[0];
-            uniforms.fadeOpacityEnd.value = fadeOpacityR[1];
-          }
-          if ("fadeSizeCurve" in newValues) {
-            setActiveFadeSizeCurve(newValues.fadeSizeCurve);
-            uniforms.fadeSizeCurveEnabled.value = newValues.fadeSizeCurve ? 1 : 0;
-          }
-          if ("fadeOpacityCurve" in newValues) {
-            setActiveFadeOpacityCurve(newValues.fadeOpacityCurve);
-            uniforms.fadeOpacityCurveEnabled.value = newValues.fadeOpacityCurve ? 1 : 0;
-          }
-          if ("velocityCurve" in newValues) {
-            setActiveVelocityCurve(newValues.velocityCurve);
-            uniforms.velocityCurveEnabled.value = newValues.velocityCurve ? 1 : 0;
-          }
-          if ("rotationSpeedCurve" in newValues) {
-            setActiveRotationSpeedCurve(newValues.rotationSpeedCurve);
-            uniforms.rotationSpeedCurveEnabled.value = newValues.rotationSpeedCurve ? 1 : 0;
-          }
-          if ("orientAxis" in newValues) {
-            uniforms.orientAxisType.value = axisToNumber(newValues.orientAxis);
-          }
-          if ("stretchBySpeed" in newValues) {
-            uniforms.stretchEnabled.value = newValues.stretchBySpeed ? 1 : 0;
-            uniforms.stretchFactor.value = (_b = (_a = newValues.stretchBySpeed) == null ? void 0 : _a.factor) != null ? _b : 1;
-            uniforms.stretchMax.value = (_d = (_c = newValues.stretchBySpeed) == null ? void 0 : _c.maxStretch) != null ? _d : 5;
-          }
-          if (newValues.gravity && Array.isArray(newValues.gravity)) {
-            uniforms.gravity.value.x = newValues.gravity[0];
-            uniforms.gravity.value.y = newValues.gravity[1];
-            uniforms.gravity.value.z = newValues.gravity[2];
-          }
-          if ("speed" in newValues) {
-            const speedR = toRange(newValues.speed, [0.1, 0.1]);
-            uniforms.speedMin.value = speedR[0];
-            uniforms.speedMax.value = speedR[1];
-          }
-          if ("lifetime" in newValues) {
-            const lifetimeR = toRange(newValues.lifetime, [1, 2]);
-            uniforms.lifetimeMin.value = 1 / lifetimeR[1];
-            uniforms.lifetimeMax.value = 1 / lifetimeR[0];
-          }
-          if ("friction" in newValues && newValues.friction) {
-            const frictionR = toRange(newValues.friction.intensity, [0, 0]);
-            uniforms.frictionIntensityStart.value = frictionR[0];
-            uniforms.frictionIntensityEnd.value = frictionR[1];
-            uniforms.frictionEasingType.value = easingToType(
-              newValues.friction.easing
-            );
-          }
-          if ("direction" in newValues) {
-            const dir3D = toRotation3D(newValues.direction);
-            uniforms.dirMinX.value = dir3D[0][0];
-            uniforms.dirMaxX.value = dir3D[0][1];
-            uniforms.dirMinY.value = dir3D[1][0];
-            uniforms.dirMaxY.value = dir3D[1][1];
-            uniforms.dirMinZ.value = dir3D[2][0];
-            uniforms.dirMaxZ.value = dir3D[2][1];
-          }
-          if ("startPosition" in newValues) {
-            const startPos3D = toRotation3D(newValues.startPosition);
-            uniforms.startPosMinX.value = startPos3D[0][0];
-            uniforms.startPosMaxX.value = startPos3D[0][1];
-            uniforms.startPosMinY.value = startPos3D[1][0];
-            uniforms.startPosMaxY.value = startPos3D[1][1];
-            uniforms.startPosMinZ.value = startPos3D[2][0];
-            uniforms.startPosMaxZ.value = startPos3D[2][1];
-          }
-          if ("rotation" in newValues) {
-            const rot3D = toRotation3D(newValues.rotation);
-            uniforms.rotationMinX.value = rot3D[0][0];
-            uniforms.rotationMaxX.value = rot3D[0][1];
-            uniforms.rotationMinY.value = rot3D[1][0];
-            uniforms.rotationMaxY.value = rot3D[1][1];
-            uniforms.rotationMinZ.value = rot3D[2][0];
-            uniforms.rotationMaxZ.value = rot3D[2][1];
-          }
-          if ("rotationSpeed" in newValues) {
-            const rotSpeed3D = toRotation3D(newValues.rotationSpeed);
-            uniforms.rotationSpeedMinX.value = rotSpeed3D[0][0];
-            uniforms.rotationSpeedMaxX.value = rotSpeed3D[0][1];
-            uniforms.rotationSpeedMinY.value = rotSpeed3D[1][0];
-            uniforms.rotationSpeedMaxY.value = rotSpeed3D[1][1];
-            uniforms.rotationSpeedMinZ.value = rotSpeed3D[2][0];
-            uniforms.rotationSpeedMaxZ.value = rotSpeed3D[2][1];
-          }
-          if ("intensity" in newValues) {
-            uniforms.intensity.value = newValues.intensity || 1;
-          }
-          if ("colorStart" in newValues && newValues.colorStart) {
-            const startColors2 = newValues.colorStart.slice(0, 8).map(hexToRgb);
-            while (startColors2.length < 8)
-              startColors2.push(startColors2[startColors2.length - 1] || [1, 1, 1]);
-            uniforms.colorStartCount.value = newValues.colorStart.length;
-            startColors2.forEach((c, i) => {
-              if (uniforms[`colorStart${i}`]) {
-                uniforms[`colorStart${i}`].value.setRGB(...c);
+          };
+        }, []);
+        const particleAPI = useMemo(
+          () => ({
+            spawn,
+            start,
+            stop,
+            get isEmitting() {
+              return emitting;
+            },
+            clear() {
+              renderer.computeAsync(computeInit);
+              nextIndex.current = 0;
+            },
+            uniforms
+          }),
+          [spawn, start, stop, emitting, renderer, computeInit, uniforms]
+        );
+        useImperativeHandle(ref, () => particleAPI, [particleAPI]);
+        const registerParticles = useVFXStore((s) => s.registerParticles);
+        const unregisterParticles = useVFXStore((s) => s.unregisterParticles);
+        useEffect3(() => {
+          if (!name) return;
+          registerParticles(name, particleAPI);
+          return () => {
+            unregisterParticles(name);
+          };
+        }, [name, particleAPI, registerParticles, unregisterParticles]);
+        const debugValuesRef = useRef3(null);
+        const prevGeometryTypeRef = useRef3(null);
+        const prevGeometryArgsRef = useRef3(null);
+        const handleDebugUpdate = useCallback2(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (newValues) => {
+            var _a2, _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, _R;
+            debugValuesRef.current = __spreadValues(__spreadValues({}, debugValuesRef.current), newValues);
+            if ("size" in newValues) {
+              const sizeR = toRange(newValues.size, [0.1, 0.3]);
+              uniforms.sizeMin.value = sizeR[0];
+              uniforms.sizeMax.value = sizeR[1];
+            }
+            if ("fadeSize" in newValues) {
+              const fadeSizeR = toRange(newValues.fadeSize, [1, 0]);
+              uniforms.fadeSizeStart.value = fadeSizeR[0];
+              uniforms.fadeSizeEnd.value = fadeSizeR[1];
+            }
+            if ("fadeOpacity" in newValues) {
+              const fadeOpacityR = toRange(newValues.fadeOpacity, [1, 0]);
+              uniforms.fadeOpacityStart.value = fadeOpacityR[0];
+              uniforms.fadeOpacityEnd.value = fadeOpacityR[1];
+            }
+            if ("fadeSizeCurve" in newValues) {
+              setActiveFadeSizeCurve(newValues.fadeSizeCurve);
+              uniforms.fadeSizeCurveEnabled.value = newValues.fadeSizeCurve ? 1 : 0;
+            }
+            if ("fadeOpacityCurve" in newValues) {
+              setActiveFadeOpacityCurve(newValues.fadeOpacityCurve);
+              uniforms.fadeOpacityCurveEnabled.value = newValues.fadeOpacityCurve ? 1 : 0;
+            }
+            if ("velocityCurve" in newValues) {
+              setActiveVelocityCurve(newValues.velocityCurve);
+              uniforms.velocityCurveEnabled.value = newValues.velocityCurve ? 1 : 0;
+            }
+            if ("rotationSpeedCurve" in newValues) {
+              setActiveRotationSpeedCurve(newValues.rotationSpeedCurve);
+              uniforms.rotationSpeedCurveEnabled.value = newValues.rotationSpeedCurve ? 1 : 0;
+            }
+            if ("orientAxis" in newValues) {
+              uniforms.orientAxisType.value = axisToNumber(newValues.orientAxis);
+            }
+            if ("stretchBySpeed" in newValues) {
+              uniforms.stretchEnabled.value = newValues.stretchBySpeed ? 1 : 0;
+              uniforms.stretchFactor.value = (_b = (_a2 = newValues.stretchBySpeed) == null ? void 0 : _a2.factor) != null ? _b : 1;
+              uniforms.stretchMax.value = (_d = (_c = newValues.stretchBySpeed) == null ? void 0 : _c.maxStretch) != null ? _d : 5;
+            }
+            if (newValues.gravity && Array.isArray(newValues.gravity)) {
+              uniforms.gravity.value.x = newValues.gravity[0];
+              uniforms.gravity.value.y = newValues.gravity[1];
+              uniforms.gravity.value.z = newValues.gravity[2];
+            }
+            if ("speed" in newValues) {
+              const speedR = toRange(newValues.speed, [0.1, 0.1]);
+              uniforms.speedMin.value = speedR[0];
+              uniforms.speedMax.value = speedR[1];
+            }
+            if ("lifetime" in newValues) {
+              const lifetimeR = toRange(newValues.lifetime, [1, 2]);
+              uniforms.lifetimeMin.value = 1 / lifetimeR[1];
+              uniforms.lifetimeMax.value = 1 / lifetimeR[0];
+            }
+            if ("friction" in newValues && newValues.friction) {
+              const frictionR = toRange(newValues.friction.intensity, [0, 0]);
+              uniforms.frictionIntensityStart.value = frictionR[0];
+              uniforms.frictionIntensityEnd.value = frictionR[1];
+              uniforms.frictionEasingType.value = easingToType(
+                newValues.friction.easing
+              );
+            }
+            if ("direction" in newValues) {
+              const dir3D = toRotation3D(newValues.direction);
+              uniforms.dirMinX.value = dir3D[0][0];
+              uniforms.dirMaxX.value = dir3D[0][1];
+              uniforms.dirMinY.value = dir3D[1][0];
+              uniforms.dirMaxY.value = dir3D[1][1];
+              uniforms.dirMinZ.value = dir3D[2][0];
+              uniforms.dirMaxZ.value = dir3D[2][1];
+            }
+            if ("startPosition" in newValues) {
+              const startPos3D = toRotation3D(newValues.startPosition);
+              uniforms.startPosMinX.value = startPos3D[0][0];
+              uniforms.startPosMaxX.value = startPos3D[0][1];
+              uniforms.startPosMinY.value = startPos3D[1][0];
+              uniforms.startPosMaxY.value = startPos3D[1][1];
+              uniforms.startPosMinZ.value = startPos3D[2][0];
+              uniforms.startPosMaxZ.value = startPos3D[2][1];
+            }
+            if ("rotation" in newValues) {
+              const rot3D = toRotation3D(newValues.rotation);
+              uniforms.rotationMinX.value = rot3D[0][0];
+              uniforms.rotationMaxX.value = rot3D[0][1];
+              uniforms.rotationMinY.value = rot3D[1][0];
+              uniforms.rotationMaxY.value = rot3D[1][1];
+              uniforms.rotationMinZ.value = rot3D[2][0];
+              uniforms.rotationMaxZ.value = rot3D[2][1];
+            }
+            if ("rotationSpeed" in newValues) {
+              const rotSpeed3D = toRotation3D(newValues.rotationSpeed);
+              uniforms.rotationSpeedMinX.value = rotSpeed3D[0][0];
+              uniforms.rotationSpeedMaxX.value = rotSpeed3D[0][1];
+              uniforms.rotationSpeedMinY.value = rotSpeed3D[1][0];
+              uniforms.rotationSpeedMaxY.value = rotSpeed3D[1][1];
+              uniforms.rotationSpeedMinZ.value = rotSpeed3D[2][0];
+              uniforms.rotationSpeedMaxZ.value = rotSpeed3D[2][1];
+            }
+            if ("rotation" in newValues || "rotationSpeed" in newValues) {
+              const rot = (_g = (_f = newValues.rotation) != null ? _f : (_e = debugValuesRef.current) == null ? void 0 : _e.rotation) != null ? _g : [0, 0];
+              const rotSpeed = (_j = (_i = newValues.rotationSpeed) != null ? _i : (_h = debugValuesRef.current) == null ? void 0 : _h.rotationSpeed) != null ? _j : [0, 0];
+              const needsRotation = isNonDefaultRotation(rot) || isNonDefaultRotation(rotSpeed);
+              if (needsRotation !== activeNeedsRotation) {
+                setActiveNeedsRotation(needsRotation);
               }
-            });
-            const currentColorEnd = (_e = debugValuesRef.current) == null ? void 0 : _e.colorEnd;
-            if (!currentColorEnd) {
-              uniforms.colorEndCount.value = newValues.colorStart.length;
+            }
+            if ("intensity" in newValues) {
+              uniforms.intensity.value = newValues.intensity || 1;
+            }
+            if ("colorStart" in newValues && newValues.colorStart) {
+              const startColors2 = newValues.colorStart.slice(0, 8).map(hexToRgb);
+              while (startColors2.length < 8)
+                startColors2.push(startColors2[startColors2.length - 1] || [1, 1, 1]);
+              uniforms.colorStartCount.value = newValues.colorStart.length;
               startColors2.forEach((c, i) => {
-                if (uniforms[`colorEnd${i}`]) {
-                  uniforms[`colorEnd${i}`].value.setRGB(...c);
+                if (uniforms[`colorStart${i}`]) {
+                  uniforms[`colorStart${i}`].value.setRGB(...c);
                 }
               });
+              const currentColorEnd = (_k = debugValuesRef.current) == null ? void 0 : _k.colorEnd;
+              if (!currentColorEnd) {
+                uniforms.colorEndCount.value = newValues.colorStart.length;
+                startColors2.forEach((c, i) => {
+                  if (uniforms[`colorEnd${i}`]) {
+                    uniforms[`colorEnd${i}`].value.setRGB(...c);
+                  }
+                });
+              }
             }
-          }
-          if ("colorEnd" in newValues) {
-            const effectiveEndColors = newValues.colorEnd || newValues.colorStart || ((_f = debugValuesRef.current) == null ? void 0 : _f.colorStart) || ["#ffffff"];
-            if (effectiveEndColors) {
-              const endColors2 = effectiveEndColors.slice(0, 8).map(hexToRgb);
-              while (endColors2.length < 8)
-                endColors2.push(endColors2[endColors2.length - 1] || [1, 1, 1]);
-              uniforms.colorEndCount.value = effectiveEndColors.length;
-              endColors2.forEach((c, i) => {
-                if (uniforms[`colorEnd${i}`]) {
-                  uniforms[`colorEnd${i}`].value.setRGB(...c);
-                }
-              });
+            if ("colorEnd" in newValues) {
+              const effectiveEndColors = newValues.colorEnd || newValues.colorStart || ((_l = debugValuesRef.current) == null ? void 0 : _l.colorStart) || ["#ffffff"];
+              if (effectiveEndColors) {
+                const endColors2 = effectiveEndColors.slice(0, 8).map(hexToRgb);
+                while (endColors2.length < 8)
+                  endColors2.push(endColors2[endColors2.length - 1] || [1, 1, 1]);
+                uniforms.colorEndCount.value = effectiveEndColors.length;
+                endColors2.forEach((c, i) => {
+                  if (uniforms[`colorEnd${i}`]) {
+                    uniforms[`colorEnd${i}`].value.setRGB(...c);
+                  }
+                });
+              }
             }
-          }
-          if ("emitterShape" in newValues) {
-            uniforms.emitterShapeType.value = (_g = newValues.emitterShape) != null ? _g : EmitterShape2.BOX;
-          }
-          if ("emitterRadius" in newValues) {
-            const emitterRadiusR = toRange(newValues.emitterRadius, [0, 1]);
-            uniforms.emitterRadiusInner.value = emitterRadiusR[0];
-            uniforms.emitterRadiusOuter.value = emitterRadiusR[1];
-          }
-          if ("emitterAngle" in newValues) {
-            uniforms.emitterAngle.value = (_h = newValues.emitterAngle) != null ? _h : Math.PI / 4;
-          }
-          if ("emitterHeight" in newValues) {
-            const emitterHeightR = toRange(newValues.emitterHeight, [0, 1]);
-            uniforms.emitterHeightMin.value = emitterHeightR[0];
-            uniforms.emitterHeightMax.value = emitterHeightR[1];
-          }
-          if ("emitterSurfaceOnly" in newValues) {
-            uniforms.emitterSurfaceOnly.value = newValues.emitterSurfaceOnly ? 1 : 0;
-          }
-          if ("emitterDirection" in newValues && newValues.emitterDirection && Array.isArray(newValues.emitterDirection)) {
-            const dir = new THREE2.Vector3(
-              ...newValues.emitterDirection
-            ).normalize();
-            uniforms.emitterDir.value.x = dir.x;
-            uniforms.emitterDir.value.y = dir.y;
-            uniforms.emitterDir.value.z = dir.z;
-          }
-          if ("turbulence" in newValues) {
-            uniforms.turbulenceIntensity.value = (_j = (_i = newValues.turbulence) == null ? void 0 : _i.intensity) != null ? _j : 0;
-            uniforms.turbulenceFrequency.value = (_l = (_k = newValues.turbulence) == null ? void 0 : _k.frequency) != null ? _l : 1;
-            uniforms.turbulenceSpeed.value = (_n = (_m = newValues.turbulence) == null ? void 0 : _m.speed) != null ? _n : 1;
-            turbulenceRef.current = newValues.turbulence;
-          }
-          if ("attractToCenter" in newValues) {
-            uniforms.attractToCenter.value = newValues.attractToCenter ? 1 : 0;
-          }
-          if ("startPositionAsDirection" in newValues) {
-            uniforms.startPositionAsDirection.value = newValues.startPositionAsDirection ? 1 : 0;
-          }
-          if ("softParticles" in newValues) {
-            uniforms.softParticlesEnabled.value = newValues.softParticles ? 1 : 0;
-          }
-          if ("softDistance" in newValues) {
-            uniforms.softDistance.value = (_o = newValues.softDistance) != null ? _o : 0.5;
-          }
-          if ("collision" in newValues) {
-            uniforms.collisionEnabled.value = newValues.collision ? 1 : 0;
-            uniforms.collisionPlaneY.value = (_r = (_q = (_p = newValues.collision) == null ? void 0 : _p.plane) == null ? void 0 : _q.y) != null ? _r : 0;
-            uniforms.collisionBounce.value = (_t = (_s = newValues.collision) == null ? void 0 : _s.bounce) != null ? _t : 0.3;
-            uniforms.collisionFriction.value = (_v = (_u = newValues.collision) == null ? void 0 : _u.friction) != null ? _v : 0.8;
-            uniforms.collisionDie.value = ((_w = newValues.collision) == null ? void 0 : _w.die) ? 1 : 0;
-            uniforms.sizeBasedGravity.value = (_y = (_x = newValues.collision) == null ? void 0 : _x.sizeBasedGravity) != null ? _y : 0;
-          }
-          if (newValues.position) {
-            positionRef.current = newValues.position;
-          }
-          if ("delay" in newValues) delayRef.current = (_z = newValues.delay) != null ? _z : 0;
-          if ("emitCount" in newValues)
-            emitCountRef.current = (_A = newValues.emitCount) != null ? _A : 1;
-          if (newValues.autoStart !== void 0) {
-            setEmitting(newValues.autoStart);
-          }
-          if (material && newValues.blending !== void 0) {
-            material.blending = newValues.blending;
-            material.needsUpdate = true;
-          }
-          if (newValues.maxParticles !== void 0 && newValues.maxParticles !== activeMaxParticles) {
-            setActiveMaxParticles(newValues.maxParticles);
-            initialized.current = false;
-            nextIndex.current = 0;
-          }
-          if (newValues.lighting !== void 0 && newValues.lighting !== activeLighting) {
-            setActiveLighting(newValues.lighting);
-          }
-          if (newValues.appearance !== void 0 && newValues.appearance !== activeAppearance) {
-            setActiveAppearance(newValues.appearance);
-          }
-          if (newValues.orientToDirection !== void 0 && newValues.orientToDirection !== activeOrientToDirection) {
-            setActiveOrientToDirection(newValues.orientToDirection);
-          }
-          if (newValues.shadow !== void 0 && newValues.shadow !== activeShadow) {
-            setActiveShadow(newValues.shadow);
-          }
-          if ("geometryType" in newValues || "geometryArgs" in newValues) {
-            const geoType = (_B = newValues.geometryType) != null ? _B : prevGeometryTypeRef.current;
-            const geoArgs = (_C = newValues.geometryArgs) != null ? _C : prevGeometryArgsRef.current;
-            const geoTypeChanged = "geometryType" in newValues && geoType !== prevGeometryTypeRef.current;
-            const geoArgsChanged = "geometryArgs" in newValues && JSON.stringify(geoArgs) !== JSON.stringify(prevGeometryArgsRef.current);
-            if (geoTypeChanged || geoArgsChanged) {
-              prevGeometryTypeRef.current = geoType;
-              prevGeometryArgsRef.current = geoArgs;
-              Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(
-                ({ createGeometry: createGeometry2, GeometryType: GeometryType2 }) => {
-                  if (geoType === GeometryType2.NONE || !geoType) {
-                    if (activeGeometry !== null && !geometry) {
-                      activeGeometry.dispose();
-                    }
-                    setActiveGeometry(null);
-                  } else {
-                    const newGeometry = createGeometry2(geoType, geoArgs);
-                    if (newGeometry) {
-                      if (activeGeometry !== null && activeGeometry !== geometry) {
+            if ("colorStart" in newValues || "colorEnd" in newValues) {
+              const startLen = (_q = (_p = (_m = newValues.colorStart) == null ? void 0 : _m.length) != null ? _p : (_o = (_n = debugValuesRef.current) == null ? void 0 : _n.colorStart) == null ? void 0 : _o.length) != null ? _q : 1;
+              const hasColorEnd = "colorEnd" in newValues ? newValues.colorEnd !== null : ((_r = debugValuesRef.current) == null ? void 0 : _r.colorEnd) !== null;
+              const needsPerParticle = startLen > 1 || hasColorEnd;
+              if (needsPerParticle !== activeNeedsPerParticleColor) {
+                setActiveNeedsPerParticleColor(needsPerParticle);
+              }
+            }
+            if ("emitterShape" in newValues) {
+              uniforms.emitterShapeType.value = (_s = newValues.emitterShape) != null ? _s : EmitterShape2.BOX;
+            }
+            if ("emitterRadius" in newValues) {
+              const emitterRadiusR = toRange(newValues.emitterRadius, [0, 1]);
+              uniforms.emitterRadiusInner.value = emitterRadiusR[0];
+              uniforms.emitterRadiusOuter.value = emitterRadiusR[1];
+            }
+            if ("emitterAngle" in newValues) {
+              uniforms.emitterAngle.value = (_t = newValues.emitterAngle) != null ? _t : Math.PI / 4;
+            }
+            if ("emitterHeight" in newValues) {
+              const emitterHeightR = toRange(newValues.emitterHeight, [0, 1]);
+              uniforms.emitterHeightMin.value = emitterHeightR[0];
+              uniforms.emitterHeightMax.value = emitterHeightR[1];
+            }
+            if ("emitterSurfaceOnly" in newValues) {
+              uniforms.emitterSurfaceOnly.value = newValues.emitterSurfaceOnly ? 1 : 0;
+            }
+            if ("emitterDirection" in newValues && newValues.emitterDirection && Array.isArray(newValues.emitterDirection)) {
+              const dir = new THREE2.Vector3(
+                ...newValues.emitterDirection
+              ).normalize();
+              uniforms.emitterDir.value.x = dir.x;
+              uniforms.emitterDir.value.y = dir.y;
+              uniforms.emitterDir.value.z = dir.z;
+            }
+            if ("turbulence" in newValues) {
+              uniforms.turbulenceIntensity.value = (_v = (_u = newValues.turbulence) == null ? void 0 : _u.intensity) != null ? _v : 0;
+              uniforms.turbulenceFrequency.value = (_x = (_w = newValues.turbulence) == null ? void 0 : _w.frequency) != null ? _x : 1;
+              uniforms.turbulenceSpeed.value = (_z = (_y = newValues.turbulence) == null ? void 0 : _y.speed) != null ? _z : 1;
+              turbulenceRef.current = newValues.turbulence;
+              const needsTurbulence = newValues.turbulence !== null && ((_B = (_A = newValues.turbulence) == null ? void 0 : _A.intensity) != null ? _B : 0) > 0;
+              if (needsTurbulence !== activeTurbulence) {
+                setActiveTurbulence(needsTurbulence);
+              }
+            }
+            if ("attractToCenter" in newValues) {
+              uniforms.attractToCenter.value = newValues.attractToCenter ? 1 : 0;
+            }
+            if ("startPositionAsDirection" in newValues) {
+              uniforms.startPositionAsDirection.value = newValues.startPositionAsDirection ? 1 : 0;
+            }
+            if ("softParticles" in newValues) {
+              uniforms.softParticlesEnabled.value = newValues.softParticles ? 1 : 0;
+            }
+            if ("softDistance" in newValues) {
+              uniforms.softDistance.value = (_C = newValues.softDistance) != null ? _C : 0.5;
+            }
+            if ("collision" in newValues) {
+              uniforms.collisionEnabled.value = newValues.collision ? 1 : 0;
+              uniforms.collisionPlaneY.value = (_F = (_E = (_D = newValues.collision) == null ? void 0 : _D.plane) == null ? void 0 : _E.y) != null ? _F : 0;
+              uniforms.collisionBounce.value = (_H = (_G = newValues.collision) == null ? void 0 : _G.bounce) != null ? _H : 0.3;
+              uniforms.collisionFriction.value = (_J = (_I = newValues.collision) == null ? void 0 : _I.friction) != null ? _J : 0.8;
+              uniforms.collisionDie.value = ((_K = newValues.collision) == null ? void 0 : _K.die) ? 1 : 0;
+              uniforms.sizeBasedGravity.value = (_M = (_L = newValues.collision) == null ? void 0 : _L.sizeBasedGravity) != null ? _M : 0;
+              const needsCollision = newValues.collision !== null && newValues.collision !== void 0;
+              if (needsCollision !== activeCollision) {
+                setActiveCollision(needsCollision);
+              }
+            }
+            if ("attractors" in newValues) {
+              const needsAttractors = newValues.attractors !== null && ((_N = newValues.attractors) == null ? void 0 : _N.length) > 0;
+              if (needsAttractors !== activeAttractors) {
+                setActiveAttractors(needsAttractors);
+              }
+            }
+            if (newValues.position) {
+              positionRef.current = newValues.position;
+            }
+            if ("delay" in newValues) delayRef.current = (_O = newValues.delay) != null ? _O : 0;
+            if ("emitCount" in newValues)
+              emitCountRef.current = (_P = newValues.emitCount) != null ? _P : 1;
+            if (newValues.autoStart !== void 0) {
+              setEmitting(newValues.autoStart);
+            }
+            if (material && newValues.blending !== void 0) {
+              material.blending = newValues.blending;
+              material.needsUpdate = true;
+            }
+            if (newValues.maxParticles !== void 0 && newValues.maxParticles !== activeMaxParticles) {
+              setActiveMaxParticles(newValues.maxParticles);
+              initialized.current = false;
+              nextIndex.current = 0;
+            }
+            if (newValues.lighting !== void 0 && newValues.lighting !== activeLighting) {
+              setActiveLighting(newValues.lighting);
+            }
+            if (newValues.appearance !== void 0 && newValues.appearance !== activeAppearance) {
+              setActiveAppearance(newValues.appearance);
+            }
+            if (newValues.orientToDirection !== void 0 && newValues.orientToDirection !== activeOrientToDirection) {
+              setActiveOrientToDirection(newValues.orientToDirection);
+            }
+            if (newValues.shadow !== void 0 && newValues.shadow !== activeShadow) {
+              setActiveShadow(newValues.shadow);
+            }
+            if ("geometryType" in newValues || "geometryArgs" in newValues) {
+              const geoType = (_Q = newValues.geometryType) != null ? _Q : prevGeometryTypeRef.current;
+              const geoArgs = (_R = newValues.geometryArgs) != null ? _R : prevGeometryArgsRef.current;
+              const geoTypeChanged = "geometryType" in newValues && geoType !== prevGeometryTypeRef.current;
+              const geoArgsChanged = "geometryArgs" in newValues && JSON.stringify(geoArgs) !== JSON.stringify(prevGeometryArgsRef.current);
+              if (geoTypeChanged || geoArgsChanged) {
+                prevGeometryTypeRef.current = geoType;
+                prevGeometryArgsRef.current = geoArgs;
+                Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(
+                  ({ createGeometry: createGeometry2, GeometryType: GeometryType2 }) => {
+                    if (geoType === GeometryType2.NONE || !geoType) {
+                      if (activeGeometry !== null && !geometry) {
                         activeGeometry.dispose();
                       }
-                      setActiveGeometry(newGeometry);
+                      setActiveGeometry(null);
+                    } else {
+                      const newGeometry = createGeometry2(geoType, geoArgs);
+                      if (newGeometry) {
+                        if (activeGeometry !== null && activeGeometry !== geometry) {
+                          activeGeometry.dispose();
+                        }
+                        setActiveGeometry(newGeometry);
+                      }
                     }
                   }
-                }
-              );
+                );
+              }
+            }
+          },
+          [
+            uniforms,
+            material,
+            renderObject,
+            activeMaxParticles,
+            activeLighting,
+            activeAppearance,
+            activeOrientToDirection,
+            activeShadow,
+            activeGeometry,
+            activeNeedsPerParticleColor,
+            activeNeedsRotation,
+            activeTurbulence,
+            activeAttractors,
+            activeCollision,
+            geometry
+          ]
+        );
+        useEffect3(() => {
+          if (!debug) return;
+          const initialValues = __spreadValues({
+            name,
+            // Include name for curve baking filename
+            maxParticles,
+            size,
+            colorStart,
+            colorEnd,
+            fadeSize,
+            fadeSizeCurve: fadeSizeCurve || null,
+            // null = linear (no curve)
+            fadeOpacity,
+            fadeOpacityCurve: fadeOpacityCurve || null,
+            // null = linear (no curve)
+            velocityCurve: velocityCurve || null,
+            // null = use friction (no curve)
+            gravity,
+            lifetime,
+            direction,
+            startPosition,
+            startPositionAsDirection,
+            speed,
+            friction,
+            appearance,
+            rotation,
+            rotationSpeed,
+            rotationSpeedCurve: rotationSpeedCurve || null,
+            // null = constant speed (no curve)
+            orientToDirection,
+            orientAxis,
+            stretchBySpeed: stretchBySpeed || null,
+            lighting,
+            shadow,
+            blending,
+            intensity,
+            position,
+            autoStart,
+            delay,
+            emitCount,
+            emitterShape,
+            emitterRadius,
+            emitterAngle,
+            emitterHeight,
+            emitterSurfaceOnly,
+            emitterDirection,
+            turbulence,
+            attractToCenter,
+            softParticles,
+            softDistance,
+            collision
+          }, detectGeometryTypeAndArgs(geometry));
+          function detectGeometryTypeAndArgs(geo) {
+            var _a2, _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;
+            if (!geo) return { geometryType: "none", geometryArgs: null };
+            const name2 = geo.constructor.name;
+            const params = geo.parameters || {};
+            switch (name2) {
+              case "BoxGeometry":
+                return {
+                  geometryType: "box",
+                  geometryArgs: {
+                    width: (_a2 = params.width) != null ? _a2 : 1,
+                    height: (_b = params.height) != null ? _b : 1,
+                    depth: (_c = params.depth) != null ? _c : 1,
+                    widthSegments: (_d = params.widthSegments) != null ? _d : 1,
+                    heightSegments: (_e = params.heightSegments) != null ? _e : 1,
+                    depthSegments: (_f = params.depthSegments) != null ? _f : 1
+                  }
+                };
+              case "SphereGeometry":
+                return {
+                  geometryType: "sphere",
+                  geometryArgs: {
+                    radius: (_g = params.radius) != null ? _g : 0.5,
+                    widthSegments: (_h = params.widthSegments) != null ? _h : 16,
+                    heightSegments: (_i = params.heightSegments) != null ? _i : 12
+                  }
+                };
+              case "CylinderGeometry":
+                return {
+                  geometryType: "cylinder",
+                  geometryArgs: {
+                    radiusTop: (_j = params.radiusTop) != null ? _j : 0.5,
+                    radiusBottom: (_k = params.radiusBottom) != null ? _k : 0.5,
+                    height: (_l = params.height) != null ? _l : 1,
+                    radialSegments: (_m = params.radialSegments) != null ? _m : 16,
+                    heightSegments: (_n = params.heightSegments) != null ? _n : 1
+                  }
+                };
+              case "ConeGeometry":
+                return {
+                  geometryType: "cone",
+                  geometryArgs: {
+                    radius: (_o = params.radius) != null ? _o : 0.5,
+                    height: (_p = params.height) != null ? _p : 1,
+                    radialSegments: (_q = params.radialSegments) != null ? _q : 16,
+                    heightSegments: (_r = params.heightSegments) != null ? _r : 1
+                  }
+                };
+              case "TorusGeometry":
+                return {
+                  geometryType: "torus",
+                  geometryArgs: {
+                    radius: (_s = params.radius) != null ? _s : 0.5,
+                    tube: (_t = params.tube) != null ? _t : 0.2,
+                    radialSegments: (_u = params.radialSegments) != null ? _u : 12,
+                    tubularSegments: (_v = params.tubularSegments) != null ? _v : 24
+                  }
+                };
+              case "PlaneGeometry":
+                return {
+                  geometryType: "plane",
+                  geometryArgs: {
+                    width: (_w = params.width) != null ? _w : 1,
+                    height: (_x = params.height) != null ? _x : 1,
+                    widthSegments: (_y = params.widthSegments) != null ? _y : 1,
+                    heightSegments: (_z = params.heightSegments) != null ? _z : 1
+                  }
+                };
+              case "CircleGeometry":
+                return {
+                  geometryType: "circle",
+                  geometryArgs: {
+                    radius: (_A = params.radius) != null ? _A : 0.5,
+                    segments: (_B = params.segments) != null ? _B : 16
+                  }
+                };
+              case "RingGeometry":
+                return {
+                  geometryType: "ring",
+                  geometryArgs: {
+                    innerRadius: (_C = params.innerRadius) != null ? _C : 0.25,
+                    outerRadius: (_D = params.outerRadius) != null ? _D : 0.5,
+                    thetaSegments: (_E = params.thetaSegments) != null ? _E : 16
+                  }
+                };
+              case "DodecahedronGeometry":
+                return {
+                  geometryType: "dodecahedron",
+                  geometryArgs: {
+                    radius: (_F = params.radius) != null ? _F : 0.5,
+                    detail: (_G = params.detail) != null ? _G : 0
+                  }
+                };
+              case "IcosahedronGeometry":
+                return {
+                  geometryType: "icosahedron",
+                  geometryArgs: {
+                    radius: (_H = params.radius) != null ? _H : 0.5,
+                    detail: (_I = params.detail) != null ? _I : 0
+                  }
+                };
+              case "OctahedronGeometry":
+                return {
+                  geometryType: "octahedron",
+                  geometryArgs: {
+                    radius: (_J = params.radius) != null ? _J : 0.5,
+                    detail: (_K = params.detail) != null ? _K : 0
+                  }
+                };
+              case "TetrahedronGeometry":
+                return {
+                  geometryType: "tetrahedron",
+                  geometryArgs: {
+                    radius: (_L = params.radius) != null ? _L : 0.5,
+                    detail: (_M = params.detail) != null ? _M : 0
+                  }
+                };
+              case "CapsuleGeometry":
+                return {
+                  geometryType: "capsule",
+                  geometryArgs: {
+                    radius: (_N = params.radius) != null ? _N : 0.25,
+                    length: (_O = params.length) != null ? _O : 0.5,
+                    capSegments: (_P = params.capSegments) != null ? _P : 4,
+                    radialSegments: (_Q = params.radialSegments) != null ? _Q : 8
+                  }
+                };
+              default:
+                return { geometryType: "none", geometryArgs: null };
             }
           }
-        },
-        [
-          uniforms,
-          material,
-          renderObject,
-          activeMaxParticles,
-          activeLighting,
-          activeAppearance,
-          activeOrientToDirection,
-          activeShadow,
-          activeGeometry,
-          geometry
-        ]
-      );
-      useEffect2(() => {
-        if (!debug) return;
-        const initialValues = __spreadValues({
-          maxParticles,
-          size,
-          colorStart,
-          colorEnd,
-          fadeSize,
-          fadeSizeCurve: fadeSizeCurve || null,
-          // null = linear (no curve)
-          fadeOpacity,
-          fadeOpacityCurve: fadeOpacityCurve || null,
-          // null = linear (no curve)
-          velocityCurve: velocityCurve || null,
-          // null = use friction (no curve)
-          gravity,
-          lifetime,
-          direction,
-          startPosition,
-          startPositionAsDirection,
-          speed,
-          friction,
-          appearance,
-          rotation,
-          rotationSpeed,
-          rotationSpeedCurve: rotationSpeedCurve || null,
-          // null = constant speed (no curve)
-          orientToDirection,
-          orientAxis,
-          stretchBySpeed: stretchBySpeed || null,
-          lighting,
-          shadow,
-          blending,
-          intensity,
-          position,
-          autoStart,
-          delay,
-          emitCount,
-          emitterShape,
-          emitterRadius,
-          emitterAngle,
-          emitterHeight,
-          emitterSurfaceOnly,
-          emitterDirection,
-          turbulence,
-          attractToCenter,
-          softParticles,
-          softDistance,
-          collision
-        }, detectGeometryTypeAndArgs(geometry));
-        function detectGeometryTypeAndArgs(geo) {
-          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;
-          if (!geo) return { geometryType: "none", geometryArgs: null };
-          const name2 = geo.constructor.name;
-          const params = geo.parameters || {};
-          switch (name2) {
-            case "BoxGeometry":
-              return {
-                geometryType: "box",
-                geometryArgs: {
-                  width: (_a = params.width) != null ? _a : 1,
-                  height: (_b = params.height) != null ? _b : 1,
-                  depth: (_c = params.depth) != null ? _c : 1,
-                  widthSegments: (_d = params.widthSegments) != null ? _d : 1,
-                  heightSegments: (_e = params.heightSegments) != null ? _e : 1,
-                  depthSegments: (_f = params.depthSegments) != null ? _f : 1
-                }
-              };
-            case "SphereGeometry":
-              return {
-                geometryType: "sphere",
-                geometryArgs: {
-                  radius: (_g = params.radius) != null ? _g : 0.5,
-                  widthSegments: (_h = params.widthSegments) != null ? _h : 16,
-                  heightSegments: (_i = params.heightSegments) != null ? _i : 12
-                }
-              };
-            case "CylinderGeometry":
-              return {
-                geometryType: "cylinder",
-                geometryArgs: {
-                  radiusTop: (_j = params.radiusTop) != null ? _j : 0.5,
-                  radiusBottom: (_k = params.radiusBottom) != null ? _k : 0.5,
-                  height: (_l = params.height) != null ? _l : 1,
-                  radialSegments: (_m = params.radialSegments) != null ? _m : 16,
-                  heightSegments: (_n = params.heightSegments) != null ? _n : 1
-                }
-              };
-            case "ConeGeometry":
-              return {
-                geometryType: "cone",
-                geometryArgs: {
-                  radius: (_o = params.radius) != null ? _o : 0.5,
-                  height: (_p = params.height) != null ? _p : 1,
-                  radialSegments: (_q = params.radialSegments) != null ? _q : 16,
-                  heightSegments: (_r = params.heightSegments) != null ? _r : 1
-                }
-              };
-            case "TorusGeometry":
-              return {
-                geometryType: "torus",
-                geometryArgs: {
-                  radius: (_s = params.radius) != null ? _s : 0.5,
-                  tube: (_t = params.tube) != null ? _t : 0.2,
-                  radialSegments: (_u = params.radialSegments) != null ? _u : 12,
-                  tubularSegments: (_v = params.tubularSegments) != null ? _v : 24
-                }
-              };
-            case "PlaneGeometry":
-              return {
-                geometryType: "plane",
-                geometryArgs: {
-                  width: (_w = params.width) != null ? _w : 1,
-                  height: (_x = params.height) != null ? _x : 1,
-                  widthSegments: (_y = params.widthSegments) != null ? _y : 1,
-                  heightSegments: (_z = params.heightSegments) != null ? _z : 1
-                }
-              };
-            case "CircleGeometry":
-              return {
-                geometryType: "circle",
-                geometryArgs: {
-                  radius: (_A = params.radius) != null ? _A : 0.5,
-                  segments: (_B = params.segments) != null ? _B : 16
-                }
-              };
-            case "RingGeometry":
-              return {
-                geometryType: "ring",
-                geometryArgs: {
-                  innerRadius: (_C = params.innerRadius) != null ? _C : 0.25,
-                  outerRadius: (_D = params.outerRadius) != null ? _D : 0.5,
-                  thetaSegments: (_E = params.thetaSegments) != null ? _E : 16
-                }
-              };
-            case "DodecahedronGeometry":
-              return {
-                geometryType: "dodecahedron",
-                geometryArgs: {
-                  radius: (_F = params.radius) != null ? _F : 0.5,
-                  detail: (_G = params.detail) != null ? _G : 0
-                }
-              };
-            case "IcosahedronGeometry":
-              return {
-                geometryType: "icosahedron",
-                geometryArgs: {
-                  radius: (_H = params.radius) != null ? _H : 0.5,
-                  detail: (_I = params.detail) != null ? _I : 0
-                }
-              };
-            case "OctahedronGeometry":
-              return {
-                geometryType: "octahedron",
-                geometryArgs: {
-                  radius: (_J = params.radius) != null ? _J : 0.5,
-                  detail: (_K = params.detail) != null ? _K : 0
-                }
-              };
-            case "TetrahedronGeometry":
-              return {
-                geometryType: "tetrahedron",
-                geometryArgs: {
-                  radius: (_L = params.radius) != null ? _L : 0.5,
-                  detail: (_M = params.detail) != null ? _M : 0
-                }
-              };
-            case "CapsuleGeometry":
-              return {
-                geometryType: "capsule",
-                geometryArgs: {
-                  radius: (_N = params.radius) != null ? _N : 0.25,
-                  length: (_O = params.length) != null ? _O : 0.5,
-                  capSegments: (_P = params.capSegments) != null ? _P : 4,
-                  radialSegments: (_Q = params.radialSegments) != null ? _Q : 8
-                }
-              };
-            default:
-              return { geometryType: "none", geometryArgs: null };
-          }
-        }
-        debugValuesRef.current = initialValues;
-        prevGeometryTypeRef.current = initialValues.geometryType;
-        prevGeometryArgsRef.current = initialValues.geometryArgs;
-        Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ renderDebugPanel: renderDebugPanel2 }) => {
-          renderDebugPanel2(initialValues, handleDebugUpdate);
-        });
-        return () => {
-          Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ destroyDebugPanel: destroyDebugPanel2 }) => {
-            destroyDebugPanel2();
+          debugValuesRef.current = initialValues;
+          prevGeometryTypeRef.current = initialValues.geometryType;
+          prevGeometryArgsRef.current = initialValues.geometryArgs;
+          Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ renderDebugPanel: renderDebugPanel2 }) => {
+            renderDebugPanel2(initialValues, handleDebugUpdate);
           });
-        };
-      }, [debug, geometry]);
-      useEffect2(() => {
-        if (!debug) return;
-        Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ updateDebugPanel: updateDebugPanel2 }) => {
-          if (debugValuesRef.current) {
-            updateDebugPanel2(__spreadValues({}, debugValuesRef.current), handleDebugUpdate);
-          }
-        });
-      }, [debug, handleDebugUpdate]);
-      return /* @__PURE__ */ jsx2("primitive", { ref: spriteRef, object: renderObject });
-    });
+          return () => {
+            Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ destroyDebugPanel: destroyDebugPanel2 }) => {
+              destroyDebugPanel2();
+            });
+          };
+        }, [debug, geometry]);
+        useEffect3(() => {
+          if (!debug) return;
+          Promise.resolve().then(() => (init_VFXParticlesDebugPanel(), VFXParticlesDebugPanel_exports)).then(({ updateDebugPanel: updateDebugPanel2 }) => {
+            if (debugValuesRef.current) {
+              updateDebugPanel2(__spreadValues({}, debugValuesRef.current), handleDebugUpdate);
+            }
+          });
+        }, [debug, handleDebugUpdate]);
+        return /* @__PURE__ */ jsx2("primitive", { ref: spriteRef, object: renderObject });
+      }
+    );
   }
 });
 
@@ -6460,8 +6902,8 @@ init_VFXParticles();
 // src/VFXEmitter.tsx
 init_react_store();
 import {
-  useRef as useRef3,
-  useEffect as useEffect3,
+  useRef as useRef4,
+  useEffect as useEffect4,
   useCallback as useCallback3,
   forwardRef as forwardRef2,
   useImperativeHandle as useImperativeHandle2
@@ -6486,10 +6928,10 @@ var VFXEmitter = forwardRef2(function VFXEmitter2({
   onEmit,
   children
 }, ref) {
-  const groupRef = useRef3(null);
-  const emitAccumulator = useRef3(0);
-  const emitting = useRef3(autoStart);
-  const hasEmittedOnce = useRef3(false);
+  const groupRef = useRef4(null);
+  const emitAccumulator = useRef4(0);
+  const emitting = useRef4(autoStart);
+  const hasEmittedOnce = useRef4(false);
   const getParticleSystem = useCallback3(() => {
     if (particlesRef) {
       return particlesRef.current || particlesRef;
@@ -6504,11 +6946,7 @@ var VFXEmitter = forwardRef2(function VFXEmitter2({
         dirRange[2][0]
       );
       minDir.applyQuaternion(quat);
-      const maxDir = new Vector32(
-        dirRange[0][1],
-        dirRange[1][1],
-        dirRange[2][1]
-      );
+      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)],
@@ -6531,23 +6969,47 @@ var VFXEmitter = forwardRef2(function VFXEmitter2({
     }
     return { position: emitPos, direction: emitDir };
   }, [localDirection, direction, position, transformDirectionByQuat]);
-  const emit = useCallback3(() => {
-    const particles = getParticleSystem();
-    if (!(particles == null ? void 0 : particles.spawn)) {
-      if (name) {
-        console.warn(`VFXEmitter: No particle system found for name "${name}"`);
+  const emit = useCallback3(
+    (emitOverrides = null) => {
+      const particles = getParticleSystem();
+      if (!(particles == null ? void 0 : particles.spawn)) {
+        if (name) {
+          console.warn(
+            `VFXEmitter: No particle system found for name "${name}"`
+          );
+        }
+        return false;
       }
-      return false;
-    }
-    const { position: emitPos, direction: emitDir } = getEmitParams();
-    const [x, y, z] = emitPos;
-    const finalOverrides = emitDir ? __spreadProps(__spreadValues({}, overrides), { direction: emitDir }) : overrides;
-    particles.spawn(x, y, z, emitCount, finalOverrides);
-    if (onEmit) {
-      onEmit({ position: emitPos, count: emitCount, direction: emitDir });
-    }
-    return true;
-  }, [getParticleSystem, getEmitParams, name, emitCount, overrides, onEmit]);
+      const { position: emitPos, direction: emitDir } = getEmitParams();
+      const [x, y, z] = emitPos;
+      const emitTimeDirection = emitOverrides == null ? void 0 : emitOverrides.direction;
+      let finalDir = emitDir;
+      if (emitTimeDirection && localDirection && groupRef.current) {
+        groupRef.current.getWorldQuaternion(_worldQuat);
+        finalDir = transformDirectionByQuat(emitTimeDirection, _worldQuat);
+      } else if (emitTimeDirection) {
+        finalDir = emitTimeDirection;
+      }
+      const _a = emitOverrides || {}, { direction: _ } = _a, emitOverridesWithoutDir = __objRest(_a, ["direction"]);
+      const mergedOverrides = __spreadValues(__spreadValues({}, overrides), emitOverridesWithoutDir);
+      const finalOverrides = finalDir ? __spreadProps(__spreadValues({}, mergedOverrides), { direction: finalDir }) : mergedOverrides;
+      particles.spawn(x, y, z, emitCount, finalOverrides);
+      if (onEmit) {
+        onEmit({ position: emitPos, count: emitCount, direction: finalDir });
+      }
+      return true;
+    },
+    [
+      getParticleSystem,
+      getEmitParams,
+      name,
+      emitCount,
+      overrides,
+      onEmit,
+      localDirection,
+      transformDirectionByQuat
+    ]
+  );
   useFrame2((_, delta) => {
     if (!emitting.current) return;
     if (!loop && hasEmittedOnce.current) {
@@ -6592,7 +7054,7 @@ var VFXEmitter = forwardRef2(function VFXEmitter2({
     },
     [getParticleSystem, getEmitParams, emitCount, overrides, onEmit]
   );
-  useEffect3(() => {
+  useEffect4(() => {
     emitting.current = autoStart;
     if (autoStart) {
       hasEmittedOnce.current = false;
@@ -6675,6 +7137,7 @@ function useVFXEmitter(name) {
 
 // src/index.ts
 init_react_store();
+init_useCurveTextureAsync();
 export {
   Appearance,
   AttractorType2 as AttractorType,
@@ -6686,6 +7149,7 @@ export {
   VFXParticles,
   bakeCurveToArray,
   createCombinedCurveTexture2 as createCombinedCurveTexture,
+  useCurveTextureAsync,
   useVFXEmitter,
   useVFXStore
 };