reze-engine 0.3.10 → 0.3.12

package/dist/particles.js

@@ -0,0 +1,266 @@
+import { Vec3 } from "./math";
+const MAX_PARTICLES = 30000;
+export const DEFAULT_PARTICLE_CONFIG = {
+    particleCount: 5000, // Reduced from 23000 for better performance
+    particleSize: 0.1, // Smaller particles
+    fadeSpeed: 0.008, // Faster fade = particles die sooner
+    explosionForce: 0.6, // Smaller explosion radius
+    hoverDuration: 1.2, // Shorter hover
+    gravity: 0.00265,
+    friction: 0.95494,
+    rocketSpeed: 1.0,
+    rocketSize: 0.4, // Smaller rocket trail
+};
+export class Firework {
+    constructor(startX, config) {
+        this.startX = startX;
+        this.config = config;
+        this.phase = "rocket";
+        this.timer = 0;
+        this.colors = [];
+        this.rocketAlive = true;
+        this.rocketLifetime = 1.0;
+        this.justExploded = false; // Flag for triggering audio
+        // Explosion particle data
+        this.particles = null;
+        this.baseColors = null;
+        // Generate color palette (mono, dual, or tri-color)
+        const rand = Math.random();
+        const baseHue = Math.random();
+        if (rand < 0.33) {
+            // MONO (1 Color)
+            this.colors.push(this.hslToRgb(baseHue, 1.0, 0.6));
+        }
+        else if (rand < 0.66) {
+            // DUAL (2 Colors - Complementary)
+            this.colors.push(this.hslToRgb(baseHue, 1.0, 0.6));
+            this.colors.push(this.hslToRgb((baseHue + 0.5) % 1.0, 1.0, 0.5));
+        }
+        else {
+            // TRI (3 Colors - Triad)
+            this.colors.push(this.hslToRgb(baseHue, 1.0, 0.6));
+            this.colors.push(this.hslToRgb((baseHue + 0.33) % 1.0, 1.0, 0.6));
+            this.colors.push(this.hslToRgb((baseHue + 0.66) % 1.0, 1.0, 0.6));
+        }
+        this.pos = new Vec3(startX, -50, (Math.random() - 0.5) * 30);
+        this.vel = new Vec3((Math.random() - 0.5) * 0.5, config.rocketSpeed * (0.9 + Math.random() * 0.3), (Math.random() - 0.5) * 0.5);
+        this.targetY = 10 + Math.random() * 20; // Higher explosion point
+    }
+    hslToRgb(h, s, l) {
+        let r, g, b;
+        if (s === 0) {
+            r = g = b = l;
+        }
+        else {
+            const hue2rgb = (p, q, t) => {
+                if (t < 0)
+                    t += 1;
+                if (t > 1)
+                    t -= 1;
+                if (t < 1 / 6)
+                    return p + (q - p) * 6 * t;
+                if (t < 1 / 2)
+                    return q;
+                if (t < 2 / 3)
+                    return p + (q - p) * (2 / 3 - t) * 6;
+                return p;
+            };
+            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const p = 2 * l - q;
+            r = hue2rgb(p, q, h + 1 / 3);
+            g = hue2rgb(p, q, h);
+            b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return new Vec3(r, g, b);
+    }
+    update(deltaTime) {
+        if (this.phase === "rocket") {
+            this.pos.x += this.vel.x;
+            this.pos.y += this.vel.y;
+            this.pos.z += this.vel.z;
+            this.vel.y *= 0.99;
+            this.rocketLifetime -= deltaTime * 0.5;
+            if (this.vel.y < 0.2 || this.pos.y >= this.targetY || this.rocketLifetime <= 0) {
+                this.explode();
+            }
+        }
+        else if (this.phase === "explode") {
+            this.timer += deltaTime;
+            if (!this.particles)
+                return;
+            const isHovering = this.timer < this.config.hoverDuration;
+            const gravityFactor = this.smoothstep(this.timer, this.config.hoverDuration, this.config.hoverDuration + 0.5);
+            let aliveCount = 0;
+            const positions = this.particles.positions;
+            const velocities = this.particles.velocities;
+            const colors = this.particles.colors;
+            const lifetimes = this.particles.lifetimes;
+            for (let i = 0; i < this.particles.count; i++) {
+                if (lifetimes[i] > 0) {
+                    aliveCount++;
+                    const i3 = i * 3;
+                    // Update position
+                    positions[i3] += velocities[i3];
+                    positions[i3 + 1] += velocities[i3 + 1];
+                    positions[i3 + 2] += velocities[i3 + 2];
+                    if (isHovering) {
+                        // Hovering phase - apply friction
+                        velocities[i3] *= this.config.friction;
+                        velocities[i3 + 1] *= this.config.friction;
+                        velocities[i3 + 2] *= this.config.friction;
+                    }
+                    else {
+                        // Falling phase - apply gravity and fade
+                        velocities[i3 + 1] -= this.config.gravity * gravityFactor;
+                        velocities[i3] *= 0.98;
+                        velocities[i3 + 1] *= 0.98;
+                        velocities[i3 + 2] *= 0.98;
+                        lifetimes[i] -= this.config.fadeSpeed;
+                    }
+                    // Update color alpha
+                    const alpha = Math.max(0, lifetimes[i]);
+                    if (this.baseColors) {
+                        colors[i3] = this.baseColors[i3] * alpha * 1.5;
+                        colors[i3 + 1] = this.baseColors[i3 + 1] * alpha * 1.5;
+                        colors[i3 + 2] = this.baseColors[i3 + 2] * alpha * 1.5;
+                    }
+                }
+            }
+            if (aliveCount === 0) {
+                this.phase = "dead";
+            }
+        }
+    }
+    smoothstep(x, edge0, edge1) {
+        const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+        return t * t * (3 - 2 * t);
+    }
+    explode() {
+        this.phase = "explode";
+        this.timer = 0;
+        this.rocketAlive = false;
+        this.justExploded = true; // Mark for audio trigger
+        const particleCount = Math.min(this.config.particleCount, MAX_PARTICLES);
+        const positions = new Float32Array(particleCount * 3);
+        const velocities = new Float32Array(particleCount * 3);
+        const colors = new Float32Array(particleCount * 3);
+        const lifetimes = new Float32Array(particleCount);
+        this.baseColors = new Float32Array(particleCount * 3);
+        const baseSpeed = this.config.explosionForce * (0.8 + Math.random() * 0.4);
+        for (let i = 0; i < particleCount; i++) {
+            const i3 = i * 3;
+            // Set initial position to explosion center
+            positions[i3] = this.pos.x;
+            positions[i3 + 1] = this.pos.y;
+            positions[i3 + 2] = this.pos.z;
+            // Generate spherical velocity distribution
+            const theta = Math.random() * Math.PI * 2;
+            const phi = Math.acos(2 * Math.random() - 1);
+            const speed = baseSpeed * (0.8 + Math.random() * 0.4);
+            velocities[i3] = speed * Math.sin(phi) * Math.cos(theta);
+            velocities[i3 + 1] = speed * Math.sin(phi) * Math.sin(theta);
+            velocities[i3 + 2] = speed * Math.cos(phi);
+            // Pick color from palette and vary brightness
+            const targetColor = this.colors[Math.floor(Math.random() * this.colors.length)];
+            const brightness = 0.5 + Math.random() * 0.8;
+            this.baseColors[i3] = targetColor.x * brightness;
+            this.baseColors[i3 + 1] = targetColor.y * brightness;
+            this.baseColors[i3 + 2] = targetColor.z * brightness;
+            colors[i3] = this.baseColors[i3];
+            colors[i3 + 1] = this.baseColors[i3 + 1];
+            colors[i3 + 2] = this.baseColors[i3 + 2];
+            lifetimes[i] = 1.0;
+        }
+        this.particles = {
+            positions,
+            velocities,
+            colors,
+            lifetimes,
+            count: particleCount,
+        };
+    }
+    isDead() {
+        return this.phase === "dead";
+    }
+    isRocket() {
+        return this.phase === "rocket" && this.rocketAlive;
+    }
+    getRocketPosition() {
+        return this.pos;
+    }
+    getRocketColor() {
+        return this.colors[0];
+    }
+    getParticleData() {
+        return this.particles;
+    }
+    hasJustExploded() {
+        return this.justExploded;
+    }
+    clearExplosionFlag() {
+        this.justExploded = false;
+    }
+}
+export class ParticleSystem {
+    constructor(config) {
+        this.fireworks = [];
+        this.config = { ...DEFAULT_PARTICLE_CONFIG };
+        this.maxConcurrentFireworks = 5; // Limit concurrent fireworks for performance
+        // Auto-launch settings
+        this.autoLaunch = false;
+        this.launchInterval = 3000; // ms
+        this.lastLaunchTime = 0;
+        this.nextLaunchDelay = 0;
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    update(deltaTime) {
+        // Update existing fireworks
+        for (let i = this.fireworks.length - 1; i >= 0; i--) {
+            this.fireworks[i].update(deltaTime);
+            if (this.fireworks[i].isDead()) {
+                this.fireworks.splice(i, 1);
+            }
+        }
+        // Auto-launch
+        if (this.autoLaunch) {
+            const now = performance.now();
+            if (now - this.lastLaunchTime > this.nextLaunchDelay) {
+                this.lastLaunchTime = now;
+                this.nextLaunchDelay = this.launchInterval + Math.random() * 1000;
+                this.spawnFirework();
+            }
+        }
+    }
+    spawnFirework(x) {
+        // Don't spawn if we're at the limit (for performance)
+        if (this.fireworks.length >= this.maxConcurrentFireworks) {
+            return;
+        }
+        const startX = x !== undefined ? x : (Math.random() - 0.5) * 5;
+        this.fireworks.push(new Firework(startX, this.config));
+    }
+    getFireworks() {
+        return this.fireworks;
+    }
+    setAutoLaunch(enabled) {
+        this.autoLaunch = enabled;
+        if (enabled) {
+            this.lastLaunchTime = performance.now();
+            this.nextLaunchDelay = 0;
+        }
+    }
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    setMaxConcurrentFireworks(max) {
+        this.maxConcurrentFireworks = Math.max(1, max);
+    }
+    getMaxConcurrentFireworks() {
+        return this.maxConcurrentFireworks;
+    }
+}

package/dist/physics.d.ts

@@ -72,8 +72,8 @@ export declare class Physics {
     private createAmmoRigidbodies;
     private createAmmoJoints;
     private normalizeAngle;
-    reset(boneWorldMatrices: Float32Array, boneInverseBindMatrices: Float32Array): void;
-    step(dt: number, boneWorldMatrices: Float32Array, boneInverseBindMatrices: Float32Array): void;
+    reset(boneWorldMatrices: Mat4[], boneInverseBindMatrices: Float32Array): void;
+    step(dt: number, boneWorldMatrices: Mat4[], boneInverseBindMatrices: Float32Array): void;
     private computeBodyOffsets;
     private positionBodiesFromBones;
     private syncFromBones;

package/dist/physics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../src/physics.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../src/physics.ts"],"names":[],"mappings":"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"}

package/dist/physics.js

@@ -336,7 +336,7 @@ export class Physics {
         if (!this.ammoInitialized || !this.ammo || !this.dynamicsWorld) {
             return;
         }
-        const boneCount = boneWorldMatrices.length / 16;
+        const boneCount = boneWorldMatrices.length;
         const Ammo = this.ammo;
         // Ensure body offsets are computed
         if (!this.rigidbodiesInitialized) {
@@ -351,9 +351,8 @@ export class Physics {
             if (!ammoBody || rb.boneIndex < 0 || rb.boneIndex >= boneCount)
                 continue;
             const boneIdx = rb.boneIndex;
-            const worldMatIdx = boneIdx * 16;
             // Get bone world matrix
-            const boneWorldMat = new Mat4(boneWorldMatrices.subarray(worldMatIdx, worldMatIdx + 16));
+            const boneWorldMat = boneWorldMatrices[boneIdx];
             // Compute body world matrix: bodyWorld = boneWorld × bodyOffsetMatrix
             // (like babylon-mmd: bodyWorldMatrix = bodyOffsetMatrix.multiplyToRef(bodyWorldMatrix))
             const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
@@ -394,7 +393,7 @@ export class Physics {
         if (!this.ammoInitialized || !this.ammo || !this.dynamicsWorld) {
             return;
         }
-        const boneCount = boneWorldMatrices.length / 16;
+        const boneCount = boneWorldMatrices.length;
         if (this.firstFrame) {
             if (!this.rigidbodiesInitialized) {
                 this.computeBodyOffsets(boneInverseBindMatrices, boneCount);
@@ -451,8 +450,7 @@ export class Physics {
             if (!ammoBody || rb.boneIndex < 0 || rb.boneIndex >= boneCount)
                 continue;
             const boneIdx = rb.boneIndex;
-            const worldMatIdx = boneIdx * 16;
-            const boneWorldMat = new Mat4(boneWorldMatrices.subarray(worldMatIdx, worldMatIdx + 16));
+            const boneWorldMat = boneWorldMatrices[boneIdx];
             // nodeWorld = boneWorld × shapeLocal (not shapeLocal × boneWorld)
             const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
             const nodeWorldMatrix = boneWorldMat.multiply(bodyOffsetMatrix);
@@ -494,8 +492,7 @@ export class Physics {
                 rb.boneIndex >= 0 &&
                 rb.boneIndex < boneCount) {
                 const boneIdx = rb.boneIndex;
-                const worldMatIdx = boneIdx * 16;
-                const boneWorldMat = new Mat4(boneWorldMatrices.subarray(worldMatIdx, worldMatIdx + 16));
+                const boneWorldMat = boneWorldMatrices[boneIdx];
                 // nodeWorld = boneWorld × shapeLocal (not shapeLocal × boneWorld)
                 const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
                 const nodeWorldMatrix = boneWorldMat.multiply(bodyOffsetMatrix);
@@ -539,7 +536,6 @@ export class Physics {
             // Only dynamic rigidbodies drive bones (Static/Kinematic follow bones)
             if (rb.type === RigidbodyType.Dynamic && rb.boneIndex >= 0 && rb.boneIndex < boneCount) {
                 const boneIdx = rb.boneIndex;
-                const worldMatIdx = boneIdx * 16;
                 const transform = ammoBody.getWorldTransform();
                 const origin = transform.getOrigin();
                 const rotation = transform.getRotation();
@@ -550,7 +546,7 @@ export class Physics {
                 const boneWorldMat = nodeWorldMatrix.multiply(rb.bodyOffsetMatrixInverse);
                 const values = boneWorldMat.values;
                 if (!isNaN(values[0]) && !isNaN(values[15]) && Math.abs(values[0]) < 1e6 && Math.abs(values[15]) < 1e6) {
-                    boneWorldMatrices.set(values, worldMatIdx);
+                    boneWorldMatrices[boneIdx].values.set(values);
                 }
                 else {
                     console.warn(`[Physics] Invalid bone world matrix for rigidbody ${i} (${rb.name}), skipping update`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "reze-engine",
-    "version": "0.3.10",
+    "version": "0.3.12",
     "description": "A WebGPU-based MMD model renderer",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",