@nice2dev/ui-3d 1.3.15 → 1.3.16

package/dist/cjs/particle/particleEditorUtils.js

@@ -1,1094 +1,1079 @@
-'use strict';
-
-var particleEditorTypes = require('./particleEditorTypes.js');
-
-/* ════════════════════════════════════════════════════════════════════════════
-   Particle System Editor — Utility Functions
-   
-   Core utilities for particle system creation, manipulation, and simulation
-   ════════════════════════════════════════════════════════════════════════════ */
-// ─── ID Generation ───────────────────────────────────────────────────────────
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const particleEditorTypes = require("./particleEditorTypes.js");
 let systemIdCounter = 0;
 let forceIdCounter = 0;
 let subEmitterIdCounter = 0;
 function generateSystemId() {
-    return `system_${++systemIdCounter}_${Date.now()}`;
+  return `system_${++systemIdCounter}_${Date.now()}`;
 }
 function generateForceId() {
-    return `force_${++forceIdCounter}_${Date.now()}`;
+  return `force_${++forceIdCounter}_${Date.now()}`;
 }
 function generateSubEmitterId() {
-    return `subemitter_${++subEmitterIdCounter}_${Date.now()}`;
+  return `subemitter_${++subEmitterIdCounter}_${Date.now()}`;
 }
-// ─── Distribution Operations ─────────────────────────────────────────────────
 function evaluateDistribution(dist, t, seed = Math.random()) {
-    var _a, _b;
-    switch (dist.type) {
-        case 'constant':
-            return dist.value;
-        case 'random':
-            return dist.min + seed * (dist.max - dist.min);
-        case 'curve':
-            return evaluateCurve(dist.curve, t) * ((_a = dist.multiplier) !== null && _a !== void 0 ? _a : 1);
-        case 'random_curve': {
-            const min = evaluateCurve(dist.curveMin, t);
-            const max = evaluateCurve(dist.curveMax, t);
-            return (min + seed * (max - min)) * ((_b = dist.multiplier) !== null && _b !== void 0 ? _b : 1);
-        }
-        default:
-            return 1;
+  switch (dist.type) {
+    case "constant":
+      return dist.value;
+    case "random":
+      return dist.min + seed * (dist.max - dist.min);
+    case "curve":
+      return evaluateCurve(dist.curve, t) * (dist.multiplier ?? 1);
+    case "random_curve": {
+      const min = evaluateCurve(dist.curveMin, t);
+      const max = evaluateCurve(dist.curveMax, t);
+      return (min + seed * (max - min)) * (dist.multiplier ?? 1);
     }
+    default:
+      return 1;
+  }
 }
 function evaluateCurve(curve, t) {
-    var _a, _b;
-    if (curve.length === 0) {
-        return 0;
-    }
-    if (curve.length === 1) {
-        return curve[0].value;
+  if (curve.length === 0) {
+    return 0;
+  }
+  if (curve.length === 1) {
+    return curve[0].value;
+  }
+  t = Math.max(0, Math.min(1, t));
+  let leftIdx = 0;
+  let rightIdx = curve.length - 1;
+  for (let i = 0; i < curve.length; i++) {
+    if (curve[i].time <= t) {
+      leftIdx = i;
     }
-    // Clamp t to [0, 1]
-    t = Math.max(0, Math.min(1, t));
-    // Find surrounding keyframes
-    let leftIdx = 0;
-    let rightIdx = curve.length - 1;
-    for (let i = 0; i < curve.length; i++) {
-        if (curve[i].time <= t) {
-            leftIdx = i;
-        }
-        if (curve[i].time >= t && i < rightIdx) {
-            rightIdx = i;
-        }
-    }
-    if (leftIdx === rightIdx) {
-        return curve[leftIdx].value;
+    if (curve[i].time >= t && i < rightIdx) {
+      rightIdx = i;
     }
-    const left = curve[leftIdx];
-    const right = curve[rightIdx];
-    // Hermite interpolation
-    const dt = right.time - left.time;
-    const localT = (t - left.time) / dt;
-    const outTangent = (_a = left.outTangent) !== null && _a !== void 0 ? _a : 0;
-    const inTangent = (_b = right.inTangent) !== null && _b !== void 0 ? _b : 0;
-    const t2 = localT * localT;
-    const t3 = t2 * localT;
-    const h00 = 2 * t3 - 3 * t2 + 1;
-    const h10 = t3 - 2 * t2 + localT;
-    const h01 = -2 * t3 + 3 * t2;
-    const h11 = t3 - t2;
-    return h00 * left.value + h10 * dt * outTangent + h01 * right.value + h11 * dt * inTangent;
+  }
+  if (leftIdx === rightIdx) {
+    return curve[leftIdx].value;
+  }
+  const left = curve[leftIdx];
+  const right = curve[rightIdx];
+  const dt = right.time - left.time;
+  const localT = (t - left.time) / dt;
+  const outTangent = left.outTangent ?? 0;
+  const inTangent = right.inTangent ?? 0;
+  const t2 = localT * localT;
+  const t3 = t2 * localT;
+  const h00 = 2 * t3 - 3 * t2 + 1;
+  const h10 = t3 - 2 * t2 + localT;
+  const h01 = -2 * t3 + 3 * t2;
+  const h11 = t3 - t2;
+  return h00 * left.value + h10 * dt * outTangent + h01 * right.value + h11 * dt * inTangent;
 }
 function evaluateVec3Distribution(dist, t, seed) {
-    return {
-        x: evaluateDistribution(dist.x, t, seed.x),
-        y: evaluateDistribution(dist.y, t, seed.y),
-        z: evaluateDistribution(dist.z, t, seed.z),
-    };
+  return {
+    x: evaluateDistribution(dist.x, t, seed.x),
+    y: evaluateDistribution(dist.y, t, seed.y),
+    z: evaluateDistribution(dist.z, t, seed.z)
+  };
 }
 function evaluateGradient(gradient, t) {
-    // Interpolate color
-    let color = { r: 1, g: 1, b: 1 };
-    const colorKeys = gradient.colorKeys;
-    if (colorKeys.length > 0) {
-        let leftIdx = 0;
-        let rightIdx = colorKeys.length - 1;
-        for (let i = 0; i < colorKeys.length; i++) {
-            if (colorKeys[i].time <= t) {
-                leftIdx = i;
-            }
-            if (colorKeys[i].time >= t && i < rightIdx) {
-                rightIdx = i;
-            }
-        }
-        if (leftIdx === rightIdx) {
-            color = { ...colorKeys[leftIdx].color };
-        }
-        else {
-            const left = colorKeys[leftIdx];
-            const right = colorKeys[rightIdx];
-            const localT = (t - left.time) / (right.time - left.time);
-            color = {
-                r: left.color.r + localT * (right.color.r - left.color.r),
-                g: left.color.g + localT * (right.color.g - left.color.g),
-                b: left.color.b + localT * (right.color.b - left.color.b),
-            };
-        }
+  let color = { r: 1, g: 1, b: 1 };
+  const colorKeys = gradient.colorKeys;
+  if (colorKeys.length > 0) {
+    let leftIdx = 0;
+    let rightIdx = colorKeys.length - 1;
+    for (let i = 0; i < colorKeys.length; i++) {
+      if (colorKeys[i].time <= t) {
+        leftIdx = i;
+      }
+      if (colorKeys[i].time >= t && i < rightIdx) {
+        rightIdx = i;
+      }
     }
-    // Interpolate alpha
-    let alpha = 1;
-    const alphaKeys = gradient.alphaKeys;
-    if (alphaKeys.length > 0) {
-        let leftIdx = 0;
-        let rightIdx = alphaKeys.length - 1;
-        for (let i = 0; i < alphaKeys.length; i++) {
-            if (alphaKeys[i].time <= t) {
-                leftIdx = i;
-            }
-            if (alphaKeys[i].time >= t && i < rightIdx) {
-                rightIdx = i;
-            }
-        }
-        if (leftIdx === rightIdx) {
-            alpha = alphaKeys[leftIdx].alpha;
-        }
-        else {
-            const left = alphaKeys[leftIdx];
-            const right = alphaKeys[rightIdx];
-            const localT = (t - left.time) / (right.time - left.time);
-            alpha = left.alpha + localT * (right.alpha - left.alpha);
-        }
+    if (leftIdx === rightIdx) {
+      color = { ...colorKeys[leftIdx].color };
+    } else {
+      const left = colorKeys[leftIdx];
+      const right = colorKeys[rightIdx];
+      const localT = (t - left.time) / (right.time - left.time);
+      color = {
+        r: left.color.r + localT * (right.color.r - left.color.r),
+        g: left.color.g + localT * (right.color.g - left.color.g),
+        b: left.color.b + localT * (right.color.b - left.color.b)
+      };
+    }
+  }
+  let alpha = 1;
+  const alphaKeys = gradient.alphaKeys;
+  if (alphaKeys.length > 0) {
+    let leftIdx = 0;
+    let rightIdx = alphaKeys.length - 1;
+    for (let i = 0; i < alphaKeys.length; i++) {
+      if (alphaKeys[i].time <= t) {
+        leftIdx = i;
+      }
+      if (alphaKeys[i].time >= t && i < rightIdx) {
+        rightIdx = i;
+      }
+    }
+    if (leftIdx === rightIdx) {
+      alpha = alphaKeys[leftIdx].alpha;
+    } else {
+      const left = alphaKeys[leftIdx];
+      const right = alphaKeys[rightIdx];
+      const localT = (t - left.time) / (right.time - left.time);
+      alpha = left.alpha + localT * (right.alpha - left.alpha);
     }
-    return { ...color, a: alpha };
+  }
+  return { ...color, a: alpha };
 }
-// ─── Vector Operations ───────────────────────────────────────────────────────
 function vec3Add(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
 }
 function vec3Sub(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
 }
 function vec3Mul(a, s) {
-    return { x: a.x * s, y: a.y * s, z: a.z * s };
+  return { x: a.x * s, y: a.y * s, z: a.z * s };
 }
 function vec3MulVec(a, b) {
-    return { x: a.x * b.x, y: a.y * b.y, z: a.z * b.z };
+  return { x: a.x * b.x, y: a.y * b.y, z: a.z * b.z };
 }
 function vec3Dot(a, b) {
-    return a.x * b.x + a.y * b.y + a.z * b.z;
+  return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 function vec3Cross(a, b) {
-    return {
-        x: a.y * b.z - a.z * b.y,
-        y: a.z * b.x - a.x * b.z,
-        z: a.x * b.y - a.y * b.x,
-    };
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
 }
 function vec3Length(v) {
-    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
 }
 function vec3Normalize(v) {
-    const len = vec3Length(v);
-    if (len === 0) {
-        return { x: 0, y: 0, z: 0 };
-    }
-    return { x: v.x / len, y: v.y / len, z: v.z / len };
+  const len = vec3Length(v);
+  if (len === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
 }
 function vec3Lerp(a, b, t) {
-    return {
-        x: a.x + t * (b.x - a.x),
-        y: a.y + t * (b.y - a.y),
-        z: a.z + t * (b.z - a.z),
-    };
+  return {
+    x: a.x + t * (b.x - a.x),
+    y: a.y + t * (b.y - a.y),
+    z: a.z + t * (b.z - a.z)
+  };
 }
 function vec3Random() {
-    return {
-        x: Math.random() * 2 - 1,
-        y: Math.random() * 2 - 1,
-        z: Math.random() * 2 - 1,
-    };
+  return {
+    x: Math.random() * 2 - 1,
+    y: Math.random() * 2 - 1,
+    z: Math.random() * 2 - 1
+  };
 }
 function vec3RandomOnSphere() {
-    const theta = Math.random() * Math.PI * 2;
-    const phi = Math.acos(Math.random() * 2 - 1);
-    return {
-        x: Math.sin(phi) * Math.cos(theta),
-        y: Math.sin(phi) * Math.sin(theta),
-        z: Math.cos(phi),
-    };
+  const theta = Math.random() * Math.PI * 2;
+  const phi = Math.acos(Math.random() * 2 - 1);
+  return {
+    x: Math.sin(phi) * Math.cos(theta),
+    y: Math.sin(phi) * Math.sin(theta),
+    z: Math.cos(phi)
+  };
 }
-// ─── Random / Noise ──────────────────────────────────────────────────────────
 function seededRandom(seed) {
-    const x = Math.sin(seed * 12.9898 + seed * 78.233) * 43758.5453;
-    return x - Math.floor(x);
+  const x = Math.sin(seed * 12.9898 + seed * 78.233) * 43758.5453;
+  return x - Math.floor(x);
 }
 function perlinNoise2D(x, y) {
-    // Simplified 2D Perlin noise
-    const xi = Math.floor(x);
-    const yi = Math.floor(y);
-    const xf = x - xi;
-    const yf = y - yi;
-    const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
-    const grad = (hash, x, y) => {
-        const h = hash & 3;
-        const u = h < 2 ? x : y;
-        const v = h < 2 ? y : x;
-        return (h & 1 ? -u : u) + (h & 2 ? -2 * v : 2 * v);
-    };
-    const hash = (x, y) => {
-        const n = x * 374761393 + y * 668265263;
-        return ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) >>> 0;
-    };
-    const u = fade(xf);
-    const v = fade(yf);
-    const aa = hash(xi, yi);
-    const ab = hash(xi, yi + 1);
-    const ba = hash(xi + 1, yi);
-    const bb = hash(xi + 1, yi + 1);
-    const x1 = grad(aa, xf, yf) * (1 - u) + grad(ba, xf - 1, yf) * u;
-    const x2 = grad(ab, xf, yf - 1) * (1 - u) + grad(bb, xf - 1, yf - 1) * u;
-    return (x1 * (1 - v) + x2 * v + 1) / 2;
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const xf = x - xi;
+  const yf = y - yi;
+  const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+  const grad = (hash2, x3, y2) => {
+    const h = hash2 & 3;
+    const u2 = h < 2 ? x3 : y2;
+    const v2 = h < 2 ? y2 : x3;
+    return (h & 1 ? -u2 : u2) + (h & 2 ? -2 * v2 : 2 * v2);
+  };
+  const hash = (x3, y2) => {
+    const n = x3 * 374761393 + y2 * 668265263;
+    return (n * (n * n * 15731 + 789221) + 1376312589 & 2147483647) >>> 0;
+  };
+  const u = fade(xf);
+  const v = fade(yf);
+  const aa = hash(xi, yi);
+  const ab = hash(xi, yi + 1);
+  const ba = hash(xi + 1, yi);
+  const bb = hash(xi + 1, yi + 1);
+  const x1 = grad(aa, xf, yf) * (1 - u) + grad(ba, xf - 1, yf) * u;
+  const x2 = grad(ab, xf, yf - 1) * (1 - u) + grad(bb, xf - 1, yf - 1) * u;
+  return (x1 * (1 - v) + x2 * v + 1) / 2;
 }
 function fbmNoise(x, y, z, octaves, roughness) {
-    let value = 0;
-    let amplitude = 1;
-    let frequency = 1;
-    let maxValue = 0;
-    for (let i = 0; i < octaves; i++) {
-        value += amplitude * perlinNoise2D(x * frequency + z * 0.5, y * frequency);
-        maxValue += amplitude;
-        amplitude *= roughness;
-        frequency *= 2;
-    }
-    return value / maxValue;
+  let value = 0;
+  let amplitude = 1;
+  let frequency = 1;
+  let maxValue = 0;
+  for (let i = 0; i < octaves; i++) {
+    value += amplitude * perlinNoise2D(x * frequency + z * 0.5, y * frequency);
+    maxValue += amplitude;
+    amplitude *= roughness;
+    frequency *= 2;
+  }
+  return value / maxValue;
 }
-// ─── Emitter Shape Sampling ──────────────────────────────────────────────────
 function sampleEmitterShape(shape, seed) {
-    let position = { x: 0, y: 0, z: 0 };
-    let direction = { x: 0, y: 1, z: 0 };
-    switch (shape.type) {
-        case 'point':
-            position = { x: 0, y: 0, z: 0 };
-            direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
-            break;
-        case 'sphere': {
-            const radius = evaluateDistribution(shape.radius, 0, seed.x);
-            const innerRadius = radius * (1 - shape.radiusThickness);
-            const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
-            const arc = (shape.arc * Math.PI) / 180;
-            const theta = seed.z * arc;
-            const phi = Math.acos(seed.x * 2 - 1);
-            position = {
-                x: r * Math.sin(phi) * Math.cos(theta),
-                y: r * Math.sin(phi) * Math.sin(theta),
-                z: r * Math.cos(phi),
-            };
-            direction = shape.sphericalDirection ? vec3Normalize(position) : { x: 0, y: 1, z: 0 };
+  let position = { x: 0, y: 0, z: 0 };
+  let direction = { x: 0, y: 1, z: 0 };
+  switch (shape.type) {
+    case "point":
+      position = { x: 0, y: 0, z: 0 };
+      direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
+      break;
+    case "sphere": {
+      const radius = evaluateDistribution(shape.radius, 0, seed.x);
+      const innerRadius = radius * (1 - shape.radiusThickness);
+      const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
+      const arc = shape.arc * Math.PI / 180;
+      const theta = seed.z * arc;
+      const phi = Math.acos(seed.x * 2 - 1);
+      position = {
+        x: r * Math.sin(phi) * Math.cos(theta),
+        y: r * Math.sin(phi) * Math.sin(theta),
+        z: r * Math.cos(phi)
+      };
+      direction = shape.sphericalDirection ? vec3Normalize(position) : { x: 0, y: 1, z: 0 };
+      break;
+    }
+    case "hemisphere": {
+      const radius = evaluateDistribution(shape.radius, 0, seed.x);
+      const innerRadius = radius * (1 - shape.radiusThickness);
+      const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
+      const arc = shape.arc * Math.PI / 180;
+      const theta = seed.z * arc;
+      const phi = Math.acos(seed.x);
+      position = {
+        x: r * Math.sin(phi) * Math.cos(theta),
+        y: r * Math.cos(phi),
+        z: r * Math.sin(phi) * Math.sin(theta)
+      };
+      direction = shape.sphericalDirection ? vec3Normalize(position) : { x: 0, y: 1, z: 0 };
+      break;
+    }
+    case "box": {
+      if (shape.emitFrom === "volume") {
+        position = {
+          x: (seed.x - 0.5) * shape.size.x,
+          y: (seed.y - 0.5) * shape.size.y,
+          z: (seed.z - 0.5) * shape.size.z
+        };
+      } else if (shape.emitFrom === "surface") {
+        const face = Math.floor(seed.x * 6);
+        const u = seed.y - 0.5;
+        const v = seed.z - 0.5;
+        switch (face) {
+          case 0:
+            position = { x: shape.size.x / 2, y: u * shape.size.y, z: v * shape.size.z };
             break;
-        }
-        case 'hemisphere': {
-            const radius = evaluateDistribution(shape.radius, 0, seed.x);
-            const innerRadius = radius * (1 - shape.radiusThickness);
-            const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
-            const arc = (shape.arc * Math.PI) / 180;
-            const theta = seed.z * arc;
-            const phi = Math.acos(seed.x); // Only upper hemisphere
-            position = {
-                x: r * Math.sin(phi) * Math.cos(theta),
-                y: r * Math.cos(phi),
-                z: r * Math.sin(phi) * Math.sin(theta),
-            };
-            direction = shape.sphericalDirection ? vec3Normalize(position) : { x: 0, y: 1, z: 0 };
+          case 1:
+            position = { x: -shape.size.x / 2, y: u * shape.size.y, z: v * shape.size.z };
             break;
-        }
-        case 'box': {
-            if (shape.emitFrom === 'volume') {
-                position = {
-                    x: (seed.x - 0.5) * shape.size.x,
-                    y: (seed.y - 0.5) * shape.size.y,
-                    z: (seed.z - 0.5) * shape.size.z,
-                };
-            }
-            else if (shape.emitFrom === 'surface') {
-                const face = Math.floor(seed.x * 6);
-                const u = seed.y - 0.5;
-                const v = seed.z - 0.5;
-                switch (face) {
-                    case 0:
-                        position = { x: shape.size.x / 2, y: u * shape.size.y, z: v * shape.size.z };
-                        break;
-                    case 1:
-                        position = { x: -shape.size.x / 2, y: u * shape.size.y, z: v * shape.size.z };
-                        break;
-                    case 2:
-                        position = { x: u * shape.size.x, y: shape.size.y / 2, z: v * shape.size.z };
-                        break;
-                    case 3:
-                        position = { x: u * shape.size.x, y: -shape.size.y / 2, z: v * shape.size.z };
-                        break;
-                    case 4:
-                        position = { x: u * shape.size.x, y: v * shape.size.y, z: shape.size.z / 2 };
-                        break;
-                    default:
-                        position = { x: u * shape.size.x, y: v * shape.size.y, z: -shape.size.z / 2 };
-                }
-            }
-            direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
+          case 2:
+            position = { x: u * shape.size.x, y: shape.size.y / 2, z: v * shape.size.z };
             break;
-        }
-        case 'cone': {
-            const radius = evaluateDistribution(shape.radius, 0, seed.x);
-            const arc = (shape.arc * Math.PI) / 180;
-            const theta = seed.z * arc;
-            const angle = (shape.angle * Math.PI) / 180;
-            const r = radius * seed.y;
-            const h = seed.x * shape.length;
-            const coneRadius = r + h * Math.tan(angle);
-            position = {
-                x: coneRadius * Math.cos(theta),
-                y: h,
-                z: coneRadius * Math.sin(theta),
-            };
-            direction = vec3Normalize({
-                x: Math.cos(theta) * Math.sin(angle),
-                y: Math.cos(angle),
-                z: Math.sin(theta) * Math.sin(angle),
-            });
+          case 3:
+            position = { x: u * shape.size.x, y: -shape.size.y / 2, z: v * shape.size.z };
             break;
-        }
-        case 'circle': {
-            const radius = evaluateDistribution(shape.radius, 0, seed.x);
-            const innerRadius = radius * (1 - shape.radiusThickness);
-            const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
-            const arc = (shape.arc * Math.PI) / 180;
-            const theta = seed.z * arc;
-            position = {
-                x: r * Math.cos(theta),
-                y: 0,
-                z: r * Math.sin(theta),
-            };
-            direction = shape.randomDirection
-                ? vec3Normalize({ x: Math.random() - 0.5, y: 1, z: Math.random() - 0.5 })
-                : { x: 0, y: 1, z: 0 };
+          case 4:
+            position = { x: u * shape.size.x, y: v * shape.size.y, z: shape.size.z / 2 };
             break;
+          default:
+            position = { x: u * shape.size.x, y: v * shape.size.y, z: -shape.size.z / 2 };
         }
-        case 'edge':
-            position = {
-                x: (seed.x - 0.5) * shape.length,
-                y: 0,
-                z: 0,
-            };
-            direction = { x: 0, y: 1, z: 0 };
-            break;
-        case 'rectangle':
-            position = {
-                x: (seed.x - 0.5) * shape.size.x,
-                y: 0,
-                z: (seed.z - 0.5) * shape.size.y,
-            };
-            direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
-            break;
+      }
+      direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
+      break;
+    }
+    case "cone": {
+      const radius = evaluateDistribution(shape.radius, 0, seed.x);
+      const arc = shape.arc * Math.PI / 180;
+      const theta = seed.z * arc;
+      const angle = shape.angle * Math.PI / 180;
+      const r = radius * seed.y;
+      const h = seed.x * shape.length;
+      const coneRadius = r + h * Math.tan(angle);
+      position = {
+        x: coneRadius * Math.cos(theta),
+        y: h,
+        z: coneRadius * Math.sin(theta)
+      };
+      direction = vec3Normalize({
+        x: Math.cos(theta) * Math.sin(angle),
+        y: Math.cos(angle),
+        z: Math.sin(theta) * Math.sin(angle)
+      });
+      break;
     }
-    return { position, direction };
+    case "circle": {
+      const radius = evaluateDistribution(shape.radius, 0, seed.x);
+      const innerRadius = radius * (1 - shape.radiusThickness);
+      const r = shape.emitFromShell ? radius : innerRadius + seed.y * (radius - innerRadius);
+      const arc = shape.arc * Math.PI / 180;
+      const theta = seed.z * arc;
+      position = {
+        x: r * Math.cos(theta),
+        y: 0,
+        z: r * Math.sin(theta)
+      };
+      direction = shape.randomDirection ? vec3Normalize({ x: Math.random() - 0.5, y: 1, z: Math.random() - 0.5 }) : { x: 0, y: 1, z: 0 };
+      break;
+    }
+    case "edge":
+      position = {
+        x: (seed.x - 0.5) * shape.length,
+        y: 0,
+        z: 0
+      };
+      direction = { x: 0, y: 1, z: 0 };
+      break;
+    case "rectangle":
+      position = {
+        x: (seed.x - 0.5) * shape.size.x,
+        y: 0,
+        z: (seed.z - 0.5) * shape.size.y
+      };
+      direction = shape.randomDirection ? vec3RandomOnSphere() : { x: 0, y: 1, z: 0 };
+      break;
+  }
+  return { position, direction };
 }
-// ─── Force Application ───────────────────────────────────────────────────────
 function applyForce(particle, force, dt, time) {
-    if (!force.enabled) {
+  if (!force.enabled) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const t = particle.age / particle.startLifetime;
+  const strength = evaluateDistribution(force.strength, t, particle.randomSeed);
+  switch (force.type) {
+    case "gravity":
+      return vec3Mul(force.direction, strength * dt);
+    case "wind": {
+      const turbulenceOffset = perlinNoise2D(
+        particle.position.x * force.frequency + time,
+        particle.position.z * force.frequency
+      ) * force.turbulence;
+      const windDir = vec3Add(force.direction, { x: turbulenceOffset, y: 0, z: turbulenceOffset });
+      return vec3Mul(vec3Normalize(windDir), strength * dt);
+    }
+    case "vortex": {
+      const toCenter = vec3Sub(force.position, particle.position);
+      const dist = vec3Length(toCenter);
+      if (dist < 1e-3 || dist > force.size) {
         return { x: 0, y: 0, z: 0 };
+      }
+      const tangent = vec3Normalize(vec3Cross(force.axis, toCenter));
+      const speed = evaluateDistribution(force.speed, t, particle.randomSeed);
+      const pull = evaluateDistribution(force.pullStrength, t, particle.randomSeed);
+      const tangentForce = vec3Mul(tangent, speed * strength * dt);
+      const pullForce = vec3Mul(vec3Normalize(toCenter), pull * strength * dt);
+      return vec3Add(tangentForce, pullForce);
     }
-    const t = particle.age / particle.startLifetime;
-    const strength = evaluateDistribution(force.strength, t, particle.randomSeed);
-    switch (force.type) {
-        case 'gravity':
-            return vec3Mul(force.direction, strength * dt);
-        case 'wind': {
-            const turbulenceOffset = perlinNoise2D(particle.position.x * force.frequency + time, particle.position.z * force.frequency) * force.turbulence;
-            const windDir = vec3Add(force.direction, { x: turbulenceOffset, y: 0, z: turbulenceOffset });
-            return vec3Mul(vec3Normalize(windDir), strength * dt);
-        }
-        case 'vortex': {
-            const toCenter = vec3Sub(force.position, particle.position);
-            const dist = vec3Length(toCenter);
-            if (dist < 0.001 || dist > force.size) {
-                return { x: 0, y: 0, z: 0 };
-            }
-            const tangent = vec3Normalize(vec3Cross(force.axis, toCenter));
-            const speed = evaluateDistribution(force.speed, t, particle.randomSeed);
-            const pull = evaluateDistribution(force.pullStrength, t, particle.randomSeed);
-            const tangentForce = vec3Mul(tangent, speed * strength * dt);
-            const pullForce = vec3Mul(vec3Normalize(toCenter), pull * strength * dt);
-            return vec3Add(tangentForce, pullForce);
-        }
-        case 'turbulence': {
-            const freqX = force.frequency.x;
-            const freqY = force.frequency.y;
-            const freqZ = force.frequency.z;
-            const scrollX = time * force.scrollSpeed.x;
-            const scrollY = time * force.scrollSpeed.y;
-            const scrollZ = time * force.scrollSpeed.z;
-            const noiseX = fbmNoise(particle.position.x * freqX + scrollX, particle.position.y * freqY, particle.position.z * freqZ, force.octaves, force.roughness) *
-                2 -
-                1;
-            const noiseY = fbmNoise(particle.position.x * freqX, particle.position.y * freqY + scrollY + 100, particle.position.z * freqZ, force.octaves, force.roughness) *
-                2 -
-                1;
-            const noiseZ = fbmNoise(particle.position.x * freqX, particle.position.y * freqY, particle.position.z * freqZ + scrollZ + 200, force.octaves, force.roughness) *
-                2 -
-                1;
-            return {
-                x: noiseX * evaluateDistribution(force.strengthX, t, particle.randomSeed) * dt,
-                y: noiseY * evaluateDistribution(force.strengthY, t, particle.randomSeed) * dt,
-                z: noiseZ * evaluateDistribution(force.strengthZ, t, particle.randomSeed) * dt,
-            };
-        }
-        case 'attractor': {
-            const toAttractor = vec3Sub(force.position, particle.position);
-            const dist = vec3Length(toAttractor);
-            if (dist < 0.001) {
-                if (force.killParticles) {
-                    particle.age = particle.startLifetime; // Kill particle
-                }
-                return { x: 0, y: 0, z: 0 };
-            }
-            if (dist > force.radius) {
-                return { x: 0, y: 0, z: 0 };
-            }
-            let falloff = 1;
-            switch (force.falloff) {
-                case 'linear':
-                    falloff = 1 - dist / force.radius;
-                    break;
-                case 'quadratic':
-                    falloff = Math.pow(1 - dist / force.radius, 2);
-                    break;
-            }
-            return vec3Mul(vec3Normalize(toAttractor), strength * falloff * dt);
-        }
-        case 'drag': {
-            const drag = evaluateDistribution(force.linearDrag, t, particle.randomSeed);
-            let multiplier = 1;
-            if (force.multiplyBySize) {
-                const size = (particle.size.x + particle.size.y + particle.size.z) / 3;
-                multiplier *= size;
-            }
-            if (force.multiplyByVelocity) {
-                multiplier *= vec3Length(particle.velocity);
-            }
-            return vec3Mul(particle.velocity, -drag * multiplier * dt);
+    case "turbulence": {
+      const freqX = force.frequency.x;
+      const freqY = force.frequency.y;
+      const freqZ = force.frequency.z;
+      const scrollX = time * force.scrollSpeed.x;
+      const scrollY = time * force.scrollSpeed.y;
+      const scrollZ = time * force.scrollSpeed.z;
+      const noiseX = fbmNoise(
+        particle.position.x * freqX + scrollX,
+        particle.position.y * freqY,
+        particle.position.z * freqZ,
+        force.octaves,
+        force.roughness
+      ) * 2 - 1;
+      const noiseY = fbmNoise(
+        particle.position.x * freqX,
+        particle.position.y * freqY + scrollY + 100,
+        particle.position.z * freqZ,
+        force.octaves,
+        force.roughness
+      ) * 2 - 1;
+      const noiseZ = fbmNoise(
+        particle.position.x * freqX,
+        particle.position.y * freqY,
+        particle.position.z * freqZ + scrollZ + 200,
+        force.octaves,
+        force.roughness
+      ) * 2 - 1;
+      return {
+        x: noiseX * evaluateDistribution(force.strengthX, t, particle.randomSeed) * dt,
+        y: noiseY * evaluateDistribution(force.strengthY, t, particle.randomSeed) * dt,
+        z: noiseZ * evaluateDistribution(force.strengthZ, t, particle.randomSeed) * dt
+      };
+    }
+    case "attractor": {
+      const toAttractor = vec3Sub(force.position, particle.position);
+      const dist = vec3Length(toAttractor);
+      if (dist < 1e-3) {
+        if (force.killParticles) {
+          particle.age = particle.startLifetime;
         }
-        default:
-            return { x: 0, y: 0, z: 0 };
+        return { x: 0, y: 0, z: 0 };
+      }
+      if (dist > force.radius) {
+        return { x: 0, y: 0, z: 0 };
+      }
+      let falloff = 1;
+      switch (force.falloff) {
+        case "linear":
+          falloff = 1 - dist / force.radius;
+          break;
+        case "quadratic":
+          falloff = Math.pow(1 - dist / force.radius, 2);
+          break;
+      }
+      return vec3Mul(vec3Normalize(toAttractor), strength * falloff * dt);
     }
+    case "drag": {
+      const drag = evaluateDistribution(force.linearDrag, t, particle.randomSeed);
+      let multiplier = 1;
+      if (force.multiplyBySize) {
+        const size = (particle.size.x + particle.size.y + particle.size.z) / 3;
+        multiplier *= size;
+      }
+      if (force.multiplyByVelocity) {
+        multiplier *= vec3Length(particle.velocity);
+      }
+      return vec3Mul(particle.velocity, -drag * multiplier * dt);
+    }
+    default:
+      return { x: 0, y: 0, z: 0 };
+  }
 }
-// ─── System Creation ─────────────────────────────────────────────────────────
-function createDefaultSystem(name = 'New Particle System') {
-    return {
-        id: generateSystemId(),
-        name,
-        version: 1,
-        // Main
-        duration: 5,
-        looping: true,
-        prewarm: false,
-        startDelay: { type: 'constant', value: 0 },
-        startLifetime: { type: 'random', min: 3, max: 5 },
-        startSpeed: { type: 'constant', value: 5 },
-        startSize3D: false,
-        startSize: { type: 'random', min: 0.5, max: 1 },
-        startRotation3D: false,
-        startRotation: { type: 'constant', value: 0 },
-        flipRotation: 0,
-        startColor: {
-            colorKeys: [{ time: 0, color: { r: 1, g: 1, b: 1 } }],
-            alphaKeys: [{ time: 0, alpha: 1 }],
-        },
-        gravityModifier: { type: 'constant', value: 0 },
-        simulationSpace: 'local',
-        simulationSpeed: 1,
-        deltaTimeType: 'scaled',
-        scalingMode: 'hierarchy',
-        playOnAwake: true,
-        // Emission
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 10 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [],
-        },
-        // Shape
-        shape: {
-            type: 'cone',
-            emitFromShell: false,
-            randomDirection: false,
-            sphericalDirection: false,
-            arcMode: 'random',
-            arcSpread: 0,
-            radius: { type: 'constant', value: 1 },
-            angle: 25,
-            length: 5,
-            radiusThickness: 1,
-            arc: 360,
-            emitFrom: 'base',
-        },
-        // Velocity over lifetime
-        velocityOverLifetime: {
-            enabled: false,
-            linear: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            space: 'local',
-            orbital: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            offset: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            radial: { type: 'constant', value: 0 },
-            speedModifier: { type: 'constant', value: 1 },
-        },
-        // Limit velocity
-        limitVelocityOverLifetime: {
-            enabled: false,
-            separateAxes: false,
-            speed: { type: 'constant', value: 10 },
-            dampen: 0.1,
-            drag: { type: 'constant', value: 0 },
-            multiplyBySize: false,
-            space: 'local',
-        },
-        // Inherit velocity
-        inheritVelocity: {
-            enabled: false,
-            mode: 'initial',
-            curve: { type: 'constant', value: 0 },
-        },
-        // Lifetime by emitter speed
-        lifetimeByEmitterSpeed: {
-            enabled: false,
-            curve: particleEditorTypes.DEFAULT_CURVE,
-            speedRange: { min: 0, max: 1 },
-        },
-        // Force over lifetime
-        forceOverLifetime: {
-            enabled: false,
-            force: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            space: 'local',
-            randomized: false,
-        },
-        // Color over lifetime
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [
-                    { time: 0, color: { r: 1, g: 1, b: 1 } },
-                    { time: 1, color: { r: 1, g: 1, b: 1 } },
-                ],
-                alphaKeys: [
-                    { time: 0, alpha: 1 },
-                    { time: 0.9, alpha: 1 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        // Color by speed
-        colorBySpeed: {
-            enabled: false,
-            color: particleEditorTypes.DEFAULT_GRADIENT,
-            range: { min: 0, max: 1 },
-        },
-        // Size over lifetime
-        sizeOverLifetime: {
-            enabled: false,
-            separateAxes: false,
-            size: {
-                type: 'curve',
-                curve: [
-                    { time: 0, value: 1 },
-                    { time: 1, value: 0 },
-                ],
-            },
-        },
-        // Size by speed
-        sizeBySpeed: {
-            enabled: false,
-            separateAxes: false,
-            size: { type: 'constant', value: 1 },
-            range: { min: 0, max: 1 },
-        },
-        // Rotation over lifetime
-        rotationOverLifetime: {
-            enabled: false,
-            separateAxes: false,
-            angularVelocity: { type: 'constant', value: 0 },
-        },
-        // Rotation by speed
-        rotationBySpeed: {
-            enabled: false,
-            separateAxes: false,
-            angularVelocity: { type: 'constant', value: 0 },
-            range: { min: 0, max: 1 },
-        },
-        // External forces
-        externalForces: [],
-        // Noise
-        noise: {
-            enabled: false,
-            strength: { type: 'constant', value: 1 },
-            frequency: 0.5,
-            scrollSpeed: 0,
-            damping: true,
-            octaves: 1,
-            octaveMultiplier: 0.5,
-            octaveScale: 2,
-            positionAmount: {
-                x: { type: 'constant', value: 1 },
-                y: { type: 'constant', value: 1 },
-                z: { type: 'constant', value: 1 },
-            },
-            rotationAmount: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            sizeAmount: { type: 'constant', value: 0 },
-            separateAxes: false,
-            remap: particleEditorTypes.DEFAULT_CURVE,
-            remapEnabled: false,
-        },
-        // Collision
-        collision: {
-            enabled: false,
-            type: 'world',
-            mode: '3d',
-            dampen: { type: 'constant', value: 0 },
-            bounce: { type: 'constant', value: 1 },
-            lifetimeLoss: { type: 'constant', value: 0 },
-            minKillSpeed: 0,
-            maxKillSpeed: 10000,
-            radiusScale: 1,
-            sendCollisionMessages: false,
-            maxCollisionShapes: 256,
-            quality: 'medium',
-        },
-        // Triggers
-        triggers: {
-            enabled: false,
-            inside: 'ignore',
-            outside: 'ignore',
-            enter: 'ignore',
-            exit: 'ignore',
-            radiusScale: 1,
-            colliderQueryMode: 'disabled',
-        },
-        // Sub-emitters
-        subEmitters: [],
-        // Texture sheet animation
-        textureSheetAnimation: {
-            enabled: false,
-            mode: 'grid',
-            tilesX: 1,
-            tilesY: 1,
-            animation: 'whole_sheet',
-            timeMode: 'lifetime',
-            cycleCount: 1,
-        },
-        // Lights
-        lights: {
-            enabled: false,
-            ratio: 1,
-            randomDistribution: false,
-            useParticleColor: true,
-            sizeAffectsRange: false,
-            alphaAffectsIntensity: false,
-            range: { type: 'constant', value: 1 },
-            intensity: { type: 'constant', value: 1 },
-            maxLights: 20,
-        },
-        // Trails
-        trails: null,
-        // Renderer
-        renderer: {
-            type: 'billboard',
-            sortMode: 'none',
-            renderAlignment: 'view',
-        },
-        // Material
-        material: {
-            shading: 'unlit',
-            blendMode: 'additive',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 0.5,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-        maxParticles: 1000,
-        gpuInstancing: false,
-    };
+function createDefaultSystem(name = "New Particle System") {
+  return {
+    id: generateSystemId(),
+    name,
+    version: 1,
+    // Main
+    duration: 5,
+    looping: true,
+    prewarm: false,
+    startDelay: { type: "constant", value: 0 },
+    startLifetime: { type: "random", min: 3, max: 5 },
+    startSpeed: { type: "constant", value: 5 },
+    startSize3D: false,
+    startSize: { type: "random", min: 0.5, max: 1 },
+    startRotation3D: false,
+    startRotation: { type: "constant", value: 0 },
+    flipRotation: 0,
+    startColor: {
+      colorKeys: [{ time: 0, color: { r: 1, g: 1, b: 1 } }],
+      alphaKeys: [{ time: 0, alpha: 1 }]
+    },
+    gravityModifier: { type: "constant", value: 0 },
+    simulationSpace: "local",
+    simulationSpeed: 1,
+    deltaTimeType: "scaled",
+    scalingMode: "hierarchy",
+    playOnAwake: true,
+    // Emission
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 10 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: []
+    },
+    // Shape
+    shape: {
+      type: "cone",
+      emitFromShell: false,
+      randomDirection: false,
+      sphericalDirection: false,
+      arcMode: "random",
+      arcSpread: 0,
+      radius: { type: "constant", value: 1 },
+      angle: 25,
+      length: 5,
+      radiusThickness: 1,
+      arc: 360,
+      emitFrom: "base"
+    },
+    // Velocity over lifetime
+    velocityOverLifetime: {
+      enabled: false,
+      linear: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      space: "local",
+      orbital: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      offset: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      radial: { type: "constant", value: 0 },
+      speedModifier: { type: "constant", value: 1 }
+    },
+    // Limit velocity
+    limitVelocityOverLifetime: {
+      enabled: false,
+      separateAxes: false,
+      speed: { type: "constant", value: 10 },
+      dampen: 0.1,
+      drag: { type: "constant", value: 0 },
+      multiplyBySize: false,
+      space: "local"
+    },
+    // Inherit velocity
+    inheritVelocity: {
+      enabled: false,
+      mode: "initial",
+      curve: { type: "constant", value: 0 }
+    },
+    // Lifetime by emitter speed
+    lifetimeByEmitterSpeed: {
+      enabled: false,
+      curve: particleEditorTypes.DEFAULT_CURVE,
+      speedRange: { min: 0, max: 1 }
+    },
+    // Force over lifetime
+    forceOverLifetime: {
+      enabled: false,
+      force: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      space: "local",
+      randomized: false
+    },
+    // Color over lifetime
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [
+          { time: 0, color: { r: 1, g: 1, b: 1 } },
+          { time: 1, color: { r: 1, g: 1, b: 1 } }
+        ],
+        alphaKeys: [
+          { time: 0, alpha: 1 },
+          { time: 0.9, alpha: 1 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    // Color by speed
+    colorBySpeed: {
+      enabled: false,
+      color: particleEditorTypes.DEFAULT_GRADIENT,
+      range: { min: 0, max: 1 }
+    },
+    // Size over lifetime
+    sizeOverLifetime: {
+      enabled: false,
+      separateAxes: false,
+      size: {
+        type: "curve",
+        curve: [
+          { time: 0, value: 1 },
+          { time: 1, value: 0 }
+        ]
+      }
+    },
+    // Size by speed
+    sizeBySpeed: {
+      enabled: false,
+      separateAxes: false,
+      size: { type: "constant", value: 1 },
+      range: { min: 0, max: 1 }
+    },
+    // Rotation over lifetime
+    rotationOverLifetime: {
+      enabled: false,
+      separateAxes: false,
+      angularVelocity: { type: "constant", value: 0 }
+    },
+    // Rotation by speed
+    rotationBySpeed: {
+      enabled: false,
+      separateAxes: false,
+      angularVelocity: { type: "constant", value: 0 },
+      range: { min: 0, max: 1 }
+    },
+    // External forces
+    externalForces: [],
+    // Noise
+    noise: {
+      enabled: false,
+      strength: { type: "constant", value: 1 },
+      frequency: 0.5,
+      scrollSpeed: 0,
+      damping: true,
+      octaves: 1,
+      octaveMultiplier: 0.5,
+      octaveScale: 2,
+      positionAmount: {
+        x: { type: "constant", value: 1 },
+        y: { type: "constant", value: 1 },
+        z: { type: "constant", value: 1 }
+      },
+      rotationAmount: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      sizeAmount: { type: "constant", value: 0 },
+      separateAxes: false,
+      remap: particleEditorTypes.DEFAULT_CURVE,
+      remapEnabled: false
+    },
+    // Collision
+    collision: {
+      enabled: false,
+      type: "world",
+      mode: "3d",
+      dampen: { type: "constant", value: 0 },
+      bounce: { type: "constant", value: 1 },
+      lifetimeLoss: { type: "constant", value: 0 },
+      minKillSpeed: 0,
+      maxKillSpeed: 1e4,
+      radiusScale: 1,
+      sendCollisionMessages: false,
+      maxCollisionShapes: 256,
+      quality: "medium"
+    },
+    // Triggers
+    triggers: {
+      enabled: false,
+      inside: "ignore",
+      outside: "ignore",
+      enter: "ignore",
+      exit: "ignore",
+      radiusScale: 1,
+      colliderQueryMode: "disabled"
+    },
+    // Sub-emitters
+    subEmitters: [],
+    // Texture sheet animation
+    textureSheetAnimation: {
+      enabled: false,
+      mode: "grid",
+      tilesX: 1,
+      tilesY: 1,
+      animation: "whole_sheet",
+      timeMode: "lifetime",
+      cycleCount: 1
+    },
+    // Lights
+    lights: {
+      enabled: false,
+      ratio: 1,
+      randomDistribution: false,
+      useParticleColor: true,
+      sizeAffectsRange: false,
+      alphaAffectsIntensity: false,
+      range: { type: "constant", value: 1 },
+      intensity: { type: "constant", value: 1 },
+      maxLights: 20
+    },
+    // Trails
+    trails: null,
+    // Renderer
+    renderer: {
+      type: "billboard",
+      sortMode: "none",
+      renderAlignment: "view"
+    },
+    // Material
+    material: {
+      shading: "unlit",
+      blendMode: "additive",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 0.5,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    },
+    maxParticles: 1e3,
+    gpuInstancing: false
+  };
 }
-// ─── Presets ─────────────────────────────────────────────────────────────────
 const PARTICLE_PRESETS = {
-    fire: () => ({
-        name: 'Fire',
-        duration: 1,
-        startLifetime: { type: 'random', min: 0.5, max: 1.5 },
-        startSpeed: { type: 'random', min: 1, max: 3 },
-        startSize: { type: 'random', min: 0.3, max: 0.8 },
-        gravityModifier: { type: 'constant', value: -0.5 },
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 50 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [],
-        },
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [
-                    { time: 0, color: { r: 1, g: 0.8, b: 0.2 } },
-                    { time: 0.5, color: { r: 1, g: 0.4, b: 0 } },
-                    { time: 1, color: { r: 0.3, g: 0, b: 0 } },
-                ],
-                alphaKeys: [
-                    { time: 0, alpha: 0.8 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        sizeOverLifetime: {
-            enabled: true,
-            separateAxes: false,
-            size: {
-                type: 'curve',
-                curve: [
-                    { time: 0, value: 0.5 },
-                    { time: 0.5, value: 1 },
-                    { time: 1, value: 0.2 },
-                ],
-            },
-        },
-        material: {
-            shading: 'unlit',
-            blendMode: 'additive',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 0.5,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-    }),
-    smoke: () => ({
-        name: 'Smoke',
-        duration: 3,
-        startLifetime: { type: 'random', min: 3, max: 5 },
-        startSpeed: { type: 'random', min: 0.5, max: 1.5 },
-        startSize: { type: 'random', min: 0.5, max: 1.5 },
-        gravityModifier: { type: 'constant', value: -0.1 },
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 10 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [],
-        },
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [
-                    { time: 0, color: { r: 0.5, g: 0.5, b: 0.5 } },
-                    { time: 1, color: { r: 0.3, g: 0.3, b: 0.3 } },
-                ],
-                alphaKeys: [
-                    { time: 0, alpha: 0.4 },
-                    { time: 0.7, alpha: 0.2 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        sizeOverLifetime: {
-            enabled: true,
-            separateAxes: false,
-            size: {
-                type: 'curve',
-                curve: [
-                    { time: 0, value: 0.5 },
-                    { time: 1, value: 2 },
-                ],
-            },
-        },
-        noise: {
-            enabled: true,
-            strength: { type: 'constant', value: 0.5 },
-            frequency: 0.5,
-            scrollSpeed: 0.2,
-            damping: true,
-            octaves: 2,
-            octaveMultiplier: 0.5,
-            octaveScale: 2,
-            positionAmount: {
-                x: { type: 'constant', value: 1 },
-                y: { type: 'constant', value: 0.5 },
-                z: { type: 'constant', value: 1 },
-            },
-            rotationAmount: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            sizeAmount: { type: 'constant', value: 0 },
-            separateAxes: false,
-            remap: particleEditorTypes.DEFAULT_CURVE,
-            remapEnabled: false,
-        },
-        material: {
-            shading: 'unlit',
-            blendMode: 'alpha',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 2,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-    }),
-    sparks: () => ({
-        name: 'Sparks',
-        duration: 0.5,
-        looping: false,
-        startLifetime: { type: 'random', min: 0.3, max: 0.8 },
-        startSpeed: { type: 'random', min: 5, max: 15 },
-        startSize: { type: 'random', min: 0.02, max: 0.05 },
-        gravityModifier: { type: 'constant', value: 1 },
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 0 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [
-                {
-                    time: 0,
-                    count: { type: 'random', min: 20, max: 40 },
-                    cycles: 1,
-                    interval: 0.1,
-                    probability: 1,
-                },
-            ],
-        },
-        shape: {
-            type: 'sphere',
-            emitFromShell: true,
-            randomDirection: true,
-            sphericalDirection: true,
-            arcMode: 'random',
-            arcSpread: 0,
-            radius: { type: 'constant', value: 0.1 },
-            radiusThickness: 0,
-            arc: 360,
-        },
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [
-                    { time: 0, color: { r: 1, g: 0.9, b: 0.4 } },
-                    { time: 0.5, color: { r: 1, g: 0.5, b: 0.1 } },
-                    { time: 1, color: { r: 0.8, g: 0.2, b: 0 } },
-                ],
-                alphaKeys: [
-                    { time: 0, alpha: 1 },
-                    { time: 0.8, alpha: 1 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        renderer: {
-            type: 'stretched_billboard',
-            sortMode: 'none',
-            renderAlignment: 'velocity',
-            speedScale: 0.02,
-            lengthScale: 1,
-            faceCamera: true,
-        },
-        material: {
-            shading: 'unlit',
-            blendMode: 'additive',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 0.1,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-    }),
-    snow: () => ({
-        name: 'Snow',
-        duration: 10,
-        startLifetime: { type: 'random', min: 10, max: 15 },
-        startSpeed: { type: 'random', min: 0.5, max: 1 },
-        startSize: { type: 'random', min: 0.05, max: 0.15 },
-        gravityModifier: { type: 'constant', value: 0.1 },
-        shape: {
-            type: 'box',
-            emitFromShell: false,
-            randomDirection: false,
-            sphericalDirection: false,
-            arcMode: 'random',
-            arcSpread: 0,
-            size: { x: 20, y: 0.1, z: 20 },
-            emitFrom: 'volume',
-        },
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 100 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [],
-        },
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [{ time: 0, color: { r: 1, g: 1, b: 1 } }],
-                alphaKeys: [
-                    { time: 0, alpha: 0 },
-                    { time: 0.1, alpha: 0.8 },
-                    { time: 0.9, alpha: 0.8 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        noise: {
-            enabled: true,
-            strength: { type: 'constant', value: 0.3 },
-            frequency: 0.3,
-            scrollSpeed: 0.1,
-            damping: false,
-            octaves: 2,
-            octaveMultiplier: 0.5,
-            octaveScale: 2,
-            positionAmount: {
-                x: { type: 'constant', value: 1 },
-                y: { type: 'constant', value: 0.2 },
-                z: { type: 'constant', value: 1 },
-            },
-            rotationAmount: {
-                x: { type: 'constant', value: 0 },
-                y: { type: 'constant', value: 0 },
-                z: { type: 'constant', value: 0 },
-            },
-            sizeAmount: { type: 'constant', value: 0 },
-            separateAxes: false,
-            remap: particleEditorTypes.DEFAULT_CURVE,
-            remapEnabled: false,
-        },
-        material: {
-            shading: 'unlit',
-            blendMode: 'alpha',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 0.2,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-    }),
-    rain: () => ({
-        name: 'Rain',
-        duration: 5,
-        startLifetime: { type: 'constant', value: 1 },
-        startSpeed: { type: 'random', min: 15, max: 20 },
-        startSize: { type: 'constant', value: 0.03 },
-        startRotation: { type: 'constant', value: 0 },
-        gravityModifier: { type: 'constant', value: 0 },
-        shape: {
-            type: 'box',
-            emitFromShell: false,
-            randomDirection: false,
-            sphericalDirection: false,
-            arcMode: 'random',
-            arcSpread: 0,
-            size: { x: 20, y: 0.1, z: 20 },
-            emitFrom: 'volume',
-        },
-        emission: {
-            enabled: true,
-            rateOverTime: { type: 'constant', value: 500 },
-            rateOverDistance: { type: 'constant', value: 0 },
-            bursts: [],
-        },
-        colorOverLifetime: {
-            enabled: true,
-            color: {
-                colorKeys: [{ time: 0, color: { r: 0.7, g: 0.8, b: 0.9 } }],
-                alphaKeys: [
-                    { time: 0, alpha: 0 },
-                    { time: 0.1, alpha: 0.5 },
-                    { time: 0.9, alpha: 0.5 },
-                    { time: 1, alpha: 0 },
-                ],
-            },
-        },
-        renderer: {
-            type: 'stretched_billboard',
-            sortMode: 'none',
-            renderAlignment: 'velocity',
-            speedScale: 0.01,
-            lengthScale: 3,
-            faceCamera: true,
-        },
-        material: {
-            shading: 'unlit',
-            blendMode: 'alpha',
-            colorMode: 'multiply',
-            flipBookBlending: false,
-            shadowCasting: 'off',
-            shadowReceiving: false,
-            cullMode: 'off',
-            sortingFudge: 0,
-            minParticleSize: 0,
-            maxParticleSize: 0.1,
-            pivot: { x: 0, y: 0, z: 0 },
-            customVertexStreams: [],
-        },
-    }),
+  fire: () => ({
+    name: "Fire",
+    duration: 1,
+    startLifetime: { type: "random", min: 0.5, max: 1.5 },
+    startSpeed: { type: "random", min: 1, max: 3 },
+    startSize: { type: "random", min: 0.3, max: 0.8 },
+    gravityModifier: { type: "constant", value: -0.5 },
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 50 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: []
+    },
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [
+          { time: 0, color: { r: 1, g: 0.8, b: 0.2 } },
+          { time: 0.5, color: { r: 1, g: 0.4, b: 0 } },
+          { time: 1, color: { r: 0.3, g: 0, b: 0 } }
+        ],
+        alphaKeys: [
+          { time: 0, alpha: 0.8 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    sizeOverLifetime: {
+      enabled: true,
+      separateAxes: false,
+      size: {
+        type: "curve",
+        curve: [
+          { time: 0, value: 0.5 },
+          { time: 0.5, value: 1 },
+          { time: 1, value: 0.2 }
+        ]
+      }
+    },
+    material: {
+      shading: "unlit",
+      blendMode: "additive",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 0.5,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    }
+  }),
+  smoke: () => ({
+    name: "Smoke",
+    duration: 3,
+    startLifetime: { type: "random", min: 3, max: 5 },
+    startSpeed: { type: "random", min: 0.5, max: 1.5 },
+    startSize: { type: "random", min: 0.5, max: 1.5 },
+    gravityModifier: { type: "constant", value: -0.1 },
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 10 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: []
+    },
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [
+          { time: 0, color: { r: 0.5, g: 0.5, b: 0.5 } },
+          { time: 1, color: { r: 0.3, g: 0.3, b: 0.3 } }
+        ],
+        alphaKeys: [
+          { time: 0, alpha: 0.4 },
+          { time: 0.7, alpha: 0.2 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    sizeOverLifetime: {
+      enabled: true,
+      separateAxes: false,
+      size: {
+        type: "curve",
+        curve: [
+          { time: 0, value: 0.5 },
+          { time: 1, value: 2 }
+        ]
+      }
+    },
+    noise: {
+      enabled: true,
+      strength: { type: "constant", value: 0.5 },
+      frequency: 0.5,
+      scrollSpeed: 0.2,
+      damping: true,
+      octaves: 2,
+      octaveMultiplier: 0.5,
+      octaveScale: 2,
+      positionAmount: {
+        x: { type: "constant", value: 1 },
+        y: { type: "constant", value: 0.5 },
+        z: { type: "constant", value: 1 }
+      },
+      rotationAmount: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      sizeAmount: { type: "constant", value: 0 },
+      separateAxes: false,
+      remap: particleEditorTypes.DEFAULT_CURVE,
+      remapEnabled: false
+    },
+    material: {
+      shading: "unlit",
+      blendMode: "alpha",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 2,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    }
+  }),
+  sparks: () => ({
+    name: "Sparks",
+    duration: 0.5,
+    looping: false,
+    startLifetime: { type: "random", min: 0.3, max: 0.8 },
+    startSpeed: { type: "random", min: 5, max: 15 },
+    startSize: { type: "random", min: 0.02, max: 0.05 },
+    gravityModifier: { type: "constant", value: 1 },
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 0 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: [
+        {
+          time: 0,
+          count: { type: "random", min: 20, max: 40 },
+          cycles: 1,
+          interval: 0.1,
+          probability: 1
+        }
+      ]
+    },
+    shape: {
+      type: "sphere",
+      emitFromShell: true,
+      randomDirection: true,
+      sphericalDirection: true,
+      arcMode: "random",
+      arcSpread: 0,
+      radius: { type: "constant", value: 0.1 },
+      radiusThickness: 0,
+      arc: 360
+    },
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [
+          { time: 0, color: { r: 1, g: 0.9, b: 0.4 } },
+          { time: 0.5, color: { r: 1, g: 0.5, b: 0.1 } },
+          { time: 1, color: { r: 0.8, g: 0.2, b: 0 } }
+        ],
+        alphaKeys: [
+          { time: 0, alpha: 1 },
+          { time: 0.8, alpha: 1 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    renderer: {
+      type: "stretched_billboard",
+      sortMode: "none",
+      renderAlignment: "velocity",
+      speedScale: 0.02,
+      lengthScale: 1,
+      faceCamera: true
+    },
+    material: {
+      shading: "unlit",
+      blendMode: "additive",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 0.1,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    }
+  }),
+  snow: () => ({
+    name: "Snow",
+    duration: 10,
+    startLifetime: { type: "random", min: 10, max: 15 },
+    startSpeed: { type: "random", min: 0.5, max: 1 },
+    startSize: { type: "random", min: 0.05, max: 0.15 },
+    gravityModifier: { type: "constant", value: 0.1 },
+    shape: {
+      type: "box",
+      emitFromShell: false,
+      randomDirection: false,
+      sphericalDirection: false,
+      arcMode: "random",
+      arcSpread: 0,
+      size: { x: 20, y: 0.1, z: 20 },
+      emitFrom: "volume"
+    },
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 100 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: []
+    },
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [{ time: 0, color: { r: 1, g: 1, b: 1 } }],
+        alphaKeys: [
+          { time: 0, alpha: 0 },
+          { time: 0.1, alpha: 0.8 },
+          { time: 0.9, alpha: 0.8 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    noise: {
+      enabled: true,
+      strength: { type: "constant", value: 0.3 },
+      frequency: 0.3,
+      scrollSpeed: 0.1,
+      damping: false,
+      octaves: 2,
+      octaveMultiplier: 0.5,
+      octaveScale: 2,
+      positionAmount: {
+        x: { type: "constant", value: 1 },
+        y: { type: "constant", value: 0.2 },
+        z: { type: "constant", value: 1 }
+      },
+      rotationAmount: {
+        x: { type: "constant", value: 0 },
+        y: { type: "constant", value: 0 },
+        z: { type: "constant", value: 0 }
+      },
+      sizeAmount: { type: "constant", value: 0 },
+      separateAxes: false,
+      remap: particleEditorTypes.DEFAULT_CURVE,
+      remapEnabled: false
+    },
+    material: {
+      shading: "unlit",
+      blendMode: "alpha",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 0.2,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    }
+  }),
+  rain: () => ({
+    name: "Rain",
+    duration: 5,
+    startLifetime: { type: "constant", value: 1 },
+    startSpeed: { type: "random", min: 15, max: 20 },
+    startSize: { type: "constant", value: 0.03 },
+    startRotation: { type: "constant", value: 0 },
+    gravityModifier: { type: "constant", value: 0 },
+    shape: {
+      type: "box",
+      emitFromShell: false,
+      randomDirection: false,
+      sphericalDirection: false,
+      arcMode: "random",
+      arcSpread: 0,
+      size: { x: 20, y: 0.1, z: 20 },
+      emitFrom: "volume"
+    },
+    emission: {
+      enabled: true,
+      rateOverTime: { type: "constant", value: 500 },
+      rateOverDistance: { type: "constant", value: 0 },
+      bursts: []
+    },
+    colorOverLifetime: {
+      enabled: true,
+      color: {
+        colorKeys: [{ time: 0, color: { r: 0.7, g: 0.8, b: 0.9 } }],
+        alphaKeys: [
+          { time: 0, alpha: 0 },
+          { time: 0.1, alpha: 0.5 },
+          { time: 0.9, alpha: 0.5 },
+          { time: 1, alpha: 0 }
+        ]
+      }
+    },
+    renderer: {
+      type: "stretched_billboard",
+      sortMode: "none",
+      renderAlignment: "velocity",
+      speedScale: 0.01,
+      lengthScale: 3,
+      faceCamera: true
+    },
+    material: {
+      shading: "unlit",
+      blendMode: "alpha",
+      colorMode: "multiply",
+      flipBookBlending: false,
+      shadowCasting: "off",
+      shadowReceiving: false,
+      cullMode: "off",
+      sortingFudge: 0,
+      minParticleSize: 0,
+      maxParticleSize: 0.1,
+      pivot: { x: 0, y: 0, z: 0 },
+      customVertexStreams: []
+    }
+  })
 };
 function applyPreset(preset) {
-    const base = createDefaultSystem();
-    const presetData = PARTICLE_PRESETS[preset]();
-    return { ...base, ...presetData };
+  const base = createDefaultSystem();
+  const presetData = PARTICLE_PRESETS[preset]();
+  return { ...base, ...presetData };
 }
-// ─── Import/Export ───────────────────────────────────────────────────────────
 function exportSystemsToJSON(systems) {
-    return JSON.stringify(systems, null, 2);
+  return JSON.stringify(systems, null, 2);
 }
 function importSystemsFromJSON(json) {
-    try {
-        const data = JSON.parse(json);
-        if (Array.isArray(data)) {
-            return data;
-        }
-        if (data && typeof data === 'object' && data.id) {
-            return [data];
-        }
-        return null;
+  try {
+    const data = JSON.parse(json);
+    if (Array.isArray(data)) {
+      return data;
     }
-    catch (_a) {
-        return null;
+    if (data && typeof data === "object" && data.id) {
+      return [data];
     }
+    return null;
+  } catch {
+    return null;
+  }
 }
 function cloneSystem(system) {
-    const cloned = JSON.parse(JSON.stringify(system));
-    cloned.id = generateSystemId();
-    cloned.name = `${system.name} (Copy)`;
-    return cloned;
+  const cloned = JSON.parse(JSON.stringify(system));
+  cloned.id = generateSystemId();
+  cloned.name = `${system.name} (Copy)`;
+  return cloned;
 }
-
 exports.PARTICLE_PRESETS = PARTICLE_PRESETS;
 exports.applyForce = applyForce;
 exports.applyPreset = applyPreset;