Heim > Artikel > Web-Frontend > Bildschirm „Flussfeld“.

Bildschirm „Flussfeld“.

Susan SarandonOriginal: 2024-10-03 20:18:29528Durchsuche

Flow Field Screen

Dynamische Flussfelder mit Vanilla JS und HTML Canvas

Waren Sie jemals von abstrakten Partikelanimationen fasziniert? Diese fließenden, dynamischen Grafiken können mit überraschend einfachen Techniken unter Verwendung von einfachem JavaScript und dem HTML-Canvas-Element erreicht werden. In diesem Artikel werden wir den Prozess der Schaffung eines Strömungsfeldes aufschlüsseln, das Tausende von Partikeln animiert und ihnen eine natürliche Bewegung verleiht.

1. Einrichten des Projekts

Zu Beginn benötigen wir drei Dateien: eine HTML-Datei zum Einrichten der Leinwand, eine CSS-Datei für das Styling und eine JavaScript-Datei für die Handhabung der Logik.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flow Fields</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <canvas id="canvas1"></canvas>
    <script src="script.js"></script>
</body>
</html>

Erläuterung:

Wir definieren ein
Die Datei „styles.css“ wird verlinkt, um die Leinwand zu formatieren.
Die Hauptanimationslogik ist in script.js enthalten.

2. Gestalten Sie die Leinwand mit CSS

Fügen wir einen einfachen Stil hinzu, um unserer Leinwand einen schwarzen Hintergrund zu geben und stellen Sie sicher, dass alle Polsterungen und Ränder entfernt werden.

* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

canvas {
    background-color: black;
}

Erläuterung:

Wenn Sie den Rand und den Abstand auf Null setzen, wird sichergestellt, dass die Leinwand den gesamten Bildschirm ausfüllt.
Der schwarze Hintergrund bietet einen schönen Kontrast zu den weißen Partikeln.

3. Partikelklasse: Die Magie erschaffen

In der Particle-Klasse liegt der Kern der Animation. Jedes Partikel bewegt sich über die Leinwand und hinterlässt eine Spur seiner früheren Positionen, wodurch der fließende Effekt entsteht.

class Particle {
    constructor(effect) {
        this.effect = effect;
        this.x = Math.floor(Math.random() * this.effect.width);
        this.y = Math.floor(Math.random() * this.effect.height);
        this.speedModifier = Math.floor(Math.random() * 5 + 1);
        this.history = [{ x: this.x, y: this.y }];
        this.maxLength = Math.floor(Math.random() * 200 + 10);
        this.timer = this.maxLength * 2;
        this.colors = ['#4C026B', '#8E0E00', '#9D0208', '#BA1A1A', '#730D9E'];
        this.color = this.colors[Math.floor(Math.random() * this.colors.length)];
    }

    draw(context) {
        context.beginPath();
        context.moveTo(this.history[0].x, this.history[0].y);
        for (let i = 1; i < this.history.length; i++) {
            context.lineTo(this.history[i].x, this.history[i].y);
        }
        context.strokeStyle = this.color;
        context.stroke();
    }

    update() {
        this.timer--;
        if (this.timer >= 1) {
            let x = Math.floor(this.x / this.effect.cellSize);
            let y = Math.floor(this.y / this.effect.cellSize);
            let index = y * this.effect.cols + x;
            let angle = this.effect.flowField[index];

            this.speedX = Math.cos(angle);
            this.speedY = Math.sin(angle);
            this.x += this.speedX * this.speedModifier;
            this.y += this.speedY * this.speedModifier;

            this.history.push({ x: this.x, y: this.y });
            if (this.history.length > this.maxLength) {
                this.history.shift();
            }
        } else if (this.history.length > 1) {
            this.history.shift();
        } else {
            this.reset();
        }
    }

    reset() {
        this.x = Math.floor(Math.random() * this.effect.width);
        this.y = Math.floor(Math.random() * this.effect.height);
        this.history = [{ x: this.x, y: this.y }];
        this.timer = this.maxLength * 2;
    }
}

Erläuterung:

Konstruktor: Jedes Partikel wird mit einer zufälligen Position und Bewegungsgeschwindigkeit initialisiert. Das Verlaufsarray verfolgt vergangene Positionen, um Spuren zu erstellen.
draw(): Diese Funktion zeichnet den Pfad des Partikels basierend auf seinem Verlauf. Das Partikel hinterlässt eine bunte Spur, die den visuellen Effekt verstärkt.
update(): Hier wird die Position des Partikels durch Berechnung des Winkels aus dem Strömungsfeld aktualisiert. Geschwindigkeit und Richtung werden durch trigonometrische Funktionen gesteuert.
reset(): Wenn das Partikel seine Spur beendet, wird es an eine neue zufällige Position zurückgesetzt.

4. Effektklasse: Organisieren der Animation

Die Effektklasse kümmert sich um die Erzeugung von Partikeln und das Strömungsfeld selbst, das die Bewegung der Partikel steuert.

class Effect {
    constructor(canvas) {
        this.canvas = canvas;
        this.width = this.canvas.width;
        this.height = this.canvas.height;
        this.particles = [];
        this.numberOfParticles = 3000;
        this.cellSize = 20;
        this.flowField = [];
        this.curve = 5;
        this.zoom = 0.12;
        this.debug = true;
        this.init();
    }

    init() {
        this.rows = Math.floor(this.height / this.cellSize);
        this.cols = Math.floor(this.width / this.cellSize);
        for (let y = 0; y < this.rows; y++) {
            for (let x = 0; x < this.cols; x++) {
                let angle = (Math.cos(x * this.zoom) + Math.sin(y * this.zoom)) * this.curve;
                this.flowField.push(angle);
            }
        }
        for (let i = 0; i < this.numberOfParticles; i++) {
            this.particles.push(new Particle(this));
        }
    }

    drawGrid(context) {
        context.save();
        context.strokeStyle = 'white';
        context.lineWidth = 0.3;
        for (let c = 0; c < this.cols; c++) {
            context.beginPath();
            context.moveTo(c * this.cellSize, 0);
            context.lineTo(c * this.cellSize, this.height);
            context.stroke();
        }
        for (let r = 0; r < this.rows; r++) {
            context.beginPath();
            context.moveTo(0, r * this.cellSize);
            context.lineTo(this.width, r * this.cellSize);
            context.stroke();
        }
        context.restore();
    }

    render(context) {
        if (this.debug) this.drawGrid(context);
        this.particles.forEach(particle => {
            particle.draw(context);
            particle.update();
        });
    }
}

Erläuterung:

Konstruktor: Initialisiert die Leinwandabmessungen, die Anzahl der Partikel und das Strömungsfeld.
init(): Berechnet die Winkel für das Strömungsfeld durch Kombination trigonometrischer Funktionen für jede Gitterzelle. Dieses Feld beeinflusst, wie sich Partikel bewegen.
drawGrid(): Zeichnet das Raster, das die Leinwand in Zellen unterteilt und beim Debuggen verwendet wird.
render(): Ruft die Zeichen- und Aktualisierungsmethoden für jedes Partikel auf, um die Partikel auf der Leinwand zu animieren.

5. Erwecken Sie es mit der Animationsschleife zum Leben

Damit alles funktioniert, benötigen wir eine Animationsschleife, die die Leinwand kontinuierlich löscht und die Partikel neu rendert:

const effect = new Effect(canvas);

function animate() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    effect.render(ctx);
    requestAnimationFrame(animate);
}
animate();

Erläuterung:

clearRect(): Löscht die Leinwand in jedem Frame, um ein Überschreiben vorheriger Frames zu vermeiden.
requestAnimationFrame: Hält die Animation flüssig, indem die Funktion animate() rekursiv aufgerufen wird.

Abschluss

Durch die Aufschlüsselung der Partikel- und Effektklassen haben wir eine flüssige und dynamische Strömungsfeldanimation erstellt, die nur Vanilla-JavaScript verwendet. Die Einfachheit des HTML-Canvas in Kombination mit den trigonometrischen Funktionen von JavaScript ermöglicht es uns, diese faszinierenden visuellen Effekte zu erstellen.

Fühlen Sie sich frei, mit der Partikelanzahl, den Farben oder der Strömungsfeldformel herumzuspielen, um Ihre eigenen einzigartigen Effekte zu erzielen!

Das obige ist der detaillierte Inhalt vonBildschirm „Flussfeld“.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

JavaScript css html Array define count for break using class JS number function constructor this location history position margin padding background animation canvas everything

Stellungnahme：

Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Vorheriger Artikel：(Die einzige aktuelle Alternative: Vanilla JavaScriptNächster Artikel：(Die einzige aktuelle Alternative: Vanilla JavaScript

In Verbindung stehende Artikel

Mehr sehen