@guinetik/gcanvas 1.0.4 → 1.0.5

package/dist/js/tde/accretiondisk.js

@@ -0,0 +1,471 @@
+import { GameObject, Painter, Tweenetik, Easing } from "/gcanvas.es.min.js";
+import { keplerianOmega } from "/gcanvas.es.min.js";
+import { CONFIG } from "./config.js";
+
+/**
+ * AccretionDisk - Keplerian particle disk with gravitational lensing
+ *
+ * Uses the same proven lensing formula as demos/js/blackhole.js:
+ * - Single-pass lensing that pushes particles outward
+ * - Einstein ring forms naturally from disk geometry
+ * - Doppler beaming for brightness variation
+ */
+
+const DISK_CONFIG = {
+    // Orbital bounds (multiplier of BH radius)
+    innerRadiusMultiplier: 1.5,
+    outerRadiusMultiplier: 9.0,    // Wide disk with margin from screen edges
+
+    // Particle properties
+    maxParticles: 10000,
+    particleLifetime: 1000,
+    spawnRate: 500,
+
+    // Orbital physics
+    baseOrbitalSpeed: 0.8,
+
+    // Decay mechanics
+    decayChanceBase: 0.0002,
+    decaySpeedFactor: 0.995,
+
+    // Disk geometry - thin disk with some spread
+    diskThickness: 0.006,
+
+    // Lensing - pushes particles outward to form Einstein ring
+    ringRadiusFactor: 1.8,      // Higher = more margin between BH and ring
+    lensingFalloff: 1.8,        // Slightly wider falloff
+
+    // Visual - heat gradient (white-hot inner to deep red outer)
+    colorHot: { r: 255, g: 250, b: 220 },   // Inner (white-hot)
+    colorMid: { r: 255, g: 160, b: 50 },    // Mid (orange)
+    colorCool: { r: 180, g: 40, b: 40 },    // Outer (deep red)
+
+    sizeMin: .8,
+    sizeMax: 1.2,
+};
+
+export class AccretionDisk extends GameObject {
+    constructor(game, options = {}) {
+        super(game, options);
+
+        this.camera = options.camera;
+        this.bhRadius = options.bhRadius ?? 50;
+        this.bhMass = options.bhMass ?? CONFIG.blackHole.initialMass;
+
+        // Disk bounds scale with BH radius
+        this.innerRadius = this.bhRadius * DISK_CONFIG.innerRadiusMultiplier;
+        this.outerRadius = this.bhRadius * DISK_CONFIG.outerRadiusMultiplier;
+
+        // State
+        this.active = false;
+        this.lensingStrength = 0;   // Ramps up during activation
+        this.scale = 0;             // For expand-from-BH animation
+
+        // Callback when particle falls into BH
+        this.onParticleConsumed = options.onParticleConsumed ?? null;
+
+        // Particle array
+        this.particles = [];
+    }
+
+    /**
+     * Activate disk with expand-from-center animation
+     */
+    activate() {
+        if (this.active) return;
+        this.active = true;
+        this.scale = 0.3;  // Start partially expanded so it's visible immediately
+        this.lensingStrength = 0;
+        // Expansion from BH center - 2 seconds (was 4, felt too slow)
+        Tweenetik.to(this, { scale: 1 }, 2.0, Easing.easeOutQuart);
+        // Lensing ramps up alongside scale
+        Tweenetik.to(this, { lensingStrength: 1 }, 2.5, Easing.easeOutQuad);
+    }
+
+    init() {
+        this.particles = [];
+    }
+
+    /**
+     * Get heat-based color for particle at given radius
+     */
+    getHeatColor(distance) {
+        const t = (distance - this.innerRadius) / (this.outerRadius - this.innerRadius);
+
+        let r, g, b;
+        if (t < 0.5) {
+            // Inner half: hot -> mid
+            const t2 = t * 2;
+            r = DISK_CONFIG.colorHot.r + (DISK_CONFIG.colorMid.r - DISK_CONFIG.colorHot.r) * t2;
+            g = DISK_CONFIG.colorHot.g + (DISK_CONFIG.colorMid.g - DISK_CONFIG.colorHot.g) * t2;
+            b = DISK_CONFIG.colorHot.b + (DISK_CONFIG.colorMid.b - DISK_CONFIG.colorHot.b) * t2;
+        } else {
+            // Outer half: mid -> cool
+            const t2 = (t - 0.5) * 2;
+            r = DISK_CONFIG.colorMid.r + (DISK_CONFIG.colorCool.r - DISK_CONFIG.colorMid.r) * t2;
+            g = DISK_CONFIG.colorMid.g + (DISK_CONFIG.colorCool.g - DISK_CONFIG.colorMid.g) * t2;
+            b = DISK_CONFIG.colorMid.b + (DISK_CONFIG.colorCool.b - DISK_CONFIG.colorMid.b) * t2;
+        }
+
+        return { r: Math.round(r), g: Math.round(g), b: Math.round(b) };
+    }
+
+    /**
+     * Spawn a new particle at random position in disk
+     */
+    spawnParticle() {
+        if (this.particles.length >= DISK_CONFIG.maxParticles) return;
+
+        // Balanced distribution with slight inner bias for lensing visibility
+        // Lower power = more particles near inner edge (where lensing is strongest)
+        const t = Math.pow(Math.random(), 0.6);
+        const distance = this.innerRadius + (this.outerRadius - this.innerRadius) * t;
+
+        const angle = Math.random() * Math.PI * 2;
+
+        // Keplerian orbital speed
+        const speed = keplerianOmega(distance, this.bhMass, DISK_CONFIG.baseOrbitalSpeed, this.outerRadius);
+
+        // Small vertical offset for thin disk
+        const baseScale = this.game.baseScale ?? Math.min(this.game.width, this.game.height);
+        const yOffset = (Math.random() - 0.5) * baseScale * DISK_CONFIG.diskThickness;
+
+        this.particles.push({
+            angle,
+            distance,
+            yOffset,
+            speed,
+            // Small random initial age prevents batch death
+            age: Math.random() * DISK_CONFIG.particleLifetime * 0.1,  // Only 10% spread
+            isFalling: false,
+            size: DISK_CONFIG.sizeMin + Math.random() * (DISK_CONFIG.sizeMax - DISK_CONFIG.sizeMin),
+            baseColor: this.getHeatColor(distance),
+        });
+    }
+
+    /**
+     * Capture a particle from the tidal stream
+     * Converts Cartesian stream particle to polar disk orbit
+     */
+    captureParticle(streamParticle) {
+        if (this.particles.length >= DISK_CONFIG.maxParticles) return;
+
+        const x = streamParticle.x;
+        const z = streamParticle.z;
+        const dist = Math.sqrt(x * x + z * z);
+
+        // Skip if outside disk bounds
+        if (dist < this.innerRadius || dist > this.outerRadius) return;
+
+        const angle = Math.atan2(z, x);
+
+        // Calculate tangential velocity from stream particle
+        const vx = streamParticle.vx ?? 0;
+        const vz = streamParticle.vz ?? 0;
+        const tangentVx = -z / dist;
+        const tangentVz = x / dist;
+        const tangentSpeed = vx * tangentVx + vz * tangentVz;
+
+        // Convert to angular velocity
+        const angularVelocity = Math.abs(tangentSpeed) / dist;
+
+        // Target Keplerian speed
+        const keplerianSpeed = keplerianOmega(dist, this.bhMass, DISK_CONFIG.baseOrbitalSpeed, this.outerRadius);
+
+        // Blend toward Keplerian (captured particles circularize)
+        const blendedSpeed = (angularVelocity + keplerianSpeed) / 2;
+
+        this.particles.push({
+            angle,
+            distance: dist,
+            yOffset: streamParticle.y ?? 0,
+            speed: blendedSpeed,
+            age: 0,
+            isFalling: false,
+            size: streamParticle.size ?? (DISK_CONFIG.sizeMin + Math.random() * (DISK_CONFIG.sizeMax - DISK_CONFIG.sizeMin)),
+            baseColor: this.getHeatColor(dist),
+        });
+    }
+
+    /**
+     * Check if particle should begin decay spiral
+     */
+    checkDecay(p) {
+        // Higher decay chance near ISCO (innermost stable circular orbit)
+        const iscoProximity = (p.distance - this.innerRadius) / (this.outerRadius - this.innerRadius);
+        const ageDecayFactor = Math.min(1, p.age / DISK_CONFIG.particleLifetime);
+
+        // Particles near inner edge or old ones are more likely to fall
+        const decayChance = DISK_CONFIG.decayChanceBase *
+            (1 + 3 * (1 - iscoProximity)) *
+            (1 + ageDecayFactor);
+
+        if (Math.random() < decayChance) {
+            p.isFalling = true;
+        }
+    }
+
+    update(dt) {
+        super.update(dt);
+
+        // Spawn new particles when active
+        if (this.active && this.particles.length < DISK_CONFIG.maxParticles) {
+            for (let i = 0; i < DISK_CONFIG.spawnRate; i++) {
+                this.spawnParticle();
+            }
+        }
+
+        // Update particles
+        for (let i = this.particles.length - 1; i >= 0; i--) {
+            const p = this.particles[i];
+            p.age += dt;
+
+            // Remove old particles
+            if (p.age > DISK_CONFIG.particleLifetime) {
+                this.particles.splice(i, 1);
+                continue;
+            }
+
+            if (p.isFalling) {
+                // Spiral inward - exponential decay
+                p.distance *= DISK_CONFIG.decaySpeedFactor;
+                p.angle += p.speed * dt * 2; // Accelerate as falls
+                p.yOffset *= 0.95; // Flatten toward equator
+
+                // Consumed by black hole
+                if (p.distance < this.bhRadius * 0.5) {
+                    this.particles.splice(i, 1);
+                    if (this.onParticleConsumed) {
+                        this.onParticleConsumed();
+                    }
+                    continue;
+                }
+            } else {
+                // Normal Keplerian orbit
+                p.angle += p.speed * dt;
+
+                // Check for decay
+                this.checkDecay(p);
+            }
+        }
+    }
+
+    /**
+     * Build render list with camera-space lensing
+     * Uses the proven formula from demos/js/blackhole.js
+     */
+    buildRenderList() {
+        const renderList = [];
+        if (!this.camera || this.particles.length === 0) return renderList;
+
+        const lensingStrength = this.lensingStrength;
+
+        for (const p of this.particles) {
+            // World coordinates (flat disk in x-z plane)
+            const scaledDist = p.distance * this.scale;
+            let x = Math.cos(p.angle) * scaledDist;
+            let y = p.yOffset * this.scale;
+            let z = Math.sin(p.angle) * scaledDist;
+
+            // Transform to camera space
+            const cosY = Math.cos(this.camera.rotationY);
+            const sinY = Math.sin(this.camera.rotationY);
+            let xCam = x * cosY - z * sinY;
+            let zCam = x * sinY + z * cosY;
+
+            const cosX = Math.cos(this.camera.rotationX);
+            const sinX = Math.sin(this.camera.rotationX);
+            let yCam = y * cosX - zCam * sinX;
+            zCam = y * sinX + zCam * cosX;
+
+            // === GRAVITATIONAL LENSING ===
+            // Creates the Interstellar effect: disk curves around BH
+
+            // Camera tilt: 0 when edge-on, 1 when top-down
+            const cameraTilt = Math.abs(Math.sin(this.camera.rotationX));
+            const isBehind = zCam > 0;
+            const currentR = Math.sqrt(xCam * xCam + yCam * yCam);
+
+            if (lensingStrength > 0 && currentR < this.bhRadius * 6) {
+                const ringRadius = this.bhRadius * DISK_CONFIG.ringRadiusFactor;
+                const lensFactor = Math.exp(-currentR / (this.bhRadius * DISK_CONFIG.lensingFalloff));
+                const warp = lensFactor * 1.2 * lensingStrength;
+
+                // Determine upper/lower half for asymmetric effects
+                const angleRelativeToCamera = p.angle + this.camera.rotationY;
+                const isUpperHalf = Math.sin(angleRelativeToCamera) > 0;
+
+                // === RADIAL PUSH: Curves particles around BH silhouette ===
+                // Bottom ring should have TIGHTER radius (less expansion) at edge-on views
+                // But stay symmetric at top-down views
+                if (currentR > 0) {
+                    let radialWarp = warp;
+
+                    // Edge-on factor: 1 at edge-on, 0 at top-down
+                    const edgeOnFactor = 1 - cameraTilt;
+
+                    // Reduce radial expansion for bottom half, but only at edge-on angles
+                    // This creates the tighter bottom ring radius seen in Interstellar
+                    if (!isUpperHalf && isBehind) {
+                        // At edge-on: bottom gets 40% of radial push (tight ring)
+                        // At top-down: bottom gets 100% (symmetric circle)
+                        radialWarp *= 1.0 - edgeOnFactor * 0.6;
+                    }
+
+                    const ratio = (currentR + ringRadius * radialWarp) / currentR;
+                    xCam *= ratio;
+                    yCam *= ratio;
+                }
+
+                // === VERTICAL CURVES: Only when camera is tilted ===
+                if (cameraTilt > 0.05) {
+                    // Arc shape - smooth curve
+                    const arcWidth = this.bhRadius * 5.0;
+                    const normalizedX = xCam / arcWidth;
+                    const arcCurve = Math.max(0, Math.cos(normalizedX * Math.PI * 0.5));
+
+                    // Depth factor - different for front vs back
+                    const depthFactor = isBehind
+                        ? Math.min(1.0, zCam / (this.bhRadius * 3))
+                        : Math.min(1.0, Math.abs(zCam) / (this.bhRadius * 3));
+
+                    // Ring height - scales with tilt
+                    const ringHeight = this.bhRadius * 2.0 * lensFactor * depthFactor * cameraTilt * lensingStrength;
+
+                    // Apply vertical displacement
+                    if (isBehind) {
+                        // Back particles: upper half UP, lower half DOWN
+                        if (isUpperHalf) {
+                            yCam -= ringHeight * arcCurve;
+                        } else {
+                            // Bottom ring: less vertical displacement too
+                            yCam += ringHeight * arcCurve * 0.5;
+                        }
+                    } else {
+                        // Front particles: curve DOWN slightly
+                        yCam += ringHeight * arcCurve * 0.4;
+                    }
+                }
+            }
+
+            // Perspective projection
+            const perspectiveScale = this.camera.perspective / (this.camera.perspective + zCam);
+            const screenX = xCam * perspectiveScale;
+            const screenY = yCam * perspectiveScale;
+
+            // Skip particles behind camera
+            if (zCam < -this.camera.perspective + 10) continue;
+
+            // Doppler beaming - approaching side brighter
+            const velocityDir = Math.cos(p.angle + this.camera.rotationY);
+            const doppler = 1 + velocityDir * 0.4;
+
+            // Age-based fade
+            const ageRatio = p.age / DISK_CONFIG.particleLifetime;
+            const alpha = Math.max(0.3, 1 - Math.pow(ageRatio, 2.5));
+
+            // Color (redshift for falling particles)
+            let color = p.baseColor;
+            if (p.isFalling) {
+                const fallProgress = 1 - (p.distance / this.innerRadius);
+                color = {
+                    r: Math.round(p.baseColor.r * (1 - fallProgress * 0.5)),
+                    g: Math.round(p.baseColor.g * (1 - fallProgress * 0.7)),
+                    b: Math.round(p.baseColor.b * (1 - fallProgress * 0.3)),
+                };
+            }
+
+            renderList.push({
+                x: screenX,
+                y: screenY,
+                z: zCam,
+                scale: perspectiveScale,
+                color,
+                doppler,
+                alpha,
+                size: p.size,
+            });
+        }
+
+        // Sort back to front for proper blending
+        renderList.sort((a, b) => b.z - a.z);
+        return renderList;
+    }
+
+    /**
+     * Clear all particles
+     */
+    clear() {
+        this.particles = [];
+    }
+
+    /**
+     * Update BH radius - also updates disk bounds since they scale with BH
+     * Particles inside the event horizon are consumed; others remain in place
+     * and will naturally be replaced by new spawns at correct radii
+     */
+    updateBHRadius(radius) {
+        this.bhRadius = radius;
+        // Disk bounds scale with BH radius
+        this.innerRadius = this.bhRadius * DISK_CONFIG.innerRadiusMultiplier;
+        this.outerRadius = this.bhRadius * DISK_CONFIG.outerRadiusMultiplier;
+
+        // Consume particles swallowed by event horizon (same threshold as update loop)
+        const consumeRadius = this.bhRadius * 0.5;
+        for (let i = this.particles.length - 1; i >= 0; i--) {
+            const p = this.particles[i];
+
+            if (p.distance < consumeRadius) {
+                this.particles.splice(i, 1);
+                if (this.onParticleConsumed) {
+                    this.onParticleConsumed();
+                }
+            }
+        }
+    }
+
+    render() {
+        super.render();
+
+        if (!this.active || !this.camera || this.particles.length === 0) return;
+
+        const cx = this.game.width / 2;
+        const cy = this.game.height / 2;
+        const baseScale = this.game.baseScale ?? Math.min(this.game.width, this.game.height);
+        const renderList = this.buildRenderList();
+
+        Painter.useCtx((ctx) => {
+            // Reset transform (bypass Scene3D transforms)
+            ctx.setTransform(1, 0, 0, 1, 0, 0);
+
+            for (const item of renderList) {
+                const { r, g, b } = item.color;
+                const size = baseScale * 0.003 * item.scale;
+                if (size < 0.1) continue;
+
+                // Apply Doppler brightness
+                const dr = Math.min(255, Math.round(r * item.doppler));
+                const dg = Math.min(255, Math.round(g * item.doppler * 0.95));
+                const db = Math.min(255, Math.round(b * item.doppler * 0.9));
+
+                const finalAlpha = Math.max(0, Math.min(1, item.alpha * item.doppler));
+
+                // Core particle
+                ctx.fillStyle = `rgba(${dr}, ${dg}, ${db}, ${finalAlpha})`;
+                ctx.beginPath();
+                ctx.arc(cx + item.x, cy + item.y, size / 2, 0, Math.PI * 2);
+                ctx.fill();
+
+                // Additive glow for bright/close particles (from blackhole.js)
+                if (item.doppler > 1.1 && item.alpha > 0.5) {
+                    ctx.globalCompositeOperation = "screen";
+                    ctx.fillStyle = `rgba(${dr}, ${dg}, ${db}, ${finalAlpha * 0.4})`;
+                    ctx.beginPath();
+                    ctx.arc(cx + item.x, cy + item.y, size, 0, Math.PI * 2);
+                    ctx.fill();
+                    ctx.globalCompositeOperation = "source-over";
+                }
+            }
+        });
+    }
+}

package/dist/js/tde/blackhole.js

@@ -0,0 +1,219 @@
+import { GameObject, Sphere3D, Painter, Easing } from "/gcanvas.es.min.js";
+import { CONFIG } from "./config.js";
+
+export class BlackHole extends GameObject {
+    constructor(game, options = {}) {
+        super(game, options);
+        this.mass = options.initialMass ?? CONFIG.blackHole.initialMass;
+        this.baseRadius = game.baseScale ? game.baseScale * CONFIG.bhRadiusRatio : 50;
+        this.currentRadius = this.baseRadius;
+
+        // Awakening state - BH starts dormant, wakes up as it feeds
+        this.awakeningLevel = 0;    // 0 = dormant (pure black), 1 = fully awake
+        this.feedingPulse = 0;      // Temporary glow boost when consuming
+        this.totalConsumed = 0;     // Track total mass consumed
+
+        // Dynamic growth animation
+        this.growthSpurt = 0;       // Overshoot when consuming (decays to 0)
+        this.breathPhase = 0;       // Oscillation phase for breathing effect
+        this.targetRadius = this.baseRadius;  // Smooth radius target
+
+        // Rotation - black holes spin!
+        this.rotation = 0;
+        this.rotationSpeed = options.rotationSpeed ?? 2.9; // Slow, ominous spin
+
+        // Use WebGL shaders for rendering
+        this.useShader = options.useShader ?? true;
+    }
+
+    init() {
+        this.updateVisual();
+    }
+
+    /**
+     * Add mass from consumed particles - triggers awakening and pulse
+     *
+     * @param {number} amount - Amount of mass to add
+     *
+     * Note: Feeding pulse is only triggered before the stable phase.
+     * Once stabilizing, particles can still be consumed but won't
+     * cause the visual pulse effect.
+     */
+    addConsumedMass(amount) {
+        this.totalConsumed += amount;
+
+        // Skip pulse effects if we're in the stable phase
+        if (this.isStabilizing) {
+            return;
+        }
+
+        // Awakening increases as BH feeds (slow ramp up)
+        const awakeningProgress = Math.min(1, this.totalConsumed * 0.1);
+        this.awakeningLevel = Math.max(this.awakeningLevel, awakeningProgress);
+
+        // Feeding pulse - temporary glow boost
+        this.feedingPulse = Math.min(1, this.feedingPulse + amount * 0.2);
+
+        // Growth spurt - overshoot effect when consuming
+        // More dramatic spurts as awakening increases
+        const spurtIntensity = 0.03 + this.awakeningLevel * 0.05;
+        this.growthSpurt = Math.min(0.15, this.growthSpurt + amount * spurtIntensity);
+    }
+
+    /**
+     * Reset to dormant state
+     */
+    resetAwakening() {
+        this.awakeningLevel = 0;
+        this.feedingPulse = 0;
+        this.totalConsumed = 0;
+        this.rotation = 0;
+        this.growthSpurt = 0;
+        this.breathPhase = 0;
+        this.isStabilizing = false;  // Reset stabilization state
+    }
+
+    updateVisual() {
+        // Calculate how much mass has been absorbed (0 = none, 1 = full star)
+        const massAbsorbed = Math.max(0, this.mass - CONFIG.blackHole.initialMass);
+        const absorptionProgress = massAbsorbed / CONFIG.star.initialMass;
+
+        // Apply easing to make growth feel more organic
+        // easeOutCubic: rapid initial growth that slows as it fills
+        const easedProgress = Easing.easeOutCubic(absorptionProgress);
+
+        // Base radius from absorption with easing
+        const baseScale = this.baseRadius / CONFIG.bhRadiusRatio;
+        const radiusFraction = CONFIG.bhRadiusRatio +
+            easedProgress * (CONFIG.bhFinalRadiusRatio - CONFIG.bhRadiusRatio);
+        this.targetRadius = baseScale * radiusFraction;
+
+        // Breathing oscillation - subtle when dormant, stronger when awake
+        const breathAmplitude = 0.01 + this.awakeningLevel * 0.02 + this.feedingPulse * 0.03;
+        const breathSpeed = 1.5 + this.awakeningLevel * 0.5;  // Faster when active
+        const breathOffset = Math.sin(this.breathPhase * breathSpeed) * breathAmplitude;
+
+        // Growth spurt overshoot effect (elastic rebound)
+        const spurtOffset = this.growthSpurt * (1 + Math.sin(this.breathPhase * 8) * 0.3);
+
+        // Combine all effects
+        this.currentRadius = this.targetRadius * (1 + breathOffset + spurtOffset);
+
+        if (this.currentRadius <= 0) {
+            this.currentRadius = this.baseRadius;
+        }
+
+        // Edge brightness increases with awakening
+        const awakeFactor = this.awakeningLevel;
+        const pulseFactor = this.feedingPulse;
+
+        // For Canvas 2D fallback - gradient rendering
+        // Dormant: pure black edges (#101010)
+        // Awake: warmer edges with hint of orange/red glow
+        const edgeBase = 16 + Math.round(awakeFactor * 24 + pulseFactor * 16); // 16-56
+        const edgeR = Math.min(255, edgeBase + Math.round(awakeFactor * 40 + pulseFactor * 60));
+        const edgeG = Math.min(255, edgeBase + Math.round(awakeFactor * 20 + pulseFactor * 30));
+        const edgeB = edgeBase;
+
+        const midBase = 8 + Math.round(awakeFactor * 12 + pulseFactor * 8);
+        const midR = Math.min(255, midBase + Math.round(awakeFactor * 20 + pulseFactor * 30));
+        const midG = Math.min(255, midBase + Math.round(awakeFactor * 10 + pulseFactor * 15));
+        const midB = midBase;
+
+        const gradient = Painter.colors.radialGradient(
+            0, 0, 0.01 * this.currentRadius,
+            0, 0, this.currentRadius,
+            [
+                { offset: 0, color: "#000" },
+                { offset: 0.5, color: "#000" },
+                { offset: 0.85, color: `rgb(${midR}, ${midG}, ${midB})` },
+                { offset: 1, color: `rgb(${edgeR}, ${edgeG}, ${edgeB})` },
+            ]
+        );
+
+        if (!this.core) {
+            this.core = new Sphere3D(this.currentRadius, {
+                color: gradient,
+                camera: this.game.camera,
+                stroke: null,   // No wireframe
+                debug: false,
+                segments: 32,   // Smoother sphere
+                // WebGL shader options
+                useShader: this.useShader,
+                shaderType: "blackHole",
+                shaderUniforms: {
+                    uAwakeningLevel: awakeFactor,
+                    uFeedingPulse: pulseFactor,
+                    uRotation: this.rotation,
+                },
+            });
+        } else {
+            this.core.radius = this.currentRadius;
+            this.core.color = gradient;  // Keep gradient for Canvas 2D fallback
+            // Update shader uniforms
+            if (this.core.useShader) {
+                this.core.setShaderUniforms({
+                    uAwakeningLevel: awakeFactor,
+                    uFeedingPulse: pulseFactor,
+                    uRotation: this.rotation,
+                });
+            }
+            this.core._generateGeometry();
+        }
+    }
+
+    update(dt) {
+        super.update(dt);
+
+        // Animate breathing phase
+        this.breathPhase += dt * Math.PI * 2;  // Full cycle per second
+
+        // Spin the black hole - rotation speeds up when feeding
+        const spinMultiplier = 1 + this.feedingPulse * 2 + this.awakeningLevel * 0.5;
+        this.rotation += this.rotationSpeed * spinMultiplier * dt;
+
+        // Decay feeding pulse over time
+        if (this.feedingPulse > 0) {
+            this.feedingPulse = Math.max(0, this.feedingPulse - dt * 1.5);
+        }
+
+        // Decay growth spurt with elastic damping
+        if (this.growthSpurt > 0) {
+            // Fast initial decay, slows down (feels like elastic settling)
+            const decayRate = 3 + this.growthSpurt * 5;  // Faster when larger
+            this.growthSpurt = Math.max(0, this.growthSpurt - dt * decayRate);
+        }
+
+        // Decay awakening level when stabilizing (slow cool-down)
+        // Minimum level is 0.3 - never goes fully dormant after feeding
+        if (this.isStabilizing && this.awakeningLevel > 0.3) {
+            this.awakeningLevel = Math.max(0.3, this.awakeningLevel - dt * 0.15);
+        }
+
+        this.updateVisual();
+    }
+
+    /**
+     * Start the stabilization phase - black hole calms down
+     */
+    startStabilizing() {
+        this.isStabilizing = true;
+    }
+
+    /**
+     * Reset stabilization state
+     */
+    resetStabilizing() {
+        this.isStabilizing = false;
+    }
+
+    onResize(baseRadius) {
+        this.baseRadius = baseRadius;
+        this.updateVisual();
+    }
+
+    render() {
+        super.render();
+        this.core.render();
+    }
+}