ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GPU/HW: Move shadergen parameters to functions

This commit is contained in:
Stenzek 2024-10-19 18:25:40 +10:00
parent 1d21ca61e7
commit aa0c0068ce
No known key found for this signature in database
8 changed files with 198 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/core/gpu_hw.cpp
View File

@ -987,10 +987,14 @@ void GPU_HW::DestroyBuffers()
bool GPU_HW::CompilePipelines(Error* error) bool GPU_HW::CompilePipelines(Error* error)
{ {
const GPUDevice::Features features = g_gpu_device->GetFeatures(); const GPUDevice::Features features = g_gpu_device->GetFeatures();
const bool per_sample_shading = g_settings.gpu_per_sample_shading && features.per_sample_shading; const bool upscaled = (m_resolution_scale > 1);
const bool force_round_texcoords = (m_resolution_scale > 1 && m_texture_filtering == GPUTextureFilter::Nearest && const bool msaa = (m_multisamples > 1);
g_settings.gpu_force_round_texcoords); const bool per_sample_shading = (msaa && g_settings.gpu_per_sample_shading && features.per_sample_shading);
const bool force_round_texcoords =
(upscaled && m_texture_filtering == GPUTextureFilter::Nearest && g_settings.gpu_force_round_texcoords);
const bool true_color = g_settings.gpu_true_color; const bool true_color = g_settings.gpu_true_color;
const bool scaled_dithering = (!m_true_color && upscaled && g_settings.gpu_scaled_dithering);
const bool disable_color_perspective = ShouldDisableColorPerspective();
// Determine when to use shader blending. // Determine when to use shader blending.
// FBFetch is free, we need it for filtering without DSB, or when accurate blending is forced. // FBFetch is free, we need it for filtering without DSB, or when accurate blending is forced.
@ -1029,10 +1033,8 @@ bool GPU_HW::CompilePipelines(Error* error)
INFO_LOG("Using feedback loops: {}", needs_feedback_loop ? "YES" : "NO"); INFO_LOG("Using feedback loops: {}", needs_feedback_loop ? "YES" : "NO");
// Start generating shaders. // Start generating shaders.
GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), m_resolution_scale, m_multisamples, per_sample_shading, const GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), m_supports_dual_source_blend,
m_true_color, (m_resolution_scale > 1 && g_settings.gpu_scaled_dithering), m_supports_framebuffer_fetch);
m_write_mask_as_depth, ShouldDisableColorPerspective(), m_supports_dual_source_blend,
m_supports_framebuffer_fetch);
const u32 active_texture_modes = const u32 active_texture_modes =
m_allow_sprite_mode ? NUM_TEXTURE_MODES : m_allow_sprite_mode ? NUM_TEXTURE_MODES :
@ -1085,7 +1087,8 @@ bool GPU_HW::CompilePipelines(Error* error)
const bool uv_limits = ShouldClampUVs(sprite ? m_sprite_texture_filtering : m_texture_filtering); const bool uv_limits = ShouldClampUVs(sprite ? m_sprite_texture_filtering : m_texture_filtering);
const std::string vs = shadergen.GenerateBatchVertexShader( const std::string vs = shadergen.GenerateBatchVertexShader(
textured != 0, palette == 1, palette == 2, uv_limits, !sprite && force_round_texcoords, m_pgxp_depth_buffer); upscaled, msaa, per_sample_shading, textured != 0, palette == 1, palette == 2, uv_limits,
!sprite && force_round_texcoords, m_pgxp_depth_buffer, disable_color_perspective);
if (!(batch_vertex_shaders[textured][palette][sprite] = if (!(batch_vertex_shaders[textured][palette][sprite] =
g_gpu_device->CreateShader(GPUShaderStage::Vertex, shadergen.GetLanguage(), vs, error))) g_gpu_device->CreateShader(GPUShaderStage::Vertex, shadergen.GetLanguage(), vs, error)))
{ {
@ -1157,10 +1160,11 @@ bool GPU_HW::CompilePipelines(Error* error)
(render_mode == static_cast<u8>(BatchRenderMode::ShaderBlend) && m_use_rov_for_shader_blend); (render_mode == static_cast<u8>(BatchRenderMode::ShaderBlend) && m_use_rov_for_shader_blend);
const std::string fs = shadergen.GenerateBatchFragmentShader( const std::string fs = shadergen.GenerateBatchFragmentShader(
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTransparencyMode>(transparency_mode), static_cast<BatchRenderMode>(render_mode), static_cast<GPUTransparencyMode>(transparency_mode),
shader_texmode, sprite ? m_sprite_texture_filtering : m_texture_filtering, uv_limits, shader_texmode, sprite ? m_sprite_texture_filtering : m_texture_filtering, upscaled, msaa,
!sprite && force_round_texcoords, ConvertToBoolUnchecked(dithering), per_sample_shading, uv_limits, !sprite && force_round_texcoords, true_color,
ConvertToBoolUnchecked(interlacing), ConvertToBoolUnchecked(check_mask), use_rov, needs_rov_depth, ConvertToBoolUnchecked(dithering), scaled_dithering, disable_color_perspective,
(depth_test != 0)); ConvertToBoolUnchecked(interlacing), ConvertToBoolUnchecked(check_mask), m_write_mask_as_depth,
use_rov, needs_rov_depth, (depth_test != 0));
if (!(batch_fragment_shaders[depth_test][render_mode][transparency_mode][texture_mode][check_mask] if (!(batch_fragment_shaders[depth_test][render_mode][transparency_mode][texture_mode][check_mask]
[dithering][interlacing] = g_gpu_device->CreateShader( [dithering][interlacing] = g_gpu_device->CreateShader(
@ -1433,7 +1437,8 @@ bool GPU_HW::CompilePipelines(Error* error)
{ {
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader( std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(), GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMFillFragmentShader(ConvertToBoolUnchecked(wrapped), ConvertToBoolUnchecked(interlaced)), shadergen.GenerateVRAMFillFragmentShader(ConvertToBoolUnchecked(wrapped), ConvertToBoolUnchecked(interlaced),
m_write_mask_as_depth),
error); error);
if (!fs) if (!fs)
return false; return false;
@ -1451,8 +1456,9 @@ bool GPU_HW::CompilePipelines(Error* error)
// VRAM copy // VRAM copy
{ {
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
shadergen.GenerateVRAMCopyFragmentShader(), error); GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMCopyFragmentShader(m_resolution_scale, m_write_mask_as_depth), error);
if (!fs) if (!fs)
return false; return false;
@ -1479,9 +1485,10 @@ bool GPU_HW::CompilePipelines(Error* error)
{ {
const bool use_buffer = features.supports_texture_buffers; const bool use_buffer = features.supports_texture_buffers;
const bool use_ssbo = features.texture_buffers_emulated_with_ssbo; const bool use_ssbo = features.texture_buffers_emulated_with_ssbo;
std::unique_ptr<GPUShader> fs = std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMWriteFragmentShader(use_buffer, use_ssbo), error); shadergen.GenerateVRAMWriteFragmentShader(m_resolution_scale, use_buffer, use_ssbo, m_write_mask_as_depth),
error);
if (!fs) if (!fs)
return false; return false;
@ -1527,7 +1534,7 @@ bool GPU_HW::CompilePipelines(Error* error)
if (m_write_mask_as_depth) if (m_write_mask_as_depth)
{ {
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader( std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(), shadergen.GenerateVRAMUpdateDepthFragmentShader(), error); GPUShaderStage::Fragment, shadergen.GetLanguage(), shadergen.GenerateVRAMUpdateDepthFragmentShader(msaa), error);
if (!fs) if (!fs)
return false; return false;
@ -1553,8 +1560,9 @@ bool GPU_HW::CompilePipelines(Error* error)
// VRAM read // VRAM read
{ {
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), std::unique_ptr<GPUShader> fs =
shadergen.GenerateVRAMReadFragmentShader(), error); g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMReadFragmentShader(m_resolution_scale, m_multisamples), error);
if (!fs) if (!fs)
return false; return false;
@ -1577,9 +1585,10 @@ bool GPU_HW::CompilePipelines(Error* error)
if (depth_extract && !m_pgxp_depth_buffer) if (depth_extract && !m_pgxp_depth_buffer)
continue; continue;
std::unique_ptr<GPUShader> fs = std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMExtractFragmentShader(color_24bit, depth_extract), error); shadergen.GenerateVRAMExtractFragmentShader(m_resolution_scale, m_multisamples, color_24bit, depth_extract),
error);
if (!fs) if (!fs)
return false; return false;

160
src/core/gpu_hw_shadergen.cpp
View File

@ -8,20 +8,15 @@
#include "common/assert.h" #include "common/assert.h"
GPU_HW_ShaderGen::GPU_HW_ShaderGen(RenderAPI render_api, u32 resolution_scale, u32 multisamples, GPU_HW_ShaderGen::GPU_HW_ShaderGen(RenderAPI render_api, bool supports_dual_source_blend,
bool per_sample_shading, bool true_color, bool scaled_dithering, bool supports_framebuffer_fetch)
bool write_mask_as_depth, bool disable_color_perspective, : ShaderGen(render_api, GetShaderLanguageForAPI(render_api), supports_dual_source_blend, supports_framebuffer_fetch)
bool supports_dual_source_blend, bool supports_framebuffer_fetch)
: ShaderGen(render_api, GetShaderLanguageForAPI(render_api), supports_dual_source_blend, supports_framebuffer_fetch),
m_resolution_scale(resolution_scale), m_multisamples(multisamples), m_per_sample_shading(per_sample_shading),
m_true_color(true_color), m_scaled_dithering(scaled_dithering), m_write_mask_as_depth(write_mask_as_depth),
m_disable_color_perspective(disable_color_perspective)
{ {
} }
GPU_HW_ShaderGen::~GPU_HW_ShaderGen() = default; GPU_HW_ShaderGen::~GPU_HW_ShaderGen() = default;
void GPU_HW_ShaderGen::WriteColorConversionFunctions(std::stringstream& ss) void GPU_HW_ShaderGen::WriteColorConversionFunctions(std::stringstream& ss) const
{ {
ss << R"( ss << R"(
uint RGBA8ToRGBA5551(float4 v) uint RGBA8ToRGBA5551(float4 v)
@ -45,7 +40,7 @@ float4 RGBA5551ToRGBA8(uint v)
)"; )";
} }
void GPU_HW_ShaderGen::WriteBatchUniformBuffer(std::stringstream& ss) void GPU_HW_ShaderGen::WriteBatchUniformBuffer(std::stringstream& ss) const
{ {
DeclareUniformBuffer(ss, DeclareUniformBuffer(ss,
{"uint2 u_texture_window_and", "uint2 u_texture_window_or", "float u_src_alpha_factor", {"uint2 u_texture_window_and", "uint2 u_texture_window_or", "float u_src_alpha_factor",
@ -55,8 +50,10 @@ void GPU_HW_ShaderGen::WriteBatchUniformBuffer(std::stringstream& ss)
false); false);
} }
std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool palette, bool page_texture, bool uv_limits, std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool upscaled, bool msaa, bool per_sample_shading,
bool force_round_texcoords, bool pgxp_depth) bool textured, bool palette, bool page_texture, bool uv_limits,
bool force_round_texcoords, bool pgxp_depth,
bool disable_color_perspective) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -66,7 +63,7 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
DefineMacro(ss, "UV_LIMITS", uv_limits); DefineMacro(ss, "UV_LIMITS", uv_limits);
DefineMacro(ss, "FORCE_ROUND_TEXCOORDS", force_round_texcoords); DefineMacro(ss, "FORCE_ROUND_TEXCOORDS", force_round_texcoords);
DefineMacro(ss, "PGXP_DEPTH", pgxp_depth); DefineMacro(ss, "PGXP_DEPTH", pgxp_depth);
DefineMacro(ss, "UPSCALED", m_resolution_scale > 1); DefineMacro(ss, "UPSCALED", upscaled);
WriteBatchUniformBuffer(ss); WriteBatchUniformBuffer(ss);
@ -76,13 +73,12 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
{ {
DeclareVertexEntryPoint( DeclareVertexEntryPoint(
ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage", "float4 a_uv_limits"}, 1, 1, ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage", "float4 a_uv_limits"}, 1, 1,
{{"nointerpolation", "float4 v_uv_limits"}}, false, "", UsingMSAA(), UsingPerSampleShading(), {{"nointerpolation", "float4 v_uv_limits"}}, false, "", msaa, per_sample_shading, disable_color_perspective);
m_disable_color_perspective);
} }
else else
{ {
DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage"}, 1, 1, {}, DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage"}, 1, 1, {},
false, "", UsingMSAA(), UsingPerSampleShading(), m_disable_color_perspective); false, "", msaa, per_sample_shading, disable_color_perspective);
} }
} }
else if (textured) else if (textured)
@ -93,19 +89,19 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage", "float4 a_uv_limits"}, 1, 1, ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage", "float4 a_uv_limits"}, 1, 1,
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}, {{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"},
{"nointerpolation", "float4 v_uv_limits"}}, {"nointerpolation", "float4 v_uv_limits"}},
false, "", UsingMSAA(), UsingPerSampleShading(), m_disable_color_perspective); false, "", msaa, per_sample_shading, disable_color_perspective);
} }
else else
{ {
DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage"}, 1, 1, DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0", "uint a_texcoord", "uint a_texpage"}, 1, 1,
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}}, false, "", {{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}}, false, "", msaa,
UsingMSAA(), UsingPerSampleShading(), m_disable_color_perspective); per_sample_shading, disable_color_perspective);
} }
} }
else else
{ {
DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0"}, 1, 0, {}, false, "", UsingMSAA(), DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0"}, 1, 0, {}, false, "", msaa, per_sample_shading,
UsingPerSampleShading(), m_disable_color_perspective); disable_color_perspective);
} }
ss << R"( ss << R"(
@ -179,7 +175,7 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
return ss.str(); return ss.str();
} }
void GPU_HW_ShaderGen::WriteBatchTextureFilter(std::stringstream& ss, GPUTextureFilter texture_filter) void GPU_HW_ShaderGen::WriteBatchTextureFilter(std::stringstream& ss, GPUTextureFilter texture_filter) const
{ {
// JINC2 and xBRZ shaders originally from beetle-psx, modified to support filtering mask channel. // JINC2 and xBRZ shaders originally from beetle-psx, modified to support filtering mask channel.
if (texture_filter == GPUTextureFilter::Bilinear || texture_filter == GPUTextureFilter::BilinearBinAlpha) if (texture_filter == GPUTextureFilter::Bilinear || texture_filter == GPUTextureFilter::BilinearBinAlpha)
@ -713,10 +709,12 @@ void FilteredSampleFromVRAM(TEXPAGE_VALUE texpage, float2 coords, float4 uv_limi
std::string GPU_HW_ShaderGen::GenerateBatchFragmentShader( std::string GPU_HW_ShaderGen::GenerateBatchFragmentShader(
GPU_HW::BatchRenderMode render_mode, GPUTransparencyMode transparency, GPU_HW::BatchTextureMode texture_mode, GPU_HW::BatchRenderMode render_mode, GPUTransparencyMode transparency, GPU_HW::BatchTextureMode texture_mode,
GPUTextureFilter texture_filtering, bool uv_limits, bool force_round_texcoords, bool dithering, bool interlacing, GPUTextureFilter texture_filtering, bool upscaled, bool msaa, bool per_sample_shading, bool uv_limits,
bool check_mask, bool use_rov, bool use_rov_depth, bool rov_depth_test) bool force_round_texcoords, bool true_color, bool dithering, bool scaled_dithering, bool disable_color_perspective,
bool interlacing, bool check_mask, bool write_mask_as_depth, bool use_rov, bool use_rov_depth,
bool rov_depth_test) const
{ {
DebugAssert(!m_true_color || !dithering); // Should not be doing dithering+true color. DebugAssert(!true_color || !dithering); // Should not be doing dithering+true color.
// TODO: don't write depth for shader blend // TODO: don't write depth for shader blend
DebugAssert(transparency == GPUTransparencyMode::Disabled || render_mode == GPU_HW::BatchRenderMode::ShaderBlend); DebugAssert(transparency == GPUTransparencyMode::Disabled || render_mode == GPU_HW::BatchRenderMode::ShaderBlend);
@ -746,18 +744,18 @@ std::string GPU_HW_ShaderGen::GenerateBatchFragmentShader(
DefineMacro(ss, "PALETTE_8_BIT", texture_mode == GPU_HW::BatchTextureMode::Palette8Bit); DefineMacro(ss, "PALETTE_8_BIT", texture_mode == GPU_HW::BatchTextureMode::Palette8Bit);
DefineMacro(ss, "PAGE_TEXTURE", page_texture); DefineMacro(ss, "PAGE_TEXTURE", page_texture);
DefineMacro(ss, "DITHERING", dithering); DefineMacro(ss, "DITHERING", dithering);
DefineMacro(ss, "DITHERING_SCALED", m_scaled_dithering); DefineMacro(ss, "DITHERING_SCALED", dithering && scaled_dithering);
DefineMacro(ss, "INTERLACING", interlacing); DefineMacro(ss, "INTERLACING", interlacing);
DefineMacro(ss, "TRUE_COLOR", m_true_color); DefineMacro(ss, "TRUE_COLOR", true_color);
DefineMacro(ss, "TEXTURE_FILTERING", texture_filtering != GPUTextureFilter::Nearest); DefineMacro(ss, "TEXTURE_FILTERING", texture_filtering != GPUTextureFilter::Nearest);
DefineMacro(ss, "UV_LIMITS", uv_limits); DefineMacro(ss, "UV_LIMITS", uv_limits);
DefineMacro(ss, "USE_ROV", use_rov); DefineMacro(ss, "USE_ROV", use_rov);
DefineMacro(ss, "USE_ROV_DEPTH", use_rov_depth); DefineMacro(ss, "USE_ROV_DEPTH", use_rov_depth);
DefineMacro(ss, "ROV_DEPTH_TEST", rov_depth_test); DefineMacro(ss, "ROV_DEPTH_TEST", rov_depth_test);
DefineMacro(ss, "USE_DUAL_SOURCE", use_dual_source); DefineMacro(ss, "USE_DUAL_SOURCE", use_dual_source);
DefineMacro(ss, "WRITE_MASK_AS_DEPTH", m_write_mask_as_depth); DefineMacro(ss, "WRITE_MASK_AS_DEPTH", write_mask_as_depth);
DefineMacro(ss, "FORCE_ROUND_TEXCOORDS", force_round_texcoords); DefineMacro(ss, "FORCE_ROUND_TEXCOORDS", force_round_texcoords);
DefineMacro(ss, "UPSCALED", m_resolution_scale > 1); DefineMacro(ss, "UPSCALED", upscaled);
// Used for converting to normalized coordinates for sampling. // Used for converting to normalized coordinates for sampling.
ss << "CONSTANT float2 RCP_VRAM_SIZE = float2(1.0 / float(" << VRAM_WIDTH << "), 1.0 / float(" << VRAM_HEIGHT ss << "CONSTANT float2 RCP_VRAM_SIZE = float2(1.0 / float(" << VRAM_WIDTH << "), 1.0 / float(" << VRAM_HEIGHT
@ -903,14 +901,14 @@ float4 SampleFromPageTexture(float2 coords)
if (uv_limits) if (uv_limits)
{ {
DeclareFragmentEntryPoint(ss, 1, 1, {{"nointerpolation", "float4 v_uv_limits"}}, true, num_fragment_outputs, DeclareFragmentEntryPoint(ss, 1, 1, {{"nointerpolation", "float4 v_uv_limits"}}, true, num_fragment_outputs,
use_dual_source, m_write_mask_as_depth, UsingMSAA(), UsingPerSampleShading(), false, use_dual_source, write_mask_as_depth, msaa, per_sample_shading, false,
m_disable_color_perspective, shader_blending && !use_rov, use_rov); disable_color_perspective, shader_blending && !use_rov, use_rov);
} }
else else
{ {
DeclareFragmentEntryPoint(ss, 1, 1, {}, true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth, DeclareFragmentEntryPoint(ss, 1, 1, {}, true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
UsingMSAA(), UsingPerSampleShading(), false, m_disable_color_perspective, per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
shader_blending && !use_rov, use_rov); use_rov);
} }
} }
else if (textured) else if (textured)
@ -923,23 +921,22 @@ float4 SampleFromPageTexture(float2 coords)
DeclareFragmentEntryPoint(ss, 1, 1, DeclareFragmentEntryPoint(ss, 1, 1,
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}, {{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"},
{"nointerpolation", "float4 v_uv_limits"}}, {"nointerpolation", "float4 v_uv_limits"}},
true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth, UsingMSAA(), true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
UsingPerSampleShading(), false, m_disable_color_perspective, per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
shader_blending && !use_rov, use_rov); use_rov);
} }
else else
{ {
DeclareFragmentEntryPoint(ss, 1, 1, {{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}}, true, DeclareFragmentEntryPoint(ss, 1, 1, {{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}}, true,
num_fragment_outputs, use_dual_source, m_write_mask_as_depth, UsingMSAA(), num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa, per_sample_shading,
UsingPerSampleShading(), false, m_disable_color_perspective, false, disable_color_perspective, shader_blending && !use_rov, use_rov);
shader_blending && !use_rov, use_rov);
} }
} }
else else
{ {
DeclareFragmentEntryPoint(ss, 1, 0, {}, true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth, DeclareFragmentEntryPoint(ss, 1, 0, {}, true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
UsingMSAA(), UsingPerSampleShading(), false, m_disable_color_perspective, per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
shader_blending && !use_rov, use_rov); use_rov);
} }
ss << R"( ss << R"(
@ -1181,23 +1178,26 @@ float4 SampleFromPageTexture(float2 coords)
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMExtractFragmentShader(bool color_24bit, bool depth_buffer) std::string GPU_HW_ShaderGen::GenerateVRAMExtractFragmentShader(u32 resolution_scale, u32 multisamples,
bool color_24bit, bool depth_buffer) const
{ {
const bool msaa = (multisamples > 1);
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
WriteColorConversionFunctions(ss); WriteColorConversionFunctions(ss);
DefineMacro(ss, "COLOR_24BIT", color_24bit); DefineMacro(ss, "COLOR_24BIT", color_24bit);
DefineMacro(ss, "DEPTH_BUFFER", depth_buffer); DefineMacro(ss, "DEPTH_BUFFER", depth_buffer);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA()); DefineMacro(ss, "MULTISAMPLING", msaa);
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n"; ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\n";
ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ") * RESOLUTION_SCALE;\n"; ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ") * RESOLUTION_SCALE;\n";
ss << "CONSTANT uint MULTISAMPLES = " << m_multisamples << "u;\n"; ss << "CONSTANT uint MULTISAMPLES = " << multisamples << "u;\n";
DeclareUniformBuffer(ss, {"uint2 u_vram_offset", "uint u_skip_x", "uint u_line_skip"}, true); DeclareUniformBuffer(ss, {"uint2 u_vram_offset", "uint u_skip_x", "uint u_line_skip"}, true);
DeclareTexture(ss, "samp0", 0, UsingMSAA()); DeclareTexture(ss, "samp0", 0, msaa);
if (depth_buffer) if (depth_buffer)
DeclareTexture(ss, "samp1", 1, UsingMSAA()); DeclareTexture(ss, "samp1", 1, msaa);
ss << R"( ss << R"(
float4 LoadVRAM(int2 coords) float4 LoadVRAM(int2 coords)
@ -1269,7 +1269,7 @@ float3 SampleVRAM24(uint2 icoords)
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateWireframeGeometryShader() std::string GPU_HW_ShaderGen::GenerateWireframeGeometryShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1342,7 +1342,7 @@ void main(triangle GSInput input[3], inout LineStream<GSOutput> output)
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader() std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1357,18 +1357,20 @@ std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMReadFragmentShader() std::string GPU_HW_ShaderGen::GenerateVRAMReadFragmentShader(u32 resolution_scale, u32 multisamples) const
{ {
const bool msaa = (multisamples > 1);
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
WriteColorConversionFunctions(ss); WriteColorConversionFunctions(ss);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA()); DefineMacro(ss, "MULTISAMPLING", msaa);
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n"; ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\n";
ss << "CONSTANT uint MULTISAMPLES = " << m_multisamples << "u;\n"; ss << "CONSTANT uint MULTISAMPLES = " << multisamples << "u;\n";
DeclareUniformBuffer(ss, {"uint2 u_base_coords", "uint2 u_size"}, true); DeclareUniformBuffer(ss, {"uint2 u_base_coords", "uint2 u_size"}, true);
DeclareTexture(ss, "samp0", 0, UsingMSAA()); DeclareTexture(ss, "samp0", 0, msaa);
ss << R"( ss << R"(
float4 LoadVRAM(int2 coords) float4 LoadVRAM(int2 coords)
@ -1420,16 +1422,17 @@ uint SampleVRAM(uint2 coords)
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMWriteFragmentShader(bool use_buffer, bool use_ssbo) std::string GPU_HW_ShaderGen::GenerateVRAMWriteFragmentShader(u32 resolution_scale, bool use_buffer, bool use_ssbo,
bool write_mask_as_depth) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
WriteColorConversionFunctions(ss); WriteColorConversionFunctions(ss);
DefineMacro(ss, "WRITE_MASK_AS_DEPTH", m_write_mask_as_depth); DefineMacro(ss, "WRITE_MASK_AS_DEPTH", write_mask_as_depth);
DefineMacro(ss, "USE_BUFFER", use_buffer); DefineMacro(ss, "USE_BUFFER", use_buffer);
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n"; ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\n";
ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ");\n"; ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ");\n";
DeclareUniformBuffer(ss, DeclareUniformBuffer(ss,
@ -1463,7 +1466,7 @@ std::string GPU_HW_ShaderGen::GenerateVRAMWriteFragmentShader(bool use_buffer, b
ss << "#define GET_VALUE(buffer_offset) (LOAD_TEXTURE_BUFFER(samp0, int(buffer_offset)).r)\n\n"; ss << "#define GET_VALUE(buffer_offset) (LOAD_TEXTURE_BUFFER(samp0, int(buffer_offset)).r)\n\n";
} }
DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 1, false, m_write_mask_as_depth); DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 1, false, write_mask_as_depth);
ss << R"( ss << R"(
{ {
uint2 coords = uint2(v_pos.xy) / uint2(RESOLUTION_SCALE, RESOLUTION_SCALE); uint2 coords = uint2(v_pos.xy) / uint2(RESOLUTION_SCALE, RESOLUTION_SCALE);
@ -1496,17 +1499,17 @@ std::string GPU_HW_ShaderGen::GenerateVRAMWriteFragmentShader(bool use_buffer, b
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader() std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader(u32 resolution_scale, bool write_mask_as_depth) const
{ {
// TODO: This won't currently work because we can't bind the texture to both the shader and framebuffer. // TODO: This won't currently work because we can't bind the texture to both the shader and framebuffer.
const bool msaa = false; const bool msaa = false;
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
DefineMacro(ss, "WRITE_MASK_AS_DEPTH", m_write_mask_as_depth); DefineMacro(ss, "WRITE_MASK_AS_DEPTH", write_mask_as_depth);
DefineMacro(ss, "MSAA_COPY", msaa); DefineMacro(ss, "MSAA_COPY", msaa);
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n"; ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\n";
ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ") * RESOLUTION_SCALE;\n"; ss << "CONSTANT uint2 VRAM_SIZE = uint2(" << VRAM_WIDTH << ", " << VRAM_HEIGHT << ") * RESOLUTION_SCALE;\n";
DeclareUniformBuffer(ss, DeclareUniformBuffer(ss,
@ -1515,7 +1518,7 @@ std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader()
true); true);
DeclareTexture(ss, "samp0", 0, msaa); DeclareTexture(ss, "samp0", 0, msaa);
DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 1, false, m_write_mask_as_depth, false, false, msaa); DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 1, false, write_mask_as_depth, false, false, msaa);
ss << R"( ss << R"(
{ {
uint2 dst_coords = uint2(v_pos.xy); uint2 dst_coords = uint2(v_pos.xy);
@ -1550,18 +1553,19 @@ std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMFillFragmentShader(bool wrapped, bool interlaced) std::string GPU_HW_ShaderGen::GenerateVRAMFillFragmentShader(bool wrapped, bool interlaced,
bool write_mask_as_depth) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
DefineMacro(ss, "WRITE_MASK_AS_DEPTH", m_write_mask_as_depth); DefineMacro(ss, "WRITE_MASK_AS_DEPTH", write_mask_as_depth);
DefineMacro(ss, "WRAPPED", wrapped); DefineMacro(ss, "WRAPPED", wrapped);
DefineMacro(ss, "INTERLACED", interlaced); DefineMacro(ss, "INTERLACED", interlaced);
DeclareUniformBuffer( DeclareUniformBuffer(
ss, {"uint2 u_dst_coords", "uint2 u_end_coords", "float4 u_fill_color", "uint u_interlaced_displayed_field"}, true); ss, {"uint2 u_dst_coords", "uint2 u_end_coords", "float4 u_fill_color", "uint u_interlaced_displayed_field"}, true);
DeclareFragmentEntryPoint(ss, 0, 1, {}, interlaced || wrapped, 1, false, m_write_mask_as_depth, false, false, false); DeclareFragmentEntryPoint(ss, 0, 1, {}, interlaced || wrapped, 1, false, write_mask_as_depth, false, false, false);
ss << R"( ss << R"(
{ {
#if INTERLACED || WRAPPED #if INTERLACED || WRAPPED
@ -1591,13 +1595,13 @@ std::string GPU_HW_ShaderGen::GenerateVRAMFillFragmentShader(bool wrapped, bool
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader() std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader(bool msaa) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA()); DefineMacro(ss, "MULTISAMPLING", msaa);
DeclareTexture(ss, "samp0", 0, UsingMSAA()); DeclareTexture(ss, "samp0", 0, msaa);
DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 0, false, true, false, false, UsingMSAA()); DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 0, false, true, false, false, msaa);
ss << R"( ss << R"(
{ {
@ -1612,12 +1616,12 @@ std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader()
return ss.str(); return ss.str();
} }
void GPU_HW_ShaderGen::WriteAdaptiveDownsampleUniformBuffer(std::stringstream& ss) void GPU_HW_ShaderGen::WriteAdaptiveDownsampleUniformBuffer(std::stringstream& ss) const
{ {
DeclareUniformBuffer(ss, {"float2 u_uv_min", "float2 u_uv_max", "float2 u_pixel_size", "float u_lod"}, true); DeclareUniformBuffer(ss, {"float2 u_uv_min", "float2 u_uv_max", "float2 u_pixel_size", "float u_lod"}, true);
} }
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader() std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1636,7 +1640,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader()
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader() std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1670,7 +1674,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader() std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1707,7 +1711,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader() std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1725,7 +1729,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader(
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 factor) std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 factor) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -1752,7 +1756,7 @@ std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 fact
return ss.str(); return ss.str();
} }
std::string GPU_HW_ShaderGen::GenerateReplacementMergeFragmentShader(bool semitransparent, bool bilinear_filter) std::string GPU_HW_ShaderGen::GenerateReplacementMergeFragmentShader(bool semitransparent, bool bilinear_filter) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);

65
src/core/gpu_hw_shadergen.h
View File

@ -10,48 +10,41 @@
class GPU_HW_ShaderGen : public ShaderGen class GPU_HW_ShaderGen : public ShaderGen
{ {
public: public:
GPU_HW_ShaderGen(RenderAPI render_api, u32 resolution_scale, u32 multisamples, bool per_sample_shading, GPU_HW_ShaderGen(RenderAPI render_api, bool supports_dual_source_blend, bool supports_framebuffer_fetch);
bool true_color, bool scaled_dithering, bool write_mask_as_depth, bool disable_color_perspective,
bool supports_dual_source_blend, bool supports_framebuffer_fetch);
~GPU_HW_ShaderGen(); ~GPU_HW_ShaderGen();
std::string GenerateBatchVertexShader(bool textured, bool palette, bool page_texture, bool uv_limits, std::string GenerateBatchVertexShader(bool upscaled, bool msaa, bool per_sample_shading, bool textured, bool palette,
bool force_round_texcoords, bool pgxp_depth); bool page_texture, bool uv_limits, bool force_round_texcoords, bool pgxp_depth,
bool disable_color_perspective) const;
std::string GenerateBatchFragmentShader(GPU_HW::BatchRenderMode render_mode, GPUTransparencyMode transparency, std::string GenerateBatchFragmentShader(GPU_HW::BatchRenderMode render_mode, GPUTransparencyMode transparency,
GPU_HW::BatchTextureMode texture_mode, GPUTextureFilter texture_filtering, GPU_HW::BatchTextureMode texture_mode, GPUTextureFilter texture_filtering,
bool uv_limits, bool force_round_texcoords, bool dithering, bool interlacing, bool upscaled, bool msaa, bool per_sample_shading, bool uv_limits,
bool check_mask, bool use_rov, bool use_rov_depth, bool rov_depth_test); bool force_round_texcoords, bool true_color, bool dithering,
std::string GenerateWireframeGeometryShader(); bool scaled_dithering, bool disable_color_perspective, bool interlacing,
std::string GenerateWireframeFragmentShader(); bool check_mask, bool write_mask_as_depth, bool use_rov, bool use_rov_depth,
std::string GenerateVRAMReadFragmentShader(); bool rov_depth_test) const;
std::string GenerateVRAMWriteFragmentShader(bool use_buffer, bool use_ssbo); std::string GenerateWireframeGeometryShader() const;
std::string GenerateVRAMCopyFragmentShader(); std::string GenerateWireframeFragmentShader() const;
std::string GenerateVRAMFillFragmentShader(bool wrapped, bool interlaced); std::string GenerateVRAMReadFragmentShader(u32 resolution_scale, u32 multisamples) const;
std::string GenerateVRAMUpdateDepthFragmentShader(); std::string GenerateVRAMWriteFragmentShader(u32 resolution_scale, bool use_buffer, bool use_ssbo,
std::string GenerateVRAMExtractFragmentShader(bool color_24bit, bool depth_buffer); bool write_mask_as_depth) const;
std::string GenerateVRAMCopyFragmentShader(u32 resolution_scale, bool write_mask_as_depth) const;
std::string GenerateVRAMFillFragmentShader(bool wrapped, bool interlaced, bool write_mask_as_depth) const;
std::string GenerateVRAMUpdateDepthFragmentShader(bool msaa) const;
std::string GenerateVRAMExtractFragmentShader(u32 resolution_scale, u32 multisamples, bool color_24bit,
bool depth_buffer) const;
std::string GenerateAdaptiveDownsampleVertexShader(); std::string GenerateAdaptiveDownsampleVertexShader() const;
std::string GenerateAdaptiveDownsampleMipFragmentShader(); std::string GenerateAdaptiveDownsampleMipFragmentShader() const;
std::string GenerateAdaptiveDownsampleBlurFragmentShader(); std::string GenerateAdaptiveDownsampleBlurFragmentShader() const;
std::string GenerateAdaptiveDownsampleCompositeFragmentShader(); std::string GenerateAdaptiveDownsampleCompositeFragmentShader() const;
std::string GenerateBoxSampleDownsampleFragmentShader(u32 factor); std::string GenerateBoxSampleDownsampleFragmentShader(u32 factor) const;
std::string GenerateReplacementMergeFragmentShader(bool semitransparent, bool bilinear_filter); std::string GenerateReplacementMergeFragmentShader(bool semitransparent, bool bilinear_filter) const;
private: private:
ALWAYS_INLINE bool UsingMSAA() const { return m_multisamples > 1; } void WriteColorConversionFunctions(std::stringstream& ss) const;
ALWAYS_INLINE bool UsingPerSampleShading() const { return m_multisamples > 1 && m_per_sample_shading; } void WriteBatchUniformBuffer(std::stringstream& ss) const;
void WriteBatchTextureFilter(std::stringstream& ss, GPUTextureFilter texture_filter) const;
void WriteColorConversionFunctions(std::stringstream& ss); void WriteAdaptiveDownsampleUniformBuffer(std::stringstream& ss) const;
void WriteBatchUniformBuffer(std::stringstream& ss);
void WriteBatchTextureFilter(std::stringstream& ss, GPUTextureFilter texture_filter);
void WriteAdaptiveDownsampleUniformBuffer(std::stringstream& ss);
u32 m_resolution_scale;
u32 m_multisamples;
bool m_per_sample_shading;
bool m_true_color;
bool m_scaled_dithering;
bool m_write_mask_as_depth;
bool m_disable_color_perspective;
}; };

4
src/core/gpu_hw_texture_cache.cpp
View File

@ -765,8 +765,8 @@ bool GPUTextureCache::CompilePipelines()
// Most flags don't matter here. // Most flags don't matter here.
const GPUDevice::Features features = g_gpu_device->GetFeatures(); const GPUDevice::Features features = g_gpu_device->GetFeatures();
GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), 1, 1, false, false, false, false, false, const GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), features.dual_source_blend,
features.dual_source_blend, features.framebuffer_fetch); features.framebuffer_fetch);
std::unique_ptr<GPUShader> fullscreen_quad_vertex_shader = g_gpu_device->CreateShader( std::unique_ptr<GPUShader> fullscreen_quad_vertex_shader = g_gpu_device->CreateShader(
GPUShaderStage::Vertex, shadergen.GetLanguage(), shadergen.GenerateScreenQuadVertexShader()); GPUShaderStage::Vertex, shadergen.GetLanguage(), shadergen.GenerateScreenQuadVertexShader());
if (!fullscreen_quad_vertex_shader) if (!fullscreen_quad_vertex_shader)

18
src/core/gpu_shadergen.cpp
View File

@ -10,7 +10,7 @@ GPUShaderGen::GPUShaderGen(RenderAPI render_api, bool supports_dual_source_blend
GPUShaderGen::~GPUShaderGen() = default; GPUShaderGen::~GPUShaderGen() = default;
void GPUShaderGen::WriteDisplayUniformBuffer(std::stringstream& ss) void GPUShaderGen::WriteDisplayUniformBuffer(std::stringstream& ss) const
{ {
// Rotation matrix split into rows to avoid padding in HLSL. // Rotation matrix split into rows to avoid padding in HLSL.
DeclareUniformBuffer(ss, DeclareUniformBuffer(ss,
@ -24,7 +24,7 @@ float2 ClampUV(float2 uv) {
})"; })";
} }
std::string GPUShaderGen::GenerateDisplayVertexShader() std::string GPUShaderGen::GenerateDisplayVertexShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -48,7 +48,7 @@ std::string GPUShaderGen::GenerateDisplayVertexShader()
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateDisplayFragmentShader(bool clamp_uv, bool nearest) std::string GPUShaderGen::GenerateDisplayFragmentShader(bool clamp_uv, bool nearest) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -73,7 +73,7 @@ std::string GPUShaderGen::GenerateDisplayFragmentShader(bool clamp_uv, bool near
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader() std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -102,7 +102,7 @@ std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader() std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -120,7 +120,7 @@ std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader() std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -141,7 +141,7 @@ std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader() std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -161,7 +161,7 @@ std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader()
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateFastMADReconstructFragmentShader() std::string GPUShaderGen::GenerateFastMADReconstructFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -220,7 +220,7 @@ CONSTANT float3 SENSITIVITY = float3(0.08f, 0.08f, 0.08f);
return ss.str(); return ss.str();
} }
std::string GPUShaderGen::GenerateChromaSmoothingFragmentShader() std::string GPUShaderGen::GenerateChromaSmoothingFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);

18
src/core/gpu_shadergen.h
View File

@ -11,17 +11,17 @@ public:
GPUShaderGen(RenderAPI render_api, bool supports_dual_source_blend, bool supports_framebuffer_fetch); GPUShaderGen(RenderAPI render_api, bool supports_dual_source_blend, bool supports_framebuffer_fetch);
~GPUShaderGen(); ~GPUShaderGen();
std::string GenerateDisplayVertexShader(); std::string GenerateDisplayVertexShader() const;
std::string GenerateDisplayFragmentShader(bool clamp_uv, bool nearest); std::string GenerateDisplayFragmentShader(bool clamp_uv, bool nearest) const;
std::string GenerateDisplaySharpBilinearFragmentShader(); std::string GenerateDisplaySharpBilinearFragmentShader() const;
std::string GenerateInterleavedFieldExtractFragmentShader(); std::string GenerateInterleavedFieldExtractFragmentShader() const;
std::string GenerateDeinterlaceWeaveFragmentShader(); std::string GenerateDeinterlaceWeaveFragmentShader() const;
std::string GenerateDeinterlaceBlendFragmentShader(); std::string GenerateDeinterlaceBlendFragmentShader() const;
std::string GenerateFastMADReconstructFragmentShader(); std::string GenerateFastMADReconstructFragmentShader() const;
std::string GenerateChromaSmoothingFragmentShader(); std::string GenerateChromaSmoothingFragmentShader() const;
private: private:
void WriteDisplayUniformBuffer(std::stringstream& ss); void WriteDisplayUniformBuffer(std::stringstream& ss) const;
}; };

33
src/util/shadergen.cpp
View File

@ -88,12 +88,12 @@ bool ShaderGen::UseGLSLBindingLayout()
#endif #endif
} }
void ShaderGen::DefineMacro(std::stringstream& ss, const char* name, bool enabled) void ShaderGen::DefineMacro(std::stringstream& ss, const char* name, bool enabled) const
{ {
ss << "#define " << name << " " << BoolToUInt32(enabled) << "\n"; ss << "#define " << name << " " << BoolToUInt32(enabled) << "\n";
} }
void ShaderGen::DefineMacro(std::stringstream& ss, const char* name, s32 value) void ShaderGen::DefineMacro(std::stringstream& ss, const char* name, s32 value) const
{ {
ss << "#define " << name << " " << value << "\n"; ss << "#define " << name << " " << value << "\n";
} }
@ -151,7 +151,7 @@ TinyString ShaderGen::GetGLSLVersionString(RenderAPI render_api, u32 version)
(glsl_es && major_version >= 3) ? " es" : ""); (glsl_es && major_version >= 3) ? " es" : "");
} }
void ShaderGen::WriteHeader(std::stringstream& ss, bool enable_rov /* = false */) void ShaderGen::WriteHeader(std::stringstream& ss, bool enable_rov /* = false */) const
{ {
if (m_shader_language == GPUShaderLanguage::GLSL || m_shader_language == GPUShaderLanguage::GLSLES) if (m_shader_language == GPUShaderLanguage::GLSL || m_shader_language == GPUShaderLanguage::GLSLES)
ss << m_glsl_version_string << "\n\n"; ss << m_glsl_version_string << "\n\n";
@ -340,7 +340,7 @@ void ShaderGen::WriteHeader(std::stringstream& ss, bool enable_rov /* = false */
m_has_uniform_buffer = false; m_has_uniform_buffer = false;
} }
void ShaderGen::WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan) void ShaderGen::WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan) const
{ {
if (m_shader_language == GPUShaderLanguage::GLSLVK) if (m_shader_language == GPUShaderLanguage::GLSLVK)
{ {
@ -371,7 +371,7 @@ void ShaderGen::WriteUniformBufferDeclaration(std::stringstream& ss, bool push_c
} }
void ShaderGen::DeclareUniformBuffer(std::stringstream& ss, const std::initializer_list<const char*>& members, void ShaderGen::DeclareUniformBuffer(std::stringstream& ss, const std::initializer_list<const char*>& members,
bool push_constant_on_vulkan) bool push_constant_on_vulkan) const
{ {
WriteUniformBufferDeclaration(ss, push_constant_on_vulkan); WriteUniformBufferDeclaration(ss, push_constant_on_vulkan);
@ -382,7 +382,7 @@ void ShaderGen::DeclareUniformBuffer(std::stringstream& ss, const std::initializ
} }
void ShaderGen::DeclareTexture(std::stringstream& ss, const char* name, u32 index, bool multisampled /* = false */, void ShaderGen::DeclareTexture(std::stringstream& ss, const char* name, u32 index, bool multisampled /* = false */,
bool is_int /* = false */, bool is_unsigned /* = false */) bool is_int /* = false */, bool is_unsigned /* = false */) const
{ {
if (m_glsl) if (m_glsl)
{ {
@ -402,7 +402,8 @@ void ShaderGen::DeclareTexture(std::stringstream& ss, const char* name, u32 inde
} }
} }
void ShaderGen::DeclareTextureBuffer(std::stringstream& ss, const char* name, u32 index, bool is_int, bool is_unsigned) void ShaderGen::DeclareTextureBuffer(std::stringstream& ss, const char* name, u32 index, bool is_int,
bool is_unsigned) const
{ {
if (m_glsl) if (m_glsl)
{ {
@ -421,7 +422,7 @@ void ShaderGen::DeclareTextureBuffer(std::stringstream& ss, const char* name, u3
} }
void ShaderGen::DeclareImage(std::stringstream& ss, const char* name, u32 index, bool is_float /* = false */, void ShaderGen::DeclareImage(std::stringstream& ss, const char* name, u32 index, bool is_float /* = false */,
bool is_int /* = false */, bool is_unsigned /* = false */) bool is_int /* = false */, bool is_unsigned /* = false */) const
{ {
if (m_glsl) if (m_glsl)
{ {
@ -464,7 +465,7 @@ void ShaderGen::DeclareVertexEntryPoint(
std::stringstream& ss, const std::initializer_list<const char*>& attributes, u32 num_color_outputs, std::stringstream& ss, const std::initializer_list<const char*>& attributes, u32 num_color_outputs,
u32 num_texcoord_outputs, const std::initializer_list<std::pair<const char*, const char*>>& additional_outputs, u32 num_texcoord_outputs, const std::initializer_list<std::pair<const char*, const char*>>& additional_outputs,
bool declare_vertex_id /* = false */, const char* output_block_suffix /* = "" */, bool msaa /* = false */, bool declare_vertex_id /* = false */, const char* output_block_suffix /* = "" */, bool msaa /* = false */,
bool ssaa /* = false */, bool noperspective_color /* = false */) bool ssaa /* = false */, bool noperspective_color /* = false */) const
{ {
if (m_glsl) if (m_glsl)
{ {
@ -574,7 +575,7 @@ void ShaderGen::DeclareFragmentEntryPoint(
bool declare_fragcoord /* = false */, u32 num_color_outputs /* = 1 */, bool dual_source_output /* = false */, bool declare_fragcoord /* = false */, u32 num_color_outputs /* = 1 */, bool dual_source_output /* = false */,
bool depth_output /* = false */, bool msaa /* = false */, bool ssaa /* = false */, bool depth_output /* = false */, bool msaa /* = false */, bool ssaa /* = false */,
bool declare_sample_id /* = false */, bool noperspective_color /* = false */, bool feedback_loop /* = false */, bool declare_sample_id /* = false */, bool noperspective_color /* = false */, bool feedback_loop /* = false */,
bool rov /* = false */) bool rov /* = false */) const
{ {
if (m_glsl) if (m_glsl)
{ {
@ -779,7 +780,7 @@ void ShaderGen::DeclareFragmentEntryPoint(
} }
} }
std::string ShaderGen::GenerateScreenQuadVertexShader(float z /* = 0.0f */) std::string ShaderGen::GenerateScreenQuadVertexShader(float z /* = 0.0f */) const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -795,7 +796,7 @@ std::string ShaderGen::GenerateScreenQuadVertexShader(float z /* = 0.0f */)
return ss.str(); return ss.str();
} }
std::string ShaderGen::GenerateUVQuadVertexShader() std::string ShaderGen::GenerateUVQuadVertexShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -815,7 +816,7 @@ std::string ShaderGen::GenerateUVQuadVertexShader()
return ss.str(); return ss.str();
} }
std::string ShaderGen::GenerateFillFragmentShader() std::string ShaderGen::GenerateFillFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -831,7 +832,7 @@ std::string ShaderGen::GenerateFillFragmentShader()
return ss.str(); return ss.str();
} }
std::string ShaderGen::GenerateCopyFragmentShader() std::string ShaderGen::GenerateCopyFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -849,7 +850,7 @@ std::string ShaderGen::GenerateCopyFragmentShader()
return ss.str(); return ss.str();
} }
std::string ShaderGen::GenerateImGuiVertexShader() std::string ShaderGen::GenerateImGuiVertexShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);
@ -869,7 +870,7 @@ std::string ShaderGen::GenerateImGuiVertexShader()
return ss.str(); return ss.str();
} }
std::string ShaderGen::GenerateImGuiFragmentShader() std::string ShaderGen::GenerateImGuiFragmentShader() const
{ {
std::stringstream ss; std::stringstream ss;
WriteHeader(ss); WriteHeader(ss);

34
src/util/shadergen.h
View File

@ -25,13 +25,13 @@ public:
ALWAYS_INLINE GPUShaderLanguage GetLanguage() const { return m_shader_language; } ALWAYS_INLINE GPUShaderLanguage GetLanguage() const { return m_shader_language; }
std::string GenerateScreenQuadVertexShader(float z = 0.0f); std::string GenerateScreenQuadVertexShader(float z = 0.0f) const;
std::string GenerateUVQuadVertexShader(); std::string GenerateUVQuadVertexShader() const;
std::string GenerateFillFragmentShader(); std::string GenerateFillFragmentShader() const;
std::string GenerateCopyFragmentShader(); std::string GenerateCopyFragmentShader() const;
std::string GenerateImGuiVertexShader(); std::string GenerateImGuiVertexShader() const;
std::string GenerateImGuiFragmentShader(); std::string GenerateImGuiFragmentShader() const;
protected: protected:
ALWAYS_INLINE bool IsVulkan() const { return (m_render_api == RenderAPI::Vulkan); } ALWAYS_INLINE bool IsVulkan() const { return (m_render_api == RenderAPI::Vulkan); }
@ -40,29 +40,29 @@ protected:
const char* GetInterpolationQualifier(bool interface_block, bool centroid_interpolation, bool sample_interpolation, const char* GetInterpolationQualifier(bool interface_block, bool centroid_interpolation, bool sample_interpolation,
bool is_out) const; bool is_out) const;
void DefineMacro(std::stringstream& ss, const char* name, bool enabled); void DefineMacro(std::stringstream& ss, const char* name, bool enabled) const;
void DefineMacro(std::stringstream& ss, const char* name, s32 value); void DefineMacro(std::stringstream& ss, const char* name, s32 value) const;
void WriteHeader(std::stringstream& ss, bool enable_rov = false); void WriteHeader(std::stringstream& ss, bool enable_rov = false) const;
void WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan); void WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan) const;
void DeclareUniformBuffer(std::stringstream& ss, const std::initializer_list<const char*>& members, void DeclareUniformBuffer(std::stringstream& ss, const std::initializer_list<const char*>& members,
bool push_constant_on_vulkan); bool push_constant_on_vulkan) const;
void DeclareTexture(std::stringstream& ss, const char* name, u32 index, bool multisampled = false, void DeclareTexture(std::stringstream& ss, const char* name, u32 index, bool multisampled = false,
bool is_int = false, bool is_unsigned = false); bool is_int = false, bool is_unsigned = false) const;
void DeclareTextureBuffer(std::stringstream& ss, const char* name, u32 index, bool is_int, bool is_unsigned); void DeclareTextureBuffer(std::stringstream& ss, const char* name, u32 index, bool is_int, bool is_unsigned) const;
void DeclareImage(std::stringstream& ss, const char* name, u32 index, bool is_float = false, bool is_int = false, void DeclareImage(std::stringstream& ss, const char* name, u32 index, bool is_float = false, bool is_int = false,
bool is_unsigned = false); bool is_unsigned = false) const;
void DeclareVertexEntryPoint(std::stringstream& ss, const std::initializer_list<const char*>& attributes, void DeclareVertexEntryPoint(std::stringstream& ss, const std::initializer_list<const char*>& attributes,
u32 num_color_outputs, u32 num_texcoord_outputs, u32 num_color_outputs, u32 num_texcoord_outputs,
const std::initializer_list<std::pair<const char*, const char*>>& additional_outputs, const std::initializer_list<std::pair<const char*, const char*>>& additional_outputs,
bool declare_vertex_id = false, const char* output_block_suffix = "", bool msaa = false, bool declare_vertex_id = false, const char* output_block_suffix = "", bool msaa = false,
bool ssaa = false, bool noperspective_color = false); bool ssaa = false, bool noperspective_color = false) const;
void void
DeclareFragmentEntryPoint(std::stringstream& ss, u32 num_color_inputs, u32 num_texcoord_inputs, DeclareFragmentEntryPoint(std::stringstream& ss, u32 num_color_inputs, u32 num_texcoord_inputs,
const std::initializer_list<std::pair<const char*, const char*>>& additional_inputs = {}, const std::initializer_list<std::pair<const char*, const char*>>& additional_inputs = {},
bool declare_fragcoord = false, u32 num_color_outputs = 1, bool dual_source_output = false, bool declare_fragcoord = false, u32 num_color_outputs = 1, bool dual_source_output = false,
bool depth_output = false, bool msaa = false, bool ssaa = false, bool depth_output = false, bool msaa = false, bool ssaa = false,
bool declare_sample_id = false, bool noperspective_color = false, bool declare_sample_id = false, bool noperspective_color = false,
bool feedback_loop = false, bool rov = false); bool feedback_loop = false, bool rov = false) const;
RenderAPI m_render_api; RenderAPI m_render_api;
GPUShaderLanguage m_shader_language; GPUShaderLanguage m_shader_language;
@ -72,7 +72,7 @@ protected:
bool m_supports_framebuffer_fetch; bool m_supports_framebuffer_fetch;
bool m_use_glsl_interface_blocks = false; bool m_use_glsl_interface_blocks = false;
bool m_use_glsl_binding_layout = false; bool m_use_glsl_binding_layout = false;
bool m_has_uniform_buffer = false; mutable bool m_has_uniform_buffer = false;
TinyString m_glsl_version_string; TinyString m_glsl_version_string;
}; };