Comment puis-je reproduire les limitations de couleurs de la NES avec un pixel shader HLSL?

Donc, comme le mode 256 couleurs est déprécié et n'est plus pris en charge en mode Direct3D, j'ai eu l'idée d'utiliser un pixel shader à la place pour simuler la palette NES de toutes les couleurs possibles afin que les objets en décoloration et ainsi de suite n'aient pas de fondus en douceur avec les canaux alpha . (Je sais que les objets ne peuvent pas vraiment disparaître sur le NES, mais j'ai tous les objets qui apparaissent et disparaissent sur un fond noir uni, ce qui serait possible avec l'échange de palette. En outre, l'écran apparaît et disparaît lorsque vous faites une pause ce que je sais aussi possible avec le changement de palette comme cela a été fait dans quelques jeux Mega Man.) Le problème est que je ne connais pratiquement rien des shaders HLSL.

Comment fait-on ça?

Dans le pixel shader, vous pouvez passer dans un 256x256 Texture2D avec les couleurs de palette alignées horizontalement dans une rangée. Ensuite, vos textures NES seraient converties en Texture2Ds direct3D avec toujours des pixels convertis en une valeur d'index 0-255. Il existe un format de texture qui utilise uniquement la valeur rouge dans D3D9. Ainsi, la texture ne prendrait que 8 bits par pixel, mais les données qui entrent dans le shader seraient de 0 à 1.

// Le pixel shader pourrait ressembler à ceci:

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

EDIT: Une manière plus correcte serait d'ajouter toutes les versions de palette de mélange dont vous avez besoin alignées verticalement dans la texture et de les référencer avec la valeur alpha de votre colorIndex:

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

Une troisième façon serait de simuler la faible qualité de fondu NES en ombrant la couleur alpha:

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 vous ne vous souciez pas vraiment de l'utilisation de la mémoire de texture (et l'idée de souffler une quantité folle de mémoire de texture pour obtenir un look rétro a une sorte d'attrait pervers), vous pouvez créer une texture 3D 256x256x256 mappant toutes les combinaisons RVB à votre palette sélectionnée . Ensuite, dans votre shader, il ne devient qu'une ligne de code à la fin:

return tex3d (paletteMap, color.rgb);

Il n'est peut-être même pas nécessaire d'aller jusqu'au 256x256x256 - quelque chose comme 64x64x64 peut être suffisant - et vous pouvez même changer les mappages de palette à la volée en utilisant cette méthode (mais à un coût important en raison d'une grande mise à jour de texture dynamique).

(ma solution ne fonctionne que si vous ne vous souciez pas de changer les palettes à la volée à l'aide de shaders)

Vous pouvez utiliser n'importe quel type de texture et effectuer un simple calcul sur un shader. L'astuce est que vous avez plus d'informations sur les couleurs que vous n'en avez besoin, donc ce que vous allez simplement vous débarrasser des informations que vous ne voulez pas.

La couleur 8 bits est au format RRRGGGBB . Ce qui vous donne 8 nuances de rouge et de vert et 4 nuances de bleu.

Cette solution fonctionnera pour toutes les textures de format de couleur RVB (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);
}

note: j'ai écrit cela du haut de ma tête, mais je suis vraiment sûr que cela compilera et fonctionnera pour vous

Une autre possibilité serait d'utiliser le format de texture D3DFMT_R3G3B2 qui est en fait le même que les graphiques 8 bits. Lorsque vous placez des données dans cette texture, vous pouvez utiliser une opération de bits simple par octet.

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