std.color — RGBA-Farben

→ Zurück zur Unit-Übersicht

Farben als vier ganzzahlige Kanäle von 0 bis 255: Rot, Grün, Blau und Deckkraft. Alle Operationen rechnen ohne Fließkomma. Enthalten sind Vorgabefarben, Aufhellen und Abdunkeln, Graustufen, Sättigung, Farbverläufe, Alpha-Überlagerung sowie Hex- und HSL-Umrechnung.

Einsatzbereiche: Grafikausgabe, Bildverarbeitung, Oberflächen, Terminalfarben.

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

<WRAP alert> Seit 1.0.20F rechnet ColorFromHSL korrekt (#1484) — nachgemessen:

HSL(0,255,128)   →  (255, 0, 0)
HSL(60,255,128)  →  (255, 255, 0)
HSL(120,255,128) →  (0, 255, 0)
HSL(240,255,128) →  (0, 0, 255)
HSL(0,0,128)     →  (128, 128, 128)

Sättigung und Helligkeit laufen über 0..255, nicht über Prozent. Die reine Farbe liegt bei l = 128; ColorFromHSL(60, 100, 50) ergibt darum keine Gelbfarbe, sondern ein dunkles, entsättigtes (69, 69, 31).

ColorFromHex unterscheidet RGB von ARGB an der Größe der Zahl: alles über $FFFFFF gilt als ARGB. Eine vollständig transparente Farbe lässt sich damit nicht ausdrücken — ColorFromHex($00000000) ergibt undurchsichtiges Schwarz. Dafür gibt es ColorFromHexARGB, das die Zahl immer als ARGB liest (#1485). </WRAP>

import std.color;

Zieht std.math mit (Clamp64, Min64, Max64, Lerp64).

Die Konstruktoren klemmen jeden Kanal selbst auf den gültigen Bereich — ColorNew(300, -20, 0, 99) ergibt rgba(255, 0, 0, 99). Wer die Felder direkt setzt, umgeht diese Prüfung; ColorIsValid meldet das nachträglich.

Je eine Funktion ohne Parameter, alle deckend:

ColorLerp erbt den Promille-Maßstab von Lerp64 aus std.math. Achtung beim Wechsel zwischen Units: Vec2Lerp in std.vector erwartet denselben Parameter in Millionstel.

ColorDistance summiert die drei Kanalabstände, statt die Wurzel aus der Quadratsumme zu ziehen: Schwarz zu Weiß ergibt 765, geometrisch wären es 442. Für „welche Palettenfarbe passt am besten„ kann das eine andere Rangfolge liefern (#1485).

Die Einheiten sind gemischt: der Farbwinkel in Grad, Sättigung und Helligkeit dagegen im 0–255-Raster. Eine Umkehrfunktion ColorToHSL gibt es nicht.

import std.color;

fn zeig(name: pchar, c: Color): void {
    PrintLn(name, " = rgba(", IntToStr(c.r), ", ", IntToStr(c.g), ", ", IntToStr(c.b), ", ", IntToStr(c.a), ")");
}

fn main(): int64 {
    // Werte werden beim Anlegen auf 0..255 geklemmt
    zeig("ColorNew(300,-20,0,99)", ColorNew(300, -20, 0, 99));
    zeig("ColorRGB(255,136,0)   ", ColorRGB(255, 136, 0));

    // Hex in beide Richtungen
    var orange: Color := ColorFromHex(16746496);          // 0xFF8800
    zeig("FromHex(0xFF8800)     ", orange);
    PrintLn("ToHex     = ", IntToStr(ColorToHex(orange)));
    PrintLn("ToHexARGB = ", IntToStr(ColorToHexARGB(orange)));

    // Aufhellen, abdunkeln, entsaettigen
    zeig("Brighten(+50)         ", ColorBrighten(orange, 50));
    zeig("Darken(-50)           ", ColorDarken(orange, 50));
    zeig("Grayscale             ", ColorGrayscale(orange));
    zeig("Invert                ", ColorInvert(orange));

    // Farbverlauf: t in Promille (0..1000)
    PrintLn("-- Verlauf schwarz -> weiss:");
    zeig("  0 %", ColorLerp(ColorBlack(), ColorWhite(), 0));
    zeig(" 25 %", ColorLerp(ColorBlack(), ColorWhite(), 250));
    zeig(" 50 %", ColorLerp(ColorBlack(), ColorWhite(), 500));
    zeig("100 %", ColorLerp(ColorBlack(), ColorWhite(), 1000));

    // Halbtransparente Farbe ueber Hintergrund legen
    var halbRot: Color := ColorRGBA(255, 0, 0, 128);
    zeig("Blend(halbRot ueber weiss)", ColorBlend(halbRot, ColorWhite()));
    return 0;
}

Ausgabe:

ColorNew(300,-20,0,99) = rgba(255, 0, 0, 99)
ColorRGB(255,136,0)    = rgba(255, 136, 0, 255)
FromHex(0xFF8800)      = rgba(255, 136, 0, 255)
ToHex     = 16746496
ToHexARGB = 4294936576
Brighten(+50)          = rgba(255, 186, 50, 255)
Darken(-50)            = rgba(205, 86, 0, 255)
Grayscale              = rgba(156, 156, 156, 255)
Invert                 = rgba(0, 119, 255, 255)
-- Verlauf schwarz -> weiss:
  0 % = rgba(0, 0, 0, 255)
 25 % = rgba(63, 63, 63, 255)
 50 % = rgba(127, 127, 127, 255)
100 % = rgba(255, 255, 255, 255)
Blend(halbRot ueber weiss) = rgba(255, 127, 127, 255)

ColorBlend rechnet die Deckkraft korrekt ein: halbtransparentes Rot über Weiß ergibt ein helles Rosa mit voller Deckung.

Geprüft mit lyxc 1.0.21A.

Die Primärfarben stimmen, alles dazwischen liegt daneben:

Die Sektorgrenzen in der internen Hilfsfunktion sind auf das 0–255-Raster falsch übertragen; genau an den Sechstel-Grenzen fällt die Rechnung in den falschen Zweig.

Zusätzlich wirkt die Helligkeit nur nach unten:

l=64  -> rgba(128, 0, 0)     dunkelrot, korrekt
l=128 -> rgba(255, 0, 0)     rot, korrekt
l=200 -> rgba(255, 0, 0)     sollte zu Weiss aufhellen
l=255 -> rgba(255, 0, 0)     sollte reines Weiss sein

Die Formel bildet nur den Fall „Helligkeit unter der Hälfte“ ab. Ein Verlauf über die Helligkeit endet damit bei der Vollfarbe statt bei Weiß.

Bis zum Fix Farbverläufe über ColorLerp gegen ColorWhite() bzw. ColorBlack() bilden — das arbeitet korrekt.

var c: Color := ColorEmpty();                    // rgba(0, 0, 0, 0)
var zurueck: Color := ColorFromHex(ColorToHexARGB(c));
PrintLn(IntToStr(zurueck.a));                    // 255 statt 0

ColorFromHex schließt aus der Größe des Werts auf ein vorhandenes Alphabyte. Bei Alpha 0 bleibt das obere Byte leer, der Wert liegt unter der Schwelle — und die Farbe gilt als deckend. Eine unsichtbare Farbe übersteht den Rundlauf also nicht.

Für Werte mit gesetztem Alphabyte arbeitet die Funktion korrekt: ColorFromHex(0x80FF0000) ergibt rgba(255, 0, 0, 128).

Wer Transparenz braucht, setzt sie nach dem Einlesen ausdrücklich:

var c: Color := ColorWithAlpha(ColorFromHex(0xFF0000), 0);

• std.math — Clamp64, Lerp64, Min64/Max64
• std.vector — Vec2Lerp, beachte den anderen Maßstab für t