Interactive Bioluminescent Particle Swarm: High-Performance Canvas UI

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Dynamic Kinetic Flow Field</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
        }

body {
            background-color: #08080c;
            overflow: hidden;
            width: 100vw;
            height: 100vh;
        }

#canvas {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            z-index: 1;
        }

.ui-container {
            position: absolute;
            bottom: 40px;
            left: 40px;
            z-index: 2;
            pointer-events: none;
            background: rgba(15, 15, 20, 0.4);
            backdrop-filter: blur(15px);
            -webkit-backdrop-filter: blur(15px);
            border: 1px solid rgba(255, 255, 255, 0.08);
            border-radius: 16px;
            padding: 24px;
            width: 320px;
            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.5);
        }

.header {
            margin-bottom: 20px;
        }

.title {
            color: #ffffff;
            font-size: 1.1rem;
            font-weight: 700;
            letter-spacing: 2px;
            text-transform: uppercase;
            margin-bottom: 4px;
            display: flex;
            align-items: center;
            gap: 10px;
        }

.status-dot {
            width: 8px;
            height: 8px;
            background-color: #00ffcc;
            border-radius: 50%;
            box-shadow: 0 0 10px #00ffcc;
            animation: pulse 2s infinite;
        }

.subtitle {
            color: #8892b0;
            font-size: 0.75rem;
            letter-spacing: 1px;
            text-transform: uppercase;
        }

.metrics {
            display: flex;
            flex-direction: column;
            gap: 12px;
        }

.metric-row {
            display: flex;
            justify-content: space-between;
            align-items: center;
            border-bottom: 1px solid rgba(255, 255, 255, 0.05);
            padding-bottom: 8px;
        }

.metric-label {
            color: #a8b2d1;
            font-size: 0.75rem;
            letter-spacing: 1px;
        }

.metric-value {
            color: #64ffda;
            font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
            font-size: 0.9rem;
            font-weight: 600;
        }

@keyframes pulse {
            0% { transform: scale(0.95); opacity: 0.5; }
            50% { transform: scale(1.2); opacity: 1; }
            100% { transform: scale(0.95); opacity: 0.5; }
        }
    </style>
</head>
<body>

<div class="ui-container">
        <div class="header">
            <div class="title">
                <div class="status-dot"></div>
                Orbital Swarm
            </div>
            <div class="subtitle">High-Performance Rendering</div>
        </div>
        <div class="metrics">
            <div class="metric-row">
                <span class="metric-label">Entity Count</span>
                <span class="metric-value" id="count-val">2500</span>
            </div>
            <div class="metric-row">
                <span class="metric-label">Avg Velocity</span>
                <span class="metric-value" id="vel-val">0.00 μ/s</span>
            </div>
            <div class="metric-row">
                <span class="metric-label">Render Engine</span>
                <span class="metric-value">Canvas 2D</span>
            </div>
        </div>
    </div>

let particles = [];
        let mouse = { x: width / 2, y: height / 2, active: false };
        let totalVelocity = 0;

window.addEventListener('resize', () => {
            width = canvas.width = window.innerWidth;
            height = canvas.height = window.innerHeight;
        });

window.addEventListener('mousemove', (e) => {
            mouse.x = e.clientX;
            mouse.y = e.clientY;
            mouse.active = true;
        });

window.addEventListener('mouseout', () => {
            mouse.active = false;
        });

class Particle {
            constructor() {
                this.x = Math.random() * width;
                this.y = Math.random() * height;
                this.vx = (Math.random() - 0.5) * 2;
                this.vy = (Math.random() - 0.5) * 2;
                this.size = Math.random() * 1.5 + 0.5;
                this.hue = Math.random() * 60 + 180;
            }

update() {
                let targetX = mouse.active ? mouse.x : width / 2;
                let targetY = mouse.active ? mouse.y : height / 2;

let dx = targetX - this.x;
                let dy = targetY - this.y;
                let dist = Math.sqrt(dx * dx + dy * dy);

if (dist < 400) {
                    let force = (400 - dist) / 400;
                    let angle = Math.atan2(dy, dx);
                    
                    this.vx += Math.cos(angle + Math.PI / 2) * force * 0.8;
                    this.vy += Math.sin(angle + Math.PI / 2) * force * 0.8;
                    
                    this.vx += Math.cos(angle) * force * 0.1;
                    this.vy += Math.sin(angle) * force * 0.1;
                } else if (!mouse.active) {
                    let angle = Math.atan2(height / 2 - this.y, width / 2 - this.x);
                    this.vx += Math.cos(angle) * 0.02;
                    this.vy += Math.sin(angle) * 0.02;
                }

this.vx *= 0.985;
                this.vy *= 0.985;

this.x += this.vx;
                this.y += this.vy;

if (this.x < 0) this.x = width;
                if (this.x > width) this.x = 0;
                if (this.y < 0) this.y = height;
                if (this.y > height) this.y = 0;

let speed = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
                totalVelocity += speed;
                
                this.hue = (speed * 20 + 180) % 360;
            }

draw() {
                ctx.fillStyle = `hsl(${this.hue}, 100%, 60%)`;
                ctx.fillRect(this.x, this.y, this.size, this.size);
            }
        }

const particleCount = 2500;
        for (let i = 0; i < particleCount; i++) {
            particles.push(new Particle());
        }

let frameCounter = 0;

function animate() {
            ctx.fillStyle = 'rgba(8, 8, 12, 0.12)';
            ctx.fillRect(0, 0, width, height);

totalVelocity = 0;

for (let i = 0; i < particleCount; i++) {
                particles[i].update();
                particles[i].draw();
            }

frameCounter++;
            if (frameCounter % 10 === 0) {
                let avgVel = totalVelocity / particleCount;
                velVal.textContent = `${avgVel.toFixed(2)} μ/s`;
            }

requestAnimationFrame(animate);
        }

animate();
    </script>
</body>
</html>

Interactive Bioluminescent Particle Swarm: High-Performance Canvas UI

You may like these posts :

Write Your Comment