@nice2dev/ui-3d 1.0.0 → 1.0.2

package/dist/cjs/particle/particleEditorUtils.js

@@ -0,0 +1,1084 @@
+'use strict';
+
+var particleEditorTypes = require('./particleEditorTypes.js');
+
+/* ════════════════════════════════════════════════════════════════════════════
+   Particle System Editor — Utility Functions
+   
+   Core utilities for particle system creation, manipulation, and simulation
+   ════════════════════════════════════════════════════════════════════════════ */
+// ─── ID Generation ───────────────────────────────────────────────────────────
+let systemIdCounter = 0;
+let forceIdCounter = 0;
+let subEmitterIdCounter = 0;
+function generateSystemId() {
+    return `system_${++systemIdCounter}_${Date.now()}`;
+}
+function generateForceId() {
+    return `force_${++forceIdCounter}_${Date.now()}`;
+}
+function generateSubEmitterId() {
+    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;
+    }
+}
+function evaluateCurve(curve, t) {
+    var _a, _b;
+    if (curve.length === 0)
+        return 0;
+    if (curve.length === 1)
+        return curve[0].value;
+    // 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;
+    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;
+}
+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),
+    };
+}
+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),
+            };
+        }
+    }
+    // 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);
+        }
+    }
+    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 };
+}
+function vec3Sub(a, b) {
+    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 };
+}
+function vec3MulVec(a, b) {
+    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;
+}
+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,
+    };
+}
+function vec3Length(v) {
+    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 };
+}
+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),
+    };
+}
+function vec3Random() {
+    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),
+    };
+}
+// ─── Random / Noise ──────────────────────────────────────────────────────────
+function seededRandom(seed) {
+    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;
+}
+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;
+}
+// ─── 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 };
+            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 };
+            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 };
+            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;
+        }
+        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)
+        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 < 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);
+        }
+        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,
+    };
+}
+// ─── 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: [],
+        },
+    }),
+};
+function applyPreset(preset) {
+    const base = createDefaultSystem();
+    const presetData = PARTICLE_PRESETS[preset]();
+    return { ...base, ...presetData };
+}
+// ─── Import/Export ───────────────────────────────────────────────────────────
+function exportSystemsToJSON(systems) {
+    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;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function cloneSystem(system) {
+    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;
+exports.cloneSystem = cloneSystem;
+exports.createDefaultSystem = createDefaultSystem;
+exports.evaluateCurve = evaluateCurve;
+exports.evaluateDistribution = evaluateDistribution;
+exports.evaluateGradient = evaluateGradient;
+exports.evaluateVec3Distribution = evaluateVec3Distribution;
+exports.exportSystemsToJSON = exportSystemsToJSON;
+exports.fbmNoise = fbmNoise;
+exports.generateForceId = generateForceId;
+exports.generateSubEmitterId = generateSubEmitterId;
+exports.generateSystemId = generateSystemId;
+exports.importSystemsFromJSON = importSystemsFromJSON;
+exports.perlinNoise2D = perlinNoise2D;
+exports.sampleEmitterShape = sampleEmitterShape;
+exports.seededRandom = seededRandom;
+exports.vec3Add = vec3Add;
+exports.vec3Cross = vec3Cross;
+exports.vec3Dot = vec3Dot;
+exports.vec3Length = vec3Length;
+exports.vec3Lerp = vec3Lerp;
+exports.vec3Mul = vec3Mul;
+exports.vec3MulVec = vec3MulVec;
+exports.vec3Normalize = vec3Normalize;
+exports.vec3Random = vec3Random;
+exports.vec3RandomOnSphere = vec3RandomOnSphere;
+exports.vec3Sub = vec3Sub;
+//# sourceMappingURL=particleEditorUtils.js.map