diff options
Diffstat (limited to 'Source/Core/VideoCommon/TextureConversionShader.cpp')
| -rw-r--r-- | Source/Core/VideoCommon/TextureConversionShader.cpp | 468 |
1 files changed, 287 insertions, 181 deletions
diff --git a/Source/Core/VideoCommon/TextureConversionShader.cpp b/Source/Core/VideoCommon/TextureConversionShader.cpp index e57cbdf603..7359c2aea3 100644 --- a/Source/Core/VideoCommon/TextureConversionShader.cpp +++ b/Source/Core/VideoCommon/TextureConversionShader.cpp @@ -15,7 +15,9 @@ #include "VideoCommon/RenderBase.h" #include "VideoCommon/TextureCacheBase.h" #include "VideoCommon/TextureConversionShader.h" +#include "VideoCommon/VertexManagerBase.h" #include "VideoCommon/VideoCommon.h" +#include "VideoCommon/VideoConfig.h" #define WRITE p += sprintf @@ -59,21 +61,10 @@ u16 GetEncodedSampleCount(EFBCopyFormat format) static void WriteHeader(char*& p, APIType ApiType) { - if (ApiType == APIType::OpenGL) + if (ApiType == APIType::OpenGL || ApiType == APIType::Vulkan) { // left, top, of source rectangle within source texture // width of the destination rectangle, scale_factor (1 or 2) - WRITE(p, "uniform int4 position;\n"); - WRITE(p, "uniform float y_scale;\n"); - WRITE(p, "uniform float gamma_rcp;\n"); - WRITE(p, "uniform float2 clamp_tb;\n"); - WRITE(p, "uniform float3 filter_coefficients;\n"); - WRITE(p, "#define samp0 samp9\n"); - WRITE(p, "SAMPLER_BINDING(9) uniform sampler2DArray samp0;\n"); - WRITE(p, "FRAGMENT_OUTPUT_LOCATION(0) out vec4 ocol0;\n"); - } - else if (ApiType == APIType::Vulkan) - { WRITE(p, "UBO_BINDING(std140, 1) uniform PSBlock {\n"); WRITE(p, " int4 position;\n"); WRITE(p, " float y_scale;\n"); @@ -81,8 +72,9 @@ static void WriteHeader(char*& p, APIType ApiType) WRITE(p, " float2 clamp_tb;\n"); WRITE(p, " float3 filter_coefficients;\n"); WRITE(p, "};\n"); + WRITE(p, "VARYING_LOCATION(0) in float3 v_tex0;\n"); WRITE(p, "SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n"); - WRITE(p, "FRAGMENT_OUTPUT_LOCATION(0) out vec4 ocol0;\n"); + WRITE(p, "FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n"); } else // D3D { @@ -147,7 +139,7 @@ static void WriteSampleFunction(char*& p, const EFBCopyParams& params, APIType A else { // Handle D3D depth inversion. - if (ApiType == APIType::D3D || ApiType == APIType::Vulkan) + if (!g_ActiveConfig.backend_info.bSupportsReversedDepthRange) WRITE(p, "1.0 - ("); else WRITE(p, "("); @@ -225,7 +217,9 @@ static void WriteSwizzler(char*& p, const EFBCopyParams& params, EFBCopyFormat f else // D3D { WRITE(p, "void main(\n"); - WRITE(p, " out float4 ocol0 : SV_Target, in float4 rawpos : SV_Position)\n"); + WRITE(p, " in float3 v_tex0 : TEXCOORD0,\n"); + WRITE(p, " in float4 rawpos : SV_Position,\n"); + WRITE(p, " out float4 ocol0 : SV_Target)\n"); WRITE(p, "{\n" " int2 sampleUv;\n" " int2 uv1 = int2(rawpos.xy);\n"); @@ -846,38 +840,65 @@ const char* GenerateEncodingShader(const EFBCopyParams& params, APIType api_type // NOTE: In these uniforms, a row refers to a row of blocks, not texels. static const char decoding_shader_header[] = R"( -#ifdef VULKAN - -layout(std140, push_constant) uniform PushConstants { - uvec2 dst_size; - uvec2 src_size; - uint src_offset; - uint src_row_stride; - uint palette_offset; -} push_constants; -#define u_dst_size (push_constants.dst_size) -#define u_src_size (push_constants.src_size) -#define u_src_offset (push_constants.src_offset) -#define u_src_row_stride (push_constants.src_row_stride) -#define u_palette_offset (push_constants.palette_offset) +#if defined(PALETTE_FORMAT_IA8) || defined(PALETTE_FORMAT_RGB565) || defined(PALETTE_FORMAT_RGB5A3) +#define HAS_PALETTE 1 +#endif -TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer; -TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer; +#ifdef API_D3D +cbuffer UBO : register(b0) { +#else +UBO_BINDING(std140, 1) uniform UBO { +#endif + uint2 u_dst_size; + uint2 u_src_size; + uint u_src_offset; + uint u_src_row_stride; + uint u_palette_offset; +}; + +#ifdef API_D3D + +Buffer<uint4> s_input_buffer : register(t0); +#ifdef HAS_PALETTE +Buffer<uint4> s_palette_buffer : register(t1); +#endif -IMAGE_BINDING(rgba8, 0) uniform writeonly image2DArray output_image; +RWTexture2DArray<unorm float4> output_image : register(u0); + +// Helpers for reading/writing. +#define texelFetch(buffer, pos) buffer.Load(pos) +#define imageStore(image, coords, value) image[coords] = value +#define GROUP_MEMORY_BARRIER_WITH_SYNC GroupMemoryBarrierWithGroupSync(); +#define GROUP_SHARED groupshared + +#define DEFINE_MAIN(lx, ly) \ + [numthreads(lx, ly, 1)] \ + void main(uint3 gl_WorkGroupID : SV_GroupId, \ + uint3 gl_LocalInvocationID : SV_GroupThreadID, \ + uint3 gl_GlobalInvocationID : SV_DispatchThreadID) + +uint bitfieldExtract(uint val, int off, int size) +{ + // This built-in function is only support in OpenGL 4.0+ and ES 3.1+\n" + // Microsoft's HLSL compiler automatically optimises this to a bitfield extract instruction. + uint mask = uint((1 << size) - 1); + return uint(val >> off) & mask; +} #else -uniform uvec2 u_dst_size; -uniform uvec2 u_src_size; -uniform uint u_src_offset; -uniform uint u_src_row_stride; -uniform uint u_palette_offset; +TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer; +#ifdef HAS_PALETTE +TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer; +#endif +IMAGE_BINDING(rgba8, 0) uniform writeonly image2DArray output_image; -SAMPLER_BINDING(9) uniform usamplerBuffer s_input_buffer; -SAMPLER_BINDING(10) uniform usamplerBuffer s_palette_buffer; +#define GROUP_MEMORY_BARRIER_WITH_SYNC memoryBarrierShared(); barrier(); +#define GROUP_SHARED shared -layout(rgba8, binding = 0) uniform writeonly image2DArray output_image; +#define DEFINE_MAIN(lx, ly) \ + layout(local_size_x = lx, local_size_y = ly) in; \ + void main() #endif @@ -908,10 +929,10 @@ uint Convert6To8(uint v) return (v << 2) | (v >> 4); } -uint GetTiledTexelOffset(uvec2 block_size, uvec2 coords) +uint GetTiledTexelOffset(uint2 block_size, uint2 coords) { - uvec2 block = coords / block_size; - uvec2 offset = coords % block_size; + uint2 block = coords / block_size; + uint2 offset = coords % block_size; uint buffer_pos = u_src_offset; buffer_pos += block.y * u_src_row_stride; buffer_pos += block.x * (block_size.x * block_size.y); @@ -920,16 +941,16 @@ uint GetTiledTexelOffset(uvec2 block_size, uvec2 coords) return buffer_pos; } -uvec4 GetPaletteColor(uint index) +uint4 GetPaletteColor(uint index) { // Fetch and swap BE to LE. uint val = Swap16(texelFetch(s_palette_buffer, int(u_palette_offset + index)).x); - uvec4 color; + uint4 color; #if defined(PALETTE_FORMAT_IA8) uint a = bitfieldExtract(val, 8, 8); uint i = bitfieldExtract(val, 0, 8); - color = uvec4(i, i, i, a); + color = uint4(i, i, i, a); #elif defined(PALETTE_FORMAT_RGB565) color.x = Convert5To8(bitfieldExtract(val, 11, 5)); color.y = Convert6To8(bitfieldExtract(val, 5, 6)); @@ -953,29 +974,27 @@ uvec4 GetPaletteColor(uint index) } #else // Not used. - color = uvec4(0, 0, 0, 0); + color = uint4(0, 0, 0, 0); #endif return color; } -vec4 GetPaletteColorNormalized(uint index) +float4 GetPaletteColorNormalized(uint index) { - uvec4 color = GetPaletteColor(index); - return vec4(color) / 255.0; + uint4 color = GetPaletteColor(index); + return float4(color) / 255.0; } )"; static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ {TextureFormat::I4, - {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x8 blocks, 4 bits per pixel // We need to do the tiling manually here because the texel size is smaller than @@ -996,108 +1015,98 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ else i = Convert4To8((val & 0x0Fu)); - uvec4 color = uvec4(i, i, i, i); - vec4 norm_color = vec4(color) / 255.0; + uint4 color = uint4(i, i, i, i); + float4 norm_color = float4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::IA4, - {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel - uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords); uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint i = Convert4To8((val & 0x0Fu)); uint a = Convert4To8((val >> 4)); - uvec4 color = uvec4(i, i, i, a); - vec4 norm_color = vec4(color) / 255.0; + uint4 color = uint4(i, i, i, a); + float4 norm_color = float4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::I8, - {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel - uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords); uint i = texelFetch(s_input_buffer, int(buffer_pos)).x; - uvec4 color = uvec4(i, i, i, i); - vec4 norm_color = vec4(color) / 255.0; + uint4 color = uint4(i, i, i, i); + float4 norm_color = float4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::IA8, - {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks, 16 bits per pixel - uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords); uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint a = (val & 0xFFu); uint i = (val >> 8); - uvec4 color = uvec4(i, i, i, a); - vec4 norm_color = vec4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + uint4 color = uint4(i, i, i, a); + float4 norm_color = float4(color) / 255.0; + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::RGB565, - {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks - uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords); uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x); - uvec4 color; + uint4 color; color.x = Convert5To8(bitfieldExtract(val, 11, 5)); color.y = Convert6To8(bitfieldExtract(val, 5, 6)); color.z = Convert5To8(bitfieldExtract(val, 0, 5)); color.a = 255u; - vec4 norm_color = vec4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = float4(color) / 255.0; + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::RGB5A3, - {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks - uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords); uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x); - uvec4 color; + uint4 color; if ((val & 0x8000u) != 0u) { color.x = Convert5To8(bitfieldExtract(val, 10, 5)); @@ -1113,19 +1122,17 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ color.b = Convert4To8(bitfieldExtract(val, 0, 4)); } - vec4 norm_color = vec4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = float4(color) / 255.0; + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::RGBA8, - {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks // We can't use the normal calculation function, as these are packed as the AR channels @@ -1144,18 +1151,18 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ uint val1 = texelFetch(s_input_buffer, int(buffer_pos + 0u)).x; uint val2 = texelFetch(s_input_buffer, int(buffer_pos + 16u)).x; - uvec4 color; + uint4 color; color.a = (val1 & 0xFFu); color.r = (val1 >> 8); color.g = (val2 & 0xFFu); color.b = (val2 >> 8); - vec4 norm_color = vec4(color) / 255.0; - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = float4(color) / 255.0; + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::CMPR, - {BUFFER_FORMAT_R32G32_UINT, 0, 64, 1, true, + {TEXEL_BUFFER_FORMAT_R32G32_UINT, 0, 64, 1, true, R"( // In the compute version of this decoder, we flatten the blocks to a one-dimension array. // Each group is subdivided into 16, and the first thread in each group fetches the DXT data. @@ -1167,17 +1174,15 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ #define BLOCK_SIZE (BLOCK_SIZE_X * BLOCK_SIZE_Y) #define BLOCKS_PER_GROUP (GROUP_SIZE / BLOCK_SIZE) - layout(local_size_x = GROUP_SIZE, local_size_y = 1) in; - - shared uvec2 shared_temp[BLOCKS_PER_GROUP]; - uint DXTBlend(uint v1, uint v2) { // 3/8 blend, which is close to 1/3 return ((v1 * 3u + v2 * 5u) >> 3); } - void main() + GROUP_SHARED uint2 shared_temp[BLOCKS_PER_GROUP]; + + DEFINE_MAIN(GROUP_SIZE, 8) { uint local_thread_id = gl_LocalInvocationID.x; uint block_in_group = local_thread_id / BLOCK_SIZE; @@ -1188,7 +1193,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ // from the block size of the overall texture (4 vs 8). We can however use a multiply and // subtraction to avoid the modulo for calculating the block's X coordinate. uint blocks_wide = u_src_size.x / BLOCK_SIZE_X; - uvec2 block_coords; + uint2 block_coords; block_coords.y = block_index / blocks_wide; block_coords.x = block_index - (block_coords.y * blocks_wide); @@ -1196,8 +1201,8 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ if (thread_in_block == 0u) { // Calculate tiled block coordinates. - uvec2 tile_block_coords = block_coords / 2u; - uvec2 subtile_block_coords = block_coords % 2u; + uint2 tile_block_coords = block_coords / 2u; + uint2 subtile_block_coords = block_coords % 2u; uint buffer_pos = u_src_offset; buffer_pos += tile_block_coords.y * u_src_row_stride; buffer_pos += tile_block_coords.x * 4u; @@ -1205,16 +1210,15 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ buffer_pos += subtile_block_coords.x; // Read the entire DXT block to shared memory. - uvec2 raw_data = texelFetch(s_input_buffer, int(buffer_pos)).xy; + uint2 raw_data = texelFetch(s_input_buffer, int(buffer_pos)).xy; shared_temp[block_in_group] = raw_data; } // Ensure store is completed before the remaining threads in the block continue. - memoryBarrierShared(); - barrier(); + GROUP_MEMORY_BARRIER_WITH_SYNC; // Unpack colors and swap BE to LE. - uvec2 raw_data = shared_temp[block_in_group]; + uint2 raw_data = shared_temp[block_in_group]; uint swapped = ((raw_data.x & 0xFF00FF00u) >> 8) | ((raw_data.x & 0x00FF00FFu) << 8); uint c1 = swapped & 0xFFFFu; uint c2 = swapped >> 16; @@ -1230,18 +1234,18 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ // Determine the four colors the block can use. // It's quicker to just precalculate all four colors rather than branching on the index. // NOTE: These must be masked with 0xFF. This is done at the normalization stage below. - uvec4 color0, color1, color2, color3; - color0 = uvec4(red1, green1, blue1, 255u); - color1 = uvec4(red2, green2, blue2, 255u); + uint4 color0, color1, color2, color3; + color0 = uint4(red1, green1, blue1, 255u); + color1 = uint4(red2, green2, blue2, 255u); if (c1 > c2) { - color2 = uvec4(DXTBlend(red2, red1), DXTBlend(green2, green1), DXTBlend(blue2, blue1), 255u); - color3 = uvec4(DXTBlend(red1, red2), DXTBlend(green1, green2), DXTBlend(blue1, blue2), 255u); + color2 = uint4(DXTBlend(red2, red1), DXTBlend(green2, green1), DXTBlend(blue2, blue1), 255u); + color3 = uint4(DXTBlend(red1, red2), DXTBlend(green1, green2), DXTBlend(blue1, blue2), 255u); } else { - color2 = uvec4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 255u); - color3 = uvec4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 0u); + color2 = uint4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 255u); + color3 = uint4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 0u); } // Calculate the texel coordinates that we will write to. @@ -1257,7 +1261,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ // Select the un-normalized color from the precalculated color array. // Using a switch statement here removes the need for dynamic indexing of an array. - uvec4 color; + uint4 color; switch (index) { case 0u: color = color0; break; @@ -1268,19 +1272,17 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ } // Normalize and write to the output image. - vec4 norm_color = vec4(color & 0xFFu) / 255.0; - imageStore(output_image, ivec3(ivec2(uvec2(global_x, global_y)), 0), norm_color); + float4 norm_color = float4(color & 0xFFu) / 255.0; + imageStore(output_image, int3(int2(uint2(global_x, global_y)), 0), norm_color); } )"}}, {TextureFormat::C4, - {BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C4)), 8, 8, - false, + {TEXEL_BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C4)), + 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x8 blocks, 4 bits per pixel // We need to do the tiling manually here because the texel size is smaller than @@ -1296,58 +1298,52 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ // Select high nibble for odd texels, low for even. uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint index = ((coords.x & 1u) == 0u) ? (val >> 4) : (val & 0x0Fu); - vec4 norm_color = GetPaletteColorNormalized(index); - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = GetPaletteColorNormalized(index); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::C8, - {BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C8)), 8, 8, - false, + {TEXEL_BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C8)), + 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel - uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords); uint index = texelFetch(s_input_buffer, int(buffer_pos)).x; - vec4 norm_color = GetPaletteColorNormalized(index); - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = GetPaletteColorNormalized(index); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, {TextureFormat::C14X2, - {BUFFER_FORMAT_R16_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C14X2)), 8, - 8, false, + {TEXEL_BUFFER_FORMAT_R16_UINT, + static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C14X2)), 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 coords = gl_GlobalInvocationID.xy; + uint2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks, 16 bits per pixel - uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); + uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords); uint index = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x) & 0x3FFFu; - vec4 norm_color = GetPaletteColorNormalized(index); - imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); + float4 norm_color = GetPaletteColorNormalized(index); + imageStore(output_image, int3(int2(coords), 0), norm_color); } )"}}, // We do the inverse BT.601 conversion for YCbCr to RGB // http://www.equasys.de/colorconversion.html#YCbCr-RGBColorFormatConversion {TextureFormat::XFB, - {BUFFER_FORMAT_RGBA8_UINT, 0, 8, 8, false, + {TEXEL_BUFFER_FORMAT_RGBA8_UINT, 0, 8, 8, false, R"( - layout(local_size_x = 8, local_size_y = 8) in; - - void main() + DEFINE_MAIN(8, 8) { - uvec2 uv = gl_GlobalInvocationID.xy; + uint2 uv = gl_GlobalInvocationID.xy; int buffer_pos = int(u_src_offset + (uv.y * u_src_row_stride) + (uv.x / 2u)); - vec4 yuyv = vec4(texelFetch(s_input_buffer, buffer_pos)); + float4 yuyv = float4(texelFetch(s_input_buffer, buffer_pos)); float y = mix(yuyv.r, yuyv.b, (uv.x & 1u) == 1u); @@ -1355,33 +1351,21 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ float uComp = yuyv.g - 128.0; float vComp = yuyv.a - 128.0; - vec4 rgb = vec4(yComp + (1.596 * vComp), + float4 rgb = float4(yComp + (1.596 * vComp), yComp - (0.813 * vComp) - (0.391 * uComp), yComp + (2.018 * uComp), 255.0); - vec4 rgba_norm = rgb / 255.0; - imageStore(output_image, ivec3(ivec2(uv), 0), rgba_norm); + float4 rgba_norm = rgb / 255.0; + imageStore(output_image, int3(int2(uv), 0), rgba_norm); } )"}}}; -static const std::array<u32, BUFFER_FORMAT_COUNT> s_buffer_bytes_per_texel = {{ - 1, // BUFFER_FORMAT_R8_UINT - 2, // BUFFER_FORMAT_R16_UINT - 8, // BUFFER_FORMAT_R32G32_UINT - 4, // BUFFER_FORMAT_RGBA8_UINT -}}; - const DecodingShaderInfo* GetDecodingShaderInfo(TextureFormat format) { auto iter = s_decoding_shader_info.find(format); return iter != s_decoding_shader_info.end() ? &iter->second : nullptr; } -u32 GetBytesPerBufferElement(BufferFormat buffer_format) -{ - return s_buffer_bytes_per_texel[buffer_format]; -} - std::pair<u32, u32> GetDispatchCount(const DecodingShaderInfo* info, u32 width, u32 height) { // Flatten to a single dimension? @@ -1419,4 +1403,126 @@ std::string GenerateDecodingShader(TextureFormat format, TLUTFormat palette_form return ss.str(); } +std::string GeneratePaletteConversionShader(TLUTFormat palette_format, APIType api_type) +{ + std::stringstream ss; + + ss << R"( +int Convert3To8(int v) +{ + // Swizzle bits: 00000123 -> 12312312 + return (v << 5) | (v << 2) | (v >> 1); +} +int Convert4To8(int v) +{ + // Swizzle bits: 00001234 -> 12341234 + return (v << 4) | v; +} +int Convert5To8(int v) +{ + // Swizzle bits: 00012345 -> 12345123 + return (v << 3) | (v >> 2); +} +int Convert6To8(int v) +{ + // Swizzle bits: 00123456 -> 12345612 + return (v << 2) | (v >> 4); +})"; + + switch (palette_format) + { + case TLUTFormat::IA8: + ss << R"( +float4 DecodePixel(int val) +{ + int i = val & 0xFF; + int a = val >> 8; + return float4(i, i, i, a) / 255.0; +})"; + break; + + case TLUTFormat::RGB565: + ss << R"( +float4 DecodePixel(int val) +{ + int r, g, b, a; + r = Convert5To8((val >> 11) & 0x1f); + g = Convert6To8((val >> 5) & 0x3f); + b = Convert5To8((val) & 0x1f); + a = 0xFF; + return float4(r, g, b, a) / 255.0; +})"; + break; + + case TLUTFormat::RGB5A3: + ss << R"( +float4 DecodePixel(int val) +{ + int r,g,b,a; + if ((val&0x8000) > 0) + { + r=Convert5To8((val>>10) & 0x1f); + g=Convert5To8((val>>5 ) & 0x1f); + b=Convert5To8((val ) & 0x1f); + a=0xFF; + } + else + { + a=Convert3To8((val>>12) & 0x7); + r=Convert4To8((val>>8 ) & 0xf); + g=Convert4To8((val>>4 ) & 0xf); + b=Convert4To8((val ) & 0xf); + } + return float4(r, g, b, a) / 255.0; +})"; + break; + + default: + PanicAlert("Unknown format"); + break; + } + + ss << "\n"; + + if (api_type == APIType::D3D) + { + ss << "Buffer<uint> tex0 : register(t0);\n"; + ss << "Texture2DArray tex1 : register(t1);\n"; + ss << "SamplerState samp1 : register(s1);\n"; + ss << "cbuffer PSBlock : register(b0) {\n"; + } + else + { + ss << "TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer samp0;\n"; + ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n"; + ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n"; + } + + ss << " float multiplier;\n"; + ss << " int texel_buffer_offset;\n"; + ss << "};\n"; + + if (api_type == APIType::D3D) + { + ss << "void main(in float3 v_tex0 : TEXCOORD0, out float4 ocol0 : SV_Target) {\n"; + ss << " int src = int(round(tex1.Sample(samp1, v_tex0).r * multiplier));\n"; + ss << " src = int(tex0.Load(src + texel_buffer_offset).r);\n"; + } + else + { + ss << "VARYING_LOCATION(0) in float3 v_tex0;\n"; + ss << "FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n"; + ss << "void main() {\n"; + ss << " float3 coords = v_tex0;\n"; + ss << " int src = int(round(texture(samp1, coords).r * multiplier));\n"; + ss << " src = int(texelFetch(samp0, src + texel_buffer_offset).r);\n"; + } + + ss << " src = ((src << 8) & 0xFF00) | (src >> 8);\n"; + ss << " ocol0 = DecodePixel(src);\n"; + ss << "}\n"; + + return ss.str(); +} + } // namespace TextureConversionShaderTiled |