std.vector — 2D-Vektoren

→ Zurück zur Unit-Übersicht

Vektorrechnung mit dem Typ Vec2 — zwei int64-Felder x und y. Es wird ganzzahlig gerechnet: keine Fließkommazahlen, keine FPU. Wo Nachkommastellen unvermeidlich sind (Normalisieren, Interpolieren), arbeitet die Unit mit Festkomma zum Faktor 1 000 000.

Einsatzbereiche: Basistyp für std.rect und std.circle, Spiellogik, Bildschirmkoordinaten.

Autor: Andreas Röne
Copyright: 2024–2025 Andreas Röne
Quelle: std/vector.lyx

<WRAP info> Seit lyxc 1.0.20F rechnen alle fünf früher fehlerhaften Funktionen richtig (#1476, #1477 samt der Winkelursache #1444, #1447):

Vec2Project((3,4), (1,0))    = (3000, 0)
Vec2Rotate((1,0), 90°)       = (0, 1000)
Vec2Heading((1,0))           = 0
Vec2Reflect((1,0), (0,1))    = (1000, 0)

Die Winkel werden in Mikrograd übergeben — Vec2Rotate(v, 90000000) dreht um 90°. Das entspricht der Umstellung in std.math; wer Grad einsetzt, dreht praktisch um null. </WRAP>

import std.vector;

Zieht std.math als Abhängigkeit mit.

Ein Vec2 ist ein einfacher Verbund und wird als Wert übergeben — Zuweisungen kopieren, es gibt nichts freizugeben. Die Bedeutung der Einheiten legt der Aufrufer fest: Pixel, Millimeter, Mikro-Pixel.

Festkomma zum Faktor 1 000 000. Drei Stellen arbeiten mit diesem Maßstab:

Für Vergleiche „welcher Punkt ist näher„ immer die quadrierten Varianten nehmen: sie sind exakt und sparen die Wurzel. Vec2Length rundet ab — die Länge von (1,1) ist 1, nicht 1,41.

Die festen Drehungen kommen ohne Trigonometrie aus — sie tauschen und negieren nur Komponenten und sind deshalb exakt. Wo ein rechter Winkel genügt, sind sie der richtige Weg.

import std.vector;

fn zeig(name: pchar, v: Vec2): void {
    PrintLn(name, " = (", IntToStr(v.x), ", ", IntToStr(v.y), ")");
}

fn main(): int64 {
    var a: Vec2 := Vec2New(3, 4);
    var b: Vec2 := Vec2New(1, 2);

    zeig("a           ", a);
    zeig("a + b       ", Vec2Add(a, b));
    zeig("a - b       ", Vec2Sub(a, b));
    zeig("a * 3       ", Vec2Mul(a, 3));
    PrintLn("Dot(a,b)     = ", IntToStr(Vec2Dot(a, b)), "   (3*1 + 4*2)");
    PrintLn("Cross(a,b)   = ", IntToStr(Vec2Cross(a, b)), "   (3*2 - 4*1)");
    PrintLn("LengthSquared = ", IntToStr(Vec2LengthSquared(a)));
    PrintLn("Length        = ", IntToStr(Vec2Length(a)), "   (ganzzahlig abgerundet)");

    // Normalisieren liefert Festkomma mit Faktor 1 000 000
    zeig("Normalize(3,4)", Vec2Normalize(a));
    PrintLn("   600000/1000000 = 0,6 und 800000/1000000 = 0,8");

    // Feste Drehungen brauchen keine Trigonometrie
    zeig("Rotate90      ", Vec2Rotate90(a));
    zeig("Rotate180     ", Vec2Rotate180(a));
    zeig("Perpendicular ", Vec2Perpendicular(a));

    // Interpolation: t in Millionstel
    zeig("Lerp 0 %      ", Vec2Lerp(Vec2Zero(), Vec2New(100, 200), 0));
    zeig("Lerp 50 %     ", Vec2Lerp(Vec2Zero(), Vec2New(100, 200), 500000));
    zeig("Lerp 100 %    ", Vec2Lerp(Vec2Zero(), Vec2New(100, 200), 1000000));
    return 0;
}

Ausgabe:

a            = (3, 4)
a + b        = (4, 6)
a - b        = (2, 2)
a * 3        = (9, 12)
Dot(a,b)     = 11   (3*1 + 4*2)
Cross(a,b)   = 2   (3*2 - 4*1)
LengthSquared = 25
Length        = 5   (ganzzahlig abgerundet)
Normalize(3,4) = (600000, 800000)
   600000/1000000 = 0,6 und 800000/1000000 = 0,8
Rotate90       = (-4, 3)
Rotate180      = (-3, -4)
Perpendicular  = (-4, 3)
Lerp 0 %       = (0, 0)
Lerp 50 %      = (50, 100)
Lerp 100 %     = (100, 200)

Geprüft mit lyxc 1.0.21A.

Project((3,4) auf (1,0)) = (0, 0)      erwartet (3, 0)
Reflect((1,-1) an (0,1)) = (1, -1)     erwartet (1, 1)

Beide teilen das Skalarprodukt durch 1 000 000. Bei ganzzahligen Vektoren ist dieses Produkt klein — für (3,4)·(1,0) = 3 ergibt die Division 0, und die anschließende Multiplikation liefert den Nullvektor. Vec2Reflect zieht dadurch nichts ab und gibt den Eingabevektor zurück; eine Spiegelung, die nichts spiegelt, fällt am Aufrufort nicht auf.

Bei Vec2Project kommt hinzu, dass die Quadratlänge des Zielvektors zwar berechnet, aber nicht in die Rechnung übernommen wird — der Nenner der Projektionsformel fehlt.

Ersatz bis zum Fix:

fn ProjektionAuf(v: Vec2, onto: Vec2): Vec2 {
    var lenSq: int64 := Vec2LengthSquared(onto);
    if (lenSq == 0) { return Vec2Zero(); }
    var dot: int64 := Vec2Dot(v, onto);
    var r: Vec2;
    r.x := onto.x * dot / lenSq;
    r.y := onto.y * dot / lenSq;
    return r;
}

(100,0) um 0 Grad   = (-64436, 0)      erwartet (100, 0)
(100,0) um 90 Grad  = (0, -64436)      erwartet (0, 100)
(100,0) um 180 Grad = (64436, 0)       erwartet (-100, 0)
Heading(1,1)         = 89999550        erwartet 45000000
AngleTo((1,0),(0,1)) = 179999999       erwartet 90000000

Seit 1.0.20F stimmen diese Werte — die Ursache lag nicht in dieser Unit, sondern in Sin64/Cos64 (#1444) und Atan2Microdegrees (#1447) aus std.math. Nachgemessen:

Vec2Rotate((1,0), 90000000)   = (0, 1000)
Vec2Heading((1,0))            = 0
Vec2Reflect((1,0), (0,1))     = (1000, 0)

Der Winkel wird in Mikrograd übergeben — Vec2Rotate(v, 90000000) dreht um 90°. Für rechte Winkel bleiben Vec2Rotate90/180/270 der kürzere Weg.

Vec2Div(v, 0) läuft ungeprüft in die Hardware-Division und beendet den Prozess mit SIGFPE. Der Divisor ist vorher selbst zu prüfen.

• std.math — IntSqrt, Clamp64 und die Winkelfunktionen
• std.rect · std.circle — Geometrie auf Basis von Vec2
• std.math_batch — SIMD-Operationen auf Zahlenfeldern