Uso del colore in Direct2D
Direct2D usa il modello di colore RGB, in cui i colori sono formati combinando valori diversi di rosso, verde e blu. Un quarto componente, alfa, misura la trasparenza di un pixel. In Direct2D ognuno di questi componenti è un valore a virgola mobile con un intervallo di [0,0 1.0]. Per i tre componenti di colore, il valore misura l'intensità del colore. Per il componente alfa, 0,0 significa completamente trasparente e 1,0 significa completamente opaco. La tabella seguente mostra i colori risultanti da varie combinazioni di intensità del 100%.
| Red | Green | Blu | Color |
|---|---|---|---|
| 0 | 0 | 0 | Black |
| 1 | 0 | 0 | Rosso |
| 0 | 1 | 0 | Green |
| 0 | 0 | 1 | Blu |
| 0 | 1 | 1 | azzurro |
| 1 | 0 | 1 | Fucsia |
| 1 | 1 | 0 | Giallo |
| 1 | 1 | 1 | White |
I valori di colore compresi tra 0 e 1 comportano sfumature diverse di questi colori pure. Direct2D usa la struttura D2D1_COLOR_F per rappresentare i colori. Ad esempio, il codice seguente specifica magenta.
// Initialize a magenta color.
D2D1_COLOR_F clr;
clr.r = 1;
clr.g = 0;
clr.b = 1;
clr.a = 1; // Opaque.
È anche possibile specificare un colore usando la classe D2D1::ColorF , che deriva dalla struttura D2D1_COLOR_F .
// Equivalent to the previous example.
D2D1::ColorF clr(1, 0, 1, 1);
Fusione alfa
La fusione alfa crea aree traslucenti fondendo il colore di primo piano con il colore di sfondo, usando la formula seguente.
- color = af * Cf + (1 - af) * Cb
dove Cb è il colore di sfondo, Cf è il colore di primo piano e af è il valore alfa del colore di primo piano. Questa formula viene applicata in modo associato a ogni componente di colore. Si supponga, ad esempio, che il colore di primo piano sia (R = 1,0, G = 0,4, B = 0,0), con alfa = 0,6 e il colore di sfondo è (R = 0,0 , G = 0,5, B = 1,0). Il colore alfa-blend risultante è:
R = (1,0 * 0,6 + 0 * 0,4) = .6
G = (0,4 * 0,6 + 0,5 * 0,4) = .44
B = (0 * 0,6 + 1,0 * 0,4) = .40
L'immagine seguente mostra il risultato di questa operazione di fusione.
Formati pixel
La struttura D2D1_COLOR_F non descrive il modo in cui un pixel è rappresentato in memoria. Nella maggior parte dei casi, non importa. Direct2D gestisce tutti i dettagli interni della conversione delle informazioni sul colore in pixel. Tuttavia, potrebbe essere necessario conoscere il formato pixel se si lavora direttamente con una bitmap in memoria o se si combina Direct2D con Direct3D o GDI.
L'enumerazione DXGI_FORMAT definisce un elenco di formati pixel. L'elenco è abbastanza lungo, ma solo alcuni di essi sono rilevanti per Direct2D. Gli altri vengono usati da Direct3D.
| Formato pixel | Descrizione |
|---|---|
|
DXGI_FORMAT_B8G8R8A8_UNORM |
Si tratta del formato pixel più comune. Tutti i componenti pixel (rosso, verde, blu e alfa) sono interi senza segno a 8 bit. I componenti sono disposti in ordine BGRA in memoria. Vedere l'illustrazione seguente. |
|
DXGI_FORMAT_R8G8B8A8_UNORM |
I componenti pixel sono interi senza segno a 8 bit, nell'ordine RGBA . In altre parole, i componenti rossi e blu vengono scambiati, rispetto a DXGI_FORMAT_B8G8R8A8_UNORM. Questo formato è supportato solo per i dispositivi hardware. |
|
DXGI_FORMAT_A8_UNORM |
Questo formato contiene un componente alfa a 8 bit, senza componenti RGB. È utile per la creazione di maschere di opacità. Per altre informazioni sull'uso di maschere di opacità in Direct2D, vedere Panoramica delle destinazioni di rendering di A8 compatibili. |
La figura seguente mostra il layout dei pixel BGRA.
Per ottenere il formato pixel di una destinazione di rendering, chiamare ID2D1RenderTarget::GetPixelFormat. Il formato pixel potrebbe non corrispondere alla risoluzione dello schermo. Ad esempio, la visualizzazione potrebbe essere impostata su colore a 16 bit, anche se la destinazione di rendering usa il colore a 32 bit.
Modalità alfa
Una destinazione di rendering ha anche una modalità alfa, che definisce il modo in cui vengono trattati i valori alfa.
| Modalità Alfa | Descrizione |
|---|---|
| D2D1_ALPHA_MODE_IGNORE | Non viene eseguita alcuna fusione alfa. I valori alfa vengono ignorati. |
| D2D1_ALPHA_MODE_STRAIGHT | Alfa dritto. I componenti del colore del pixel rappresentano l'intensità del colore prima della fusione alfa. |
| D2D1_ALPHA_MODE_PREMULTIPLIED | Alfa premoltiplicato. I componenti di colore del pixel rappresentano l'intensità del colore moltiplicata per il valore alfa. Questo formato è più efficiente per il rendering di alfa retto, perché il termine (af Cf) dalla formula di fusione alfa viene precalcorato. Tuttavia, questo formato non è appropriato per l'archiviazione in un file di immagine. |
Di seguito è riportato un esempio della differenza tra alfa dritto e alfa premoltiplicato. Si supponga che il colore desiderato sia rosso puro (intensità del 100%) con 50% alfa. Come tipo Direct2D, questo colore verrebbe rappresentato come (1, 0, 0, 0,5). Usando alfa dritto e presupponendo componenti di colore a 8 bit, il componente rosso del pixel è 0xFF. Usando alfa premoltiplicato, il componente rosso viene ridimensionato del 50% in modo da essere uguale a 0x80.
Il tipo di dati D2D1_COLOR_F rappresenta sempre i colori usando alfa retto. Direct2D converte i pixel in formato alfa premoltiplicato, se necessario.
Se si sa che il programma non eseguirà alcuna fusione alfa, creare la destinazione di rendering con la modalità alfa D2D1_ALPHA_MODE_IGNORE . Questa modalità può migliorare le prestazioni, perché Direct2D può ignorare i calcoli alfa. Per altre informazioni, vedere Miglioramento delle prestazioni delle applicazioni Direct2D.