@joshtol/emotive-engine 3.3.3 → 3.3.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@joshtol/emotive-engine",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "description": "Open-source animation engine for AI-controlled emotional visualizations with musical time synchronization",
   "main": "dist/emotive-mascot.umd.js",
   "module": "dist/mascot.js",

package/src/3d/Core3DManager.js

@@ -291,6 +291,8 @@ export class Core3DManager {
         this.glowColor = [1.0, 1.0, 1.0]; // RGB
         this.glowColorHex = '#FFFFFF'; // Hex color for luminance normalization
         this.glowIntensity = 1.0;
+        // OPTIMIZATION: Cache normalized color to avoid recalculating every frame
+        this._normalizedGlowColor = null;
         this.coreGlowEnabled = true; // Toggle to enable/disable core glow
         this.glowIntensityOverride = null; // Manual override for testing
         this.intensityCalibrationOffset = 0; // Universal filter calibration offset
@@ -419,6 +421,9 @@ export class Core3DManager {
                 this.glowColor = rgb;
                 // Store hex color for bloom luminance normalization
                 this.glowColorHex = emotionData.visual.glowColor;
+                // OPTIMIZATION: Pre-compute normalized color (avoids recalculating every frame)
+                const normalized = normalizeRGBLuminance(rgb, 0.30);
+                this._normalizedGlowColor = [normalized.r, normalized.g, normalized.b];
 
                 // Calculate intensity using universal filter based on color luminance
                 // This ensures consistent visibility across all emotions regardless of color brightness
@@ -1832,11 +1837,9 @@ export class Core3DManager {
                     this.customMaterial.uniforms.glowIntensity.value = effectiveGlowIntensity;
                 }
 
-                // Normalize emotion color for consistent perceived brightness across all emotions
+                // OPTIMIZATION: Use pre-computed normalized color (calculated when emotion changes)
                 // This ensures yellow (joy) doesn't wash out the soul while blue (sadness) stays visible
-                // IMPORTANT: Use glowColor (RGB), not glowColorHex - glowColor has undertone saturation applied
-                const normalized = normalizeRGBLuminance(this.glowColor, 0.30);
-                const normalizedColor = [normalized.r, normalized.g, normalized.b];
+                const normalizedColor = this._normalizedGlowColor || [1, 1, 1];
 
                 // Update emotion color on outer shell (luminance-normalized)
                 this.customMaterial.uniforms.emotionColor.value.setRGB(
@@ -1848,12 +1851,10 @@ export class Core3DManager {
                     this.customMaterial.uniforms.blinkIntensity.value = blinkPulse;
                 }
             }
-            // Update inner core color and animation (also use normalized color)
+            // Update inner core color and animation (also use cached normalized color)
             // Only update if core glow is enabled
-            // IMPORTANT: Use glowColor (RGB), not glowColorHex - glowColor has undertone saturation applied
             if (this.coreGlowEnabled) {
-                const normalizedCore = normalizeRGBLuminance(this.glowColor, 0.30);
-                const normalizedCoreColor = [normalizedCore.r, normalizedCore.g, normalizedCore.b];
+                const normalizedCoreColor = this._normalizedGlowColor || [1, 1, 1];
                 this.updateCrystalInnerCore(normalizedCoreColor, deltaTime);
             }
         }
@@ -1878,7 +1879,10 @@ export class Core3DManager {
             calibrationRotation: this.calibrationRotation,  // Applied on top of animated rotation
             solarEclipse: this.effectManager.getSolarEclipse(),  // Pass eclipse manager for synchronized updates
             deltaTime,  // Pass deltaTime for eclipse animation
-            morphProgress: morphState.isTransitioning ? morphState.visualProgress : null  // For corona fade-in
+            morphProgress: morphState.isTransitioning ? morphState.visualProgress : null,  // For corona fade-in
+            // OPTIMIZATION FLAGS: Skip render passes when not needed
+            hasSoul: this.customMaterialType === 'crystal' && this.crystalSoul !== null,
+            hasParticles: this.particleVisibility && this.particleOrchestrator !== null
         });
 
         // Update lunar eclipse animation (Blood Moon)

package/src/3d/ThreeRenderer.js

@@ -143,6 +143,13 @@ export class ThreeRenderer {
         this._zAxis = new THREE.Vector3(0, 0, 1);
         this._cameraToMesh = new THREE.Vector3();
         this._cameraDir = new THREE.Vector3();
+
+        // OPTIMIZATION: Reusable temp vector for soul position projection (avoids allocation per frame)
+        this._soulPosTemp = new THREE.Vector3();
+        // OPTIMIZATION: Cached soul mesh reference (avoids scene.traverse every frame)
+        this._cachedSoulMesh = null;
+        // OPTIMIZATION: Reusable Vector2 for drawing buffer size queries
+        this._drawingBufferSize = new THREE.Vector2();
     }
 
     /**
@@ -1270,6 +1277,8 @@ export class ThreeRenderer {
      * @param {number} [params.cameraRoll=0] - Camera-space roll rotation
      * @param {SolarEclipse} [params.solarEclipse=null] - Solar eclipse manager for synchronized updates
      * @param {number} [params.deltaTime=0] - Delta time for eclipse animation (seconds)
+     * @param {boolean} [params.hasSoul=false] - Whether this geometry has a soul layer (optimization)
+     * @param {boolean} [params.hasParticles=true] - Whether particles are enabled (optimization)
      */
     render(params = {}) {
         // Guard against calls after destroy
@@ -1347,7 +1356,9 @@ export class ThreeRenderer {
             cameraRoll = 0,  // Camera-space roll rotation applied after all other rotations
             solarEclipse = null,  // Solar eclipse manager for synchronized updates
             deltaTime = 0,  // Delta time for eclipse animation
-            morphProgress = null  // Morph progress for corona fade-in (null = no morph, 0-1 = morphing)
+            morphProgress = null,  // Morph progress for corona fade-in (null = no morph, 0-1 = morphing)
+            hasSoul = false,  // Whether this geometry has a soul layer (skip soul pass if false)
+            hasParticles = true  // Whether particles are enabled (skip particle pass if false)
         } = params;
 
         // Update camera controls FIRST before any rendering
@@ -1488,15 +1499,17 @@ export class ThreeRenderer {
         // Render with post-processing if enabled, otherwise direct render
         if (this.composer) {
             // === STEP 0: Render soul (layer 2) to texture for refraction sampling ===
-            if (this.soulRenderTarget) {
-                // Find soul mesh in scene (needed for screen center calculation)
-                let soulMesh = null;
-                this.scene.traverse(obj => {
-                    if (obj.name === 'crystalSoul') soulMesh = obj;
-                });
+            // OPTIMIZATION: Skip soul pass entirely if geometry doesn't have a soul
+            if (this.soulRenderTarget && hasSoul) {
+                // OPTIMIZATION: Use cached soul mesh reference instead of traversing every frame
+                if (!this._cachedSoulMesh) {
+                    this.scene.traverse(obj => {
+                        if (obj.name === 'crystalSoul') this._cachedSoulMesh = obj;
+                    });
+                }
+                const soulMesh = this._cachedSoulMesh;
 
                 this.renderer.setRenderTarget(this.soulRenderTarget);
-                this.renderer.setClearColor(0x000000, 0);
                 this.renderer.clear();
 
                 // Render only soul layer (layer 2)
@@ -1515,17 +1528,17 @@ export class ThreeRenderer {
                     }
                     // Compute soul's screen center position for refraction sampling
                     if (this.coreMesh.material.uniforms.soulScreenCenter && soulMesh) {
-                        const soulWorldPos = soulMesh.position.clone();
-                        const soulNDC = soulWorldPos.project(this.camera);
+                        // OPTIMIZATION: Reuse pooled vector instead of cloning every frame
+                        this._soulPosTemp.copy(soulMesh.position);
+                        this._soulPosTemp.project(this.camera);
                         // Convert from NDC (-1 to 1) to UV (0 to 1)
-                        const soulScreenU = (soulNDC.x + 1.0) * 0.5;
-                        const soulScreenV = (soulNDC.y + 1.0) * 0.5;
+                        const soulScreenU = (this._soulPosTemp.x + 1.0) * 0.5;
+                        const soulScreenV = (this._soulPosTemp.y + 1.0) * 0.5;
                         this.coreMesh.material.uniforms.soulScreenCenter.value.set(soulScreenU, soulScreenV);
                     }
                 }
 
                 this.renderer.setRenderTarget(null);
-                this.renderer.setClearColor(0x000000, 0);
             }
 
             // === STEP 1: Render main scene (layer 0) through bloom to screen ===
@@ -1533,7 +1546,8 @@ export class ThreeRenderer {
             this.composer.render();
 
             // === STEP 2: Render particles (layer 1) to separate render target ===
-            if (this.particleRenderTarget && this.particleBloomPass) {
+            // OPTIMIZATION: Skip particle pass entirely if particles are disabled
+            if (hasParticles && this.particleRenderTarget && this.particleBloomPass) {
                 // Clear particle render target with WHITE (non-black) to prevent dark halos
                 this.renderer.setRenderTarget(this.particleRenderTarget);
                 this.renderer.setClearColor(0xffffff, 0); // White RGB, but 0 alpha
@@ -1565,7 +1579,7 @@ export class ThreeRenderer {
                 // Reset clear color
                 this.renderer.setClearColor(0x000000, 0);
                 this.renderer.setRenderTarget(null);
-            } else {
+            } else if (hasParticles) {
                 // Fallback: Render particles directly (no bloom)
                 this.camera.layers.set(1);
                 this.renderer.render(this.scene, this.camera);

package/src/3d/effects/CrystalSoul.js

@@ -95,18 +95,14 @@ const soulFragmentShader = `
 
         if (driftEnabled > 0.5) {
             float t = time * driftSpeed;
-            // Primary drift - moving in one direction
+            // OPTIMIZED: Reduced from 4 noise calls to 2 for better performance
+            // Primary drift - single noise call with combined coordinates
             float drift1 = noise3D(vPosition * 2.0 + vec3(t, t * 0.7, t * 0.3));
-            float drift2 = noise3D(vPosition * 3.0 - vec3(t * 0.5, t, t * 0.8));
-            // Use max instead of multiply to avoid near-zero products
-            primaryDrift = max(drift1, drift2);
-            primaryDrift = max(0.0, primaryDrift - 0.4) * 2.0; // Rescale after threshold
+            primaryDrift = max(0.0, drift1 - 0.3) * 1.5; // Adjusted threshold for single noise
 
-            // Secondary drift - offset in opposite direction to fill gaps
-            float drift3 = noise3D(vPosition * 2.5 - vec3(t * 0.8, t * 0.4, t));
-            float drift4 = noise3D(vPosition * 1.8 + vec3(t * 0.6, t * 0.9, t * 0.2));
-            secondaryDrift = max(drift3, drift4);
-            secondaryDrift = max(0.0, secondaryDrift - 0.4) * 2.0;
+            // Secondary drift - offset phase to fill gaps
+            float drift2 = noise3D(vPosition * 2.5 - vec3(t * 0.6, t * 0.4, t));
+            secondaryDrift = max(0.0, drift2 - 0.3) * 1.5;
 
             driftEnergy = primaryDrift + secondaryDrift;
         }
@@ -295,7 +291,7 @@ export class CrystalSoul {
             uniforms: {
                 time: { value: 0 },
                 emotionColor: { value: new THREE.Color(1, 1, 1) },
-                energyIntensity: { value: 1.5 },
+                energyIntensity: { value: 0.8 },  // Fixed value - no per-frame update needed
                 driftEnabled: { value: 1.0 },
                 driftSpeed: { value: 0.5 },
                 crossWaveEnabled: { value: 1.0 },
@@ -424,17 +420,15 @@ export class CrystalSoul {
             uniforms.time.value += deltaTime / 1000;
         }
 
-        // Update emotion color
+        // Update emotion color only if changed (avoid unnecessary GPU uniform sync)
         if (uniforms.emotionColor && glowColor) {
-            uniforms.emotionColor.value.setRGB(
-                glowColor[0], glowColor[1], glowColor[2]
-            );
+            const current = uniforms.emotionColor.value;
+            if (current.r !== glowColor[0] || current.g !== glowColor[1] || current.b !== glowColor[2]) {
+                current.setRGB(glowColor[0], glowColor[1], glowColor[2]);
+            }
         }
 
-        // Fixed intensity matching original implementation
-        if (uniforms.energyIntensity) {
-            uniforms.energyIntensity.value = 0.8;
-        }
+        // Note: energyIntensity is fixed at 0.8 (set in constructor, no per-frame update needed)
 
         // Apply breathing scale
         if (this.mesh) {