@guinetik/gcanvas 1.0.2 → 1.0.4

package/demos/js/tde/jets.js

@@ -1,290 +0,0 @@
-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

@@ -1,154 +0,0 @@
-/**
- * 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)
-    // The dark shadow region extends to ~2.6x the event horizon (photon sphere)
-    occlusionMultiplier: 2.6,
-};
-
-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;
-
-        // 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) {
-                // === 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 (projected.scale <= 0) continue;
-
-                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;
-
-                    const lensed = applyGravitationalLensing(
-                        relX, relY,
-                        effectRadius,
-                        lensingPower,
-                        LENSING_CONFIG.falloff,
-                        LENSING_CONFIG.minDistance
-                    );
-
-                    // Transform back to screen space
-                    screenX = lensed.x + bhScreenX;
-                    screenY = lensed.y + bhScreenY;
-                }
-
-                // === 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 dxBH = screenX - bhScreenX;
-                    const dyBH = screenY - bhScreenY;
-                    const distFromBH = Math.sqrt(dxBH * dxBH + dyBH * dyBH);
-                    if (distFromBH < 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;
-        });
-    }
-}