diff --git a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp index f899f7f078..1452e617e3 100644 --- a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp @@ -26,7 +26,6 @@ namespace DX11 GeometryShaderCache::GSCache GeometryShaderCache::GeometryShaders; const GeometryShaderCache::GSCacheEntry* GeometryShaderCache::last_entry; GeometryShaderUid GeometryShaderCache::last_uid; -UidChecker GeometryShaderCache::geometry_uid_checker; const GeometryShaderCache::GSCacheEntry GeometryShaderCache::pass_entry; ID3D11GeometryShader* ClearGeometryShader = nullptr; @@ -165,9 +164,6 @@ void GeometryShaderCache::Init() GeometryShaderCacheInserter inserter; g_gs_disk_cache.OpenAndRead(cache_filename, inserter); - if (g_Config.bEnableShaderDebugging) - Clear(); - last_entry = nullptr; } @@ -177,7 +173,6 @@ void GeometryShaderCache::Clear() for (auto& iter : GeometryShaders) iter.second.Destroy(); GeometryShaders.clear(); - geometry_uid_checker.Invalidate(); last_entry = nullptr; } @@ -196,12 +191,7 @@ void GeometryShaderCache::Shutdown() bool GeometryShaderCache::SetShader(u32 primitive_type) { - GeometryShaderUid uid = GetGeometryShaderUid(primitive_type, API_D3D); - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GenerateGeometryShaderCode(primitive_type, API_D3D); - geometry_uid_checker.AddToIndexAndCheck(code, uid, "Geometry", "g"); - } + GeometryShaderUid uid = GetGeometryShaderUid(primitive_type); // Check if the shader is already set if (last_entry) @@ -235,7 +225,7 @@ bool GeometryShaderCache::SetShader(u32 primitive_type) } // Need to compile a new shader - ShaderCode code = GenerateGeometryShaderCode(primitive_type, API_D3D); + ShaderCode code = GenerateGeometryShaderCode(API_D3D, uid.GetUidData()); D3DBlob* pbytecode; if (!D3D::CompileGeometryShader(code.GetBuffer(), &pbytecode)) @@ -250,11 +240,6 @@ bool GeometryShaderCache::SetShader(u32 primitive_type) bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size()); pbytecode->Release(); - if (g_ActiveConfig.bEnableShaderDebugging && success) - { - GeometryShaders[uid].code = code.GetBuffer(); - } - return success; } diff --git a/Source/Core/VideoBackends/D3D/GeometryShaderCache.h b/Source/Core/VideoBackends/D3D/GeometryShaderCache.h index b3c17cd37f..f0cab99940 100644 --- a/Source/Core/VideoBackends/D3D/GeometryShaderCache.h +++ b/Source/Core/VideoBackends/D3D/GeometryShaderCache.h @@ -32,8 +32,6 @@ private: { ID3D11GeometryShader* shader; - std::string code; - GSCacheEntry() : shader(nullptr) {} void Destroy() { SAFE_RELEASE(shader); } }; @@ -44,8 +42,6 @@ private: static const GSCacheEntry* last_entry; static GeometryShaderUid last_uid; static const GSCacheEntry pass_entry; - - static UidChecker geometry_uid_checker; }; } // namespace DX11 diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp index 3d48784647..7e6bc036e7 100644 --- a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp @@ -26,7 +26,6 @@ namespace DX11 PixelShaderCache::PSCache PixelShaderCache::PixelShaders; const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry; PixelShaderUid PixelShaderCache::last_uid; -UidChecker PixelShaderCache::pixel_uid_checker; LinearDiskCache g_ps_disk_cache; @@ -505,9 +504,6 @@ void PixelShaderCache::Init() PixelShaderCacheInserter inserter; g_ps_disk_cache.OpenAndRead(cache_filename, inserter); - if (g_Config.bEnableShaderDebugging) - Clear(); - last_entry = nullptr; } @@ -517,7 +513,6 @@ void PixelShaderCache::Clear() for (auto& iter : PixelShaders) iter.second.Destroy(); PixelShaders.clear(); - pixel_uid_checker.Invalidate(); last_entry = nullptr; } @@ -556,12 +551,7 @@ void PixelShaderCache::Shutdown() bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode) { - PixelShaderUid uid = GetPixelShaderUid(dstAlphaMode, API_D3D); - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D); - pixel_uid_checker.AddToIndexAndCheck(code, uid, "Pixel", "p"); - } + PixelShaderUid uid = GetPixelShaderUid(dstAlphaMode); // Check if the shader is already set if (last_entry) @@ -588,7 +578,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode) } // Need to compile a new shader - ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D); + ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D, uid.GetUidData()); D3DBlob* pbytecode; if (!D3D::CompilePixelShader(code.GetBuffer(), &pbytecode)) @@ -603,11 +593,6 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode) bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size()); pbytecode->Release(); - if (g_ActiveConfig.bEnableShaderDebugging && success) - { - PixelShaders[uid].code = code.GetBuffer(); - } - GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); return success; } diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.h b/Source/Core/VideoBackends/D3D/PixelShaderCache.h index e985374f97..0e81f3cf33 100644 --- a/Source/Core/VideoBackends/D3D/PixelShaderCache.h +++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.h @@ -42,8 +42,6 @@ private: { ID3D11PixelShader* shader; - std::string code; - PSCacheEntry() : shader(nullptr) {} void Destroy() { SAFE_RELEASE(shader); } }; @@ -53,8 +51,6 @@ private: static PSCache PixelShaders; static const PSCacheEntry* last_entry; static PixelShaderUid last_uid; - - static UidChecker pixel_uid_checker; }; } // namespace DX11 diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp index 7b3f71da26..cdcff17d02 100644 --- a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp @@ -24,7 +24,6 @@ namespace DX11 VertexShaderCache::VSCache VertexShaderCache::vshaders; const VertexShaderCache::VSCacheEntry* VertexShaderCache::last_entry; VertexShaderUid VertexShaderCache::last_uid; -UidChecker VertexShaderCache::vertex_uid_checker; static ID3D11VertexShader* SimpleVertexShader = nullptr; static ID3D11VertexShader* ClearVertexShader = nullptr; @@ -166,9 +165,6 @@ void VertexShaderCache::Init() VertexShaderCacheInserter inserter; g_vs_disk_cache.OpenAndRead(cache_filename, inserter); - if (g_Config.bEnableShaderDebugging) - Clear(); - last_entry = nullptr; } @@ -177,7 +173,6 @@ void VertexShaderCache::Clear() for (auto& iter : vshaders) iter.second.Destroy(); vshaders.clear(); - vertex_uid_checker.Invalidate(); last_entry = nullptr; } @@ -199,12 +194,7 @@ void VertexShaderCache::Shutdown() bool VertexShaderCache::SetShader() { - VertexShaderUid uid = GetVertexShaderUid(API_D3D); - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GenerateVertexShaderCode(API_D3D); - vertex_uid_checker.AddToIndexAndCheck(code, uid, "Vertex", "v"); - } + VertexShaderUid uid = GetVertexShaderUid(); if (last_entry) { @@ -227,7 +217,7 @@ bool VertexShaderCache::SetShader() return (entry.shader != nullptr); } - ShaderCode code = GenerateVertexShaderCode(API_D3D); + ShaderCode code = GenerateVertexShaderCode(API_D3D, uid.GetUidData()); D3DBlob* pbytecode = nullptr; D3D::CompileVertexShader(code.GetBuffer(), &pbytecode); @@ -242,11 +232,6 @@ bool VertexShaderCache::SetShader() bool success = InsertByteCode(uid, pbytecode); pbytecode->Release(); - if (g_ActiveConfig.bEnableShaderDebugging && success) - { - vshaders[uid].code = code.GetBuffer(); - } - GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); return success; } diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.h b/Source/Core/VideoBackends/D3D/VertexShaderCache.h index d680fca6de..7471d4f769 100644 --- a/Source/Core/VideoBackends/D3D/VertexShaderCache.h +++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.h @@ -38,8 +38,6 @@ private: ID3D11VertexShader* shader; D3DBlob* bytecode; // needed to initialize the input layout - std::string code; - VSCacheEntry() : shader(nullptr), bytecode(nullptr) {} void SetByteCode(D3DBlob* blob) { @@ -58,8 +56,6 @@ private: static VSCache vshaders; static const VSCacheEntry* last_entry; static VertexShaderUid last_uid; - - static UidChecker vertex_uid_checker; }; } // namespace DX11 diff --git a/Source/Core/VideoBackends/D3D12/ShaderCache.cpp b/Source/Core/VideoBackends/D3D12/ShaderCache.cpp index 2f93956003..e1803111d3 100644 --- a/Source/Core/VideoBackends/D3D12/ShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D12/ShaderCache.cpp @@ -30,22 +30,10 @@ VsBytecodeCache s_vs_bytecode_cache; // Used to keep track of blobs to release at Shutdown time. static std::vector s_shader_blob_list; -// Only used for shader debugging.. -using GsHlslCache = std::map; -using PsHlslCache = std::map; -using VsHlslCache = std::map; -static GsHlslCache s_gs_hlsl_cache; -static PsHlslCache s_ps_hlsl_cache; -static VsHlslCache s_vs_hlsl_cache; - static LinearDiskCache s_gs_disk_cache; static LinearDiskCache s_ps_disk_cache; static LinearDiskCache s_vs_disk_cache; -static UidChecker s_geometry_uid_checker; -static UidChecker s_pixel_uid_checker; -static UidChecker s_vertex_uid_checker; - static D3D12_SHADER_BYTECODE s_last_geometry_shader_bytecode; static D3D12_SHADER_BYTECODE s_last_pixel_shader_bytecode; static D3D12_SHADER_BYTECODE s_last_vertex_shader_bytecode; @@ -104,10 +92,6 @@ void ShaderCache::Init() ShaderCacheInserter vs_inserter; s_vs_disk_cache.OpenAndRead(vs_cache_filename, vs_inserter); - // Clear out cache when debugging shaders to ensure stale ones don't stick around.. - if (g_Config.bEnableShaderDebugging) - Clear(); - SETSTAT(stats.numPixelShadersAlive, static_cast(s_ps_bytecode_cache.size())); SETSTAT(stats.numPixelShadersCreated, static_cast(s_ps_bytecode_cache.size())); SETSTAT(stats.numVertexShadersAlive, static_cast(s_vs_bytecode_cache.size())); @@ -145,26 +129,15 @@ void ShaderCache::Shutdown() s_ps_disk_cache.Close(); s_vs_disk_cache.Sync(); s_vs_disk_cache.Close(); - - if (g_Config.bEnableShaderDebugging) - { - s_gs_hlsl_cache.clear(); - s_ps_hlsl_cache.clear(); - s_vs_hlsl_cache.clear(); - } - - s_geometry_uid_checker.Invalidate(); - s_pixel_uid_checker.Invalidate(); - s_vertex_uid_checker.Invalidate(); } void ShaderCache::LoadAndSetActiveShaders(DSTALPHA_MODE ps_dst_alpha_mode, u32 gs_primitive_type) { SetCurrentPrimitiveTopology(gs_primitive_type); - GeometryShaderUid gs_uid = GetGeometryShaderUid(gs_primitive_type, API_D3D); - PixelShaderUid ps_uid = GetPixelShaderUid(ps_dst_alpha_mode, API_D3D); - VertexShaderUid vs_uid = GetVertexShaderUid(API_D3D); + GeometryShaderUid gs_uid = GetGeometryShaderUid(gs_primitive_type); + PixelShaderUid ps_uid = GetPixelShaderUid(ps_dst_alpha_mode); + VertexShaderUid vs_uid = GetVertexShaderUid(); bool gs_changed = gs_uid != s_last_geometry_shader_uid; bool ps_changed = ps_uid != s_last_pixel_shader_uid; @@ -217,12 +190,6 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t { s_last_geometry_shader_uid = gs_uid; - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GenerateGeometryShaderCode(gs_primitive_type, API_D3D); - s_geometry_uid_checker.AddToIndexAndCheck(code, gs_uid, "Geometry", "g"); - } - if (gs_uid.GetUidData()->IsPassthrough()) { s_last_geometry_shader_bytecode = {}; @@ -236,7 +203,7 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t } else { - ShaderCode gs_code = GenerateGeometryShaderCode(gs_primitive_type, API_D3D); + ShaderCode gs_code = GenerateGeometryShaderCode(API_D3D, gs_uid.GetUidData()); ID3DBlob* gs_bytecode = nullptr; if (!D3D::CompileGeometryShader(gs_code.GetBuffer(), &gs_bytecode)) @@ -248,11 +215,6 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t s_last_geometry_shader_bytecode = InsertByteCode(gs_uid, &s_gs_bytecode_cache, gs_bytecode); s_gs_disk_cache.Append(gs_uid, reinterpret_cast(gs_bytecode->GetBufferPointer()), static_cast(gs_bytecode->GetBufferSize())); - - if (g_ActiveConfig.bEnableShaderDebugging) - { - s_gs_hlsl_cache[gs_uid] = gs_code.GetBuffer(); - } } } @@ -260,12 +222,6 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_ { s_last_pixel_shader_uid = ps_uid; - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D); - s_pixel_uid_checker.AddToIndexAndCheck(code, ps_uid, "Pixel", "p"); - } - auto ps_iterator = s_ps_bytecode_cache.find(ps_uid); if (ps_iterator != s_ps_bytecode_cache.end()) { @@ -274,7 +230,7 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_ } else { - ShaderCode ps_code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D); + ShaderCode ps_code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D, ps_uid.GetUidData()); ID3DBlob* ps_bytecode = nullptr; if (!D3D::CompilePixelShader(ps_code.GetBuffer(), &ps_bytecode)) @@ -289,11 +245,6 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_ SETSTAT(stats.numPixelShadersAlive, static_cast(s_ps_bytecode_cache.size())); INCSTAT(stats.numPixelShadersCreated); - - if (g_ActiveConfig.bEnableShaderDebugging) - { - s_ps_hlsl_cache[ps_uid] = ps_code.GetBuffer(); - } } } @@ -301,12 +252,6 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid) { s_last_vertex_shader_uid = vs_uid; - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode code = GenerateVertexShaderCode(API_D3D); - s_vertex_uid_checker.AddToIndexAndCheck(code, vs_uid, "Vertex", "v"); - } - auto vs_iterator = s_vs_bytecode_cache.find(vs_uid); if (vs_iterator != s_vs_bytecode_cache.end()) { @@ -315,7 +260,7 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid) } else { - ShaderCode vs_code = GenerateVertexShaderCode(API_D3D); + ShaderCode vs_code = GenerateVertexShaderCode(API_D3D, vs_uid.GetUidData()); ID3DBlob* vs_bytecode = nullptr; if (!D3D::CompileVertexShader(vs_code.GetBuffer(), &vs_bytecode)) @@ -330,11 +275,6 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid) SETSTAT(stats.numVertexShadersAlive, static_cast(s_vs_bytecode_cache.size())); INCSTAT(stats.numVertexShadersCreated); - - if (g_ActiveConfig.bEnableShaderDebugging) - { - s_vs_hlsl_cache[vs_uid] = vs_code.GetBuffer(); - } } } diff --git a/Source/Core/VideoBackends/Null/ShaderCache.cpp b/Source/Core/VideoBackends/Null/ShaderCache.cpp index e0fa000765..a08ef6952b 100644 --- a/Source/Core/VideoBackends/Null/ShaderCache.cpp +++ b/Source/Core/VideoBackends/Null/ShaderCache.cpp @@ -59,7 +59,7 @@ bool ShaderCache::SetShader(DSTALPHA_MODE dst_alpha_mode, u32 primitive_typ } // Need to compile a new shader - ShaderCode code = GenerateCode(dst_alpha_mode, primitive_type, API_OPENGL); + ShaderCode code = GenerateCode(dst_alpha_mode, API_OPENGL, uid); m_shaders.emplace(uid, code.GetBuffer()); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); diff --git a/Source/Core/VideoBackends/Null/ShaderCache.h b/Source/Core/VideoBackends/Null/ShaderCache.h index 833c8acf36..2dcdaf85b7 100644 --- a/Source/Core/VideoBackends/Null/ShaderCache.h +++ b/Source/Core/VideoBackends/Null/ShaderCache.h @@ -26,14 +26,12 @@ public: protected: virtual Uid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, API_TYPE api_type) = 0; - virtual ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, - API_TYPE api_type) = 0; + virtual ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type, Uid uid) = 0; private: std::map m_shaders; const std::string* m_last_entry = nullptr; Uid m_last_uid; - UidChecker m_uid_checker; }; class VertexShaderCache : public ShaderCache @@ -45,12 +43,12 @@ protected: VertexShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, API_TYPE api_type) override { - return GetVertexShaderUid(api_type); + return GetVertexShaderUid(); } - ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, - API_TYPE api_type) override + ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type, + VertexShaderUid uid) override { - return GenerateVertexShaderCode(api_type); + return GenerateVertexShaderCode(api_type, uid.GetUidData()); } }; @@ -63,12 +61,12 @@ protected: GeometryShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, API_TYPE api_type) override { - return GetGeometryShaderUid(primitive_type, api_type); + return GetGeometryShaderUid(primitive_type); } - ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, - API_TYPE api_type) override + ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type, + GeometryShaderUid uid) override { - return GenerateGeometryShaderCode(primitive_type, api_type); + return GenerateGeometryShaderCode(api_type, uid.GetUidData()); } }; @@ -81,12 +79,12 @@ protected: PixelShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, API_TYPE api_type) override { - return GetPixelShaderUid(dst_alpha_mode, api_type); + return GetPixelShaderUid(dst_alpha_mode); } - ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, - API_TYPE api_type) override + ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type, + PixelShaderUid uid) override { - return GeneratePixelShaderCode(dst_alpha_mode, api_type); + return GeneratePixelShaderCode(dst_alpha_mode, api_type, uid.GetUidData()); } }; diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp index 9ec9684224..58bd6c2a7b 100644 --- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp @@ -36,9 +36,6 @@ static GLuint CurrentProgram = 0; ProgramShaderCache::PCache ProgramShaderCache::pshaders; ProgramShaderCache::PCacheEntry* ProgramShaderCache::last_entry; SHADERUID ProgramShaderCache::last_uid; -UidChecker ProgramShaderCache::pixel_uid_checker; -UidChecker ProgramShaderCache::vertex_uid_checker; -UidChecker ProgramShaderCache::geometry_uid_checker; static std::string s_glsl_header = ""; @@ -209,19 +206,12 @@ SHADER* ProgramShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 primitive_ last_entry = &newentry; newentry.in_cache = 0; - ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL); - ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL); + ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL, uid.vuid.GetUidData()); + ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, uid.puid.GetUidData()); ShaderCode gcode; if (g_ActiveConfig.backend_info.bSupportsGeometryShaders && !uid.guid.GetUidData()->IsPassthrough()) - gcode = GenerateGeometryShaderCode(primitive_type, API_OPENGL); - - if (g_ActiveConfig.bEnableShaderDebugging) - { - newentry.shader.strvprog = vcode.GetBuffer(); - newentry.shader.strpprog = pcode.GetBuffer(); - newentry.shader.strgprog = gcode.GetBuffer(); - } + gcode = GenerateGeometryShaderCode(API_OPENGL, uid.guid.GetUidData()); #if defined(_DEBUG) || defined(DEBUGFAST) if (g_ActiveConfig.iLog & CONF_SAVESHADERS) @@ -397,21 +387,9 @@ GLuint ProgramShaderCache::CompileSingleShader(GLuint type, const std::string& c void ProgramShaderCache::GetShaderId(SHADERUID* uid, DSTALPHA_MODE dstAlphaMode, u32 primitive_type) { - uid->puid = GetPixelShaderUid(dstAlphaMode, API_OPENGL); - uid->vuid = GetVertexShaderUid(API_OPENGL); - uid->guid = GetGeometryShaderUid(primitive_type, API_OPENGL); - - if (g_ActiveConfig.bEnableShaderDebugging) - { - ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL); - pixel_uid_checker.AddToIndexAndCheck(pcode, uid->puid, "Pixel", "p"); - - ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL); - vertex_uid_checker.AddToIndexAndCheck(vcode, uid->vuid, "Vertex", "v"); - - ShaderCode gcode = GenerateGeometryShaderCode(primitive_type, API_OPENGL); - geometry_uid_checker.AddToIndexAndCheck(gcode, uid->guid, "Geometry", "g"); - } + uid->puid = GetPixelShaderUid(dstAlphaMode); + uid->vuid = GetVertexShaderUid(); + uid->guid = GetGeometryShaderUid(primitive_type); } ProgramShaderCache::PCacheEntry ProgramShaderCache::GetShaderProgram() @@ -436,7 +414,7 @@ void ProgramShaderCache::Init() s_buffer = StreamBuffer::Create(GL_UNIFORM_BUFFER, UBO_LENGTH); // Read our shader cache, only if supported - if (g_ogl_config.bSupportsGLSLCache && !g_Config.bEnableShaderDebugging) + if (g_ogl_config.bSupportsGLSLCache) { GLint Supported; glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &Supported); @@ -470,7 +448,7 @@ void ProgramShaderCache::Init() void ProgramShaderCache::Shutdown() { // store all shaders in cache on disk - if (g_ogl_config.bSupportsGLSLCache && !g_Config.bEnableShaderDebugging) + if (g_ogl_config.bSupportsGLSLCache) { for (auto& entry : pshaders) { @@ -516,9 +494,6 @@ void ProgramShaderCache::Shutdown() } pshaders.clear(); - pixel_uid_checker.Invalidate(); - vertex_uid_checker.Invalidate(); - s_buffer.reset(); } diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.h b/Source/Core/VideoBackends/OGL/ProgramShaderCache.h index 4852d71b86..4c97da20e2 100644 --- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.h +++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.h @@ -88,10 +88,6 @@ private: static PCacheEntry* last_entry; static SHADERUID last_uid; - static UidChecker pixel_uid_checker; - static UidChecker vertex_uid_checker; - static UidChecker geometry_uid_checker; - static u32 s_ubo_buffer_size; static s32 s_ubo_align; }; diff --git a/Source/Core/VideoCommon/GeometryShaderGen.cpp b/Source/Core/VideoCommon/GeometryShaderGen.cpp index 02744c2889..f3562254b9 100644 --- a/Source/Core/VideoCommon/GeometryShaderGen.cpp +++ b/Source/Core/VideoCommon/GeometryShaderGen.cpp @@ -20,43 +20,55 @@ static void EmitVertex(T& out, const char* vertex, API_TYPE ApiType, bool first_ template static void EndPrimitive(T& out, API_TYPE ApiType); -template -static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) +GeometryShaderUid GetGeometryShaderUid(u32 primitive_type) { - T out; - // Non-uid template parameters will write to the dummy data (=> gets optimized out) - geometry_shader_uid_data dummy_data; - geometry_shader_uid_data* uid_data = out.template GetUidData(); - if (uid_data != nullptr) - memset(uid_data, 0, sizeof(*uid_data)); - else - uid_data = &dummy_data; + ShaderUid out; + geometry_shader_uid_data* uid_data = out.GetUidData(); + memset(uid_data, 0, sizeof(geometry_shader_uid_data)); uid_data->primitive_type = primitive_type; - const unsigned int vertex_in = primitive_type + 1; - unsigned int vertex_out = primitive_type == PRIMITIVE_TRIANGLES ? 3 : 4; - uid_data->wireframe = g_ActiveConfig.bWireFrame; - if (g_ActiveConfig.bWireFrame) + uid_data->msaa = g_ActiveConfig.iMultisamples > 1; + uid_data->ssaa = g_ActiveConfig.iMultisamples > 1 && g_ActiveConfig.bSSAA; + uid_data->stereo = g_ActiveConfig.iStereoMode > 0; + uid_data->numTexGens = xfmem.numTexGen.numTexGens; + uid_data->pixel_lighting = g_ActiveConfig.bEnablePixelLighting; + + return out; +} + +static void EmitVertex(ShaderCode& out, const geometry_shader_uid_data* uid_data, + const char* vertex, API_TYPE ApiType, bool first_vertex = false); +static void EndPrimitive(ShaderCode& out, const geometry_shader_uid_data* uid_data, + API_TYPE ApiType); + +ShaderCode GenerateGeometryShaderCode(API_TYPE ApiType, const geometry_shader_uid_data* uid_data) +{ + ShaderCode out; + // Non-uid template parameters will write to the dummy data (=> gets optimized out) + + const unsigned int vertex_in = uid_data->primitive_type + 1; + unsigned int vertex_out = uid_data->primitive_type == PRIMITIVE_TRIANGLES ? 3 : 4; + + if (uid_data->wireframe) vertex_out++; - uid_data->stereo = g_ActiveConfig.iStereoMode > 0; if (ApiType == API_OPENGL) { // Insert layout parameters if (g_ActiveConfig.backend_info.bSupportsGSInstancing) { - out.Write("layout(%s, invocations = %d) in;\n", primitives_ogl[primitive_type], - g_ActiveConfig.iStereoMode > 0 ? 2 : 1); + out.Write("layout(%s, invocations = %d) in;\n", primitives_ogl[uid_data->primitive_type], + uid_data->stereo ? 2 : 1); out.Write("layout(%s_strip, max_vertices = %d) out;\n", - g_ActiveConfig.bWireFrame ? "line" : "triangle", vertex_out); + uid_data->wireframe ? "line" : "triangle", vertex_out); } else { - out.Write("layout(%s) in;\n", primitives_ogl[primitive_type]); + out.Write("layout(%s) in;\n", primitives_ogl[uid_data->primitive_type]); out.Write("layout(%s_strip, max_vertices = %d) out;\n", - g_ActiveConfig.bWireFrame ? "line" : "triangle", - g_ActiveConfig.iStereoMode > 0 ? vertex_out * 2 : vertex_out); + uid_data->wireframe ? "line" : "triangle", + uid_data->stereo ? vertex_out * 2 : vertex_out); } } @@ -73,11 +85,9 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) "\tint4 " I_TEXOFFSET ";\n" "};\n"); - uid_data->numTexGens = xfmem.numTexGen.numTexGens; - uid_data->pixel_lighting = g_ActiveConfig.bEnablePixelLighting; - out.Write("struct VS_OUTPUT {\n"); - GenerateVSOutputMembers(out, ApiType, ""); + GenerateVSOutputMembers(out, ApiType, uid_data->numTexGens, uid_data->pixel_lighting, + ""); out.Write("};\n"); if (ApiType == API_OPENGL) @@ -86,13 +96,17 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("#define InstanceID gl_InvocationID\n"); out.Write("in VertexData {\n"); - GenerateVSOutputMembers(out, ApiType, GetInterpolationQualifier(true, true)); + GenerateVSOutputMembers( + out, ApiType, uid_data->numTexGens, uid_data->pixel_lighting, + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa, true, true)); out.Write("} vs[%d];\n", vertex_in); out.Write("out VertexData {\n"); - GenerateVSOutputMembers(out, ApiType, GetInterpolationQualifier(true, false)); + GenerateVSOutputMembers( + out, ApiType, uid_data->numTexGens, uid_data->pixel_lighting, + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa, false, true)); - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) out.Write("\tflat int layer;\n"); out.Write("} ps;\n"); @@ -104,39 +118,37 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("struct VertexData {\n"); out.Write("\tVS_OUTPUT o;\n"); - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) out.Write("\tuint layer : SV_RenderTargetArrayIndex;\n"); out.Write("};\n"); if (g_ActiveConfig.backend_info.bSupportsGSInstancing) { - out.Write("[maxvertexcount(%d)]\n[instance(%d)]\n", vertex_out, - g_ActiveConfig.iStereoMode > 0 ? 2 : 1); + out.Write("[maxvertexcount(%d)]\n[instance(%d)]\n", vertex_out, uid_data->stereo ? 2 : 1); out.Write("void main(%s VS_OUTPUT o[%d], inout %sStream output, in uint " "InstanceID : SV_GSInstanceID)\n{\n", - primitives_d3d[primitive_type], vertex_in, - g_ActiveConfig.bWireFrame ? "Line" : "Triangle"); + primitives_d3d[uid_data->primitive_type], vertex_in, + uid_data->wireframe ? "Line" : "Triangle"); } else { - out.Write("[maxvertexcount(%d)]\n", - g_ActiveConfig.iStereoMode > 0 ? vertex_out * 2 : vertex_out); + out.Write("[maxvertexcount(%d)]\n", uid_data->stereo ? vertex_out * 2 : vertex_out); out.Write("void main(%s VS_OUTPUT o[%d], inout %sStream output)\n{\n", - primitives_d3d[primitive_type], vertex_in, - g_ActiveConfig.bWireFrame ? "Line" : "Triangle"); + primitives_d3d[uid_data->primitive_type], vertex_in, + uid_data->wireframe ? "Line" : "Triangle"); } out.Write("\tVertexData ps;\n"); } - if (primitive_type == PRIMITIVE_LINES) + if (uid_data->primitive_type == PRIMITIVE_LINES) { if (ApiType == API_OPENGL) { out.Write("\tVS_OUTPUT start, end;\n"); - AssignVSOutputMembers(out, "start", "vs[0]"); - AssignVSOutputMembers(out, "end", "vs[1]"); + AssignVSOutputMembers(out, "start", "vs[0]", uid_data->numTexGens, uid_data->pixel_lighting); + AssignVSOutputMembers(out, "end", "vs[1]", uid_data->numTexGens, uid_data->pixel_lighting); } else { @@ -161,16 +173,16 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) "\t\toffset = float2(0, -" I_LINEPTPARAMS ".z / " I_LINEPTPARAMS ".y);\n" "\t}\n"); } - else if (primitive_type == PRIMITIVE_POINTS) + else if (uid_data->primitive_type == PRIMITIVE_POINTS) { if (ApiType == API_OPENGL) { out.Write("\tVS_OUTPUT center;\n"); - AssignVSOutputMembers(out, "center", "vs[0]"); + AssignVSOutputMembers(out, "center", "vs[0]", uid_data->numTexGens, uid_data->pixel_lighting); } else { - out.Write("\tVS_OUTPUT center = o[0];\n"); + out.Write("\tVS_OUTPUT center = o[0];\n", uid_data->numTexGens, uid_data->pixel_lighting); } // Offset from center to upper right vertex @@ -179,7 +191,7 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) ".x, -" I_LINEPTPARAMS ".w / " I_LINEPTPARAMS ".y) * center.pos.w;\n"); } - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) { // If the GPU supports invocation we don't need a for loop and can simply use the // invocation identifier to determine which layer we're rendering. @@ -189,7 +201,7 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("\tfor (int eye = 0; eye < 2; ++eye) {\n"); } - if (g_ActiveConfig.bWireFrame) + if (uid_data->wireframe) out.Write("\tVS_OUTPUT first;\n"); out.Write("\tfor (int i = 0; i < %d; ++i) {\n", vertex_in); @@ -197,14 +209,14 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) if (ApiType == API_OPENGL) { out.Write("\tVS_OUTPUT f;\n"); - AssignVSOutputMembers(out, "f", "vs[i]"); + AssignVSOutputMembers(out, "f", "vs[i]", uid_data->numTexGens, uid_data->pixel_lighting); } else { out.Write("\tVS_OUTPUT f = o[i];\n"); } - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) { // Select the output layer out.Write("\tps.layer = eye;\n"); @@ -221,7 +233,7 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("\tf.pos.x += " I_STEREOPARAMS "[eye] * (f.pos.w - " I_STEREOPARAMS "[2]);\n"); } - if (primitive_type == PRIMITIVE_LINES) + if (uid_data->primitive_type == PRIMITIVE_LINES) { out.Write("\tVS_OUTPUT l = f;\n" "\tVS_OUTPUT r = f;\n"); @@ -232,17 +244,17 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("\tif (" I_TEXOFFSET "[2] != 0) {\n"); out.Write("\tfloat texOffset = 1.0 / float(" I_TEXOFFSET "[2]);\n"); - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < uid_data->numTexGens; ++i) { out.Write("\tif (((" I_TEXOFFSET "[0] >> %d) & 0x1) != 0)\n", i); out.Write("\t\tr.tex%d.x += texOffset;\n", i); } out.Write("\t}\n"); - EmitVertex(out, "l", ApiType, true); - EmitVertex(out, "r", ApiType); + EmitVertex(out, uid_data, "l", ApiType, true); + EmitVertex(out, uid_data, "r", ApiType); } - else if (primitive_type == PRIMITIVE_POINTS) + else if (uid_data->primitive_type == PRIMITIVE_POINTS) { out.Write("\tVS_OUTPUT ll = f;\n" "\tVS_OUTPUT lr = f;\n" @@ -258,7 +270,7 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) out.Write("\tfloat2 texOffset = float2(1.0 / float(" I_TEXOFFSET "[3]), 1.0 / float(" I_TEXOFFSET "[3]));\n"); - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < uid_data->numTexGens; ++i) { out.Write("\tif (((" I_TEXOFFSET "[1] >> %d) & 0x1) != 0) {\n", i); out.Write("\t\tll.tex%d.xy += float2(0,1) * texOffset;\n", i); @@ -268,21 +280,21 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) } out.Write("\t}\n"); - EmitVertex(out, "ll", ApiType, true); - EmitVertex(out, "lr", ApiType); - EmitVertex(out, "ul", ApiType); - EmitVertex(out, "ur", ApiType); + EmitVertex(out, uid_data, "ll", ApiType, true); + EmitVertex(out, uid_data, "lr", ApiType); + EmitVertex(out, uid_data, "ul", ApiType); + EmitVertex(out, uid_data, "ur", ApiType); } else { - EmitVertex(out, "f", ApiType, true); + EmitVertex(out, uid_data, "f", ApiType, true); } out.Write("\t}\n"); - EndPrimitive(out, ApiType); + EndPrimitive(out, uid_data, ApiType); - if (g_ActiveConfig.iStereoMode > 0 && !g_ActiveConfig.backend_info.bSupportsGSInstancing) + if (uid_data->stereo && !g_ActiveConfig.backend_info.bSupportsGSInstancing) out.Write("\t}\n"); out.Write("}\n"); @@ -290,16 +302,16 @@ static T GenerateGeometryShader(u32 primitive_type, API_TYPE ApiType) return out; } -template -static void EmitVertex(T& out, const char* vertex, API_TYPE ApiType, bool first_vertex) +static void EmitVertex(ShaderCode& out, const geometry_shader_uid_data* uid_data, + const char* vertex, API_TYPE ApiType, bool first_vertex) { - if (g_ActiveConfig.bWireFrame && first_vertex) + if (uid_data->wireframe && first_vertex) out.Write("\tif (i == 0) first = %s;\n", vertex); if (ApiType == API_OPENGL) { out.Write("\tgl_Position = %s.pos;\n", vertex); - AssignVSOutputMembers(out, "ps", vertex); + AssignVSOutputMembers(out, "ps", vertex, uid_data->numTexGens, uid_data->pixel_lighting); } else { @@ -311,24 +323,15 @@ static void EmitVertex(T& out, const char* vertex, API_TYPE ApiType, bool first_ else out.Write("\toutput.Append(ps);\n"); } -template -static void EndPrimitive(T& out, API_TYPE ApiType) + +static void EndPrimitive(ShaderCode& out, const geometry_shader_uid_data* uid_data, + API_TYPE ApiType) { - if (g_ActiveConfig.bWireFrame) - EmitVertex(out, "first", ApiType); + if (uid_data->wireframe) + EmitVertex(out, uid_data, "first", ApiType); if (ApiType == API_OPENGL) out.Write("\tEndPrimitive();\n"); else out.Write("\toutput.RestartStrip();\n"); } - -GeometryShaderUid GetGeometryShaderUid(u32 primitive_type, API_TYPE ApiType) -{ - return GenerateGeometryShader(primitive_type, ApiType); -} - -ShaderCode GenerateGeometryShaderCode(u32 primitive_type, API_TYPE ApiType) -{ - return GenerateGeometryShader(primitive_type, ApiType); -} diff --git a/Source/Core/VideoCommon/GeometryShaderGen.h b/Source/Core/VideoCommon/GeometryShaderGen.h index 961ab770c6..181bc502e1 100644 --- a/Source/Core/VideoCommon/GeometryShaderGen.h +++ b/Source/Core/VideoCommon/GeometryShaderGen.h @@ -23,11 +23,13 @@ struct geometry_shader_uid_data u32 pixel_lighting : 1; u32 primitive_type : 2; u32 wireframe : 1; + u32 msaa : 1; + u32 ssaa : 1; }; #pragma pack() typedef ShaderUid GeometryShaderUid; -ShaderCode GenerateGeometryShaderCode(u32 primitive_type, API_TYPE ApiType); -GeometryShaderUid GetGeometryShaderUid(u32 primitive_type, API_TYPE ApiType); +ShaderCode GenerateGeometryShaderCode(API_TYPE ApiType, const geometry_shader_uid_data* uid_data); +GeometryShaderUid GetGeometryShaderUid(u32 primitive_type); diff --git a/Source/Core/VideoCommon/LightingShaderGen.h b/Source/Core/VideoCommon/LightingShaderGen.h index 136e3ec50c..8cabb7fc57 100644 --- a/Source/Core/VideoCommon/LightingShaderGen.h +++ b/Source/Core/VideoCommon/LightingShaderGen.h @@ -46,19 +46,16 @@ static const char s_lighting_struct[] = "struct Light {\n" "\tfloat4 dir;\n" "};\n"; -template -static void GenerateLightShader(T& object, LightingUidData& uid_data, int index, int litchan_index, - int coloralpha) +static void GenerateLightShader(ShaderCode& object, const LightingUidData& uid_data, int index, + int litchan_index, bool alpha) { - const LitChannel& chan = - (litchan_index > 1) ? xfmem.alpha[litchan_index - 2] : xfmem.color[litchan_index]; - const char* swizzle = (coloralpha == 1) ? "xyz" : (coloralpha == 2) ? "w" : "xyzw"; - const char* swizzle_components = (coloralpha == 1) ? "3" : (coloralpha == 2) ? "" : "4"; + const char* swizzle = alpha ? "a" : "rgb"; + const char* swizzle_components = (alpha) ? "" : "3"; - uid_data.attnfunc |= chan.attnfunc << (2 * litchan_index); - uid_data.diffusefunc |= chan.diffusefunc << (2 * litchan_index); + int attnfunc = (uid_data.attnfunc >> (2 * litchan_index)) & 0x3; + int diffusefunc = (uid_data.diffusefunc >> (2 * litchan_index)) & 0x3; - switch (chan.attnfunc) + switch (attnfunc) { case LIGHTATTN_NONE: case LIGHTATTN_DIR: @@ -73,8 +70,7 @@ static void GenerateLightShader(T& object, LightingUidData& uid_data, int index, LIGHT_DIR_PARAMS(index)); object.Write("cosAttn = " LIGHT_COSATT ".xyz;\n", LIGHT_COSATT_PARAMS(index)); object.Write("distAttn = %s(" LIGHT_DISTATT ".xyz);\n", - (chan.diffusefunc == LIGHTDIF_NONE) ? "" : "normalize", - LIGHT_DISTATT_PARAMS(index)); + (diffusefunc == LIGHTDIF_NONE) ? "" : "normalize", LIGHT_DISTATT_PARAMS(index)); object.Write("attn = max(0.0f, dot(cosAttn, float3(1.0, attn, attn*attn))) / dot(distAttn, " "float3(1.0, attn, attn*attn));\n"); break; @@ -91,11 +87,9 @@ static void GenerateLightShader(T& object, LightingUidData& uid_data, int index, LIGHT_COSATT_PARAMS(index), LIGHT_COSATT_PARAMS(index), LIGHT_COSATT_PARAMS(index), LIGHT_DISTATT_PARAMS(index)); break; - default: - _assert_(0); } - switch (chan.diffusefunc) + switch (diffusefunc) { case LIGHTDIF_NONE: object.Write("lacc.%s += int%s(round(attn * float%s(" LIGHT_COL ")));\n", swizzle, @@ -104,7 +98,7 @@ static void GenerateLightShader(T& object, LightingUidData& uid_data, int index, case LIGHTDIF_SIGN: case LIGHTDIF_CLAMP: object.Write("lacc.%s += int%s(round(attn * %sdot(ldir, _norm0)) * float%s(" LIGHT_COL ")));\n", - swizzle, swizzle_components, chan.diffusefunc != LIGHTDIF_SIGN ? "max(0.0," : "(", + swizzle, swizzle_components, diffusefunc != LIGHTDIF_SIGN ? "max(0.0," : "(", swizzle_components, LIGHT_COL_PARAMS(index, swizzle)); break; default: @@ -119,19 +113,15 @@ static void GenerateLightShader(T& object, LightingUidData& uid_data, int index, // materials name is I_MATERIALS in vs and I_PMATERIALS in ps // inColorName is color in vs and colors_ in ps // dest is o.colors_ in vs and colors_ in ps -template -static void GenerateLightingShader(T& object, LightingUidData& uid_data, int components, - const char* inColorName, const char* dest) +static void GenerateLightingShaderCode(ShaderCode& object, const LightingUidData& uid_data, + int components, const char* inColorName, const char* dest) { for (unsigned int j = 0; j < xfmem.numChan.numColorChans; j++) { - const LitChannel& color = xfmem.color[j]; - const LitChannel& alpha = xfmem.alpha[j]; - object.Write("{\n"); - uid_data.matsource |= xfmem.color[j].matsource << j; - if (color.matsource) // from vertex + bool colormatsource = !!(uid_data.matsource & (1 << j)); + if (colormatsource) // from vertex { if (components & (VB_HAS_COL0 << j)) object.Write("int4 mat = int4(round(%s%d * 255.0));\n", inColorName, j); @@ -145,11 +135,9 @@ static void GenerateLightingShader(T& object, LightingUidData& uid_data, int com object.Write("int4 mat = %s[%d];\n", I_MATERIALS, j + 2); } - uid_data.enablelighting |= xfmem.color[j].enablelighting << j; - if (color.enablelighting) + if (uid_data.enablelighting & (1 << j)) { - uid_data.ambsource |= xfmem.color[j].ambsource << j; - if (color.ambsource) // from vertex + if (uid_data.ambsource & (1 << j)) // from vertex { if (components & (VB_HAS_COL0 << j)) object.Write("lacc = int4(round(%s%d * 255.0));\n", inColorName, j); @@ -158,7 +146,7 @@ static void GenerateLightingShader(T& object, LightingUidData& uid_data, int com else // TODO: this isn't verified. Here we want to read the ambient from the vertex, // but the vertex itself has no color. So we don't know which value to read. - // Returing 1.0 is the same as disabled lightning, so this could be fine + // Returning 1.0 is the same as disabled lightning, so this could be fine object.Write("lacc = int4(255, 255, 255, 255);\n"); } else // from color @@ -172,10 +160,10 @@ static void GenerateLightingShader(T& object, LightingUidData& uid_data, int com } // check if alpha is different - uid_data.matsource |= xfmem.alpha[j].matsource << (j + 2); - if (alpha.matsource != color.matsource) + bool alphamatsource = !!(uid_data.matsource & (1 << (j + 2))); + if (alphamatsource != colormatsource) { - if (alpha.matsource) // from vertex + if (alphamatsource) // from vertex { if (components & (VB_HAS_COL0 << j)) object.Write("mat.w = int(round(%s%d.w * 255.0));\n", inColorName, j); @@ -190,11 +178,9 @@ static void GenerateLightingShader(T& object, LightingUidData& uid_data, int com } } - uid_data.enablelighting |= xfmem.alpha[j].enablelighting << (j + 2); - if (alpha.enablelighting) + if (uid_data.enablelighting & (1 << (j + 2))) { - uid_data.ambsource |= xfmem.alpha[j].ambsource << (j + 2); - if (alpha.ambsource) // from vertex + if (uid_data.ambsource & (1 << (j + 2))) // from vertex { if (components & (VB_HAS_COL0 << j)) object.Write("lacc.w = int(round(%s%d.w * 255.0));\n", inColorName, j); @@ -214,56 +200,46 @@ static void GenerateLightingShader(T& object, LightingUidData& uid_data, int com object.Write("lacc.w = 255;\n"); } - if (color.enablelighting && alpha.enablelighting) + if (uid_data.enablelighting & (1 << j)) // Color lights { - // both have lighting, test if they use the same lights - int mask = 0; - uid_data.attnfunc |= color.attnfunc << (2 * j); - uid_data.attnfunc |= alpha.attnfunc << (2 * (j + 2)); - uid_data.diffusefunc |= color.diffusefunc << (2 * j); - uid_data.diffusefunc |= alpha.diffusefunc << (2 * (j + 2)); - uid_data.light_mask |= color.GetFullLightMask() << (8 * j); - uid_data.light_mask |= alpha.GetFullLightMask() << (8 * (j + 2)); - if (color.lightparams == alpha.lightparams) - { - mask = color.GetFullLightMask() & alpha.GetFullLightMask(); - if (mask) - { - for (int i = 0; i < 8; ++i) - { - if (mask & (1 << i)) - { - GenerateLightShader(object, uid_data, i, j, 3); - } - } - } - } - - // no shared lights for (int i = 0; i < 8; ++i) - { - if (!(mask & (1 << i)) && (color.GetFullLightMask() & (1 << i))) - GenerateLightShader(object, uid_data, i, j, 1); - if (!(mask & (1 << i)) && (alpha.GetFullLightMask() & (1 << i))) - GenerateLightShader(object, uid_data, i, j + 2, 2); - } + if (uid_data.light_mask & (1 << (i + 8 * j))) + GenerateLightShader(object, uid_data, i, j, false); } - else if (color.enablelighting || alpha.enablelighting) + if (uid_data.enablelighting & (1 << (j + 2))) // Alpha lights { - // lights are disabled on one channel so process only the active ones - const LitChannel& workingchannel = color.enablelighting ? color : alpha; - const int lit_index = color.enablelighting ? j : (j + 2); - int coloralpha = color.enablelighting ? 1 : 2; - - uid_data.light_mask |= workingchannel.GetFullLightMask() << (8 * lit_index); for (int i = 0; i < 8; ++i) - { - if (workingchannel.GetFullLightMask() & (1 << i)) - GenerateLightShader(object, uid_data, i, lit_index, coloralpha); - } + if (uid_data.light_mask & (1 << (i + 8 * (j + 2)))) + GenerateLightShader(object, uid_data, i, j + 2, true); } object.Write("lacc = clamp(lacc, 0, 255);\n"); object.Write("%s%d = float4((mat * (lacc + (lacc >> 7))) >> 8) / 255.0;\n", dest, j); object.Write("}\n"); } } + +static void GetLightingShaderUid(LightingUidData& uid_data) +{ + for (unsigned int j = 0; j < xfmem.numChan.numColorChans; j++) + { + uid_data.matsource |= xfmem.color[j].matsource << j; + uid_data.matsource |= xfmem.alpha[j].matsource << (j + 2); + uid_data.enablelighting |= xfmem.color[j].enablelighting << j; + uid_data.enablelighting |= xfmem.alpha[j].enablelighting << (j + 2); + + if (uid_data.enablelighting & (1 << j)) // Color lights + { + uid_data.ambsource |= xfmem.color[j].ambsource << j; + uid_data.attnfunc |= xfmem.color[j].attnfunc << (2 * j); + uid_data.diffusefunc |= xfmem.color[j].diffusefunc << (2 * j); + uid_data.light_mask |= xfmem.color[j].GetFullLightMask() << (8 * j); + } + if (uid_data.enablelighting & (1 << (j + 2))) // Alpha lights + { + uid_data.ambsource |= xfmem.alpha[j].ambsource << (j + 2); + uid_data.attnfunc |= xfmem.alpha[j].attnfunc << (2 * (j + 2)); + uid_data.diffusefunc |= xfmem.alpha[j].diffusefunc << (2 * (j + 2)); + uid_data.light_mask |= xfmem.alpha[j].GetFullLightMask() << (8 * (j + 2)); + } + } +} diff --git a/Source/Core/VideoCommon/NativeVertexFormat.h b/Source/Core/VideoCommon/NativeVertexFormat.h index b5d40bd54e..55f8a57483 100644 --- a/Source/Core/VideoCommon/NativeVertexFormat.h +++ b/Source/Core/VideoCommon/NativeVertexFormat.h @@ -31,6 +31,7 @@ enum VB_HAS_NRM2 = (1 << 12), VB_HAS_NRMALL = (7 << 10), + VB_COL_SHIFT = 13, VB_HAS_COL0 = (1 << 13), VB_HAS_COL1 = (1 << 14), diff --git a/Source/Core/VideoCommon/PixelShaderGen.cpp b/Source/Core/VideoCommon/PixelShaderGen.cpp index bc5da9a060..a94cd02c15 100644 --- a/Source/Core/VideoCommon/PixelShaderGen.cpp +++ b/Source/Core/VideoCommon/PixelShaderGen.cpp @@ -151,44 +151,209 @@ static const char* tevRasTable[] = { static const char* tevCOutputTable[] = {"prev.rgb", "c0.rgb", "c1.rgb", "c2.rgb"}; static const char* tevAOutputTable[] = {"prev.a", "c0.a", "c1.a", "c2.a"}; -template -static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE ApiType, - const char swapModeTable[4][5]); -template -static void WriteTevRegular(T& out, const char* components, int bias, int op, int clamp, int shift); -template -static void SampleTexture(T& out, const char* texcoords, const char* texswap, int texmap, - API_TYPE ApiType); -template -static void WriteAlphaTest(T& out, pixel_shader_uid_data* uid_data, API_TYPE ApiType, - DSTALPHA_MODE dstAlphaMode, bool per_pixel_depth); -template -static void WriteFog(T& out, pixel_shader_uid_data* uid_data); - -template -static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) +// FIXME: Some of the video card's capabilities (BBox support, EarlyZ support, dstAlpha support) +// leak +// into this UID; This is really unhelpful if these UIDs ever move from one machine to +// another. +PixelShaderUid GetPixelShaderUid(DSTALPHA_MODE dstAlphaMode) { - T out; - const u32 components = VertexLoaderManager::g_current_components; - // Non-uid template parameters will write to the dummy data (=> gets optimized out) - pixel_shader_uid_data dummy_data; - pixel_shader_uid_data* uid_data = out.template GetUidData(); - if (uid_data != nullptr) - memset(uid_data, 0, sizeof(*uid_data)); - else - uid_data = &dummy_data; - - unsigned int numStages = bpmem.genMode.numtevstages + 1; - unsigned int numTexgen = bpmem.genMode.numtexgens; - - out.Write("//Pixel Shader for TEV stages\n"); - out.Write("//%i TEV stages, %i texgens, %i IND stages\n", numStages, numTexgen, - bpmem.genMode.numindstages.Value()); + PixelShaderUid out; + pixel_shader_uid_data* uid_data = out.GetUidData(); + memset(uid_data, 0, sizeof(*uid_data)); uid_data->dstAlphaMode = dstAlphaMode; uid_data->genMode_numindstages = bpmem.genMode.numindstages; uid_data->genMode_numtevstages = bpmem.genMode.numtevstages; uid_data->genMode_numtexgens = bpmem.genMode.numtexgens; + uid_data->per_pixel_lighting = g_ActiveConfig.bEnablePixelLighting; + uid_data->bounding_box = g_ActiveConfig.backend_info.bSupportsBBox && + g_ActiveConfig.bBBoxEnable && BoundingBox::active; + + u32 numStages = uid_data->genMode_numtevstages + 1; + + const bool forced_early_z = + g_ActiveConfig.backend_info.bSupportsEarlyZ && bpmem.UseEarlyDepthTest() && + (g_ActiveConfig.bFastDepthCalc || bpmem.alpha_test.TestResult() == AlphaTest::UNDETERMINED) + // We can't allow early_ztest for zfreeze because depth is overridden per-pixel. + // This means it's impossible for zcomploc to be emulated on a zfrozen polygon. + && !(bpmem.zmode.testenable && bpmem.genMode.zfreeze); + const bool per_pixel_depth = + (bpmem.ztex2.op != ZTEXTURE_DISABLE && bpmem.UseLateDepthTest()) || + (!g_ActiveConfig.bFastDepthCalc && bpmem.zmode.testenable && !forced_early_z) || + (bpmem.zmode.testenable && bpmem.genMode.zfreeze); + + uid_data->per_pixel_depth = per_pixel_depth; + uid_data->forced_early_z = forced_early_z; + uid_data->fast_depth_calc = g_ActiveConfig.bFastDepthCalc; + uid_data->msaa = g_ActiveConfig.iMultisamples > 1; + uid_data->ssaa = g_ActiveConfig.iMultisamples > 1 && g_ActiveConfig.bSSAA; + uid_data->stereo = g_ActiveConfig.iStereoMode > 0; + + if (!uid_data->forced_early_z && bpmem.UseEarlyDepthTest() && + (!uid_data->fast_depth_calc || bpmem.alpha_test.TestResult() == AlphaTest::UNDETERMINED)) + { + static bool warn_once = true; + if (warn_once) + WARN_LOG(VIDEO, "Early z test enabled but not possible to emulate with current " + "configuration. Make sure to enable fast depth calculations. If this message " + "still shows up your hardware isn't able to emulate the feature properly (a " + "GPU with D3D 11.0 / OGL 4.2 support is required)."); + warn_once = false; + } + + if (uid_data->per_pixel_lighting) + { + // The lighting shader only needs the two color bits of the 23bit component bit array. + uid_data->components = + (VertexLoaderManager::g_current_components & (VB_HAS_COL0 | VB_HAS_COL1)) >> VB_COL_SHIFT; + ; + GetLightingShaderUid(uid_data->lighting); + } + + if (uid_data->genMode_numtexgens > 0) + { + for (unsigned int i = 0; i < uid_data->genMode_numtexgens; ++i) + { + // optional perspective divides + uid_data->texMtxInfo_n_projection |= xfmem.texMtxInfo[i].projection << i; + } + } + + // indirect texture map lookup + int nIndirectStagesUsed = 0; + if (uid_data->genMode_numindstages > 0) + { + for (unsigned int i = 0; i < numStages; ++i) + { + if (bpmem.tevind[i].IsActive() && bpmem.tevind[i].bt < uid_data->genMode_numindstages) + nIndirectStagesUsed |= 1 << bpmem.tevind[i].bt; + } + } + + uid_data->nIndirectStagesUsed = nIndirectStagesUsed; + for (u32 i = 0; i < uid_data->genMode_numindstages; ++i) + { + if (uid_data->nIndirectStagesUsed & (1 << i)) + uid_data->SetTevindrefValues(i, bpmem.tevindref.getTexCoord(i), bpmem.tevindref.getTexMap(i)); + } + + for (unsigned int n = 0; n < numStages; n++) + { + int texcoord = bpmem.tevorders[n / 2].getTexCoord(n & 1); + bool bHasTexCoord = (u32)texcoord < bpmem.genMode.numtexgens; + // HACK to handle cases where the tex gen is not enabled + if (!bHasTexCoord) + texcoord = bpmem.genMode.numtexgens; + + uid_data->stagehash[n].hasindstage = bpmem.tevind[n].bt < bpmem.genMode.numindstages; + uid_data->stagehash[n].tevorders_texcoord = texcoord; + if (uid_data->stagehash[n].hasindstage) + uid_data->stagehash[n].tevind = bpmem.tevind[n].hex; + + TevStageCombiner::ColorCombiner& cc = bpmem.combiners[n].colorC; + TevStageCombiner::AlphaCombiner& ac = bpmem.combiners[n].alphaC; + uid_data->stagehash[n].cc = cc.hex & 0xFFFFFF; + uid_data->stagehash[n].ac = ac.hex & 0xFFFFF0; // Storing rswap and tswap later + + if (cc.a == TEVCOLORARG_RASA || cc.a == TEVCOLORARG_RASC || cc.b == TEVCOLORARG_RASA || + cc.b == TEVCOLORARG_RASC || cc.c == TEVCOLORARG_RASA || cc.c == TEVCOLORARG_RASC || + cc.d == TEVCOLORARG_RASA || cc.d == TEVCOLORARG_RASC || ac.a == TEVALPHAARG_RASA || + ac.b == TEVALPHAARG_RASA || ac.c == TEVALPHAARG_RASA || ac.d == TEVALPHAARG_RASA) + { + const int i = bpmem.combiners[n].alphaC.rswap; + uid_data->stagehash[n].tevksel_swap1a = bpmem.tevksel[i * 2].swap1; + uid_data->stagehash[n].tevksel_swap2a = bpmem.tevksel[i * 2].swap2; + uid_data->stagehash[n].tevksel_swap1b = bpmem.tevksel[i * 2 + 1].swap1; + uid_data->stagehash[n].tevksel_swap2b = bpmem.tevksel[i * 2 + 1].swap2; + uid_data->stagehash[n].tevorders_colorchan = bpmem.tevorders[n / 2].getColorChan(n & 1); + } + + uid_data->stagehash[n].tevorders_enable = bpmem.tevorders[n / 2].getEnable(n & 1); + if (uid_data->stagehash[n].tevorders_enable) + { + const int i = bpmem.combiners[n].alphaC.tswap; + uid_data->stagehash[n].tevksel_swap1c = bpmem.tevksel[i * 2].swap1; + uid_data->stagehash[n].tevksel_swap2c = bpmem.tevksel[i * 2].swap2; + uid_data->stagehash[n].tevksel_swap1d = bpmem.tevksel[i * 2 + 1].swap1; + uid_data->stagehash[n].tevksel_swap2d = bpmem.tevksel[i * 2 + 1].swap2; + uid_data->stagehash[n].tevorders_texmap = bpmem.tevorders[n / 2].getTexMap(n & 1); + } + + if (cc.a == TEVCOLORARG_KONST || cc.b == TEVCOLORARG_KONST || cc.c == TEVCOLORARG_KONST || + cc.d == TEVCOLORARG_KONST || ac.a == TEVALPHAARG_KONST || ac.b == TEVALPHAARG_KONST || + ac.c == TEVALPHAARG_KONST || ac.d == TEVALPHAARG_KONST) + { + uid_data->stagehash[n].tevksel_kc = bpmem.tevksel[n / 2].getKC(n & 1); + uid_data->stagehash[n].tevksel_ka = bpmem.tevksel[n / 2].getKA(n & 1); + } + } + +#define MY_STRUCT_OFFSET(str, elem) ((u32)((u64) & (str).elem - (u64) & (str))) + uid_data->num_values = (uid_data->per_pixel_lighting) ? + sizeof(*uid_data) : + MY_STRUCT_OFFSET(*uid_data, stagehash[numStages]); + + AlphaTest::TEST_RESULT Pretest = bpmem.alpha_test.TestResult(); + uid_data->Pretest = Pretest; + uid_data->late_ztest = bpmem.UseLateDepthTest(); + + // NOTE: Fragment may not be discarded if alpha test always fails and early depth test is enabled + // (in this case we need to write a depth value if depth test passes regardless of the alpha + // testing result) + if (uid_data->Pretest == AlphaTest::UNDETERMINED || + (uid_data->Pretest == AlphaTest::FAIL && uid_data->late_ztest)) + { + uid_data->alpha_test_comp0 = bpmem.alpha_test.comp0; + uid_data->alpha_test_comp1 = bpmem.alpha_test.comp1; + uid_data->alpha_test_logic = bpmem.alpha_test.logic; + + // ZCOMPLOC HACK: + // The only way to emulate alpha test + early-z is to force early-z in the shader. + // As this isn't available on all drivers and as we can't emulate this feature otherwise, + // we are only able to choose which one we want to respect more. + // Tests seem to have proven that writing depth even when the alpha test fails is more + // important that a reliable alpha test, so we just force the alpha test to always succeed. + // At least this seems to be less buggy. + uid_data->alpha_test_use_zcomploc_hack = + bpmem.UseEarlyDepthTest() && bpmem.zmode.updateenable && + !g_ActiveConfig.backend_info.bSupportsEarlyZ && !bpmem.genMode.zfreeze; + } + + uid_data->zfreeze = bpmem.genMode.zfreeze; + uid_data->ztex_op = bpmem.ztex2.op; + uid_data->early_ztest = bpmem.UseEarlyDepthTest(); + uid_data->fog_fsel = bpmem.fog.c_proj_fsel.fsel; + + if (dstAlphaMode != DSTALPHA_ALPHA_PASS) + { + uid_data->fog_fsel = bpmem.fog.c_proj_fsel.fsel; + uid_data->fog_proj = bpmem.fog.c_proj_fsel.proj; + uid_data->fog_RangeBaseEnabled = bpmem.fogRange.Base.Enabled; + } + + return out; +} + +static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n, + API_TYPE ApiType); +static void WriteTevRegular(ShaderCode& out, const char* components, int bias, int op, int clamp, + int shift); +static void SampleTexture(ShaderCode& out, const char* texcoords, const char* texswap, int texmap, + bool stereo, API_TYPE ApiType); +static void WriteAlphaTest(ShaderCode& out, const pixel_shader_uid_data* uid_data, API_TYPE ApiType, + DSTALPHA_MODE dstAlphaMode, bool per_pixel_depth); +static void WriteFog(ShaderCode& out, const pixel_shader_uid_data* uid_data); + +ShaderCode GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, + const pixel_shader_uid_data* uid_data) +{ + ShaderCode out; + + u32 numStages = uid_data->genMode_numtevstages + 1; + + out.Write("//Pixel Shader for TEV stages\n"); + out.Write("//%i TEV stages, %i texgens, %i IND stages\n", numStages, uid_data->genMode_numtexgens, + uid_data->genMode_numindstages); // dot product for integer vectors out.Write("int idot(int3 x, int3 y)\n" @@ -250,7 +415,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) "\tfloat4 " I_EFBSCALE ";\n" "};\n"); - if (g_ActiveConfig.bEnablePixelLighting) + if (uid_data->per_pixel_lighting) { out.Write("%s", s_lighting_struct); @@ -267,7 +432,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write("};\n"); } - if (g_ActiveConfig.backend_info.bSupportsBBox && g_ActiveConfig.bBBoxEnable) + if (uid_data->bounding_box) { if (ApiType == API_OPENGL) { @@ -282,21 +447,11 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) } out.Write("struct VS_OUTPUT {\n"); - GenerateVSOutputMembers(out, ApiType, ""); + GenerateVSOutputMembers(out, ApiType, uid_data->genMode_numtexgens, uid_data->per_pixel_lighting, + ""); out.Write("};\n"); - const bool forced_early_z = - g_ActiveConfig.backend_info.bSupportsEarlyZ && bpmem.UseEarlyDepthTest() && - (g_ActiveConfig.bFastDepthCalc || bpmem.alpha_test.TestResult() == AlphaTest::UNDETERMINED) - // We can't allow early_ztest for zfreeze because depth is overridden per-pixel. - // This means it's impossible for zcomploc to be emulated on a zfrozen polygon. - && !(bpmem.zmode.testenable && bpmem.genMode.zfreeze); - const bool per_pixel_depth = - (bpmem.ztex2.op != ZTEXTURE_DISABLE && bpmem.UseLateDepthTest()) || - (!g_ActiveConfig.bFastDepthCalc && bpmem.zmode.testenable && !forced_early_z) || - (bpmem.zmode.testenable && bpmem.genMode.zfreeze); - - if (forced_early_z) + if (uid_data->forced_early_z) { // Zcomploc (aka early_ztest) is a way to control whether depth test is done before // or after texturing and alpha test. PC graphics APIs used to provide no way to emulate @@ -319,7 +474,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) // can be made and // doesn't define what will happen if we discard the fragment. But the way modern graphics // hardware is implemented - // means it is not unreasonable to expect the the same behaviour as early_fragment_tests. + // means it is not unreasonable to expect the same behaviour as early_fragment_tests. // We can also assume that if a driver has gone out of its way to support conservative depth and // not image_load_store // as required by OpenGL 4.2 that it will be doing the optimisation. @@ -342,8 +497,8 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write("[earlydepthstencil]\n"); } } - else if (bpmem.UseEarlyDepthTest() && (g_ActiveConfig.bFastDepthCalc || - bpmem.alpha_test.TestResult() == AlphaTest::UNDETERMINED)) + else if (bpmem.UseEarlyDepthTest() && + (uid_data->fast_depth_calc || bpmem.alpha_test.TestResult() == AlphaTest::UNDETERMINED)) { static bool warn_once = true; if (warn_once) @@ -354,43 +509,48 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) warn_once = false; } - uid_data->msaa = g_ActiveConfig.iMultisamples > 1; - uid_data->ssaa = g_ActiveConfig.iMultisamples > 1 && g_ActiveConfig.bSSAA; if (ApiType == API_OPENGL) { out.Write("out vec4 ocol0;\n"); if (dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND) out.Write("out vec4 ocol1;\n"); - if (per_pixel_depth) + if (uid_data->per_pixel_depth) out.Write("#define depth gl_FragDepth\n"); - uid_data->stereo = g_ActiveConfig.iStereoMode > 0; if (g_ActiveConfig.backend_info.bSupportsGeometryShaders) { out.Write("in VertexData {\n"); - GenerateVSOutputMembers(out, ApiType, GetInterpolationQualifier(true, true)); + GenerateVSOutputMembers( + out, ApiType, uid_data->genMode_numtexgens, uid_data->per_pixel_lighting, + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa, true, true)); - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) out.Write("\tflat int layer;\n"); out.Write("};\n"); } else { - out.Write("%s in float4 colors_0;\n", GetInterpolationQualifier()); - out.Write("%s in float4 colors_1;\n", GetInterpolationQualifier()); + out.Write("%s in float4 colors_0;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + out.Write("%s in float4 colors_1;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); // compute window position if needed because binding semantic WPOS is not widely supported // Let's set up attributes - for (unsigned int i = 0; i < numTexgen; ++i) + for (unsigned int i = 0; i < uid_data->genMode_numtexgens; ++i) { - out.Write("%s in float3 uv%d;\n", GetInterpolationQualifier(), i); + out.Write("%s in float3 uv%d;\n", GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), + i); } - out.Write("%s in float4 clipPos;\n", GetInterpolationQualifier()); - if (g_ActiveConfig.bEnablePixelLighting) + out.Write("%s in float4 clipPos;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + if (uid_data->per_pixel_lighting) { - out.Write("%s in float3 Normal;\n", GetInterpolationQualifier()); - out.Write("%s in float3 WorldPos;\n", GetInterpolationQualifier()); + out.Write("%s in float3 Normal;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + out.Write("%s in float3 WorldPos;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); } } @@ -398,7 +558,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) if (g_ActiveConfig.backend_info.bSupportsGeometryShaders) { - for (unsigned int i = 0; i < numTexgen; ++i) + for (unsigned int i = 0; i < uid_data->genMode_numtexgens; ++i) out.Write("\tfloat3 uv%d = tex%d;\n", i, i); } @@ -410,24 +570,30 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write(" out float4 ocol0 : SV_Target0,%s%s\n in float4 rawpos : SV_Position,\n", dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND ? "\n out float4 ocol1 : SV_Target1," : "", - per_pixel_depth ? "\n out float depth : SV_Depth," : ""); + uid_data->per_pixel_depth ? "\n out float depth : SV_Depth," : ""); - out.Write(" in %s float4 colors_0 : COLOR0,\n", GetInterpolationQualifier()); - out.Write(" in %s float4 colors_1 : COLOR1\n", GetInterpolationQualifier()); + out.Write(" in %s float4 colors_0 : COLOR0,\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + out.Write(" in %s float4 colors_1 : COLOR1\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); // compute window position if needed because binding semantic WPOS is not widely supported - for (unsigned int i = 0; i < numTexgen; ++i) - out.Write(",\n in %s float3 uv%d : TEXCOORD%d", GetInterpolationQualifier(), i, i); - out.Write(",\n in %s float4 clipPos : TEXCOORD%d", GetInterpolationQualifier(), numTexgen); - if (g_ActiveConfig.bEnablePixelLighting) + for (unsigned int i = 0; i < uid_data->genMode_numtexgens; ++i) + out.Write(",\n in %s float3 uv%d : TEXCOORD%d", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), i, i); + out.Write(",\n in %s float4 clipPos : TEXCOORD%d", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), + uid_data->genMode_numtexgens); + if (uid_data->per_pixel_lighting) { - out.Write(",\n in %s float3 Normal : TEXCOORD%d", GetInterpolationQualifier(), - numTexgen + 1); - out.Write(",\n in %s float3 WorldPos : TEXCOORD%d", GetInterpolationQualifier(), - numTexgen + 2); + out.Write(",\n in %s float3 Normal : TEXCOORD%d", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), + uid_data->genMode_numtexgens + 1); + out.Write(",\n in %s float3 WorldPos : TEXCOORD%d", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), + uid_data->genMode_numtexgens + 2); } - uid_data->stereo = g_ActiveConfig.iStereoMode > 0; - if (g_ActiveConfig.iStereoMode > 0) + if (uid_data->stereo) out.Write(",\n in uint layer : SV_RenderTargetArrayIndex\n"); out.Write(" ) {\n"); } @@ -449,7 +615,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write("\tfloat4 col0 = colors_0;\n"); out.Write("\tfloat4 col1 = colors_1;\n"); - if (g_ActiveConfig.bEnablePixelLighting) + if (uid_data->per_pixel_lighting) { out.Write("\tfloat3 _norm0 = normalize(Normal.xyz);\n\n"); out.Write("\tfloat3 pos = WorldPos;\n"); @@ -463,24 +629,23 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) // out.SetConstantsUsed(C_PLIGHT_COLORS, C_PLIGHT_COLORS+7); // TODO: Can be optimized further // out.SetConstantsUsed(C_PLIGHTS, C_PLIGHTS+31); // TODO: Can be optimized further // out.SetConstantsUsed(C_PMATERIALS, C_PMATERIALS+3); - uid_data->components = components; - GenerateLightingShader(out, uid_data->lighting, components, "colors_", "col"); + GenerateLightingShaderCode(out, uid_data->lighting, uid_data->components << VB_COL_SHIFT, + "colors_", "col"); } // HACK to handle cases where the tex gen is not enabled - if (numTexgen == 0) + if (uid_data->genMode_numtexgens == 0) { out.Write("\tint2 fixpoint_uv0 = int2(0, 0);\n\n"); } else { - out.SetConstantsUsed(C_TEXDIMS, C_TEXDIMS + numTexgen - 1); - for (unsigned int i = 0; i < numTexgen; ++i) + out.SetConstantsUsed(C_TEXDIMS, C_TEXDIMS + uid_data->genMode_numtexgens - 1); + for (unsigned int i = 0; i < uid_data->genMode_numtexgens; ++i) { out.Write("\tint2 fixpoint_uv%d = itrunc(", i); // optional perspective divides - uid_data->texMtxInfo_n_projection |= xfmem.texMtxInfo[i].projection << i; - if (xfmem.texMtxInfo[i].projection == XF_TEXPROJ_STQ) + if (((uid_data->texMtxInfo_n_projection >> i) & 1) == XF_TEXPROJ_STQ) { out.Write("(uv%d.z == 0.0 ? uv%d.xy : uv%d.xy / uv%d.z)", i, i, i, i); } @@ -493,27 +658,14 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) } } - // indirect texture map lookup - int nIndirectStagesUsed = 0; - if (bpmem.genMode.numindstages > 0) + for (u32 i = 0; i < uid_data->genMode_numindstages; ++i) { - for (unsigned int i = 0; i < numStages; ++i) + if (uid_data->nIndirectStagesUsed & (1 << i)) { - if (bpmem.tevind[i].IsActive() && bpmem.tevind[i].bt < bpmem.genMode.numindstages) - nIndirectStagesUsed |= 1 << bpmem.tevind[i].bt; - } - } + unsigned int texcoord = uid_data->GetTevindirefCoord(i); + unsigned int texmap = uid_data->GetTevindirefMap(i); - uid_data->nIndirectStagesUsed = nIndirectStagesUsed; - for (u32 i = 0; i < bpmem.genMode.numindstages; ++i) - { - if (nIndirectStagesUsed & (1 << i)) - { - unsigned int texcoord = bpmem.tevindref.getTexCoord(i); - unsigned int texmap = bpmem.tevindref.getTexMap(i); - - uid_data->SetTevindrefValues(i, texcoord, texmap); - if (texcoord < numTexgen) + if (texcoord < uid_data->genMode_numtexgens) { out.SetConstantsUsed(C_INDTEXSCALE + i / 2, C_INDTEXSCALE + i / 2); out.Write("\ttempcoord = fixpoint_uv%d >> " I_INDTEXSCALE "[%d].%s;\n", texcoord, i / 2, @@ -523,70 +675,53 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write("\ttempcoord = int2(0, 0);\n"); out.Write("\tint3 iindtex%d = ", i); - SampleTexture(out, "float2(tempcoord)", "abg", texmap, ApiType); + SampleTexture(out, "float2(tempcoord)", "abg", texmap, uid_data->stereo, ApiType); } } - // Uid fields for BuildSwapModeTable are set in WriteStage - char swapModeTable[4][5]; - const char* swapColors = "rgba"; - for (int i = 0; i < 4; i++) - { - swapModeTable[i][0] = swapColors[bpmem.tevksel[i * 2].swap1]; - swapModeTable[i][1] = swapColors[bpmem.tevksel[i * 2].swap2]; - swapModeTable[i][2] = swapColors[bpmem.tevksel[i * 2 + 1].swap1]; - swapModeTable[i][3] = swapColors[bpmem.tevksel[i * 2 + 1].swap2]; - swapModeTable[i][4] = '\0'; - } - for (unsigned int i = 0; i < numStages; i++) - WriteStage(out, uid_data, i, ApiType, swapModeTable); // build the equation for this stage + WriteStage(out, uid_data, i, ApiType); // build the equation for this stage -#define MY_STRUCT_OFFSET(str, elem) ((u32)((u64) & (str).elem - (u64) & (str))) - bool enable_pl = g_ActiveConfig.bEnablePixelLighting; - uid_data->num_values = - (enable_pl) ? sizeof(*uid_data) : MY_STRUCT_OFFSET(*uid_data, stagehash[numStages]); - - if (numStages) { // The results of the last texenv stage are put onto the screen, // regardless of the used destination register - if (bpmem.combiners[numStages - 1].colorC.dest != 0) + TevStageCombiner::ColorCombiner last_cc; + TevStageCombiner::AlphaCombiner last_ac; + last_cc.hex = uid_data->stagehash[uid_data->genMode_numtevstages].cc; + last_ac.hex = uid_data->stagehash[uid_data->genMode_numtevstages].ac; + if (last_cc.dest != 0) { - out.Write("\tprev.rgb = %s;\n", tevCOutputTable[bpmem.combiners[numStages - 1].colorC.dest]); + out.Write("\tprev.rgb = %s;\n", tevCOutputTable[last_cc.dest]); } - if (bpmem.combiners[numStages - 1].alphaC.dest != 0) + if (last_ac.dest != 0) { - out.Write("\tprev.a = %s;\n", tevAOutputTable[bpmem.combiners[numStages - 1].alphaC.dest]); + out.Write("\tprev.a = %s;\n", tevAOutputTable[last_ac.dest]); } } out.Write("\tprev = prev & 255;\n"); - AlphaTest::TEST_RESULT Pretest = bpmem.alpha_test.TestResult(); - uid_data->Pretest = Pretest; - // NOTE: Fragment may not be discarded if alpha test always fails and early depth test is enabled // (in this case we need to write a depth value if depth test passes regardless of the alpha // testing result) - if (Pretest == AlphaTest::UNDETERMINED || - (Pretest == AlphaTest::FAIL && bpmem.UseLateDepthTest())) - WriteAlphaTest(out, uid_data, ApiType, dstAlphaMode, per_pixel_depth); + if (uid_data->Pretest == AlphaTest::UNDETERMINED || + (uid_data->Pretest == AlphaTest::FAIL && uid_data->late_ztest)) + WriteAlphaTest(out, uid_data, ApiType, dstAlphaMode, uid_data->per_pixel_depth); - if (bpmem.genMode.zfreeze) + if (uid_data->zfreeze) { out.SetConstantsUsed(C_ZSLOPE, C_ZSLOPE); out.SetConstantsUsed(C_EFBSCALE, C_EFBSCALE); out.Write("\tfloat2 screenpos = rawpos.xy * " I_EFBSCALE ".xy;\n"); - // Opengl has reversed vertical screenspace coordiantes + // Opengl has reversed vertical screenspace coordinates if (ApiType == API_OPENGL) out.Write("\tscreenpos.y = %i.0 - screenpos.y;\n", EFB_HEIGHT); out.Write("\tint zCoord = int(" I_ZSLOPE ".z + " I_ZSLOPE ".x * screenpos.x + " I_ZSLOPE ".y * screenpos.y);\n"); } - else if (!g_ActiveConfig.bFastDepthCalc) + else if (!uid_data->fast_depth_calc) { // FastDepth means to trust the depth generated in perspective division. // It should be correct, but it seems not to be as accurate as required. TODO: Find out why! @@ -609,18 +744,10 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) // depth texture can safely be ignored if the result won't be written to the depth buffer // (early_ztest) and isn't used for fog either - const bool skip_ztexture = !per_pixel_depth && !bpmem.fog.c_proj_fsel.fsel; - - uid_data->ztex_op = bpmem.ztex2.op; - uid_data->per_pixel_depth = per_pixel_depth; - uid_data->forced_early_z = forced_early_z; - uid_data->fast_depth_calc = g_ActiveConfig.bFastDepthCalc; - uid_data->early_ztest = bpmem.UseEarlyDepthTest(); - uid_data->fog_fsel = bpmem.fog.c_proj_fsel.fsel; - uid_data->zfreeze = bpmem.genMode.zfreeze; + const bool skip_ztexture = !uid_data->per_pixel_depth && !uid_data->fog_fsel; // Note: z-textures are not written to depth buffer if early depth test is used - if (per_pixel_depth && bpmem.UseEarlyDepthTest()) + if (uid_data->per_pixel_depth && uid_data->early_ztest) { if (ApiType == API_D3D) out.Write("\tdepth = 1.0 - float(zCoord) / 16777216.0;\n"); @@ -631,17 +758,17 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) // Note: depth texture output is only written to depth buffer if late depth test is used // theoretical final depth value is used for fog calculation, though, so we have to emulate // ztextures anyway - if (bpmem.ztex2.op != ZTEXTURE_DISABLE && !skip_ztexture) + if (uid_data->ztex_op != ZTEXTURE_DISABLE && !skip_ztexture) { // use the texture input of the last texture stage (textemp), hopefully this has been read and // is in correct format... out.SetConstantsUsed(C_ZBIAS, C_ZBIAS + 1); out.Write("\tzCoord = idot(" I_ZBIAS "[0].xyzw, textemp.xyzw) + " I_ZBIAS "[1].w %s;\n", - (bpmem.ztex2.op == ZTEXTURE_ADD) ? "+ zCoord" : ""); + (uid_data->ztex_op == ZTEXTURE_ADD) ? "+ zCoord" : ""); out.Write("\tzCoord = zCoord & 0xFFFFFF;\n"); } - if (per_pixel_depth && bpmem.UseLateDepthTest()) + if (uid_data->per_pixel_depth && uid_data->late_ztest) { if (ApiType == API_D3D) out.Write("\tdepth = 1.0 - float(zCoord) / 16777216.0;\n"); @@ -656,7 +783,7 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) } else { - WriteFog(out, uid_data); + WriteFog(out, uid_data); out.Write("\tocol0 = float4(prev) / 255.0;\n"); } @@ -671,10 +798,8 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) out.Write("\tocol0.a = float(" I_ALPHA ".a) / 255.0;\n"); } - if (g_ActiveConfig.backend_info.bSupportsBBox && g_ActiveConfig.bBBoxEnable && - BoundingBox::active) + if (uid_data->bounding_box) { - uid_data->bounding_box = true; const char* atomic_op = ApiType == API_OPENGL ? "atomic" : "Interlocked"; out.Write("\tif(bbox_data[0] > int(rawpos.x)) %sMin(bbox_data[0], int(rawpos.x));\n" "\tif(bbox_data[1] < int(rawpos.x)) %sMax(bbox_data[1], int(rawpos.x));\n" @@ -688,70 +813,64 @@ static T GeneratePixelShader(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) return out; } -template -static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE ApiType, - const char swapModeTable[4][5]) +static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n, + API_TYPE ApiType) { - int texcoord = bpmem.tevorders[n / 2].getTexCoord(n & 1); - bool bHasTexCoord = (u32)texcoord < bpmem.genMode.numtexgens; - bool bHasIndStage = bpmem.tevind[n].bt < bpmem.genMode.numindstages; + auto& stage = uid_data->stagehash[n]; + out.Write("\n\t// TEV stage %d\n", n); + // HACK to handle cases where the tex gen is not enabled + u32 texcoord = stage.tevorders_texcoord; + bool bHasTexCoord = texcoord < uid_data->genMode_numtexgens; if (!bHasTexCoord) texcoord = 0; - out.Write("\n\t// TEV stage %d\n", n); - - uid_data->stagehash[n].hasindstage = bHasIndStage; - uid_data->stagehash[n].tevorders_texcoord = texcoord; - if (bHasIndStage) + if (stage.hasindstage) { - uid_data->stagehash[n].tevind = bpmem.tevind[n].hex & 0x7FFFFF; + TevStageIndirect tevind; + tevind.hex = stage.tevind; out.Write("\t// indirect op\n"); // perform the indirect op on the incoming regular coordinates using iindtex%d as the offset // coords - if (bpmem.tevind[n].bs != ITBA_OFF) + if (tevind.bs != ITBA_OFF) { const char* tevIndAlphaSel[] = {"", "x", "y", "z"}; const char* tevIndAlphaMask[] = {"248", "224", "240", "248"}; // 0b11111000, 0b11100000, 0b11110000, 0b11111000 - out.Write("alphabump = iindtex%d.%s & %s;\n", bpmem.tevind[n].bt, - tevIndAlphaSel[bpmem.tevind[n].bs], tevIndAlphaMask[bpmem.tevind[n].fmt]); + out.Write("alphabump = iindtex%d.%s & %s;\n", tevind.bt, tevIndAlphaSel[tevind.bs], + tevIndAlphaMask[tevind.fmt]); } else { // TODO: Should we reset alphabump to 0 here? } - if (bpmem.tevind[n].mid != 0) + if (tevind.mid != 0) { // format const char* tevIndFmtMask[] = {"255", "31", "15", "7"}; - out.Write("\tint3 iindtevcrd%d = iindtex%d & %s;\n", n, bpmem.tevind[n].bt, - tevIndFmtMask[bpmem.tevind[n].fmt]); + out.Write("\tint3 iindtevcrd%d = iindtex%d & %s;\n", n, tevind.bt, tevIndFmtMask[tevind.fmt]); // bias - TODO: Check if this needs to be this complicated.. const char* tevIndBiasField[] = {"", "x", "y", "xy", "z", "xz", "yz", "xyz"}; // indexed by bias const char* tevIndBiasAdd[] = {"-128", "1", "1", "1"}; // indexed by fmt - if (bpmem.tevind[n].bias == ITB_S || bpmem.tevind[n].bias == ITB_T || - bpmem.tevind[n].bias == ITB_U) - out.Write("\tiindtevcrd%d.%s += int(%s);\n", n, tevIndBiasField[bpmem.tevind[n].bias], - tevIndBiasAdd[bpmem.tevind[n].fmt]); - else if (bpmem.tevind[n].bias == ITB_ST || bpmem.tevind[n].bias == ITB_SU || - bpmem.tevind[n].bias == ITB_TU) - out.Write("\tiindtevcrd%d.%s += int2(%s, %s);\n", n, tevIndBiasField[bpmem.tevind[n].bias], - tevIndBiasAdd[bpmem.tevind[n].fmt], tevIndBiasAdd[bpmem.tevind[n].fmt]); - else if (bpmem.tevind[n].bias == ITB_STU) - out.Write("\tiindtevcrd%d.%s += int3(%s, %s, %s);\n", n, - tevIndBiasField[bpmem.tevind[n].bias], tevIndBiasAdd[bpmem.tevind[n].fmt], - tevIndBiasAdd[bpmem.tevind[n].fmt], tevIndBiasAdd[bpmem.tevind[n].fmt]); + if (tevind.bias == ITB_S || tevind.bias == ITB_T || tevind.bias == ITB_U) + out.Write("\tiindtevcrd%d.%s += int(%s);\n", n, tevIndBiasField[tevind.bias], + tevIndBiasAdd[tevind.fmt]); + else if (tevind.bias == ITB_ST || tevind.bias == ITB_SU || tevind.bias == ITB_TU) + out.Write("\tiindtevcrd%d.%s += int2(%s, %s);\n", n, tevIndBiasField[tevind.bias], + tevIndBiasAdd[tevind.fmt], tevIndBiasAdd[tevind.fmt]); + else if (tevind.bias == ITB_STU) + out.Write("\tiindtevcrd%d.%s += int3(%s, %s, %s);\n", n, tevIndBiasField[tevind.bias], + tevIndBiasAdd[tevind.fmt], tevIndBiasAdd[tevind.fmt], tevIndBiasAdd[tevind.fmt]); // multiply by offset matrix and scale - calculations are likely to overflow badly, // yet it works out since we only care about the lower 23 bits (+1 sign bit) of the result - if (bpmem.tevind[n].mid <= 3) + if (tevind.mid <= 3) { - int mtxidx = 2 * (bpmem.tevind[n].mid - 1); + int mtxidx = 2 * (tevind.mid - 1); out.SetConstantsUsed(C_INDTEXMTX + mtxidx, C_INDTEXMTX + mtxidx); out.Write("\tint2 indtevtrans%d = int2(idot(" I_INDTEXMTX @@ -763,10 +882,10 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE mtxidx, n, mtxidx); out.Write("\telse indtevtrans%d <<= (-" I_INDTEXMTX "[%d].w);\n", n, mtxidx); } - else if (bpmem.tevind[n].mid <= 7 && bHasTexCoord) + else if (tevind.mid <= 7 && bHasTexCoord) { // s matrix - _assert_(bpmem.tevind[n].mid >= 5); - int mtxidx = 2 * (bpmem.tevind[n].mid - 5); + _assert_(tevind.mid >= 5); + int mtxidx = 2 * (tevind.mid - 5); out.SetConstantsUsed(C_INDTEXMTX + mtxidx, C_INDTEXMTX + mtxidx); out.Write("\tint2 indtevtrans%d = int2(fixpoint_uv%d * iindtevcrd%d.xx) >> 8;\n", n, @@ -776,10 +895,10 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE mtxidx, n, mtxidx); out.Write("\telse indtevtrans%d <<= (-" I_INDTEXMTX "[%d].w);\n", n, mtxidx); } - else if (bpmem.tevind[n].mid <= 11 && bHasTexCoord) + else if (tevind.mid <= 11 && bHasTexCoord) { // t matrix - _assert_(bpmem.tevind[n].mid >= 9); - int mtxidx = 2 * (bpmem.tevind[n].mid - 9); + _assert_(tevind.mid >= 9); + int mtxidx = 2 * (tevind.mid - 9); out.SetConstantsUsed(C_INDTEXMTX + mtxidx, C_INDTEXMTX + mtxidx); out.Write("\tint2 indtevtrans%d = int2(fixpoint_uv%d * iindtevcrd%d.yy) >> 8;\n", n, @@ -807,24 +926,24 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE "(32<<7)", "(16<<7)", "1"}; // TODO: Should the last one be 1 or (1<<7)? // wrap S - if (bpmem.tevind[n].sw == ITW_OFF) + if (tevind.sw == ITW_OFF) out.Write("\twrappedcoord.x = fixpoint_uv%d.x;\n", texcoord); - else if (bpmem.tevind[n].sw == ITW_0) + else if (tevind.sw == ITW_0) out.Write("\twrappedcoord.x = 0;\n"); else out.Write("\twrappedcoord.x = fixpoint_uv%d.x & (%s - 1);\n", texcoord, - tevIndWrapStart[bpmem.tevind[n].sw]); + tevIndWrapStart[tevind.sw]); // wrap T - if (bpmem.tevind[n].tw == ITW_OFF) + if (tevind.tw == ITW_OFF) out.Write("\twrappedcoord.y = fixpoint_uv%d.y;\n", texcoord); - else if (bpmem.tevind[n].tw == ITW_0) + else if (tevind.tw == ITW_0) out.Write("\twrappedcoord.y = 0;\n"); else out.Write("\twrappedcoord.y = fixpoint_uv%d.y & (%s - 1);\n", texcoord, - tevIndWrapStart[bpmem.tevind[n].tw]); + tevIndWrapStart[tevind.tw]); - if (bpmem.tevind[n].fb_addprev) // add previous tevcoord + if (tevind.fb_addprev) // add previous tevcoord out.Write("\ttevcoord.xy += wrappedcoord + indtevtrans%d;\n", n); else out.Write("\ttevcoord.xy = wrappedcoord + indtevtrans%d;\n", n); @@ -833,35 +952,30 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE out.Write("\ttevcoord.xy = (tevcoord.xy << 8) >> 8;\n"); } - TevStageCombiner::ColorCombiner& cc = bpmem.combiners[n].colorC; - TevStageCombiner::AlphaCombiner& ac = bpmem.combiners[n].alphaC; - - uid_data->stagehash[n].cc = cc.hex & 0xFFFFFF; - uid_data->stagehash[n].ac = ac.hex & 0xFFFFF0; // Storing rswap and tswap later + TevStageCombiner::ColorCombiner cc; + TevStageCombiner::AlphaCombiner ac; + cc.hex = stage.cc; + ac.hex = stage.ac; if (cc.a == TEVCOLORARG_RASA || cc.a == TEVCOLORARG_RASC || cc.b == TEVCOLORARG_RASA || cc.b == TEVCOLORARG_RASC || cc.c == TEVCOLORARG_RASA || cc.c == TEVCOLORARG_RASC || cc.d == TEVCOLORARG_RASA || cc.d == TEVCOLORARG_RASC || ac.a == TEVALPHAARG_RASA || ac.b == TEVALPHAARG_RASA || ac.c == TEVALPHAARG_RASA || ac.d == TEVALPHAARG_RASA) { - const int i = bpmem.combiners[n].alphaC.rswap; - uid_data->stagehash[n].ac |= bpmem.combiners[n].alphaC.rswap; - uid_data->stagehash[n].tevksel_swap1a = bpmem.tevksel[i * 2].swap1; - uid_data->stagehash[n].tevksel_swap2a = bpmem.tevksel[i * 2].swap2; - uid_data->stagehash[n].tevksel_swap1b = bpmem.tevksel[i * 2 + 1].swap1; - uid_data->stagehash[n].tevksel_swap2b = bpmem.tevksel[i * 2 + 1].swap2; - uid_data->stagehash[n].tevorders_colorchan = bpmem.tevorders[n / 2].getColorChan(n & 1); + // Generate swizzle string to represent the Ras color channel swapping + char rasswap[5] = {"rgba"[stage.tevksel_swap1a], "rgba"[stage.tevksel_swap2a], + "rgba"[stage.tevksel_swap1b], "rgba"[stage.tevksel_swap2b], '\0'}; - const char* rasswap = swapModeTable[bpmem.combiners[n].alphaC.rswap]; - out.Write("\trastemp = %s.%s;\n", tevRasTable[bpmem.tevorders[n / 2].getColorChan(n & 1)], - rasswap); + out.Write("\trastemp = %s.%s;\n", tevRasTable[stage.tevorders_colorchan], rasswap); } - uid_data->stagehash[n].tevorders_enable = bpmem.tevorders[n / 2].getEnable(n & 1); - if (bpmem.tevorders[n / 2].getEnable(n & 1)) + if (stage.tevorders_enable) { - int texmap = bpmem.tevorders[n / 2].getTexMap(n & 1); - if (!bHasIndStage) + // Generate swizzle string to represent the texture color channel swapping + char texswap[5] = {"rgba"[stage.tevksel_swap1c], "rgba"[stage.tevksel_swap2c], + "rgba"[stage.tevksel_swap1d], "rgba"[stage.tevksel_swap2d], '\0'}; + + if (!stage.hasindstage) { // calc tevcord if (bHasTexCoord) @@ -869,21 +983,9 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE else out.Write("\ttevcoord.xy = int2(0, 0);\n"); } - - const int i = bpmem.combiners[n].alphaC.tswap; - uid_data->stagehash[n].ac |= bpmem.combiners[n].alphaC.tswap << 2; - uid_data->stagehash[n].tevksel_swap1c = bpmem.tevksel[i * 2].swap1; - uid_data->stagehash[n].tevksel_swap2c = bpmem.tevksel[i * 2].swap2; - uid_data->stagehash[n].tevksel_swap1d = bpmem.tevksel[i * 2 + 1].swap1; - uid_data->stagehash[n].tevksel_swap2d = bpmem.tevksel[i * 2 + 1].swap2; - - uid_data->stagehash[n].tevorders_texmap = bpmem.tevorders[n / 2].getTexMap(n & 1); - - const char* texswap = swapModeTable[bpmem.combiners[n].alphaC.tswap]; - uid_data->SetTevindrefTexmap(i, texmap); - out.Write("\ttextemp = "); - SampleTexture(out, "float2(tevcoord.xy)", texswap, texmap, ApiType); + SampleTexture(out, "float2(tevcoord.xy)", texswap, stage.tevorders_texmap, uid_data->stereo, + ApiType); } else { @@ -894,16 +996,15 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE cc.d == TEVCOLORARG_KONST || ac.a == TEVALPHAARG_KONST || ac.b == TEVALPHAARG_KONST || ac.c == TEVALPHAARG_KONST || ac.d == TEVALPHAARG_KONST) { - int kc = bpmem.tevksel[n / 2].getKC(n & 1); - int ka = bpmem.tevksel[n / 2].getKA(n & 1); - uid_data->stagehash[n].tevksel_kc = kc; - uid_data->stagehash[n].tevksel_ka = ka; - out.Write("\tkonsttemp = int4(%s, %s);\n", tevKSelTableC[kc], tevKSelTableA[ka]); + out.Write("\tkonsttemp = int4(%s, %s);\n", tevKSelTableC[stage.tevksel_kc], + tevKSelTableA[stage.tevksel_ka]); - if (kc > 7) - out.SetConstantsUsed(C_KCOLORS + ((kc - 0xc) % 4), C_KCOLORS + ((kc - 0xc) % 4)); - if (ka > 7) - out.SetConstantsUsed(C_KCOLORS + ((ka - 0xc) % 4), C_KCOLORS + ((ka - 0xc) % 4)); + if (stage.tevksel_kc > 7) + out.SetConstantsUsed(C_KCOLORS + ((stage.tevksel_kc - 0xc) % 4), + C_KCOLORS + ((stage.tevksel_kc - 0xc) % 4)); + if (stage.tevksel_ka > 7) + out.SetConstantsUsed(C_KCOLORS + ((stage.tevksel_ka - 0xc) % 4), + C_KCOLORS + ((stage.tevksel_ka - 0xc) % 4)); } if (cc.d == TEVCOLORARG_C0 || cc.d == TEVCOLORARG_A0 || ac.d == TEVALPHAARG_A0) @@ -993,8 +1094,8 @@ static void WriteStage(T& out, pixel_shader_uid_data* uid_data, int n, API_TYPE out.Write(";\n"); } -template -static void WriteTevRegular(T& out, const char* components, int bias, int op, int clamp, int shift) +static void WriteTevRegular(ShaderCode& out, const char* components, int bias, int op, int clamp, + int shift) { const char* tevScaleTableLeft[] = { "", // SCALE_1 @@ -1040,20 +1141,18 @@ static void WriteTevRegular(T& out, const char* components, int bias, int op, in out.Write(")%s", tevScaleTableRight[shift]); } -template -static void SampleTexture(T& out, const char* texcoords, const char* texswap, int texmap, - API_TYPE ApiType) +static void SampleTexture(ShaderCode& out, const char* texcoords, const char* texswap, int texmap, + bool stereo, API_TYPE ApiType) { out.SetConstantsUsed(C_TEXDIMS + texmap, C_TEXDIMS + texmap); if (ApiType == API_D3D) out.Write("iround(255.0 * Tex[%d].Sample(samp[%d], float3(%s.xy * " I_TEXDIMS "[%d].xy, %s))).%s;\n", - texmap, texmap, texcoords, texmap, g_ActiveConfig.iStereoMode > 0 ? "layer" : "0.0", - texswap); + texmap, texmap, texcoords, texmap, stereo ? "layer" : "0.0", texswap); else out.Write("iround(255.0 * texture(samp[%d], float3(%s.xy * " I_TEXDIMS "[%d].xy, %s))).%s;\n", - texmap, texcoords, texmap, g_ActiveConfig.iStereoMode > 0 ? "layer" : "0.0", texswap); + texmap, texcoords, texmap, stereo ? "layer" : "0.0", texswap); } static const char* tevAlphaFuncsTable[] = { @@ -1074,8 +1173,7 @@ static const char* tevAlphaFunclogicTable[] = { " == " // xnor }; -template -static void WriteAlphaTest(T& out, pixel_shader_uid_data* uid_data, API_TYPE ApiType, +static void WriteAlphaTest(ShaderCode& out, const pixel_shader_uid_data* uid_data, API_TYPE ApiType, DSTALPHA_MODE dstAlphaMode, bool per_pixel_depth) { static const char* alphaRef[2] = {I_ALPHA ".r", I_ALPHA ".g"}; @@ -1087,18 +1185,14 @@ static void WriteAlphaTest(T& out, pixel_shader_uid_data* uid_data, API_TYPE Api else out.Write("\tif(!( "); - uid_data->alpha_test_comp0 = bpmem.alpha_test.comp0; - uid_data->alpha_test_comp1 = bpmem.alpha_test.comp1; - uid_data->alpha_test_logic = bpmem.alpha_test.logic; - // Lookup the first component from the alpha function table - int compindex = bpmem.alpha_test.comp0; + int compindex = uid_data->alpha_test_comp0; out.Write(tevAlphaFuncsTable[compindex], alphaRef[0]); - out.Write("%s", tevAlphaFunclogicTable[bpmem.alpha_test.logic]); // lookup the logic op + out.Write("%s", tevAlphaFunclogicTable[uid_data->alpha_test_logic]); // lookup the logic op // Lookup the second component from the alpha function table - compindex = bpmem.alpha_test.comp1; + compindex = uid_data->alpha_test_comp1; out.Write(tevAlphaFuncsTable[compindex], alphaRef[1]); if (DriverDetails::HasBug(DriverDetails::BUG_BROKENNEGATEDBOOLEAN)) @@ -1113,16 +1207,6 @@ static void WriteAlphaTest(T& out, pixel_shader_uid_data* uid_data, API_TYPE Api out.Write("\t\tdepth = %s;\n", (ApiType == API_D3D) ? "0.0" : "1.0"); // ZCOMPLOC HACK: - // The only way to emulate alpha test + early-z is to force early-z in the shader. - // As this isn't available on all drivers and as we can't emulate this feature otherwise, - // we are only able to choose which one we want to respect more. - // Tests seem to have proven that writing depth even when the alpha test fails is more - // important that a reliable alpha test, so we just force the alpha test to always succeed. - // At least this seems to be less buggy. - uid_data->alpha_test_use_zcomploc_hack = bpmem.UseEarlyDepthTest() && bpmem.zmode.updateenable && - !g_ActiveConfig.backend_info.bSupportsEarlyZ && - !bpmem.genMode.zfreeze; - if (!uid_data->alpha_test_use_zcomploc_hack) { out.Write("\t\tdiscard;\n"); @@ -1144,19 +1228,15 @@ static const char* tevFogFuncsTable[] = { "\tfog = 1.0 - fog;\n fog = exp2(-8.0 * fog * fog);\n" // backward exp2 }; -template -static void WriteFog(T& out, pixel_shader_uid_data* uid_data) +static void WriteFog(ShaderCode& out, const pixel_shader_uid_data* uid_data) { - uid_data->fog_fsel = bpmem.fog.c_proj_fsel.fsel; - if (bpmem.fog.c_proj_fsel.fsel == 0) + if (uid_data->fog_fsel == 0) return; // no Fog - uid_data->fog_proj = bpmem.fog.c_proj_fsel.proj; - out.SetConstantsUsed(C_FOGCOLOR, C_FOGCOLOR); out.SetConstantsUsed(C_FOGI, C_FOGI); out.SetConstantsUsed(C_FOGF, C_FOGF + 1); - if (bpmem.fog.c_proj_fsel.proj == 0) + if (uid_data->fog_proj == 0) { // perspective // ze = A/(B - (Zs >> B_SHF) @@ -1178,8 +1258,7 @@ static void WriteFog(T& out, pixel_shader_uid_data* uid_data) // ze *= x_adjust // TODO Instead of this theoretical calculation, we should use the // coefficient table given in the fog range BP registers! - uid_data->fog_RangeBaseEnabled = bpmem.fogRange.Base.Enabled; - if (bpmem.fogRange.Base.Enabled) + if (uid_data->fog_RangeBaseEnabled) { out.SetConstantsUsed(C_FOGF, C_FOGF); out.Write("\tfloat x_adjust = (2.0 * (rawpos.x / " I_FOGF "[0].y)) - 1.0 - " I_FOGF "[0].x;\n"); @@ -1190,26 +1269,16 @@ static void WriteFog(T& out, pixel_shader_uid_data* uid_data) out.Write("\tfloat fog = clamp(ze - " I_FOGF "[1].z, 0.0, 1.0);\n"); - if (bpmem.fog.c_proj_fsel.fsel > 3) + if (uid_data->fog_fsel > 3) { - out.Write("%s", tevFogFuncsTable[bpmem.fog.c_proj_fsel.fsel]); + out.Write("%s", tevFogFuncsTable[uid_data->fog_fsel]); } else { - if (bpmem.fog.c_proj_fsel.fsel != 2) - WARN_LOG(VIDEO, "Unknown Fog Type! %08x", bpmem.fog.c_proj_fsel.fsel); + if (uid_data->fog_fsel != 2) + WARN_LOG(VIDEO, "Unknown Fog Type! %08x", uid_data->fog_fsel); } out.Write("\tint ifog = iround(fog * 256.0);\n"); out.Write("\tprev.rgb = (prev.rgb * (256 - ifog) + " I_FOGCOLOR ".rgb * ifog) >> 8;\n"); } - -PixelShaderUid GetPixelShaderUid(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) -{ - return GeneratePixelShader(dstAlphaMode, ApiType); -} - -ShaderCode GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType) -{ - return GeneratePixelShader(dstAlphaMode, ApiType); -} diff --git a/Source/Core/VideoCommon/PixelShaderGen.h b/Source/Core/VideoCommon/PixelShaderGen.h index 8a62b6bb04..b222a1958f 100644 --- a/Source/Core/VideoCommon/PixelShaderGen.h +++ b/Source/Core/VideoCommon/PixelShaderGen.h @@ -24,12 +24,11 @@ struct pixel_shader_uid_data u32 num_values; // TODO: Shouldn't be a u32 u32 NumValues() const { return num_values; } - u32 components : 23; + u32 components : 2; u32 dstAlphaMode : 2; u32 Pretest : 2; u32 nIndirectStagesUsed : 4; u32 stereo : 1; - u32 genMode_numtexgens : 4; u32 genMode_numtevstages : 4; u32 genMode_numindstages : 3; @@ -38,20 +37,21 @@ struct pixel_shader_uid_data u32 alpha_test_logic : 2; u32 alpha_test_use_zcomploc_hack : 1; u32 fog_proj : 1; + u32 fog_fsel : 3; u32 fog_RangeBaseEnabled : 1; u32 ztex_op : 2; u32 fast_depth_calc : 1; u32 per_pixel_depth : 1; + u32 per_pixel_lighting : 1; u32 forced_early_z : 1; u32 early_ztest : 1; + u32 late_ztest : 1; u32 bounding_box : 1; - - // TODO: 29 bits of padding is a waste. Can we free up some bits elseware? u32 zfreeze : 1; u32 msaa : 1; u32 ssaa : 1; - u32 pad : 29; + u32 pad : 16; u32 texMtxInfo_n_projection : 8; // 8x1 bit u32 tevindref_bi0 : 3; @@ -63,7 +63,7 @@ struct pixel_shader_uid_data u32 tevindref_bi4 : 3; u32 tevindref_bc4 : 3; - inline void SetTevindrefValues(int index, u32 texcoord, u32 texmap) + void SetTevindrefValues(int index, u32 texcoord, u32 texmap) { if (index == 0) { @@ -86,31 +86,54 @@ struct pixel_shader_uid_data tevindref_bi4 = texmap; } } - inline void SetTevindrefTexmap(int index, u32 texmap) + + u32 GetTevindirefCoord(int index) const { if (index == 0) { - tevindref_bi0 = texmap; + return tevindref_bc0; } else if (index == 1) { - tevindref_bi1 = texmap; + return tevindref_bc1; } else if (index == 2) { - tevindref_bi2 = texmap; + return tevindref_bc3; } else if (index == 3) { - tevindref_bi4 = texmap; + return tevindref_bc4; } + return 0; + } + + u32 GetTevindirefMap(int index) const + { + if (index == 0) + { + return tevindref_bi0; + } + else if (index == 1) + { + return tevindref_bi1; + } + else if (index == 2) + { + return tevindref_bi2; + } + else if (index == 3) + { + return tevindref_bi4; + } + return 0; } struct { // TODO: Can save a lot space by removing the padding bits u32 cc : 24; - u32 ac : 24; + u32 ac : 24; // tswap and rswap are left blank (encoded into the tevksel fields below) u32 tevorders_texmap : 3; u32 tevorders_texcoord : 3; @@ -136,13 +159,12 @@ struct pixel_shader_uid_data u32 pad3 : 14; } stagehash[16]; - // TODO: I think we're fine without an enablePixelLighting field, should probably double check, - // though.. LightingUidData lighting; }; #pragma pack() typedef ShaderUid PixelShaderUid; -ShaderCode GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType); -PixelShaderUid GetPixelShaderUid(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType); +ShaderCode GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, + const pixel_shader_uid_data* uid_data); +PixelShaderUid GetPixelShaderUid(DSTALPHA_MODE dstAlphaMode); diff --git a/Source/Core/VideoCommon/ShaderGenCommon.h b/Source/Core/VideoCommon/ShaderGenCommon.h index 2668c8ea7d..d3e0bb1ec5 100644 --- a/Source/Core/VideoCommon/ShaderGenCommon.h +++ b/Source/Core/VideoCommon/ShaderGenCommon.h @@ -154,74 +154,6 @@ public: private: std::vector constant_usage; // TODO: Is vector appropriate here? }; -/** - * Checks if there has been - */ -template -class UidChecker -{ -public: - void Invalidate() - { - m_shaders.clear(); - m_uids.clear(); - } - - void AddToIndexAndCheck(CodeT& new_code, const UidT& new_uid, const char* shader_type, - const char* dump_prefix) - { - bool uid_is_indexed = std::find(m_uids.begin(), m_uids.end(), new_uid) != m_uids.end(); - if (!uid_is_indexed) - { - m_uids.push_back(new_uid); - m_shaders[new_uid] = new_code.GetBuffer(); - } - else - { - // uid is already in the index => check if there's a shader with the same uid but different - // code - auto& old_code = m_shaders[new_uid]; - if (old_code != new_code.GetBuffer()) - { - static int num_failures = 0; - - std::string temp = - StringFromFormat("%s%ssuid_mismatch_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), - dump_prefix, ++num_failures); - - // TODO: Should also dump uids - std::ofstream file; - OpenFStream(file, temp, std::ios_base::out); - file << "Old shader code:\n" << old_code; - file << "\n\nNew shader code:\n" << new_code.GetBuffer(); - file << "\n\nShader uid:\n"; - for (unsigned int i = 0; i < new_uid.GetUidDataSize(); ++i) - { - u8 value = new_uid.GetUidDataRaw()[i]; - if ((i % 4) == 0) - { - auto last_value = - (i + 3 < new_uid.GetUidDataSize() - 1) ? i + 3 : new_uid.GetUidDataSize(); - file << std::setfill(' ') << std::dec; - file << "Values " << std::setw(2) << i << " - " << last_value << ": "; - } - - file << std::setw(2) << std::setfill('0') << std::hex << value << std::setw(1); - if ((i % 4) < 3) - file << ' '; - else - file << std::endl; - } - - ERROR_LOG(VIDEO, "%s shader uid mismatch! See %s for details", shader_type, temp.c_str()); - } - } - } - -private: - std::map m_shaders; - std::vector m_uids; -}; template inline void DefineOutputMember(T& object, API_TYPE api_type, const char* qualifier, @@ -245,40 +177,41 @@ inline void DefineOutputMember(T& object, API_TYPE api_type, const char* qualifi } template -inline void GenerateVSOutputMembers(T& object, API_TYPE api_type, const char* qualifier) +inline void GenerateVSOutputMembers(T& object, API_TYPE api_type, u32 texgens, + bool per_pixel_lighting, const char* qualifier) { DefineOutputMember(object, api_type, qualifier, "float4", "pos", -1, "POSITION"); DefineOutputMember(object, api_type, qualifier, "float4", "colors_", 0, "COLOR", 0); DefineOutputMember(object, api_type, qualifier, "float4", "colors_", 1, "COLOR", 1); - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < texgens; ++i) DefineOutputMember(object, api_type, qualifier, "float3", "tex", i, "TEXCOORD", i); - DefineOutputMember(object, api_type, qualifier, "float4", "clipPos", -1, "TEXCOORD", - xfmem.numTexGen.numTexGens); + DefineOutputMember(object, api_type, qualifier, "float4", "clipPos", -1, "TEXCOORD", texgens); - if (g_ActiveConfig.bEnablePixelLighting) + if (per_pixel_lighting) { DefineOutputMember(object, api_type, qualifier, "float3", "Normal", -1, "TEXCOORD", - xfmem.numTexGen.numTexGens + 1); + texgens + 1); DefineOutputMember(object, api_type, qualifier, "float3", "WorldPos", -1, "TEXCOORD", - xfmem.numTexGen.numTexGens + 2); + texgens + 2); } } template -inline void AssignVSOutputMembers(T& object, const char* a, const char* b) +inline void AssignVSOutputMembers(T& object, const char* a, const char* b, u32 texgens, + bool per_pixel_lighting) { object.Write("\t%s.pos = %s.pos;\n", a, b); object.Write("\t%s.colors_0 = %s.colors_0;\n", a, b); object.Write("\t%s.colors_1 = %s.colors_1;\n", a, b); - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < texgens; ++i) object.Write("\t%s.tex%d = %s.tex%d;\n", a, i, b, i); object.Write("\t%s.clipPos = %s.clipPos;\n", a, b); - if (g_ActiveConfig.bEnablePixelLighting) + if (per_pixel_lighting) { object.Write("\t%s.Normal = %s.Normal;\n", a, b); object.Write("\t%s.WorldPos = %s.WorldPos;\n", a, b); @@ -293,23 +226,24 @@ inline void AssignVSOutputMembers(T& object, const char* a, const char* b) // As a workaround, we interpolate at the centroid of the coveraged pixel, which // is always inside the primitive. // Without MSAA, this flag is defined to have no effect. -inline const char* GetInterpolationQualifier(bool in_glsl_interface_block = false, bool in = false) +inline const char* GetInterpolationQualifier(bool msaa, bool ssaa, + bool in_glsl_interface_block = false, bool in = false) { - if (g_ActiveConfig.iMultisamples <= 1) + if (!msaa) return ""; // Without GL_ARB_shading_language_420pack support, the interpolation qualifier must be // "centroid in" and not "centroid", even within an interface block. if (in_glsl_interface_block && !g_ActiveConfig.backend_info.bSupportsBindingLayout) { - if (!g_ActiveConfig.bSSAA) + if (!ssaa) return in ? "centroid in" : "centroid out"; else return in ? "sample in" : "sample out"; } else { - if (!g_ActiveConfig.bSSAA) + if (!ssaa) return "centroid"; else return "sample"; diff --git a/Source/Core/VideoCommon/VertexShaderGen.cpp b/Source/Core/VideoCommon/VertexShaderGen.cpp index 618d097370..77444e7dfc 100644 --- a/Source/Core/VideoCommon/VertexShaderGen.cpp +++ b/Source/Core/VideoCommon/VertexShaderGen.cpp @@ -14,22 +14,73 @@ #include "VideoCommon/VertexShaderGen.h" #include "VideoCommon/VideoConfig.h" -template -static T GenerateVertexShader(API_TYPE api_type) +VertexShaderUid GetVertexShaderUid() { - T out; - const u32 components = VertexLoaderManager::g_current_components; - // Non-uid template parameters will write to the dummy data (=> gets optimized out) - vertex_shader_uid_data dummy_data; - vertex_shader_uid_data* uid_data = out.template GetUidData(); - if (uid_data != nullptr) - memset(uid_data, 0, sizeof(*uid_data)); - else - uid_data = &dummy_data; + VertexShaderUid out; + vertex_shader_uid_data* uid_data = out.GetUidData(); + memset(uid_data, 0, sizeof(*uid_data)); _assert_(bpmem.genMode.numtexgens == xfmem.numTexGen.numTexGens); _assert_(bpmem.genMode.numcolchans == xfmem.numChan.numColorChans); + uid_data->numTexGens = xfmem.numTexGen.numTexGens; + uid_data->components = VertexLoaderManager::g_current_components; + uid_data->pixel_lighting = g_ActiveConfig.bEnablePixelLighting; + uid_data->msaa = g_ActiveConfig.iMultisamples > 1; + uid_data->ssaa = g_ActiveConfig.iMultisamples > 1 && g_ActiveConfig.bSSAA; + uid_data->numColorChans = xfmem.numChan.numColorChans; + + GetLightingShaderUid(uid_data->lighting); + + // transform texcoords + for (unsigned int i = 0; i < uid_data->numTexGens; ++i) + { + auto& texinfo = uid_data->texMtxInfo[i]; + + texinfo.sourcerow = xfmem.texMtxInfo[i].sourcerow; + texinfo.texgentype = xfmem.texMtxInfo[i].texgentype; + texinfo.inputform = xfmem.texMtxInfo[i].inputform; + + // first transformation + switch (texinfo.texgentype) + { + case XF_TEXGEN_EMBOSS_MAP: // calculate tex coords into bump map + if (uid_data->components & (VB_HAS_NRM1 | VB_HAS_NRM2)) + { + // transform the light dir into tangent space + texinfo.embosslightshift = xfmem.texMtxInfo[i].embosslightshift; + texinfo.embosssourceshift = xfmem.texMtxInfo[i].embosssourceshift; + } + else + { + texinfo.embosssourceshift = xfmem.texMtxInfo[i].embosssourceshift; + } + break; + case XF_TEXGEN_COLOR_STRGBC0: + case XF_TEXGEN_COLOR_STRGBC1: + break; + case XF_TEXGEN_REGULAR: + default: + uid_data->texMtxInfo_n_projection |= xfmem.texMtxInfo[i].projection << i; + break; + } + + uid_data->dualTexTrans_enabled = xfmem.dualTexTrans.enabled; + // CHECKME: does this only work for regular tex gen types? + if (uid_data->dualTexTrans_enabled && texinfo.texgentype == XF_TEXGEN_REGULAR) + { + auto& postInfo = uid_data->postMtxInfo[i]; + postInfo.index = xfmem.postMtxInfo[i].index; + postInfo.normalize = xfmem.postMtxInfo[i].normalize; + } + } + + return out; +} + +ShaderCode GenerateVertexShaderCode(API_TYPE api_type, const vertex_shader_uid_data* uid_data) +{ + ShaderCode out; out.Write("%s", s_lighting_struct); // uniforms @@ -42,34 +93,30 @@ static T GenerateVertexShader(API_TYPE api_type) out.Write("};\n"); out.Write("struct VS_OUTPUT {\n"); - GenerateVSOutputMembers(out, api_type, ""); + GenerateVSOutputMembers(out, api_type, uid_data->numTexGens, uid_data->pixel_lighting, ""); out.Write("};\n"); - uid_data->numTexGens = xfmem.numTexGen.numTexGens; - uid_data->components = components; - uid_data->pixel_lighting = g_ActiveConfig.bEnablePixelLighting; - if (api_type == API_OPENGL) { out.Write("in float4 rawpos; // ATTR%d,\n", SHADER_POSITION_ATTRIB); - if (components & VB_HAS_POSMTXIDX) + if (uid_data->components & VB_HAS_POSMTXIDX) out.Write("in int posmtx; // ATTR%d,\n", SHADER_POSMTX_ATTRIB); - if (components & VB_HAS_NRM0) + if (uid_data->components & VB_HAS_NRM0) out.Write("in float3 rawnorm0; // ATTR%d,\n", SHADER_NORM0_ATTRIB); - if (components & VB_HAS_NRM1) + if (uid_data->components & VB_HAS_NRM1) out.Write("in float3 rawnorm1; // ATTR%d,\n", SHADER_NORM1_ATTRIB); - if (components & VB_HAS_NRM2) + if (uid_data->components & VB_HAS_NRM2) out.Write("in float3 rawnorm2; // ATTR%d,\n", SHADER_NORM2_ATTRIB); - if (components & VB_HAS_COL0) + if (uid_data->components & VB_HAS_COL0) out.Write("in float4 color0; // ATTR%d,\n", SHADER_COLOR0_ATTRIB); - if (components & VB_HAS_COL1) + if (uid_data->components & VB_HAS_COL1) out.Write("in float4 color1; // ATTR%d,\n", SHADER_COLOR1_ATTRIB); for (int i = 0; i < 8; ++i) { - u32 hastexmtx = (components & (VB_HAS_TEXMTXIDX0 << i)); - if ((components & (VB_HAS_UV0 << i)) || hastexmtx) + u32 hastexmtx = (uid_data->components & (VB_HAS_TEXMTXIDX0 << i)); + if ((uid_data->components & (VB_HAS_UV0 << i)) || hastexmtx) out.Write("in float%d tex%d; // ATTR%d,\n", hastexmtx ? 3 : 2, i, SHADER_TEXTURE0_ATTRIB + i); } @@ -77,7 +124,9 @@ static T GenerateVertexShader(API_TYPE api_type) if (g_ActiveConfig.backend_info.bSupportsGeometryShaders) { out.Write("out VertexData {\n"); - GenerateVSOutputMembers(out, api_type, GetInterpolationQualifier(true, false)); + GenerateVSOutputMembers( + out, api_type, uid_data->numTexGens, uid_data->pixel_lighting, + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa, false, true)); out.Write("} vs;\n"); } else @@ -85,19 +134,25 @@ static T GenerateVertexShader(API_TYPE api_type) // Let's set up attributes for (u32 i = 0; i < 8; ++i) { - if (i < xfmem.numTexGen.numTexGens) + if (i < uid_data->numTexGens) { - out.Write("%s out float3 uv%u;\n", GetInterpolationQualifier(), i); + out.Write("%s out float3 uv%u;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa), i); } } - out.Write("%s out float4 clipPos;\n", GetInterpolationQualifier()); - if (g_ActiveConfig.bEnablePixelLighting) + out.Write("%s out float4 clipPos;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + if (uid_data->pixel_lighting) { - out.Write("%s out float3 Normal;\n", GetInterpolationQualifier()); - out.Write("%s out float3 WorldPos;\n", GetInterpolationQualifier()); + out.Write("%s out float3 Normal;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + out.Write("%s out float3 WorldPos;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); } - out.Write("%s out float4 colors_0;\n", GetInterpolationQualifier()); - out.Write("%s out float4 colors_1;\n", GetInterpolationQualifier()); + out.Write("%s out float4 colors_0;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); + out.Write("%s out float4 colors_1;\n", + GetInterpolationQualifier(uid_data->msaa, uid_data->ssaa)); } out.Write("void main()\n{\n"); @@ -107,23 +162,23 @@ static T GenerateVertexShader(API_TYPE api_type) out.Write("VS_OUTPUT main(\n"); // inputs - if (components & VB_HAS_NRM0) + if (uid_data->components & VB_HAS_NRM0) out.Write(" float3 rawnorm0 : NORMAL0,\n"); - if (components & VB_HAS_NRM1) + if (uid_data->components & VB_HAS_NRM1) out.Write(" float3 rawnorm1 : NORMAL1,\n"); - if (components & VB_HAS_NRM2) + if (uid_data->components & VB_HAS_NRM2) out.Write(" float3 rawnorm2 : NORMAL2,\n"); - if (components & VB_HAS_COL0) + if (uid_data->components & VB_HAS_COL0) out.Write(" float4 color0 : COLOR0,\n"); - if (components & VB_HAS_COL1) + if (uid_data->components & VB_HAS_COL1) out.Write(" float4 color1 : COLOR1,\n"); for (int i = 0; i < 8; ++i) { - u32 hastexmtx = (components & (VB_HAS_TEXMTXIDX0 << i)); - if ((components & (VB_HAS_UV0 << i)) || hastexmtx) + u32 hastexmtx = (uid_data->components & (VB_HAS_TEXMTXIDX0 << i)); + if ((uid_data->components & (VB_HAS_UV0 << i)) || hastexmtx) out.Write(" float%d tex%d : TEXCOORD%d,\n", hastexmtx ? 3 : 2, i, i); } - if (components & VB_HAS_POSMTXIDX) + if (uid_data->components & VB_HAS_POSMTXIDX) out.Write(" int posmtx : BLENDINDICES,\n"); out.Write(" float4 rawpos : POSITION) {\n"); } @@ -131,26 +186,26 @@ static T GenerateVertexShader(API_TYPE api_type) out.Write("VS_OUTPUT o;\n"); // transforms - if (components & VB_HAS_POSMTXIDX) + if (uid_data->components & VB_HAS_POSMTXIDX) { out.Write("float4 pos = float4(dot(" I_TRANSFORMMATRICES "[posmtx], rawpos), dot(" I_TRANSFORMMATRICES "[posmtx+1], rawpos), dot(" I_TRANSFORMMATRICES "[posmtx+2], rawpos), 1);\n"); - if (components & VB_HAS_NRMALL) + if (uid_data->components & VB_HAS_NRMALL) { out.Write("int normidx = posmtx & 31;\n"); out.Write("float3 N0 = " I_NORMALMATRICES "[normidx].xyz, N1 = " I_NORMALMATRICES "[normidx+1].xyz, N2 = " I_NORMALMATRICES "[normidx+2].xyz;\n"); } - if (components & VB_HAS_NRM0) + if (uid_data->components & VB_HAS_NRM0) out.Write("float3 _norm0 = normalize(float3(dot(N0, rawnorm0), dot(N1, rawnorm0), dot(N2, " "rawnorm0)));\n"); - if (components & VB_HAS_NRM1) + if (uid_data->components & VB_HAS_NRM1) out.Write( "float3 _norm1 = float3(dot(N0, rawnorm1), dot(N1, rawnorm1), dot(N2, rawnorm1));\n"); - if (components & VB_HAS_NRM2) + if (uid_data->components & VB_HAS_NRM2) out.Write( "float3 _norm2 = float3(dot(N0, rawnorm2), dot(N1, rawnorm2), dot(N2, rawnorm2));\n"); } @@ -158,21 +213,21 @@ static T GenerateVertexShader(API_TYPE api_type) { out.Write("float4 pos = float4(dot(" I_POSNORMALMATRIX "[0], rawpos), dot(" I_POSNORMALMATRIX "[1], rawpos), dot(" I_POSNORMALMATRIX "[2], rawpos), 1.0);\n"); - if (components & VB_HAS_NRM0) + if (uid_data->components & VB_HAS_NRM0) out.Write("float3 _norm0 = normalize(float3(dot(" I_POSNORMALMATRIX "[3].xyz, rawnorm0), dot(" I_POSNORMALMATRIX "[4].xyz, rawnorm0), dot(" I_POSNORMALMATRIX "[5].xyz, rawnorm0)));\n"); - if (components & VB_HAS_NRM1) + if (uid_data->components & VB_HAS_NRM1) out.Write("float3 _norm1 = float3(dot(" I_POSNORMALMATRIX "[3].xyz, rawnorm1), dot(" I_POSNORMALMATRIX "[4].xyz, rawnorm1), dot(" I_POSNORMALMATRIX "[5].xyz, rawnorm1));\n"); - if (components & VB_HAS_NRM2) + if (uid_data->components & VB_HAS_NRM2) out.Write("float3 _norm2 = float3(dot(" I_POSNORMALMATRIX "[3].xyz, rawnorm2), dot(" I_POSNORMALMATRIX "[4].xyz, rawnorm2), dot(" I_POSNORMALMATRIX "[5].xyz, rawnorm2));\n"); } - if (!(components & VB_HAS_NRM0)) + if (!(uid_data->components & VB_HAS_NRM0)) out.Write("float3 _norm0 = float3(0.0, 0.0, 0.0);\n"); out.Write("o.pos = float4(dot(" I_PROJECTION "[0], pos), dot(" I_PROJECTION @@ -182,20 +237,19 @@ static T GenerateVertexShader(API_TYPE api_type) "float3 ldir, h, cosAttn, distAttn;\n" "float dist, dist2, attn;\n"); - uid_data->numColorChans = xfmem.numChan.numColorChans; - if (xfmem.numChan.numColorChans == 0) + if (uid_data->numColorChans == 0) { - if (components & VB_HAS_COL0) + if (uid_data->components & VB_HAS_COL0) out.Write("o.colors_0 = color0;\n"); else out.Write("o.colors_0 = float4(1.0, 1.0, 1.0, 1.0);\n"); } - GenerateLightingShader(out, uid_data->lighting, components, "color", "o.colors_"); + GenerateLightingShaderCode(out, uid_data->lighting, uid_data->components, "color", "o.colors_"); - if (xfmem.numChan.numColorChans < 2) + if (uid_data->numColorChans < 2) { - if (components & VB_HAS_COL1) + if (uid_data->components & VB_HAS_COL1) out.Write("o.colors_1 = color1;\n"); else out.Write("o.colors_1 = o.colors_0;\n"); @@ -203,20 +257,19 @@ static T GenerateVertexShader(API_TYPE api_type) // transform texcoords out.Write("float4 coord = float4(0.0, 0.0, 1.0, 1.0);\n"); - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < uid_data->numTexGens; ++i) { - TexMtxInfo& texinfo = xfmem.texMtxInfo[i]; + auto& texinfo = uid_data->texMtxInfo[i]; out.Write("{\n"); out.Write("coord = float4(0.0, 0.0, 1.0, 1.0);\n"); - uid_data->texMtxInfo[i].sourcerow = xfmem.texMtxInfo[i].sourcerow; switch (texinfo.sourcerow) { case XF_SRCGEOM_INROW: out.Write("coord.xyz = rawpos.xyz;\n"); break; case XF_SRCNORMAL_INROW: - if (components & VB_HAS_NRM0) + if (uid_data->components & VB_HAS_NRM0) { out.Write("coord.xyz = rawnorm0.xyz;\n"); } @@ -226,40 +279,37 @@ static T GenerateVertexShader(API_TYPE api_type) texinfo.texgentype == XF_TEXGEN_COLOR_STRGBC1); break; case XF_SRCBINORMAL_T_INROW: - if (components & VB_HAS_NRM1) + if (uid_data->components & VB_HAS_NRM1) { out.Write("coord.xyz = rawnorm1.xyz;\n"); } break; case XF_SRCBINORMAL_B_INROW: - if (components & VB_HAS_NRM2) + if (uid_data->components & VB_HAS_NRM2) { out.Write("coord.xyz = rawnorm2.xyz;\n"); } break; default: _assert_(texinfo.sourcerow <= XF_SRCTEX7_INROW); - if (components & (VB_HAS_UV0 << (texinfo.sourcerow - XF_SRCTEX0_INROW))) + if (uid_data->components & (VB_HAS_UV0 << (texinfo.sourcerow - XF_SRCTEX0_INROW))) out.Write("coord = float4(tex%d.x, tex%d.y, 1.0, 1.0);\n", texinfo.sourcerow - XF_SRCTEX0_INROW, texinfo.sourcerow - XF_SRCTEX0_INROW); break; } // Input form of AB11 sets z element to 1.0 - uid_data->texMtxInfo[i].inputform = xfmem.texMtxInfo[i].inputform; + if (texinfo.inputform == XF_TEXINPUT_AB11) out.Write("coord.z = 1.0;\n"); // first transformation - uid_data->texMtxInfo[i].texgentype = xfmem.texMtxInfo[i].texgentype; switch (texinfo.texgentype) { case XF_TEXGEN_EMBOSS_MAP: // calculate tex coords into bump map - if (components & (VB_HAS_NRM1 | VB_HAS_NRM2)) + if (uid_data->components & (VB_HAS_NRM1 | VB_HAS_NRM2)) { // transform the light dir into tangent space - uid_data->texMtxInfo[i].embosslightshift = xfmem.texMtxInfo[i].embosslightshift; - uid_data->texMtxInfo[i].embosssourceshift = xfmem.texMtxInfo[i].embosssourceshift; out.Write("ldir = normalize(" LIGHT_POS ".xyz - pos.xyz);\n", LIGHT_POS_PARAMS(texinfo.embosslightshift)); out.Write( @@ -271,7 +321,6 @@ static T GenerateVertexShader(API_TYPE api_type) // The following assert was triggered in House of the Dead Overkill and Star Wars Rogue // Squadron 2 //_assert_(0); // should have normals - uid_data->texMtxInfo[i].embosssourceshift = xfmem.texMtxInfo[i].embosssourceshift; out.Write("o.tex%d.xyz = o.tex%d.xyz;\n", i, texinfo.embosssourceshift); } @@ -284,11 +333,10 @@ static T GenerateVertexShader(API_TYPE api_type) break; case XF_TEXGEN_REGULAR: default: - uid_data->texMtxInfo_n_projection |= xfmem.texMtxInfo[i].projection << i; - if (components & (VB_HAS_TEXMTXIDX0 << i)) + if (uid_data->components & (VB_HAS_TEXMTXIDX0 << i)) { out.Write("int tmp = int(tex%d.z);\n", i); - if (texinfo.projection == XF_TEXPROJ_STQ) + if (((uid_data->texMtxInfo_n_projection >> i) & 1) == XF_TEXPROJ_STQ) out.Write("o.tex%d.xyz = float3(dot(coord, " I_TRANSFORMMATRICES "[tmp]), dot(coord, " I_TRANSFORMMATRICES "[tmp+1]), dot(coord, " I_TRANSFORMMATRICES "[tmp+2]));\n", @@ -300,7 +348,7 @@ static T GenerateVertexShader(API_TYPE api_type) } else { - if (texinfo.projection == XF_TEXPROJ_STQ) + if (((uid_data->texMtxInfo_n_projection >> i) & 1) == XF_TEXPROJ_STQ) out.Write("o.tex%d.xyz = float3(dot(coord, " I_TEXMATRICES "[%d]), dot(coord, " I_TEXMATRICES "[%d]), dot(coord, " I_TEXMATRICES "[%d]));\n", @@ -313,20 +361,16 @@ static T GenerateVertexShader(API_TYPE api_type) break; } - uid_data->dualTexTrans_enabled = xfmem.dualTexTrans.enabled; // CHECKME: does this only work for regular tex gen types? - if (xfmem.dualTexTrans.enabled && texinfo.texgentype == XF_TEXGEN_REGULAR) + if (uid_data->dualTexTrans_enabled && texinfo.texgentype == XF_TEXGEN_REGULAR) { - const PostMtxInfo& postInfo = xfmem.postMtxInfo[i]; + auto& postInfo = uid_data->postMtxInfo[i]; - uid_data->postMtxInfo[i].index = xfmem.postMtxInfo[i].index; - int postidx = postInfo.index; out.Write("float4 P0 = " I_POSTTRANSFORMMATRICES "[%d];\n" "float4 P1 = " I_POSTTRANSFORMMATRICES "[%d];\n" "float4 P2 = " I_POSTTRANSFORMMATRICES "[%d];\n", - postidx & 0x3f, (postidx + 1) & 0x3f, (postidx + 2) & 0x3f); + postInfo.index & 0x3f, (postInfo.index + 1) & 0x3f, (postInfo.index + 2) & 0x3f); - uid_data->postMtxInfo[i].normalize = xfmem.postMtxInfo[i].normalize; if (postInfo.normalize) out.Write("o.tex%d.xyz = normalize(o.tex%d.xyz);\n", i, i); @@ -342,15 +386,15 @@ static T GenerateVertexShader(API_TYPE api_type) // clipPos/w needs to be done in pixel shader, not here out.Write("o.clipPos = o.pos;\n"); - if (g_ActiveConfig.bEnablePixelLighting) + if (uid_data->pixel_lighting) { out.Write("o.Normal = _norm0;\n"); out.Write("o.WorldPos = pos.xyz;\n"); - if (components & VB_HAS_COL0) + if (uid_data->components & VB_HAS_COL0) out.Write("o.colors_0 = color0;\n"); - if (components & VB_HAS_COL1) + if (uid_data->components & VB_HAS_COL1) out.Write("o.colors_1 = color1;\n"); } @@ -390,16 +434,16 @@ static T GenerateVertexShader(API_TYPE api_type) { if (g_ActiveConfig.backend_info.bSupportsGeometryShaders) { - AssignVSOutputMembers(out, "vs", "o"); + AssignVSOutputMembers(out, "vs", "o", uid_data->numTexGens, uid_data->pixel_lighting); } else { // TODO: Pass interface blocks between shader stages even if geometry shaders // are not supported, however that will require at least OpenGL 3.2 support. - for (unsigned int i = 0; i < xfmem.numTexGen.numTexGens; ++i) + for (unsigned int i = 0; i < uid_data->numTexGens; ++i) out.Write("uv%d.xyz = o.tex%d;\n", i, i); out.Write("clipPos = o.clipPos;\n"); - if (g_ActiveConfig.bEnablePixelLighting) + if (uid_data->pixel_lighting) { out.Write("Normal = o.Normal;\n"); out.Write("WorldPos = o.WorldPos;\n"); @@ -418,13 +462,3 @@ static T GenerateVertexShader(API_TYPE api_type) return out; } - -VertexShaderUid GetVertexShaderUid(API_TYPE api_type) -{ - return GenerateVertexShader(api_type); -} - -ShaderCode GenerateVertexShaderCode(API_TYPE api_type) -{ - return GenerateVertexShader(api_type); -} diff --git a/Source/Core/VideoCommon/VertexShaderGen.h b/Source/Core/VideoCommon/VertexShaderGen.h index 959226ea15..e8dfba2e1c 100644 --- a/Source/Core/VideoCommon/VertexShaderGen.h +++ b/Source/Core/VideoCommon/VertexShaderGen.h @@ -37,10 +37,13 @@ struct vertex_shader_uid_data u32 numColorChans : 2; u32 dualTexTrans_enabled : 1; u32 pixel_lighting : 1; - u32 pad : 1; + u32 msaa : 1; u32 texMtxInfo_n_projection : 16; // Stored separately to guarantee that the texMtxInfo struct is // 8 bits wide + u32 ssaa : 1; + u32 pad : 15; + struct { u32 inputform : 2; @@ -63,5 +66,5 @@ struct vertex_shader_uid_data typedef ShaderUid VertexShaderUid; -VertexShaderUid GetVertexShaderUid(API_TYPE api_type); -ShaderCode GenerateVertexShaderCode(API_TYPE api_type); +VertexShaderUid GetVertexShaderUid(); +ShaderCode GenerateVertexShaderCode(API_TYPE api_type, const vertex_shader_uid_data* uid_data); diff --git a/Source/Core/VideoCommon/VideoConfig.cpp b/Source/Core/VideoCommon/VideoConfig.cpp index 753a65f9eb..c19528d7d9 100644 --- a/Source/Core/VideoCommon/VideoConfig.cpp +++ b/Source/Core/VideoCommon/VideoConfig.cpp @@ -79,7 +79,6 @@ void VideoConfig::Load(const std::string& ini_file) settings->Get("TexFmtOverlayCenter", &bTexFmtOverlayCenter, 0); settings->Get("WireFrame", &bWireFrame, 0); settings->Get("DisableFog", &bDisableFog, 0); - settings->Get("EnableShaderDebugging", &bEnableShaderDebugging, false); settings->Get("BorderlessFullscreen", &bBorderlessFullscreen, false); settings->Get("SWZComploc", &bZComploc, true); @@ -120,18 +119,6 @@ void VideoConfig::Load(const std::string& ini_file) interface->Get("UsePanicHandlers", &bTmp, true); SetEnableAlert(bTmp); - // Shader Debugging causes a huge slowdown and it's easy to forget about it - // since it's not exposed in the settings dialog. It's only used by - // developers, so displaying an obnoxious message avoids some confusion and - // is not too annoying/confusing for users. - // - // XXX(delroth): This is kind of a bad place to put this, but the current - // VideoCommon is a mess and we don't have a central initialization - // function to do these kind of checks. Instead, the init code is - // triplicated for each video backend. - if (bEnableShaderDebugging) - OSD::AddMessage("Warning: Shader Debugging is enabled, performance will suffer heavily", 15000); - VerifyValidity(); } @@ -299,7 +286,6 @@ void VideoConfig::Save(const std::string& ini_file) settings->Set("TexFmtOverlayCenter", bTexFmtOverlayCenter); settings->Set("Wireframe", bWireFrame); settings->Set("DisableFog", bDisableFog); - settings->Set("EnableShaderDebugging", bEnableShaderDebugging); settings->Set("BorderlessFullscreen", bBorderlessFullscreen); settings->Set("SWZComploc", bZComploc); diff --git a/Source/Core/VideoCommon/VideoConfig.h b/Source/Core/VideoCommon/VideoConfig.h index d39bfdd118..d78c63ba90 100644 --- a/Source/Core/VideoCommon/VideoConfig.h +++ b/Source/Core/VideoCommon/VideoConfig.h @@ -132,9 +132,6 @@ struct VideoConfig final // D3D only config, mostly to be merged into the above int iAdapter; - // Debugging - bool bEnableShaderDebugging; - // VideoSW Debugging int drawStart; int drawEnd;