Jak mogę powielić ograniczenia kolorów NES za pomocą modułu cieniującego piksele HLSL?

Ponieważ tryb 256 kolorów jest przestarzały i nie jest już obsługiwany w trybie Direct3D, wpadłem na pomysł, aby zamiast tego użyć modułu cieniującego piksele do symulacji palety NES wszystkich możliwych kolorów, aby blaknące obiekty i inne elementy nie miały płynnego wygaszania z kanałami alfa . (Wiem, że obiekty nie mogły tak naprawdę zanikać w systemie NES, ale mam wszystkie obiekty, które zanikają i zanikają na jednolitym czarnym tle, co byłoby możliwe przy zamianie palet. Ponadto ekran zanika i zanika po wstrzymaniu co, jak wiem, było możliwe również przy zamianie palet, jak miało to miejsce w kilku grach Mega Man.) Problem polega na tym, że nie wiem nic o shaderach HLSL.

Jak mam to zrobić?

W module cieniującym piksele można przekazać teksturę Texture2D 256 x 256 z kolorami palet ustawionymi poziomo w rzędzie. Następnie tekstury NES zostaną przekonwertowane na Direct3D Texture2D z każdym pikselem przekonwertowanym na wartość indeksu 0-255. Istnieje format tekstury, który używa tylko czerwonej wartości w D3D9. Zatem tekstura zajmowałaby tylko 8 bitów na piksel, ale dane, które wchodzą do modułu cieniującego, wynosiłyby od 0-1.

// Moduł cieniujący piksele może wyglądać tak:

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

EDYCJA: Bardziej poprawnym sposobem byłoby dodanie we wszystkich mieszanych wersjach palet wyrównanych pionowo w teksturze i odniesienie ich do wartości „alpha” koloru colorIndex:

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

Trzecim sposobem byłoby po prostu sfałszowanie niskiej jakości zanikania NES poprzez przyciemnianie koloru 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;
}

Jeśli tak naprawdę nie obchodzi Cię użycie pamięci tekstur (a pomysł, aby uzyskać niesamowitą ilość pamięci tekstur, aby uzyskać retro wygląd, ma pewien przewrotny urok), możesz zbudować teksturę 3D 256x256x256 3D, odwzorowującą wszystkie kombinacje RGB na wybraną paletę . Następnie w twoim module cieniującym staje się tylko jedną linią kodu na końcu:

return tex3d (paletteMap, color.rgb);

Może nawet nie być konieczne przejście do 256x256x256 - coś takiego jak 64x64x64 może być wystarczające - i możesz nawet zmieniać mapowania palet w locie za pomocą tej metody (ale przy znacznych kosztach ze względu na dużą dynamiczną aktualizację tekstur).

(oba moje rozwiązania działają tylko wtedy, gdy nie obchodzi Cię zmiana palet w locie za pomocą shaderów)

Możesz użyć dowolnego rodzaju tekstury i wykonać proste obliczenia na module cieniującym. Sztuczka polega na tym, że masz więcej informacji o kolorze niż potrzebujesz, więc po prostu pozbędziesz się informacji, których nie chcesz.

8- bitowy kolor ma formalną RRRGGGBB . Co daje 8 odcieni czerwieni i zieleni oraz 4 odcienie niebieskiego.

To rozwiązanie będzie działać dla dowolnych tekstur w formacie 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);
}

Uwaga: napisałem to z góry mojej głowy, ale jestem pewien, że to się dla ciebie skompiluje i zadziała

Inną możliwością byłoby użycie formatu tekstury D3DFMT_R3G3B2 , który jest faktycznie taki sam jak grafika 8- bitowa . Kiedy wstawiasz dane do tej tekstury, możesz użyć prostej operacji bitowej na bajt.

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