¿Cómo puedo replicar las limitaciones de color del NES con un sombreador de píxeles HLSL?

Entonces, dado que el modo de 256 colores se deprecia y ya no es compatible con el modo Direct3D, tuve la idea de usar un sombreador de píxeles en su lugar para simular la paleta NES de todos los colores posibles para que los objetos que se desvanecen y otros no se desvanezcan con canales alfa . (Sé que los objetos realmente no se pueden desvanecer en el NES, pero tengo todos los objetos que se desvanecen en un fondo negro sólido, lo que sería posible con el intercambio de paletas. Además, la pantalla se desvanece cuando se detiene. que sé que también fue posible con el intercambio de paletas como se hizo en algunos juegos de Mega Man.) El problema es que no sé casi nada sobre los sombreadores HLSL.

¿Cómo lo hago?

En el sombreador de píxeles, puede pasar un Texture2D de 256x256 con los colores de la paleta alineados horizontalmente en una fila. Luego, sus texturas NES se convertirán en direct3D Texture2Ds con píxeles convertidos a un valor de índice 0-255. Hay un formato de textura que solo usa el valor rojo en D3D9. Por lo tanto, la textura solo ocuparía 8 bits por píxel, pero los datos que entran en el sombreador serían de 0-1.

// El sombreador de píxeles podría verse así:

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

EDITAR: Una forma más correcta sería agregar todas las versiones de paletas de mezcla que necesita alineadas verticalmente en la textura y hacer referencia a ellas con el valor 'alfa' de su colorIndex:

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

Una tercera forma sería simular la baja calidad de desvanecimiento de NES sombreando el color 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;
}

Si realmente no le importa el uso de la memoria de textura (y la idea de soplar una cantidad increíble de memoria de textura para lograr un aspecto retro tiene un tipo de atractivo perverso), puede construir un mapeo de texturas 3D de 256x256x256 todas las combinaciones RGB a su paleta seleccionada . Luego, en su sombreador, se convierte en una línea de código al final:

return tex3d (paletteMap, color.rgb);

Puede que ni siquiera sea necesario llegar hasta 256x256x256, algo como 64x64x64 puede ser suficiente, e incluso podría cambiar las asignaciones de paletas sobre la marcha utilizando este método (pero a un costo significativo debido a una gran actualización dinámica de textura).

(ambas soluciones funcionan solo si no le importa cambiar paletas sobre la marcha con sombreadores)

Puede usar cualquier tipo de textura y hacer un simple cálculo en un sombreador. El truco es que tienes más información de color de la que necesitas, por lo que simplemente eliminarás la información que no deseas.

El color de 8 bits está en forma bits RRRGGGBB . Lo que te da 8 tonos de rojo y verde y 4 tonos de azul.

Esta solución funcionará para cualquier textura de formato de color 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: escribí eso desde la parte superior de mi cabeza, pero estoy realmente seguro de que compilará y funcionará para usted

Otra posibilidad sería utilizar el formato de textura D3DFMT_R3G3B2 que en realidad es el mismo que los gráficos de 8 bits. Cuando coloca datos en esta textura, puede usar una operación de bits simple por byte.

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