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)
{
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 force_round_texcoords = (m_resolution_scale > 1 && m_texture_filtering == GPUTextureFilter::Nearest &&
g_settings.gpu_force_round_texcoords);
const bool upscaled = (m_resolution_scale > 1);
const bool msaa = (m_multisamples > 1);
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 scaled_dithering = (!m_true_color && upscaled && g_settings.gpu_scaled_dithering);
const bool disable_color_perspective = ShouldDisableColorPerspective();
// Determine when to use shader blending.
// 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");
// Start generating shaders.
GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), m_resolution_scale, m_multisamples, per_sample_shading,
m_true_color, (m_resolution_scale > 1 && g_settings.gpu_scaled_dithering),
m_write_mask_as_depth, ShouldDisableColorPerspective(), m_supports_dual_source_blend,
m_supports_framebuffer_fetch);
const GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), m_supports_dual_source_blend,
m_supports_framebuffer_fetch);
const u32 active_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 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] =
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);
const std::string fs = shadergen.GenerateBatchFragmentShader(
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTransparencyMode>(transparency_mode),
shader_texmode, sprite ? m_sprite_texture_filtering : m_texture_filtering, uv_limits,
!sprite && force_round_texcoords, ConvertToBoolUnchecked(dithering),
ConvertToBoolUnchecked(interlacing), ConvertToBoolUnchecked(check_mask), use_rov, needs_rov_depth,
(depth_test != 0));
shader_texmode, sprite ? m_sprite_texture_filtering : m_texture_filtering, upscaled, msaa,
per_sample_shading, uv_limits, !sprite && force_round_texcoords, true_color,
ConvertToBoolUnchecked(dithering), scaled_dithering, disable_color_perspective,
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]
[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(
GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMFillFragmentShader(ConvertToBoolUnchecked(wrapped), ConvertToBoolUnchecked(interlaced)),
shadergen.GenerateVRAMFillFragmentShader(ConvertToBoolUnchecked(wrapped), ConvertToBoolUnchecked(interlaced),
m_write_mask_as_depth),
error);
if (!fs)
return false;
@ -1451,8 +1456,9 @@ bool GPU_HW::CompilePipelines(Error* error)
// VRAM copy
{
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMCopyFragmentShader(), error);
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMCopyFragmentShader(m_resolution_scale, m_write_mask_as_depth), error);
if (!fs)
return false;
@ -1479,9 +1485,10 @@ bool GPU_HW::CompilePipelines(Error* error)
{
const bool use_buffer = features.supports_texture_buffers;
const bool use_ssbo = features.texture_buffers_emulated_with_ssbo;
std::unique_ptr<GPUShader> fs =
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMWriteFragmentShader(use_buffer, use_ssbo), error);
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMWriteFragmentShader(m_resolution_scale, use_buffer, use_ssbo, m_write_mask_as_depth),
error);
if (!fs)
return false;
@ -1527,7 +1534,7 @@ bool GPU_HW::CompilePipelines(Error* error)
if (m_write_mask_as_depth)
{
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)
return false;
@ -1553,8 +1560,9 @@ bool GPU_HW::CompilePipelines(Error* error)
// VRAM read
{
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMReadFragmentShader(), error);
std::unique_ptr<GPUShader> fs =
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMReadFragmentShader(m_resolution_scale, m_multisamples), error);
if (!fs)
return false;
@ -1577,9 +1585,10 @@ bool GPU_HW::CompilePipelines(Error* error)
if (depth_extract && !m_pgxp_depth_buffer)
continue;
std::unique_ptr<GPUShader> fs =
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMExtractFragmentShader(color_24bit, depth_extract), error);
std::unique_ptr<GPUShader> fs = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(),
shadergen.GenerateVRAMExtractFragmentShader(m_resolution_scale, m_multisamples, color_24bit, depth_extract),
error);
if (!fs)
return false;

160
src/core/gpu_hw_shadergen.cpp
View File

@ -8,20 +8,15 @@
#include "common/assert.h"
GPU_HW_ShaderGen::GPU_HW_ShaderGen(RenderAPI render_api, u32 resolution_scale, u32 multisamples,
bool per_sample_shading, bool true_color, bool scaled_dithering,
bool write_mask_as_depth, bool disable_color_perspective,
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(RenderAPI render_api, bool supports_dual_source_blend,
bool supports_framebuffer_fetch)
: ShaderGen(render_api, GetShaderLanguageForAPI(render_api), supports_dual_source_blend, supports_framebuffer_fetch)
{
}
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"(
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,
{"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);
}
std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool palette, bool page_texture, bool uv_limits,
bool force_round_texcoords, bool pgxp_depth)
std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool upscaled, bool msaa, bool per_sample_shading,
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;
WriteHeader(ss);
@ -66,7 +63,7 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
DefineMacro(ss, "UV_LIMITS", uv_limits);
DefineMacro(ss, "FORCE_ROUND_TEXCOORDS", force_round_texcoords);
DefineMacro(ss, "PGXP_DEPTH", pgxp_depth);
DefineMacro(ss, "UPSCALED", m_resolution_scale > 1);
DefineMacro(ss, "UPSCALED", upscaled);
WriteBatchUniformBuffer(ss);
@ -76,13 +73,12 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
{
DeclareVertexEntryPoint(
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(),
m_disable_color_perspective);
{{"nointerpolation", "float4 v_uv_limits"}}, false, "", msaa, per_sample_shading, disable_color_perspective);
}
else
{
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)
@ -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,
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"},
{"nointerpolation", "float4 v_uv_limits"}},
false, "", UsingMSAA(), UsingPerSampleShading(), m_disable_color_perspective);
false, "", msaa, per_sample_shading, disable_color_perspective);
}
else
{
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, "",
UsingMSAA(), UsingPerSampleShading(), m_disable_color_perspective);
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"}}, false, "", msaa,
per_sample_shading, disable_color_perspective);
}
}
else
{
DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0"}, 1, 0, {}, false, "", UsingMSAA(),
UsingPerSampleShading(), m_disable_color_perspective);
DeclareVertexEntryPoint(ss, {"float4 a_pos", "float4 a_col0"}, 1, 0, {}, false, "", msaa, per_sample_shading,
disable_color_perspective);
}
ss << R"(
@ -179,7 +175,7 @@ std::string GPU_HW_ShaderGen::GenerateBatchVertexShader(bool textured, bool pale
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.
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(
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,
bool check_mask, bool use_rov, bool use_rov_depth, bool rov_depth_test)
GPUTextureFilter texture_filtering, bool upscaled, bool msaa, bool per_sample_shading, bool uv_limits,
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
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, "PAGE_TEXTURE", page_texture);
DefineMacro(ss, "DITHERING", dithering);
DefineMacro(ss, "DITHERING_SCALED", m_scaled_dithering);
DefineMacro(ss, "DITHERING_SCALED", dithering && scaled_dithering);
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, "UV_LIMITS", uv_limits);
DefineMacro(ss, "USE_ROV", use_rov);
DefineMacro(ss, "USE_ROV_DEPTH", use_rov_depth);
DefineMacro(ss, "ROV_DEPTH_TEST", rov_depth_test);
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, "UPSCALED", m_resolution_scale > 1);
DefineMacro(ss, "UPSCALED", upscaled);
// 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
@ -903,14 +901,14 @@ float4 SampleFromPageTexture(float2 coords)
if (uv_limits)
{
DeclareFragmentEntryPoint(ss, 1, 1, {{"nointerpolation", "float4 v_uv_limits"}}, true, num_fragment_outputs,
use_dual_source, m_write_mask_as_depth, UsingMSAA(), UsingPerSampleShading(), false,
m_disable_color_perspective, shader_blending && !use_rov, use_rov);
use_dual_source, write_mask_as_depth, msaa, per_sample_shading, false,
disable_color_perspective, shader_blending && !use_rov, use_rov);
}
else
{
DeclareFragmentEntryPoint(ss, 1, 1, {}, true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth,
UsingMSAA(), UsingPerSampleShading(), false, m_disable_color_perspective,
shader_blending && !use_rov, use_rov);
DeclareFragmentEntryPoint(ss, 1, 1, {}, true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
use_rov);
}
}
else if (textured)
@ -923,23 +921,22 @@ float4 SampleFromPageTexture(float2 coords)
DeclareFragmentEntryPoint(ss, 1, 1,
{{"nointerpolation", palette ? "uint4 v_texpage" : "uint2 v_texpage"},
{"nointerpolation", "float4 v_uv_limits"}},
true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth, UsingMSAA(),
UsingPerSampleShading(), false, m_disable_color_perspective,
shader_blending && !use_rov, use_rov);
true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
use_rov);
}
else
{
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(),
UsingPerSampleShading(), false, m_disable_color_perspective,
shader_blending && !use_rov, use_rov);
num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa, per_sample_shading,
false, disable_color_perspective, shader_blending && !use_rov, use_rov);
}
}
else
{
DeclareFragmentEntryPoint(ss, 1, 0, {}, true, num_fragment_outputs, use_dual_source, m_write_mask_as_depth,
UsingMSAA(), UsingPerSampleShading(), false, m_disable_color_perspective,
shader_blending && !use_rov, use_rov);
DeclareFragmentEntryPoint(ss, 1, 0, {}, true, num_fragment_outputs, use_dual_source, write_mask_as_depth, msaa,
per_sample_shading, false, disable_color_perspective, shader_blending && !use_rov,
use_rov);
}
ss << R"(
@ -1181,23 +1178,26 @@ float4 SampleFromPageTexture(float2 coords)
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;
WriteHeader(ss);
WriteColorConversionFunctions(ss);
DefineMacro(ss, "COLOR_24BIT", color_24bit);
DefineMacro(ss, "DEPTH_BUFFER", depth_buffer);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA());
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n";
DefineMacro(ss, "MULTISAMPLING", msaa);
ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\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);
DeclareTexture(ss, "samp0", 0, UsingMSAA());
DeclareTexture(ss, "samp0", 0, msaa);
if (depth_buffer)
DeclareTexture(ss, "samp1", 1, UsingMSAA());
DeclareTexture(ss, "samp1", 1, msaa);
ss << R"(
float4 LoadVRAM(int2 coords)
@ -1269,7 +1269,7 @@ float3 SampleVRAM24(uint2 icoords)
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateWireframeGeometryShader()
std::string GPU_HW_ShaderGen::GenerateWireframeGeometryShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1342,7 +1342,7 @@ void main(triangle GSInput input[3], inout LineStream<GSOutput> output)
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader()
std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1357,18 +1357,20 @@ std::string GPU_HW_ShaderGen::GenerateWireframeFragmentShader()
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;
WriteHeader(ss);
WriteColorConversionFunctions(ss);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA());
ss << "CONSTANT uint RESOLUTION_SCALE = " << m_resolution_scale << "u;\n";
ss << "CONSTANT uint MULTISAMPLES = " << m_multisamples << "u;\n";
DefineMacro(ss, "MULTISAMPLING", msaa);
ss << "CONSTANT uint RESOLUTION_SCALE = " << resolution_scale << "u;\n";
ss << "CONSTANT uint MULTISAMPLES = " << multisamples << "u;\n";
DeclareUniformBuffer(ss, {"uint2 u_base_coords", "uint2 u_size"}, true);
DeclareTexture(ss, "samp0", 0, UsingMSAA());
DeclareTexture(ss, "samp0", 0, msaa);
ss << R"(
float4 LoadVRAM(int2 coords)
@ -1420,16 +1422,17 @@ uint SampleVRAM(uint2 coords)
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;
WriteHeader(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);
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";
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";
}
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"(
{
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();
}
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.
const bool msaa = false;
std::stringstream 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);
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";
DeclareUniformBuffer(ss,
@ -1515,7 +1518,7 @@ std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader()
true);
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"(
{
uint2 dst_coords = uint2(v_pos.xy);
@ -1550,18 +1553,19 @@ std::string GPU_HW_ShaderGen::GenerateVRAMCopyFragmentShader()
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;
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, "INTERLACED", interlaced);
DeclareUniformBuffer(
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"(
{
#if INTERLACED || WRAPPED
@ -1591,13 +1595,13 @@ std::string GPU_HW_ShaderGen::GenerateVRAMFillFragmentShader(bool wrapped, bool
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader()
std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader(bool msaa) const
{
std::stringstream ss;
WriteHeader(ss);
DefineMacro(ss, "MULTISAMPLING", UsingMSAA());
DeclareTexture(ss, "samp0", 0, UsingMSAA());
DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 0, false, true, false, false, UsingMSAA());
DefineMacro(ss, "MULTISAMPLING", msaa);
DeclareTexture(ss, "samp0", 0, msaa);
DeclareFragmentEntryPoint(ss, 0, 1, {}, true, 0, false, true, false, false, msaa);
ss << R"(
{
@ -1612,12 +1616,12 @@ std::string GPU_HW_ShaderGen::GenerateVRAMUpdateDepthFragmentShader()
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);
}
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader()
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1636,7 +1640,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleVertexShader()
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader()
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1670,7 +1674,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleMipFragmentShader()
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader()
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1707,7 +1711,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleBlurFragmentShader()
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader()
std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -1725,7 +1729,7 @@ std::string GPU_HW_ShaderGen::GenerateAdaptiveDownsampleCompositeFragmentShader(
return ss.str();
}
std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 factor)
std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 factor) const
{
std::stringstream ss;
WriteHeader(ss);
@ -1752,7 +1756,7 @@ std::string GPU_HW_ShaderGen::GenerateBoxSampleDownsampleFragmentShader(u32 fact
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;
WriteHeader(ss);

65
src/core/gpu_hw_shadergen.h
View File

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

4
src/core/gpu_hw_texture_cache.cpp
View File

@ -765,8 +765,8 @@ bool GPUTextureCache::CompilePipelines()
// Most flags don't matter here.
const GPUDevice::Features features = g_gpu_device->GetFeatures();
GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), 1, 1, false, false, false, false, false,
features.dual_source_blend, features.framebuffer_fetch);
const GPU_HW_ShaderGen shadergen(g_gpu_device->GetRenderAPI(), features.dual_source_blend,
features.framebuffer_fetch);
std::unique_ptr<GPUShader> fullscreen_quad_vertex_shader = g_gpu_device->CreateShader(
GPUShaderStage::Vertex, shadergen.GetLanguage(), shadergen.GenerateScreenQuadVertexShader());
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;
void GPUShaderGen::WriteDisplayUniformBuffer(std::stringstream& ss)
void GPUShaderGen::WriteDisplayUniformBuffer(std::stringstream& ss) const
{
// Rotation matrix split into rows to avoid padding in HLSL.
DeclareUniformBuffer(ss,
@ -24,7 +24,7 @@ float2 ClampUV(float2 uv) {
})";
}
std::string GPUShaderGen::GenerateDisplayVertexShader()
std::string GPUShaderGen::GenerateDisplayVertexShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -48,7 +48,7 @@ std::string GPUShaderGen::GenerateDisplayVertexShader()
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;
WriteHeader(ss);
@ -73,7 +73,7 @@ std::string GPUShaderGen::GenerateDisplayFragmentShader(bool clamp_uv, bool near
return ss.str();
}
std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader()
std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -102,7 +102,7 @@ std::string GPUShaderGen::GenerateDisplaySharpBilinearFragmentShader()
return ss.str();
}
std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader()
std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -120,7 +120,7 @@ std::string GPUShaderGen::GenerateInterleavedFieldExtractFragmentShader()
return ss.str();
}
std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader()
std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -141,7 +141,7 @@ std::string GPUShaderGen::GenerateDeinterlaceWeaveFragmentShader()
return ss.str();
}
std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader()
std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -161,7 +161,7 @@ std::string GPUShaderGen::GenerateDeinterlaceBlendFragmentShader()
return ss.str();
}
std::string GPUShaderGen::GenerateFastMADReconstructFragmentShader()
std::string GPUShaderGen::GenerateFastMADReconstructFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -220,7 +220,7 @@ CONSTANT float3 SENSITIVITY = float3(0.08f, 0.08f, 0.08f);
return ss.str();
}
std::string GPUShaderGen::GenerateChromaSmoothingFragmentShader()
std::string GPUShaderGen::GenerateChromaSmoothingFragmentShader() const
{
std::stringstream 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();
std::string GenerateDisplayVertexShader();
std::string GenerateDisplayFragmentShader(bool clamp_uv, bool nearest);
std::string GenerateDisplaySharpBilinearFragmentShader();
std::string GenerateDisplayVertexShader() const;
std::string GenerateDisplayFragmentShader(bool clamp_uv, bool nearest) const;
std::string GenerateDisplaySharpBilinearFragmentShader() const;
std::string GenerateInterleavedFieldExtractFragmentShader();
std::string GenerateDeinterlaceWeaveFragmentShader();
std::string GenerateDeinterlaceBlendFragmentShader();
std::string GenerateFastMADReconstructFragmentShader();
std::string GenerateInterleavedFieldExtractFragmentShader() const;
std::string GenerateDeinterlaceWeaveFragmentShader() const;
std::string GenerateDeinterlaceBlendFragmentShader() const;
std::string GenerateFastMADReconstructFragmentShader() const;
std::string GenerateChromaSmoothingFragmentShader();
std::string GenerateChromaSmoothingFragmentShader() const;
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
}
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";
}
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";
}
@ -151,7 +151,7 @@ TinyString ShaderGen::GetGLSLVersionString(RenderAPI render_api, u32 version)
(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)
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;
}
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)
{
@ -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,
bool push_constant_on_vulkan)
bool push_constant_on_vulkan) const
{
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 */,
bool is_int /* = false */, bool is_unsigned /* = false */)
bool is_int /* = false */, bool is_unsigned /* = false */) const
{
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)
{
@ -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 */,
bool is_int /* = false */, bool is_unsigned /* = false */)
bool is_int /* = false */, bool is_unsigned /* = false */) const
{
if (m_glsl)
{
@ -464,7 +465,7 @@ void ShaderGen::DeclareVertexEntryPoint(
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,
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)
{
@ -574,7 +575,7 @@ void ShaderGen::DeclareFragmentEntryPoint(
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 declare_sample_id /* = false */, bool noperspective_color /* = false */, bool feedback_loop /* = false */,
bool rov /* = false */)
bool rov /* = false */) const
{
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;
WriteHeader(ss);
@ -795,7 +796,7 @@ std::string ShaderGen::GenerateScreenQuadVertexShader(float z /* = 0.0f */)
return ss.str();
}
std::string ShaderGen::GenerateUVQuadVertexShader()
std::string ShaderGen::GenerateUVQuadVertexShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -815,7 +816,7 @@ std::string ShaderGen::GenerateUVQuadVertexShader()
return ss.str();
}
std::string ShaderGen::GenerateFillFragmentShader()
std::string ShaderGen::GenerateFillFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -831,7 +832,7 @@ std::string ShaderGen::GenerateFillFragmentShader()
return ss.str();
}
std::string ShaderGen::GenerateCopyFragmentShader()
std::string ShaderGen::GenerateCopyFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -849,7 +850,7 @@ std::string ShaderGen::GenerateCopyFragmentShader()
return ss.str();
}
std::string ShaderGen::GenerateImGuiVertexShader()
std::string ShaderGen::GenerateImGuiVertexShader() const
{
std::stringstream ss;
WriteHeader(ss);
@ -869,7 +870,7 @@ std::string ShaderGen::GenerateImGuiVertexShader()
return ss.str();
}
std::string ShaderGen::GenerateImGuiFragmentShader()
std::string ShaderGen::GenerateImGuiFragmentShader() const
{
std::stringstream ss;
WriteHeader(ss);

34
src/util/shadergen.h
View File

@ -25,13 +25,13 @@ public:
ALWAYS_INLINE GPUShaderLanguage GetLanguage() const { return m_shader_language; }
std::string GenerateScreenQuadVertexShader(float z = 0.0f);
std::string GenerateUVQuadVertexShader();
std::string GenerateFillFragmentShader();
std::string GenerateCopyFragmentShader();
std::string GenerateScreenQuadVertexShader(float z = 0.0f) const;
std::string GenerateUVQuadVertexShader() const;
std::string GenerateFillFragmentShader() const;
std::string GenerateCopyFragmentShader() const;
std::string GenerateImGuiVertexShader();
std::string GenerateImGuiFragmentShader();
std::string GenerateImGuiVertexShader() const;
std::string GenerateImGuiFragmentShader() const;
protected:
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,
bool is_out) const;
void DefineMacro(std::stringstream& ss, const char* name, bool enabled);
void DefineMacro(std::stringstream& ss, const char* name, s32 value);
void WriteHeader(std::stringstream& ss, bool enable_rov = false);
void WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan);
void DefineMacro(std::stringstream& ss, const char* name, bool enabled) const;
void DefineMacro(std::stringstream& ss, const char* name, s32 value) const;
void WriteHeader(std::stringstream& ss, bool enable_rov = false) const;
void WriteUniformBufferDeclaration(std::stringstream& ss, bool push_constant_on_vulkan) const;
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,
bool is_int = false, bool is_unsigned = false);
void DeclareTextureBuffer(std::stringstream& ss, const char* name, u32 index, bool is_int, bool is_unsigned);
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) const;
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,
u32 num_color_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 ssaa = false, bool noperspective_color = false);
bool ssaa = false, bool noperspective_color = false) const;
void
DeclareFragmentEntryPoint(std::stringstream& ss, u32 num_color_inputs, u32 num_texcoord_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 depth_output = false, bool msaa = false, bool ssaa = 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;
GPUShaderLanguage m_shader_language;
@ -72,7 +72,7 @@ protected:
bool m_supports_framebuffer_fetch;
bool m_use_glsl_interface_blocks = 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;
};