@guinetik/gcanvas 1.0.0 → 1.0.1

package/demos/js/tde/index.js

@@ -34,9 +34,9 @@ export class TDEDemo extends Game {
     this.updateScaledSizes();
 
     this.camera = new Camera3D({
-      rotationX: 0.3,
+      rotationX: 0.2,
       rotationY: 0,
-      rotationZ: 0,
+      rotationZ: 0.0,
       perspective: this.baseScale * 1.8, // Zoomed out for wider view
       autoRotate: true,
       autoRotateSpeed: 0.08,
@@ -81,13 +81,37 @@ export class TDEDemo extends Game {
     });
     applyAnchor(this.infoLabel, {
       anchor: Position.BOTTOM_LEFT,
-      anchorOffsetX: -60,
-      anchorMargin: 20,
+      anchorOffsetX: -70,
     });
     this.infoLabel.zIndex = 100;
     this.pipeline.add(this.infoLabel);
 
-    // Replay button (above phase text)
+    // Star View toggle button (above phase text)
+    this.starViewButton = new Button(this, {
+      width: 120,
+      height: 32,
+      text: "★ Star View",
+      font: "14px monospace",
+      colorDefaultBg: "rgba(0, 0, 0, 0.6)",
+      colorDefaultStroke: "#666",
+      colorDefaultText: "#aaa",
+      colorHoverBg: "rgba(30, 30, 30, 0.8)",
+      colorHoverStroke: "#44aaff",
+      colorHoverText: "#44aaff",
+      colorPressedBg: "rgba(50, 50, 50, 0.9)",
+      colorPressedStroke: "#66ccff",
+      colorPressedText: "#66ccff",
+      onClick: () => this.toggleStarView(),
+    });
+    applyAnchor(this.starViewButton, {
+      anchor: Position.BOTTOM_LEFT,
+      anchorMargin: 20,
+      anchorOffsetY: -30, // Above the phase text
+    });
+    this.starViewButton.zIndex = 100;
+    this.pipeline.add(this.starViewButton);
+
+    // Replay button (above star view button)
     this.replayButton = new Button(this, {
       width: 120,
       height: 32,
@@ -107,7 +131,7 @@ export class TDEDemo extends Game {
     applyAnchor(this.replayButton, {
       anchor: Position.BOTTOM_LEFT,
       anchorMargin: 20,
-      anchorOffsetY: -30, // Above the phase text
+      anchorOffsetY: -70, // Above the star view button
     });
     this.replayButton.zIndex = 100;
     this.pipeline.add(this.replayButton);
@@ -115,15 +139,22 @@ export class TDEDemo extends Game {
     // FPS Counter (bottom right)
     this.fpsCounter = new FPSCounter(this, {
       font: "12px monospace",
-      color: "#666",
-    });
-    applyAnchor(this.fpsCounter, {
       anchor: Position.BOTTOM_RIGHT,
-      anchorMargin: 20,
+      anchorMargin: 0,
+      color: "#00FF00",
     });
     this.fpsCounter.zIndex = 100;
     this.pipeline.add(this.fpsCounter);
 
+    // Camera Rotation Text (bottom right)
+    this.cameraRotationText = new Text(this, `Camera Rotation: X:${this.camera.rotationX.toFixed(2)} Y:${this.camera.rotationY.toFixed(2)} Z:${this.camera.rotationZ.toFixed(2)}`, {
+      font: "12px monospace",
+      anchor: Position.BOTTOM_CENTER,
+      color: "#ACACAC",
+    });
+    this.cameraRotationText.zIndex = 100;
+    this.pipeline.add(this.cameraRotationText);
+
     this.initStateMachine();
 
     // Initialize state properly (same as restart)
@@ -150,25 +181,26 @@ export class TDEDemo extends Game {
             if (star) {
               // === VIOLENT BRIGHTNESS FLARE ===
               star.tidalFlare = 2.0;
-              // Fade over 5 seconds
-              Tweenetik.to(star, { tidalFlare: 0 }, 5.0, Easing.easeOutQuad);
+              // Fade slowly - easeInQuad keeps it bright longer before dropping
+              Tweenetik.to(star, { tidalFlare: 0 }, 8.0, Easing.easeInQuad);
               
               // === GEOMETRY WOBBLE - comet-like trauma ===
               // Spike the wobble high - violent shaking
               star.tidalWobble = 1.2;
-              // Fade back to stable over 6 seconds (star tries to recover)
-              Tweenetik.to(star, { tidalWobble: 0.1 }, 6.0, Easing.easeOutElastic);
+              // Fade back to stable over 8 seconds (star tries to recover)
+              Tweenetik.to(star, { tidalWobble: 0.1 }, 8.0, Easing.easeOutElastic);
               
               // === SUDDEN STRETCH SPIKE - comet shape ===
               // Force immediate elongation like panels 2-3 in reference
               star.tidalStretch = 0.8;
               // Ease back toward spherical (but not fully - it can't recover)
-              Tweenetik.to(star, { tidalStretch: 0.2 }, 4.0, Easing.easeOutQuad);
+              Tweenetik.to(star, { tidalStretch: 0.3 }, 6.0, Easing.easeInQuad);
               
-              // === STRESS SPIKE ===
-              star.stressLevel = 0.6;
-              // Slowly calm down but not fully
-              Tweenetik.to(star, { stressLevel: 0.25 }, 5.0, Easing.easeOutQuad);
+              // === STRESS SPIKE (controls white color) ===
+              star.stressLevel = 0.8;
+              // Stay stressed longer - easeInQuad keeps it white before fading
+              // End at 0.4 (still visibly stressed, not back to original)
+              Tweenetik.to(star, { stressLevel: 0.4 }, 10.0, Easing.easeInQuad);
               
               // === PARTICLE BURST ===
               if (this.scene.stream) {
@@ -219,6 +251,41 @@ export class TDEDemo extends Game {
     });
   }
 
+  /**
+   * Toggle between star-following camera view and default view
+   */
+  toggleStarView() {
+    const star = this.scene.star;
+
+    if (this.camera.isFollowing()) {
+      // Switch back to default view
+      this.camera.unfollow(true); // true = animate back to initial position
+      this.starViewButton.text = "★ Star View";
+
+      // Re-enable auto-rotate
+      this.camera.autoRotate = true;
+    } else {
+      // Follow the star, looking at the black hole
+      // Position camera just above the star's surface (north pole perspective)
+      // Very close offset = immersive "standing on the star" feel
+      const offsetHeight = star.currentRadius * 0.3; // Just above surface
+
+      this.camera.follow(star, {
+        offsetX: 0,
+        offsetY: offsetHeight,  // Barely above the star's "north pole"
+        offsetZ: 0,
+        lookAt: true,
+        lookAtTarget: this.scene.bh, // Look at black hole
+        lerp: 0.12,  // Slightly snappier follow for immersion
+      });
+
+      this.starViewButton.text = "◉ BH View";
+
+      // Disable auto-rotate while following
+      this.camera.autoRotate = false;
+    }
+  }
+
   restart() {
     // Reset masses
     this.scene.bh.mass = CONFIG.blackHole.initialMass;
@@ -278,6 +345,21 @@ export class TDEDemo extends Game {
     // Reset velocity tracking to avoid spike after position reset
     this.scene.star.resetVelocity();
 
+    // Kill any lingering tweens on the star (from previous run's stretch phase)
+    Tweenetik.killTarget(this.scene.star);
+
+    // Reset star's tidal state (color, stress, stretch, etc.)
+    this.scene.star.tidalStretch = 0;
+    this.scene.star.pulsationPhase = 0;
+    this.scene.star.stressLevel = 0;
+    this.scene.star.tidalProgress = 0;
+    this.scene.star.tidalFlare = 0;
+    this.scene.star.tidalWobble = 0;
+    this.scene.star.angularVelocity = CONFIG.star.rotationSpeed ?? 0.5;
+    this.scene.star.rotation = 0;
+    this.scene.star.currentColor = null; // Force recalc
+    this.scene.star.updateVisual(); // Apply reset immediately
+
     // Clear tidal stream particles
     if (this.scene.stream) {
       this.scene.stream.clear();
@@ -310,6 +392,14 @@ export class TDEDemo extends Game {
       this.starField.lensingStrength = 0.15;
     }
 
+    // Reset camera to default view if following
+    if (this.camera.isFollowing()) {
+      this.camera.unfollow(false); // Don't animate, just reset
+      this.camera.reset();
+      if (this.starViewButton) this.starViewButton.text = "★ Star View";
+      this.camera.autoRotate = true;
+    }
+
     // Hide replay button
     if (this.replayButton) this.replayButton.visible = false;
 
@@ -381,6 +471,8 @@ export class TDEDemo extends Game {
     if (!this.fsm) return;
     this.fsm.update(dt);
 
+    this.cameraRotationText.text = `Camera Rotation: X:${this.camera.rotationX.toFixed(2)} Y:${this.camera.rotationY.toFixed(2)}`;
+
     const state = this.fsm.state;
     const progress = this.fsm.progress;
     const star = this.scene.star;
@@ -586,15 +678,42 @@ export class TDEDemo extends Game {
 
       const pos = polarToCartesian(star.orbitalRadius, star.phi);
 
-      // Vertical wobble - only after chaos builds
-      const verticalWobble = chaos > 0.01
-        ? Math.sin(time * 1.7) * chaos * baseRadius * 0.12
-        + Math.cos(time * 3.9) * chaos * baseRadius * 0.06
-        : 0;
+      // === ORBITAL PLANE TILT ===
+      // As chaos builds, the orbital plane itself starts wobbling
+      // This creates the effect of the orbit tilting dramatically
+      let tiltX = 0;  // Tilt around X-axis (makes orbit bob front-to-back)
+      let tiltZ = 0;  // Tilt around Z-axis (makes orbit bob left-to-right)
+
+      if (chaos > 0.005) {
+        // Max tilt in radians (~30 degrees = 0.52 rad) - very dramatic!
+        const maxTilt = 0.52 * (chaos / 0.6);  // Scale with chaos (0.6 is max chaos)
+
+        // Multiple frequencies for organic, unstable feel
+        // Slower base frequencies so the tilt is visible, faster harmonics for jitter
+        tiltX = Math.sin(time * 0.8) * maxTilt
+              + Math.sin(time * 2.1) * maxTilt * 0.5
+              + Math.sin(time * 4.5) * maxTilt * 0.15;  // High freq jitter
+        tiltZ = Math.cos(time * 0.6) * maxTilt * 0.8
+              + Math.sin(time * 1.9) * maxTilt * 0.4
+              + Math.cos(time * 5.2) * maxTilt * 0.1;   // High freq jitter
+      }
 
-      star.x = pos.x;
-      star.y = verticalWobble;
-      star.z = pos.z;
+      // Apply orbital plane tilt rotation
+      // Rotate around X-axis: affects Y and Z
+      const cosX = Math.cos(tiltX);
+      const sinX = Math.sin(tiltX);
+      let newY = -pos.z * sinX;
+      let newZ = pos.z * cosX;
+
+      // Rotate around Z-axis: affects X and Y
+      const cosZ = Math.cos(tiltZ);
+      const sinZ = Math.sin(tiltZ);
+      const finalX = pos.x * cosZ - newY * sinZ;
+      const finalY = pos.x * sinZ + newY * cosZ;
+
+      star.x = finalX;
+      star.y = finalY;
+      star.z = newZ;
 
       // Emit particles throughout disrupt phase (more than stretch)
       if (this.scene.stream && star.mass > 0) {
@@ -623,6 +742,12 @@ export class TDEDemo extends Game {
 
         // Trigger accrete state when star mass is depleted
         if (star.mass <= 0) {
+          // If camera was following the star, switch back to default view
+          if (this.camera.isFollowing()) {
+            this.camera.unfollow(true);
+            if (this.starViewButton) this.starViewButton.text = "★ Star View";
+            this.camera.autoRotate = true;
+          }
           this.fsm.trigger("starConsumed");
         }
       }

package/demos/js/tde/lensedstarfield.js

@@ -24,7 +24,8 @@ const LENSING_CONFIG = {
     minDistance: 5,
 
     // Occlusion radius multiplier (stars within BH radius * this are hidden)
-    occlusionMultiplier: 1.15,
+    // The dark shadow region extends to ~2.6x the event horizon (photon sphere)
+    occlusionMultiplier: 2.6,
 };
 
 export class LensedStarfield extends StarField {
@@ -68,49 +69,55 @@ export class LensedStarfield extends StarField {
         const lensingPower = LENSING_CONFIG.baseStrength * this.lensingStrength;
         const effectRadius = LENSING_CONFIG.effectRadiusPixels;
 
+        // Project black hole position once for all stars
+        // This is crucial when camera has moved (e.g., following the star)
+        const bhProjected = this.camera.project(0, 0, 0);
+        const bhScreenX = bhProjected.x;
+        const bhScreenY = bhProjected.y;
+
         Painter.useCtx((ctx) => {
             ctx.globalCompositeOperation = "source-over";
 
             for (const star of this.stars) {
-                // === CAMERA SPACE TRANSFORMATION ===
-                const cosY = Math.cos(this.camera.rotationY);
-                const sinY = Math.sin(this.camera.rotationY);
-                let xCam = star.x * cosY - star.z * sinY;
-                let zCam = star.x * sinY + star.z * cosY;
-
-                const cosX = Math.cos(this.camera.rotationX);
-                const sinX = Math.sin(this.camera.rotationX);
-                let yCam = star.y * cosX - zCam * sinX;
-                zCam = star.y * sinX + zCam * cosX;
+                // === USE CAMERA.PROJECT FOR PROPER POSITION HANDLING ===
+                // This accounts for camera position (translation) not just rotation
+                const projected = this.camera.project(star.x, star.y, star.z);
 
                 // Skip stars behind camera
-                if (zCam < -this.camera.perspective + 50) continue;
+                if (projected.scale <= 0) continue;
 
-                // === PERSPECTIVE PROJECTION ===
-                const perspectiveScale = this.camera.perspective / (this.camera.perspective + zCam);
-                let screenX = xCam * perspectiveScale;
-                let screenY = yCam * perspectiveScale;
+                let screenX = projected.x;
+                let screenY = projected.y;
+                const perspectiveScale = projected.scale;
+
+                // === GRAVITATIONAL LENSING (relative to BH screen position) ===
+                // Only apply to stars "behind" the black hole (positive z after projection)
+                if (lensingPower > 0 && projected.z > 0) {
+                    // Calculate position relative to BH's screen position
+                    const relX = screenX - bhScreenX;
+                    const relY = screenY - bhScreenY;
 
-                // === GRAVITATIONAL LENSING (screen space) ===
-                // Only apply to stars "behind" the black hole (zCam > 0)
-                if (lensingPower > 0 && zCam > 0) {
                     const lensed = applyGravitationalLensing(
-                        screenX, screenY,
+                        relX, relY,
                         effectRadius,
                         lensingPower,
                         LENSING_CONFIG.falloff,
                         LENSING_CONFIG.minDistance
                     );
-                    screenX = lensed.x;
-                    screenY = lensed.y;
+
+                    // Transform back to screen space
+                    screenX = lensed.x + bhScreenX;
+                    screenY = lensed.y + bhScreenY;
                 }
 
-                // === OCCLUSION CHECK ===
+                // === OCCLUSION CHECK (relative to BH screen position) ===
                 // Hide stars that fall within the black hole's occlusion radius
                 if (this.blackHole) {
                     const bhScreenRadius = this.blackHole.currentRadius * LENSING_CONFIG.occlusionMultiplier;
-                    const distFromCenter = Math.sqrt(screenX * screenX + screenY * screenY);
-                    if (distFromCenter < bhScreenRadius) continue;
+                    const dxBH = screenX - bhScreenX;
+                    const dyBH = screenY - bhScreenY;
+                    const distFromBH = Math.sqrt(dxBH * dxBH + dyBH * dyBH);
+                    if (distFromBH < bhScreenRadius) continue;
                 }
 
                 // Final screen position

package/demos/js/tde/tdestar.js

@@ -2,15 +2,12 @@ import { GameObject, Sphere3D } from "../../../src/index.js";
 import { polarToCartesian } from "../../../src/math/gr.js";
 import { CONFIG } from "./config.js";
 
-// Star shader configuration
-const STAR_SHADER_CONFIG = {
-    useShader: true,
-    shaderType: "star",
-    shaderUniforms: {
-        uStarColor: [1.0, 0.85, 0.3],  // Golden yellow
-        uTemperature: 5500,             // K (slightly cooler than Sun)
-        uActivityLevel: 0.75,            // Moderate surface activity
-    },
+// Performance tuning: reduce update frequency for expensive operations
+const PERF_CONFIG = {
+    geometryUpdateThreshold: 0.02,  // Only regenerate geometry if radius changes by 2%
+    uniformUpdateInterval: 2,        // Update shader uniforms every N frames
+    breathingEnabled: true,          // Toggle breathing effect
+    stressColorEnabled: true,        // Toggle dynamic color shifts
 };
 
 export class Star extends GameObject {
@@ -48,6 +45,11 @@ export class Star extends GameObject {
         this.tidalProgress = 0;     // External tidal progress from FSM (0-1)
         this.tidalFlare = 0;        // 0-1, sudden brightness burst at disruption start
         this.tidalWobble = 0;       // 0-1, violent geometry wobble during trauma
+
+        // Performance optimization state
+        this._frameCount = 0;
+        this._lastGeometryRadius = 0;
+        this._cachedUniforms = null;
     }
 
     init() {
@@ -93,109 +95,73 @@ export class Star extends GameObject {
         const massRatio = this.mass / this.initialMass;
 
         // === NON-LINEAR SIZE COLLAPSE ===
-        // Star resists at first (internal pressure), then collapses rapidly
-        // Use a power curve: slow start, rapid end
-        const collapseProgress = 1 - massRatio;  // 0 = full, 1 = gone
-        const resistanceCurve = Math.pow(collapseProgress, 0.5);  // sqrt = resists early
-        const effectiveMassRatio = 1 - resistanceCurve;
+        // Use sqrt for resistance curve (star resists early, then collapses)
+        const collapseProgress = 1 - massRatio;
+        const effectiveMassRatio = 1 - Math.sqrt(collapseProgress);
 
         // Base radius with non-linear collapse
         this.currentRadius = this.baseRadius * Math.max(0.05, effectiveMassRatio);
 
-        // Don't update geometry if star is consumed
+        // Don't update if star is consumed
         if (this.currentRadius <= 0 || this.mass <= 0) {
             return;
         }
 
-        // === TIDAL STRETCH (Spaghettification) ===
-        // Create comet/teardrop shape pointed toward black hole
-        const dist = Math.sqrt(this.x * this.x + (this.z || 0) * (this.z || 0)) || 1;
+        // === TIDAL STRETCH (Simplified) ===
+        const zVal = this.z || 0;
+        const distSq = this.x * this.x + zVal * zVal;
+        const dist = Math.sqrt(distSq) || 1;
+        const invDist = 1 / dist;
         
         // Direction toward black hole (unit vector)
-        let dirX = -this.x / dist;
-        let dirZ = -(this.z || 0) / dist;
+        const dirX = -this.x * invDist;
+        const dirZ = -zVal * invDist;
         
         // Proximity factor: closer to BH = more stretch
-        let proximityFactor = Math.max(0, 1 - dist / this.initialOrbitalRadius);
+        const proximityFactor = Math.max(0, 1 - dist / this.initialOrbitalRadius);
         
-        // Calculate stretch amount based on phase and proximity
+        // Simplified stretch calculation
         if (collapseProgress > 0.8) {
-            // Very late stage - reduce stretch as star becomes tiny
             this.tidalStretch = (1 - collapseProgress) * 2;
         } else {
-            // Main deformation: builds with tidalProgress and proximity
-            // tidalProgress is driven by FSM state (0 in approach, ramps in stretch/disrupt)
-            const baseStretch = this.tidalProgress * 1.2;  // Up to 1.2 stretch
-            const proximityBoost = proximityFactor * 0.5;  // Extra stretch when close
-            
-            this.tidalStretch = baseStretch + proximityBoost;
-            this.tidalStretch = Math.min(1.8, this.tidalStretch);  // Cap at 1.8
+            this.tidalStretch = Math.min(1.8, this.tidalProgress * 1.2 + proximityFactor * 0.5);
         }
 
-        // === BREATHING (Slow, ominous expansion/contraction) ===
-        // Very slow rhythm - like a dying star's final gasps
-        // No rapid bouncing - this should feel cosmic, not cartoonish
-        const breathingAmp = 0.03 * (1 - collapseProgress * 0.5);  // Subtle, weakens as disrupted
-        const breathing = Math.sin(this.pulsationPhase) * breathingAmp;
-
-        // Apply breathing to radius (very subtle)
-        this.currentRadius *= (1 + breathing);
+        // === BREATHING (Optional, can be disabled for performance) ===
+        if (PERF_CONFIG.breathingEnabled) {
+            const breathingAmp = 0.03 * (1 - collapseProgress * 0.5);
+            this.currentRadius *= (1 + Math.sin(this.pulsationPhase) * breathingAmp);
+        }
 
-        // === STRESS LEVEL ===
-        // Combines proximity and mass loss - drives surface chaos
-        // Use power curve so stress stays LOW for most of disruption, then ramps up sharply
-        // This gives more time to see the red-orange star with surface chaos
-        const rawStress = proximityFactor * 0.4 + collapseProgress * 0.6;  // Reduced weights
-        // Power of 3 = stays low longer, ramps up sharply at the end
-        this.stressLevel = Math.min(1, Math.pow(rawStress, 2.5));
+        // === STRESS LEVEL (Simplified power curve) ===
+        const rawStress = proximityFactor * 0.4 + collapseProgress * 0.6;
+        this.stressLevel = Math.min(1, rawStress * rawStress * rawStress);  // Cubic approximation
 
         // === ACTIVITY & ROTATION ===
-        const activityLevel = 0.3 + this.stressLevel * 0.7;  // 0.3 -> 1.0
-
-        // Angular momentum conservation: shrinking = faster spin
+        const activityLevel = 0.3 + this.stressLevel * 0.7;
         const baseRotationSpeed = CONFIG.star.rotationSpeed ?? 0.5;
-        const spinUpFactor = 1 / Math.max(0.2, effectiveMassRatio);  // Inverse of size
-        const rotationSpeed = Math.min(10, baseRotationSpeed * spinUpFactor);
-
-        // === COLOR SHIFT ===
-        // Start deep red-orange, transition through orange → yellow → white
-        // This lets us see the tidal chaos on a colorful surface before brightening
-        //
-        // Phase 1 (stress 0-0.5): Deep red-orange, surface chaos building
-        // Phase 2 (stress 0.5-0.8): Shift to orange-yellow, intense activity
-        // Phase 3 (stress 0.8-1.0): Rapid shift to white-hot, death throes
-
-        // Temperature increases with stress (tidal heating is real physics!)
-        const tempShift = this.stressLevel * this.stressLevel * 2500;  // Up to +2500K at max stress
-        const temperature = (CONFIG.star.temperature ?? 3800) + tempShift;
-
-        // Color transition: red-orange → orange → yellow → white
-        // R stays high, G increases with stress, B only increases late
-        let r = 1.0;
-        let g, b;
-
-        if (this.stressLevel < 0.5) {
-            // Phase 1: Deep red-orange → orange (stress 0-0.5)
-            const t = this.stressLevel * 2;  // 0 to 1 over this phase
-            g = 0.35 + t * 0.25;  // 0.35 → 0.6
-            b = 0.15 + t * 0.1;   // 0.15 → 0.25
-        } else if (this.stressLevel < 0.8) {
-            // Phase 2: Orange → yellow-orange (stress 0.5-0.8)
-            const t = (this.stressLevel - 0.5) / 0.3;  // 0 to 1
-            g = 0.6 + t * 0.2;    // 0.6 → 0.8
-            b = 0.25 + t * 0.1;   // 0.25 → 0.35
+        const rotationSpeed = Math.min(10, baseRotationSpeed / Math.max(0.2, effectiveMassRatio));
+
+        // === COLOR SHIFT (Simplified linear interpolation) ===
+        let r = 1.0, g, b;
+        const stress = this.stressLevel;
+        
+        if (PERF_CONFIG.stressColorEnabled) {
+            // Simplified color: lerp from red-orange to white based on stress
+            g = 0.35 + stress * 0.6;   // 0.35 → 0.95
+            b = 0.15 + stress * 0.7;   // 0.15 → 0.85
         } else {
-            // Phase 3: Yellow-orange → white-hot (stress 0.8-1.0)
-            const t = (this.stressLevel - 0.8) / 0.2;  // 0 to 1
-            g = 0.8 + t * 0.15;   // 0.8 → 0.95
-            b = 0.35 + t * 0.5;   // 0.35 → 0.85 (rapid blue increase = white)
+            g = 0.5;
+            b = 0.2;
         }
 
         const stressColor = [r, g, b];
-
-        // Expose current color for particle emission
         this.currentColor = stressColor;
 
+        // Temperature calculation
+        const temperature = (CONFIG.star.temperature ?? 3800) + stress * stress * 2500;
+
+        // === VISUAL UPDATE ===
         if (!this.visual) {
             this.visual = new Sphere3D(this.currentRadius, {
                 color: CONFIG.star.color,
@@ -215,23 +181,37 @@ export class Star extends GameObject {
                     uTidalWobble: this.tidalWobble,
                 },
             });
+            this._lastGeometryRadius = this.currentRadius;
         } else {
             this.visual.radius = this.currentRadius;
-            if (this.visual.useShader) {
-                this.visual.setShaderUniforms({
-                    uStarColor: stressColor,
-                    uTemperature: temperature,
-                    uActivityLevel: activityLevel,
-                    uRotationSpeed: rotationSpeed,
-                    uTidalStretch: this.tidalStretch,
-                    uStretchDirX: dirX,
-                    uStretchDirZ: dirZ,
-                    uStressLevel: this.stressLevel,
-                    uTidalFlare: this.tidalFlare,
-                    uTidalWobble: this.tidalWobble,
-                });
+            
+            // Only update shader uniforms every N frames
+            this._frameCount++;
+            if (this._frameCount >= PERF_CONFIG.uniformUpdateInterval) {
+                this._frameCount = 0;
+                
+                if (this.visual.useShader) {
+                    this.visual.setShaderUniforms({
+                        uStarColor: stressColor,
+                        uTemperature: temperature,
+                        uActivityLevel: activityLevel,
+                        uRotationSpeed: rotationSpeed,
+                        uTidalStretch: this.tidalStretch,
+                        uStretchDirX: dirX,
+                        uStretchDirZ: dirZ,
+                        uStressLevel: this.stressLevel,
+                        uTidalFlare: this.tidalFlare,
+                        uTidalWobble: this.tidalWobble,
+                    });
+                }
+            }
+            
+            // Only regenerate geometry if radius changed significantly
+            const radiusChange = Math.abs(this.currentRadius - this._lastGeometryRadius) / this._lastGeometryRadius;
+            if (radiusChange > PERF_CONFIG.geometryUpdateThreshold) {
+                this.visual._generateGeometry();
+                this._lastGeometryRadius = this.currentRadius;
             }
-            this.visual._generateGeometry();
         }
     }