Como replicar as limitações de cores do NES com um sombreador de pixel HLSL?

Portanto, como o modo 256 cores é depreciado e não é mais suportado no modo Direct3D, tive a ideia de usar um sombreador de pixel para simular a paleta NES de todas as cores possíveis, para que os objetos desbotados e outros objetos não tenham desbotamentos suaves com canais alfa . (Eu sei que os objetos não podem desaparecer no NES, mas tenho todos os objetos que aparecem e desaparecem em um fundo preto sólido, o que seria possível com a troca de paleta. Além disso, a tela aparece e desaparece quando você pausa o que eu sei também era possível com a troca de paleta, como foi feito em alguns jogos do Mega Man.) O problema é que não sei quase nada sobre os shaders HLSL.

Como eu faço isso?

No sombreador de pixels, você pode passar um Texture2D de 256x256 com as cores do palete alinhadas horizontalmente em uma linha. Em seguida, suas texturas NES seriam convertidas em direct3D Texture2Ds com cada pixel convertido em um valor de índice de 0 a 255. Há um formato de textura que usa apenas o valor vermelho em D3D9. Portanto, a textura ocuparia apenas 8 bits por pixel, mas os dados que entram no shader seriam de 0 a 1.

// O pixel shader pode ficar assim:

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

EDIT: Uma maneira mais correta seria adicionar todas as versões de paletes de mesclagem que você precisa alinhadas verticalmente na textura e referenciá-las com o valor 'alpha' do seu colorIndex:

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

Uma terceira maneira seria falsificar a baixa qualidade de desbotamento do NES ao sombrear a cor 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 você realmente não se importa com o uso da memória de textura (e a idéia de soprar uma quantidade insana de memória de textura para obter uma aparência retrô tem um tipo de apelo perverso), você pode criar uma textura 3D de 256x256x256 mapeando todas as combinações RGB para a paleta selecionada . Então, no seu sombreador, ele se torna uma linha de código no final:

return tex3d (paletteMap, color.rgb);

Pode até não ser necessário ir até 256x256x256 - algo como 64x64x64 pode ser suficiente - e você pode até mudar os mapeamentos de paleta rapidamente usando esse método (mas a um custo significativo devido a uma grande atualização dinâmica de textura).

(a minha solução funciona apenas se você não se importar em trocar paletes em tempo real usando shaders)

Você pode usar qualquer tipo de textura e fazer apenas um cálculo simples em um shader. O truque é que você tem mais informações sobre cores do que precisa, então você apenas se livrará das informações que não deseja.

A cor 8bit está em formar RRRGGGBB . O que lhe dá 8 tons de vermelho e verde e 4 tons de azul.

Esta solução funcionará para qualquer textura de formato de cor 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: eu escrevi isso do alto da minha cabeça, mas eu tenho certeza que ele irá compilar e trabalhar para você

Outra possibilidade seria usar o formato de textura D3DFMT_R3G3B2 que é realmente o mesmo que os gráficos de 8 bits. Quando você coloca dados nessa textura, pode usar uma operação de bit simples por byte.

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