@joshtol/emotive-engine 3.3.4 → 3.3.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@joshtol/emotive-engine",
-  "version": "3.3.4",
+  "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);
             }
         }

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();
     }
 
     /**
@@ -1494,14 +1501,15 @@ export class ThreeRenderer {
             // === STEP 0: Render soul (layer 2) to texture for refraction sampling ===
             // OPTIMIZATION: Skip soul pass entirely if geometry doesn't have a soul
             if (this.soulRenderTarget && hasSoul) {
-                // Find soul mesh in scene (needed for screen center calculation)
-                let soulMesh = null;
-                this.scene.traverse(obj => {
-                    if (obj.name === 'crystalSoul') soulMesh = obj;
-                });
+                // 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)
@@ -1520,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 ===

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

@@ -291,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 },
@@ -420,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) {