Come posso replicare i limiti di colore del NES con uno shader pixel HLSL?

Quindi, poiché la modalità 256 colori è deprezzata e non è più supportata nella modalità Direct3D, ho avuto l'idea di utilizzare un pixel shader invece di simulare la tavolozza NES di tutti i colori possibili in modo che gli oggetti in dissolvenza e quant'altro non abbiano dissolvenze sfumate uniformi con i canali alfa . (So ​​che gli oggetti non possono davvero svanire sul NES, ma ho tutti gli oggetti che si dissolvono dentro e fuori su uno sfondo nero solido, il che sarebbe possibile con lo scambio di palette. Inoltre, lo schermo si dissolve dentro e fuori quando si mette in pausa che so anche possibile con lo scambio di palette, come è stato fatto in alcuni giochi di Mega Man.) Il problema è che non so quasi nulla degli shader HLSL.

Come lo faccio?

Nel pixel shader è possibile passare un Texture2D 256x256 con i colori del pallet allineati orizzontalmente in fila. Quindi le trame NES verrebbero convertite in Texture2Ds direct3D con pixel sempre convertiti in un valore di indice 0-255. Esiste un formato texture che utilizza solo il valore rosso in D3D9. Quindi la trama occuperebbe solo 8 bit per pixel, ma i dati che entrano nello shader sarebbero compresi tra 0 e 1.

// Pixel shader potrebbe apparire così:

float4 mainPS() : COLOR0
{
    float4 colorIndex = tex2D(MainTexture, uv);
    float4 palletColor = tex2D(PalletTexture, float2(colorIndex.x, 0);
    return palletColor;
}

MODIFICA: Un modo più corretto sarebbe quello di aggiungere in tutta la versione del pallet di fusione che è necessario allineare verticalmente nella trama e fare riferimento a loro con il valore 'alpha' di colorIndex:

float4 mainPS() : COLOR0
{
    float4 colorIndex = tex2D(MainTexture, uv);
    float4 palletColor = tex2D(PalletTexture, float2(colorIndex.x, colorIndex.a);
    return palletColor;
}

Un terzo modo sarebbe quello di falsificare la bassa qualità di dissolvenza del NES toon ombreggiando il colore alfa:

float4 mainPS() : COLOR0
{
    float4 colorIndex = tex2D(MainTexture, uv);
    float4 palletColor = tex2D(PalletTexture, float2(colorIndex.x, 0);
    palletColor.a = floor(palletColor.a * fadeQuality) / fadeQuality;
    //NOTE: If fadeQuality where to equal say '3' there would be only 3 levels of fade.
    return palletColor;
}

Se non ti interessa davvero l'utilizzo della memoria delle trame (e l'idea di soffiare una quantità folle di memoria delle trame per ottenere un aspetto retrò ha una sorta di fascino perverso) potresti costruire una trama 3d 256x256x256 che mappa tutte le combinazioni RGB sulla tavolozza selezionata . Quindi nel tuo shader diventa solo una riga di codice alla fine:

return tex3d (paletteMap, color.rgb);

Potrebbe non essere nemmeno necessario andare fino a 256x256x256 - qualcosa come 64x64x64 potrebbe essere sufficiente - e potresti persino cambiare al volo le mappature della tavolozza usando questo metodo (ma a costi significativi a causa di un grande aggiornamento dinamico della trama).

(entrambe le mie soluzioni funzionano solo se non ti interessa cambiare al volo i pallet con gli shader)

Puoi usare qualsiasi tipo di trama e fare un semplice calcolo su uno shader. Il trucco è che hai più informazioni sul colore di quelle che ti servono, quindi quello che ti sbarazzerai delle informazioni che non vuoi.

Il colore a 8 bit è in formato RRRGGGBB . Che ti dà 8 tonalità di rosso e verde e 4 tonalità di blu.

Questa soluzione funzionerà con qualsiasi texture in formato colore RGB (A).

float4 mainPS() : COLOR0
{
    const float oneOver7 = 1.0 / 8.0;
    const float oneOver3 = 1.0 / 3.0;

    float4 color = tex2D(YourTexture, uvCoord);
    float R = floor(color.r * 7.99) * oneOver7;
    float G = floor(color.g * 7.99) * oneOver7;
    float B = floor(color.b * 3.99) * oneOver3;

    return float4(R, G, B, 1);
}

nota: l'ho scritto dalla cima della mia testa, ma sono davvero sicuro che si compili e funzionerà per te

Un'altra possibilità sarebbe quella di utilizzare il formato texture D3DFMT_R3G3B2 che è effettivamente lo stesso della grafica a 8 bit. Quando si inseriscono dati in questa trama, è possibile utilizzare una semplice operazione di bit per byte.

tex[index] = (R & 8) << 5 + ((G & 8) << 2) + (B & 4);