TColor - Zusammenfügen der Farben

[Neutral General]

Weil die RGBAToColor()-Funktion Schwachsinn ist...

Die funktioniert (wie schon von einigen weiter oben beschrieben) nicht, weil TColor keinen Alpha-Kanal besitzt/unterstützt. In dem 4. Byte wird irgendwas anderes (Palette?!) gespeichert. Und wenn das 4. Byte nicht = 0 ist, kam bei mir zu 99% einfach nur Schwarz raus

[Muellermilchtrinker]

Wie könnte ich das denn dann machen?
Also 4 Schieberegler (von 0..255) (r,g,b,a) damit dann eine Farbe einstellen und auf einem Vorschaubild anzeigen. Danach die Farbe als 8 stellige Hex ausgeben im Format: $AARRGGBB (da bei der Delphifunktion doch 2 Farben gedreht sind)

[Sir Rufo]

Zitat von Muellermilchtrinker:

Wie könnte ich das denn dann machen?
Also 4 Schieberegler (von 0..255) (r,g,b,a) damit dann eine Farbe einstellen und auf einem Vorschaubild anzeigen. Danach die Farbe als 8 stellige Hex ausgeben im Format: $AARRGGBB (da bei der Delphifunktion doch 2 Farben gedreht sind)

Da ist nichts gedreht oder verdreht, sondern genau wie im schönen Dezimalsystem.
Einer, Zehner, Hunderter, Tausender (THZE) oder mal analog dazu
R, G, B, A (AGBR) und da jeder Wert (dezimal) von 0-255 oder (hex) von $00-$FF schreibt man auch gerne als Maske für die resultierende Hex-Darstellung ($AABBGGRR)

Bei einer Umrechnung nach TColor kann aber nur der RGB-Anteil verarbeitet werden, weil TColor eben nix mit dem Alpha-Kanal zu schaffen hat.

Für die tatsächlich resultierende Farbe die auf dem Schirm dann erscheinen muss zu errechnen, benötigt man eben noch die aktuelle Hintergrundfarbe.

Das führt uns somit zu folgendem Funktionsrumpf:
function GetColor( ARGB : TARGB; Color : TColor ): TColor;

[Sir Rufo]

Sodele, da habe ich doch mal einen kleinen süßen Record zusammengebaut, der nun einen Farbwert mit einem Alphakanal beherbergt.
Benutzt werden kann der wie TColor (durch überladene Operatoren) hat aber noch eine Zusatzfunktion (PaintColor), um etwas mit dem Alpha-Wert anzufangen.

Eine Demo ist im Anhang.
TARGBColorGUI.png
(Exe, kompletter Source)

Delphi-Quellcode:

unit insARGBColor;

interface

uses
  Graphics;

type
  TARGBColor = record
    R, G, B, A : Byte;
    class operator implicit( ARGB : TARGBColor ) : TColor;
    class operator implicit( Color : TColor ) : TARGBColor;
    function PaintColor( Color : TColor ) : TColor;
  end;

implementation

{ TARGBColor }

class operator TARGBColor.implicit( ARGB : TARGBColor ) : TColor;
begin
  Result := ARGB.R or ( ARGB.G shl 8 ) or ( ARGB.B shl 16 );
end;

class operator TARGBColor.implicit( Color : TColor ) : TARGBColor;
begin
  Result.R := Byte( Color );
  Result.G := Byte( Color shr 8 );
  Result.B := Byte( Color shr 16 );
end;

function TARGBColor.PaintColor( Color : TColor ) : TColor;
var
  Col, res : TARGBColor;
begin
  Col    := Color;
  res.R  := ( Self.R * Self.A + Col.R * ( 255 - Self.A ) ) div 255;
  res.G  := ( Self.G * Self.A + Col.G * ( 255 - Self.A ) ) div 255;
  res.B  := ( Self.B * Self.A + Col.B * ( 255 - Self.A ) ) div 255;
  Result := res;
end;

end.

[Satty67]

Ok, das sieht gut aus. Aber weil ich auch gerade nebenher gebastelt hab (natürlich zeitlich total versagt ) poste ich auch mein Ergebnis, dass Deinen angebotenen Funktionsrumpf als Vorlage hatte:

Delphi-Quellcode:

type
  TARGB = packed record
    A,R,G,B : Byte;
  end;

function MixColor(ARGB : TARGB; Color : TColor): TColor;
var
  R, G, B : Byte;
begin
  R := Color and $FF;
  G := (Color shr 8) and $FF;
  B := (Color shr 16) and $FF;
  R := ((ARGB.R * ARGB.A) + (R * ($FF - ARGB.A))) div $FF;
  G := ((ARGB.G * ARGB.A) + (G * ($FF - ARGB.A))) div $FF;
  B := ((ARGB.B * ARGB.A) + (B * ($FF - ARGB.A))) div $FF;
  Result := R + (G shl 8) + (B shl 16);
end;

Zumindest bei der Berechnung/Mixen scheint es richtig (war da garnicht so sicher)