@guinetik/gcanvas 1.0.0

package/demos/js/tde/jets.js

@@ -0,0 +1,290 @@
+import { GameObject, Painter, Tweenetik, Easing } from "../../../src/index.js";
+
+/**
+ * RelativisticJets - Bipolar jets shooting from black hole poles
+ *
+ * Physics:
+ * - Particles ejected along ±Y axis (perpendicular to disk)
+ * - Conical spread gives characteristic jet shape
+ * - Velocity decreases with distance (deceleration)
+ * - Bright blue-white core fading to orange at edges
+ */
+
+const JET_CONFIG = {
+    // Particle properties
+    maxParticles: 6000,
+    particleLifetime: 8.0,      // Shorter lifetime - continuous turnover
+    spawnRatePerSecond: 800,    // Particles per SECOND (not per frame)
+
+    // Jet geometry
+    coneAngle: 0.06,            // Tight cone for focused beams
+    initialSpeed: 1200,         // Fast ejection - relativistic!
+    speedVariation: 300,        // Random variation in speed
+
+    // Jet length - shoots off screen
+    maxLength: 50000,           // Way off screen
+
+    // Visual - bright particles
+    colorCore: { r: 220, g: 240, b: 255 },    // Blue-white core
+    colorEdge: { r: 255, g: 160, b: 80 },     // Orange edge
+    sizeMin: 0.8,
+    sizeMax: 1.0,
+
+    // Animation
+    activationDuration: 0.3,    // Quick ignition
+    deactivationDuration: 5.0,  // Graceful fade
+};
+
+export class RelativisticJets extends GameObject {
+    constructor(game, options = {}) {
+        super(game, options);
+
+        this.camera = options.camera;
+        this.bhRadius = options.bhRadius ?? 50;
+
+        // State
+        this.active = false;
+        this.intensity = 0;     // 0-1, controls spawn rate and brightness
+        this.isDeactivating = false;  // Prevent multiple deactivate() calls
+
+        // Particle arrays - one for each jet (up and down)
+        this.particles = [];
+    }
+
+    init() {
+        this.particles = [];
+    }
+
+    /**
+     * Activate jets with intensity ramp-up
+     * Uses easeOutExpo for explosive ignition feel
+     */
+    activate() {
+        if (this.active) return;
+        this.active = true;
+        this.intensity = 0;
+        // Explosive start, then sustains - like jets igniting
+        Tweenetik.to(this, { intensity: 1 }, JET_CONFIG.activationDuration, Easing.easeOutExpo);
+    }
+
+    /**
+     * Deactivate jets with fade-out
+     */
+    deactivate() {
+        if (!this.active || this.isDeactivating) return;
+        this.isDeactivating = true;
+        // Slow graceful fade
+        Tweenetik.to(this, { intensity: 0 }, JET_CONFIG.deactivationDuration, Easing.easeInQuad, {
+            onComplete: () => {
+                this.active = false;
+                this.isDeactivating = false;
+            }
+        });
+    }
+
+    /**
+     * Pulse the jets - boost intensity for sustained firing
+     */
+    pulse() {
+        if (!this.active) return;
+        this.intensity = 1;
+        Tweenetik.to(this, { intensity: 0.6 }, 2.0, Easing.easeOutQuad);
+    }
+
+    /**
+     * Spawn jet particles from both poles
+     * @param {number} dt - Delta time for frame-rate independent spawning
+     */
+    spawnParticles(dt) {
+        if (this.particles.length >= JET_CONFIG.maxParticles) return;
+
+        // Frame-rate independent spawning
+        const spawnCount = Math.floor(JET_CONFIG.spawnRatePerSecond * dt * this.intensity);
+
+        for (let i = 0; i < spawnCount; i++) {
+            // Spawn from both poles (up and down)
+            const direction = Math.random() < 0.5 ? 1 : -1;
+
+            // Conical spread - random angle within cone
+            const spreadAngle = Math.random() * JET_CONFIG.coneAngle;
+            const azimuth = Math.random() * Math.PI * 2;
+
+            // Convert to velocity components
+            const speed = JET_CONFIG.initialSpeed +
+                (Math.random() - 0.5) * JET_CONFIG.speedVariation;
+
+            // Y is the main jet direction, x/z give the spread
+            const vy = direction * speed * Math.cos(spreadAngle);
+            const spreadMag = speed * Math.sin(spreadAngle);
+            const vx = spreadMag * Math.cos(azimuth);
+            const vz = spreadMag * Math.sin(azimuth);
+
+            // Start position - slightly offset from BH center along jet axis
+            const startOffset = this.bhRadius * 1.034;
+
+            this.particles.push({
+                x: vx * 0.01,   // Tiny initial spread
+                y: direction * startOffset,
+                z: vz * 0.01,
+                vx,
+                vy,
+                vz,
+                age: 0,
+                direction,      // Track which jet (for color)
+                size: JET_CONFIG.sizeMin + Math.random() * (JET_CONFIG.sizeMax - JET_CONFIG.sizeMin),
+                // Core particles (small spread) are brighter
+                isCore: spreadAngle < JET_CONFIG.coneAngle * 0.3,
+            });
+        }
+    }
+
+    update(dt) {
+        super.update(dt);
+
+        if (!this.active) return;
+
+        // Spawn new particles (dt-based for consistent rate)
+        this.spawnParticles(dt);
+
+        // Update existing particles
+        const maxDist = this.bhRadius * JET_CONFIG.maxLength;
+
+        for (let i = this.particles.length - 1; i >= 0; i--) {
+            const p = this.particles[i];
+            p.age += dt;
+
+            // Remove old particles
+            if (p.age > JET_CONFIG.particleLifetime) {
+                this.particles.splice(i, 1);
+                continue;
+            }
+
+            // Remove particles that traveled too far
+            const dist = Math.abs(p.y);
+            if (dist > maxDist) {
+                this.particles.splice(i, 1);
+                continue;
+            }
+
+            // No deceleration - relativistic jets maintain speed
+            // Particles stream continuously at near-constant velocity
+
+            // Move particle
+            p.x += p.vx * dt;
+            p.y += p.vy * dt;
+            p.z += p.vz * dt;
+        }
+    }
+
+    /**
+     * Build render list with camera projection
+     */
+    buildRenderList() {
+        const renderList = [];
+        if (!this.camera || this.particles.length === 0) return renderList;
+
+        for (const p of this.particles) {
+            // Transform to camera space
+            const cosY = Math.cos(this.camera.rotationY);
+            const sinY = Math.sin(this.camera.rotationY);
+            let xCam = p.x * cosY - p.z * sinY;
+            let zCam = p.x * sinY + p.z * cosY;
+
+            const cosX = Math.cos(this.camera.rotationX);
+            const sinX = Math.sin(this.camera.rotationX);
+            let yCam = p.y * cosX - zCam * sinX;
+            zCam = p.y * sinX + zCam * cosX;
+
+            // 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;
+
+            // Color: core is blue-white, edge is orange
+            // Also fade with distance from BH
+            const distFactor = Math.min(1, Math.abs(p.y) / (this.bhRadius * JET_CONFIG.maxLength * 0.5));
+            const ageFactor = 1 - (p.age / JET_CONFIG.particleLifetime);
+
+            let color;
+            if (p.isCore) {
+                // Core: bright blue-white
+                color = {
+                    r: JET_CONFIG.colorCore.r,
+                    g: JET_CONFIG.colorCore.g,
+                    b: JET_CONFIG.colorCore.b,
+                };
+            } else {
+                // Edge: lerp toward orange with distance
+                color = {
+                    r: JET_CONFIG.colorCore.r + (JET_CONFIG.colorEdge.r - JET_CONFIG.colorCore.r) * distFactor,
+                    g: JET_CONFIG.colorCore.g + (JET_CONFIG.colorEdge.g - JET_CONFIG.colorCore.g) * distFactor,
+                    b: JET_CONFIG.colorCore.b + (JET_CONFIG.colorEdge.b - JET_CONFIG.colorCore.b) * distFactor,
+                };
+            }
+
+            // Alpha based on age, intensity, and distance
+            const alpha = ageFactor * this.intensity * (1 - distFactor * 0.5);
+
+            renderList.push({
+                x: screenX,
+                y: screenY,
+                z: zCam,
+                scale: perspectiveScale,
+                color,
+                alpha,
+                size: p.size * (p.isCore ? 1.5 : 1),
+            });
+        }
+
+        // Sort back to front
+        renderList.sort((a, b) => b.z - a.z);
+        return renderList;
+    }
+
+    /**
+     * Clear all particles
+     */
+    clear() {
+        this.particles = [];
+        this.active = false;
+        this.intensity = 0;
+        this.isDeactivating = false;
+    }
+
+    /**
+     * Update BH radius
+     */
+    updateBHRadius(radius) {
+        this.bhRadius = radius;
+    }
+
+    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 renderList = this.buildRenderList();
+
+        Painter.useCtx((ctx) => {
+            // Reset transform
+            ctx.setTransform(1, 0, 0, 1, 0, 0);
+            ctx.globalCompositeOperation = "lighter";
+
+            for (const item of renderList) {
+                const { r, g, b } = item.color;
+
+                ctx.fillStyle = `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${item.alpha})`;
+                ctx.beginPath();
+                ctx.arc(cx + item.x, cy + item.y, item.size * item.scale, 0, Math.PI * 2);
+                ctx.fill();
+            }
+
+            ctx.globalCompositeOperation = "source-over";
+        });
+    }
+}

package/demos/js/tde/lensedstarfield.js

@@ -0,0 +1,147 @@
+/**
+ * LensedStarfield - Starfield with gravitational lensing around black hole
+ *
+ * Extends the base StarField to add camera-space lensing effects:
+ * - Stars behind the black hole are displaced radially outward
+ * - Creates the "Einstein ring" effect where light bends around massive objects
+ * - Lensing strength can be animated for dramatic effect
+ */
+import { Painter } from "../../../src/index.js";
+import { applyGravitationalLensing } from "../../../src/math/gr.js";
+import { StarField } from "../blackhole/starfield.obj.js";
+
+const LENSING_CONFIG = {
+    // How far the lensing effect reaches in screen pixels
+    effectRadiusPixels: 600,
+
+    // Base strength (multiplied by lensingStrength property)
+    baseStrength: 200,
+
+    // Falloff exponent - higher = tighter effect around BH
+    falloff: 0.008,
+
+    // Minimum screen distance to apply lensing (avoid division issues)
+    minDistance: 5,
+
+    // Occlusion radius multiplier (stars within BH radius * this are hidden)
+    occlusionMultiplier: 1.15,
+};
+
+export class LensedStarfield extends StarField {
+    /**
+     * @param {Game} game
+     * @param {Object} options
+     * @param {Camera3D} options.camera
+     * @param {BlackHole} options.blackHole - Reference to black hole for radius
+     * @param {number} options.starCount
+     */
+    constructor(game, options = {}) {
+        super(game, options);
+
+        // Reference to black hole (for radius and position)
+        this.blackHole = options.blackHole ?? null;
+
+        // Animated lensing strength (0 = off, 1 = full)
+        // Allows ramping up during disruption phases
+        this.lensingStrength = options.lensingStrength ?? 1.0;
+    }
+
+    /**
+     * Update black hole reference (if set after construction)
+     */
+    setBlackHole(bh) {
+        this.blackHole = bh;
+    }
+
+    /**
+     * Override render to apply gravitational lensing
+     */
+    render() {
+        // Skip parent render - we do our own with lensing
+        if (!this.camera) return;
+
+        const cx = this.game.width / 2;
+        const cy = this.game.height / 2;
+        const time = performance.now() / 1000;
+
+        // Lensing parameters (strength scales with lensingStrength property)
+        const lensingPower = LENSING_CONFIG.baseStrength * this.lensingStrength;
+        const effectRadius = LENSING_CONFIG.effectRadiusPixels;
+
+        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;
+
+                // Skip stars behind camera
+                if (zCam < -this.camera.perspective + 50) continue;
+
+                // === PERSPECTIVE PROJECTION ===
+                const perspectiveScale = this.camera.perspective / (this.camera.perspective + zCam);
+                let screenX = xCam * perspectiveScale;
+                let screenY = yCam * perspectiveScale;
+
+                // === GRAVITATIONAL LENSING (screen space) ===
+                // Only apply to stars "behind" the black hole (zCam > 0)
+                if (lensingPower > 0 && zCam > 0) {
+                    const lensed = applyGravitationalLensing(
+                        screenX, screenY,
+                        effectRadius,
+                        lensingPower,
+                        LENSING_CONFIG.falloff,
+                        LENSING_CONFIG.minDistance
+                    );
+                    screenX = lensed.x;
+                    screenY = lensed.y;
+                }
+
+                // === OCCLUSION CHECK ===
+                // 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;
+                }
+
+                // Final screen position
+                const finalX = cx + screenX;
+                const finalY = cy + screenY;
+
+                // Viewport cull
+                if (finalX < -30 || finalX > this.game.width + 30 ||
+                    finalY < -30 || finalY > this.game.height + 30) continue;
+
+                // === TWINKLE ===
+                const val = Math.sin(time * star.twinkleSpeed + star.twinklePhase);
+                const alpha = 0.6 + 0.4 * val;
+                if (alpha < 0.1) continue;
+
+                // === DRAW ===
+                const finalSize = star.type.baseSize * star.baseScale * perspectiveScale;
+                const sprite = this.sprites.get(star.type.type);
+                if (!sprite) continue;
+
+                ctx.globalAlpha = alpha;
+                ctx.drawImage(
+                    sprite,
+                    finalX - finalSize * 2,
+                    finalY - finalSize * 2,
+                    finalSize * 4,
+                    finalSize * 4
+                );
+            }
+
+            ctx.globalAlpha = 1.0;
+        });
+    }
+}