From 437761843850ce32974fd4729d7b8d7d0405a04f Mon Sep 17 00:00:00 2001 From: degasus Date: Mon, 7 Oct 2013 16:02:24 +0200 Subject: [PATCH 1/9] VideoCommon: keep a copy of the const buffer in VideoCommon The upload in the backend isn't done, it's just pushed by the mostly removed SetMulti*SConstant4fv. Also no optimizations was done on VideoCommon side, but I can start now :-) Sorry for the hacky way, but I think this is a nice (working) snapshot for a much bigger change. --- .../D3D/Src/PixelShaderCache.cpp | 40 +------- Source/Core/VideoBackends/D3D/Src/Render.h | 6 -- .../D3D/Src/VertexShaderCache.cpp | 27 +----- .../OGL/Src/PixelShaderCache.cpp | 72 ++------------ Source/Core/VideoBackends/OGL/Src/Render.h | 6 -- .../OGL/Src/VertexShaderCache.cpp | 97 ++----------------- Source/Core/VideoCommon/Src/ConstantManager.h | 46 +++++++++ Source/Core/VideoCommon/Src/PixelShaderGen.h | 20 ++-- .../VideoCommon/Src/PixelShaderManager.cpp | 43 ++++++-- .../Core/VideoCommon/Src/PixelShaderManager.h | 6 ++ Source/Core/VideoCommon/Src/RenderBase.h | 7 -- .../Src/TextureConversionShader.cpp | 6 -- .../VideoCommon/Src/TextureConversionShader.h | 2 - Source/Core/VideoCommon/Src/VertexShaderGen.h | 18 ++-- .../VideoCommon/Src/VertexShaderManager.cpp | 50 +++++++++- .../VideoCommon/Src/VertexShaderManager.h | 4 + Source/Core/VideoCommon/Src/VideoCommon.h | 1 - 17 files changed, 172 insertions(+), 279 deletions(-) create mode 100644 Source/Core/VideoCommon/Src/ConstantManager.h diff --git a/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp index 56b61e05cd..8109d7fd20 100644 --- a/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp @@ -538,47 +538,9 @@ bool PixelShaderCache::InsertByteCode(const PixelShaderUid &uid, const void* byt // These are "callbacks" from VideoCommon and thus must be outside namespace DX11. // This will have to be changed when we merge. - -// HACK to avoid some invasive VideoCommon changes -// these values are hardcoded, they depend on internal D3DCompile behavior; TODO: Solve this with D3DReflect or something -// offset given in floats, table index is float4 -static const unsigned int ps_constant_offset_table[] = { - 0, 4, 8, 12, // C_COLORS, 16 - 16, 20, 24, 28, // C_KCOLORS, 16 - 32, // C_ALPHA, 4 - 36, 40, 44, 48, 52, 56, 60, 64, // C_TEXDIMS, 32 - 68, 72, // C_ZBIAS, 8 - 76, 80, // C_INDTEXSCALE, 8 - 84, 88, 92, 96, 100, 104, // C_INDTEXMTX, 24 - 108, 112, 116, // C_FOG, 12 - 120, 124, 128, 132, 136, // C_PLIGHTS0, 20 - 140, 144, 148, 152, 156, // C_PLIGHTS1, 20 - 160, 164, 168, 172, 176, // C_PLIGHTS2, 20 - 180, 184, 188, 192, 196, // C_PLIGHTS3, 20 - 200, 204, 208, 212, 216, // C_PLIGHTS4, 20 - 220, 224, 228, 232, 236, // C_PLIGHTS5, 20 - 240, 244, 248, 252, 256, // C_PLIGHTS6, 20 - 260, 264, 268, 272, 276, // C_PLIGHTS7, 20 - 280, 284, 288, 292 // C_PMATERIALS, 16 -}; -void Renderer::SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - psconstants[ps_constant_offset_table[const_number] ] = f1; - psconstants[ps_constant_offset_table[const_number]+1] = f2; - psconstants[ps_constant_offset_table[const_number]+2] = f3; - psconstants[ps_constant_offset_table[const_number]+3] = f4; - pscbufchanged = true; -} - -void Renderer::SetPSConstant4fv(unsigned int const_number, const float* f) -{ - memcpy(&psconstants[ps_constant_offset_table[const_number]], f, sizeof(float)*4); - pscbufchanged = true; -} - void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float* f) { - memcpy(&psconstants[ps_constant_offset_table[const_number]], f, sizeof(float)*4*count); + memcpy(psconstants, f, sizeof(float)*4*count); pscbufchanged = true; } diff --git a/Source/Core/VideoBackends/D3D/Src/Render.h b/Source/Core/VideoBackends/D3D/Src/Render.h index 1fddfdb244..c0090cd2f2 100644 --- a/Source/Core/VideoBackends/D3D/Src/Render.h +++ b/Source/Core/VideoBackends/D3D/Src/Render.h @@ -52,13 +52,7 @@ public: static bool CheckForResize(); - void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); - void SetPSConstant4fv(unsigned int const_number, const float *f); void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); - - void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); - void SetVSConstant4fv(unsigned int const_number, const float *f); - void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f); void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); }; diff --git a/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp index d9ea7e2a8c..6f3c4051b1 100644 --- a/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp @@ -280,32 +280,7 @@ bool VertexShaderCache::InsertByteCode(const VertexShaderUid &uid, D3DBlob* bcod // These are "callbacks" from VideoCommon and thus must be outside namespace DX11. // This will have to be changed when we merge. -// maps the constant numbers to float indices in the constant buffer -void Renderer::SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - vsconstants[vs_constant_offset_table[const_number] ] = f1; - vsconstants[vs_constant_offset_table[const_number]+1] = f2; - vsconstants[vs_constant_offset_table[const_number]+2] = f3; - vsconstants[vs_constant_offset_table[const_number]+3] = f4; - vscbufchanged = true; -} - -void Renderer::SetVSConstant4fv(unsigned int const_number, const float* f) -{ - memcpy(&vsconstants[vs_constant_offset_table[const_number]], f, sizeof(float)*4); - vscbufchanged = true; -} - -void Renderer::SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float* f) -{ - for (unsigned int i = 0; i < count; i++) - { - memcpy(&vsconstants[vs_constant_offset_table[const_number+i]], f+3*i, sizeof(float)*3); - vsconstants[vs_constant_offset_table[const_number+i]+3] = 0.f; - } - vscbufchanged = true; -} - +// TODO: fetch directly from VideoCommon void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float* f) { memcpy(&vsconstants[vs_constant_offset_table[const_number]], f, sizeof(float)*4*count); diff --git a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp index 3fac62bd73..0635003dfd 100644 --- a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp @@ -24,66 +24,7 @@ namespace OGL { -void SetPSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1) -{ - ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); - for (int a = 0; a < NUM_UNIFORMS; ++a) - { - if (!strcmp(name, UniformNames[a])) - { - if (tmp.shader.UniformLocations[a] == -1) - return; - else if (tmp.shader.UniformSize[a] <= offset) - return; - else - { - unsigned int maxcount= tmp.shader.UniformSize[a]-offset; - glUniform4fv(tmp.shader.UniformLocations[a] + offset, std::min(count, maxcount), f); - return; - } - } - } -} - // Renderer functions -void Renderer::SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - float const f[4] = {f1, f2, f3, f4}; - - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiPSConstant4fv(const_number, f, 1); - return; - } - for (unsigned int a = 0; a < 10; ++a) - { - if (const_number >= PSVar_Loc[a].reg && const_number < (PSVar_Loc[a].reg + PSVar_Loc[a].size)) - { - unsigned int offset = const_number - PSVar_Loc[a].reg; - SetPSConstant4fvByName(PSVar_Loc[a].name, offset, f); - return; - } - } -} - -void Renderer::SetPSConstant4fv(unsigned int const_number, const float *f) -{ - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiPSConstant4fv(const_number, f, 1); - return; - } - for (unsigned int a = 0; a < 10; ++a) - { - if (const_number >= PSVar_Loc[a].reg && const_number < (PSVar_Loc[a].reg + PSVar_Loc[a].size)) - { - unsigned int offset = const_number - PSVar_Loc[a].reg; - SetPSConstant4fvByName(PSVar_Loc[a].name, offset, f); - return; - } - } -} - void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) @@ -91,14 +32,15 @@ void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int cou ProgramShaderCache::SetMultiPSConstant4fv(const_number, f, count); return; } + + ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); for (unsigned int a = 0; a < 10; ++a) { - if (const_number >= PSVar_Loc[a].reg && const_number < (PSVar_Loc[a].reg + PSVar_Loc[a].size)) - { - unsigned int offset = const_number - PSVar_Loc[a].reg; - SetPSConstant4fvByName(PSVar_Loc[a].name, offset, f, count); - return; - } + u32 offset = PSVar_Loc[a].reg - const_number; + if(offset >= count) return; + u32 size = std::min(tmp.shader.UniformSize[a], count-offset); + if(size > 0) + glUniform4fv(tmp.shader.UniformLocations[a], size, f + 4*offset); } } } // namespace OGL diff --git a/Source/Core/VideoBackends/OGL/Src/Render.h b/Source/Core/VideoBackends/OGL/Src/Render.h index 4086ad3e87..6216097e79 100644 --- a/Source/Core/VideoBackends/OGL/Src/Render.h +++ b/Source/Core/VideoBackends/OGL/Src/Render.h @@ -81,13 +81,7 @@ public: bool SaveScreenshot(const std::string &filename, const TargetRectangle &rc); - void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); - void SetPSConstant4fv(unsigned int const_number, const float *f); void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); - - void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); - void SetVSConstant4fv(unsigned int const_number, const float *f); - void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f); void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); private: diff --git a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp index 8e2c048f8d..09f2368bad 100644 --- a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp @@ -24,65 +24,6 @@ namespace OGL { -void SetVSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1) -{ - ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); - for (int a = 0; a < NUM_UNIFORMS; ++a) - { - if (!strcmp(name, UniformNames[a])) - { - if (tmp.shader.UniformLocations[a] == -1) - return; - else if (tmp.shader.UniformSize[a] <= offset) - return; - else - { - unsigned int maxcount= tmp.shader.UniformSize[a]-offset; - glUniform4fv(tmp.shader.UniformLocations[a] + offset, std::min(count, maxcount), f); - return; - } - } - } -} - -void Renderer::SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - float const buf[4] = {f1, f2, f3, f4}; - - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiVSConstant4fv(const_number, buf, 1); - return; - } - for (unsigned int a = 0; a < 9; ++a) - { - if (const_number >= VSVar_Loc[a].reg && const_number < ( VSVar_Loc[a].reg + VSVar_Loc[a].size)) - { - unsigned int offset = const_number - VSVar_Loc[a].reg; - SetVSConstant4fvByName(VSVar_Loc[a].name, offset, buf); - return; - } - } -} - -void Renderer::SetVSConstant4fv(unsigned int const_number, const float *f) -{ - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiVSConstant4fv(const_number, f, 1); - return; - } - for (unsigned int a = 0; a < 9; ++a) - { - if (const_number >= VSVar_Loc[a].reg && const_number < ( VSVar_Loc[a].reg + VSVar_Loc[a].size)) - { - unsigned int offset = const_number - VSVar_Loc[a].reg; - SetVSConstant4fvByName(VSVar_Loc[a].name, offset, f); - return; - } - } -} - void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) @@ -90,40 +31,14 @@ void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int cou ProgramShaderCache::SetMultiVSConstant4fv(const_number, f, count); return; } + ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); for (unsigned int a = 0; a < 9; ++a) { - if (const_number >= VSVar_Loc[a].reg && const_number < ( VSVar_Loc[a].reg + VSVar_Loc[a].size)) - { - unsigned int offset = const_number - VSVar_Loc[a].reg; - SetVSConstant4fvByName(VSVar_Loc[a].name, offset, f, count); - return; - } - } -} - -void Renderer::SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) -{ - float buf[4 * C_VENVCONST_END]; - for (unsigned int i = 0; i < count; i++) - { - buf[4*i ] = *f++; - buf[4*i+1] = *f++; - buf[4*i+2] = *f++; - buf[4*i+3] = 0.f; - } - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiVSConstant4fv(const_number, buf, count); - return; - } - for (unsigned int a = 0; a < 9; ++a) - { - if (const_number >= VSVar_Loc[a].reg && const_number < ( VSVar_Loc[a].reg + VSVar_Loc[a].size)) - { - unsigned int offset = const_number - VSVar_Loc[a].reg; - SetVSConstant4fvByName(VSVar_Loc[a].name, offset, buf, count); - return; - } + u32 offset = VSVar_Loc[a].reg - const_number; + if(offset >= count) return; + u32 size = std::min(tmp.shader.UniformSize[a+10], count-offset); + if(size > 0) + glUniform4fv(tmp.shader.UniformLocations[a+10], size, f + 4*offset); } } diff --git a/Source/Core/VideoCommon/Src/ConstantManager.h b/Source/Core/VideoCommon/Src/ConstantManager.h new file mode 100644 index 0000000000..f86d12e2db --- /dev/null +++ b/Source/Core/VideoCommon/Src/ConstantManager.h @@ -0,0 +1,46 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#ifndef _CONSTANTMANAGER_H +#define _CONSTANTMANAGER_H + +// all constant buffer attributes must be 16 bytes aligned, so this are the only allowed components: +typedef float float4[4]; +typedef u8 uchar16[16]; +typedef s8 schar16[16]; +typedef u16 ushort8[8]; +typedef s16 sshort8[8]; +typedef u32 uint4[4]; +typedef s32 sint4[4]; + +struct PixelShaderConstants +{ + float4 colors[4]; + float4 kcolors[4]; + float4 alpha; + float4 texdims[8]; + float4 zbias[2]; + float4 indtexscale[2]; + float4 indtexmts[6]; + float4 fog[3]; + + // For pixel lighting + float4 plights[40]; + float4 pmaterials[4]; +}; + +struct VertexShaderConstants +{ + float4 posnormalmatrix[6]; + float4 projection[4]; + float4 materials[4]; + float4 lights[40]; + float4 texmatrices[24]; + float4 transformmatrices[64]; + float4 normalmatrices[32]; + float4 posttransformmatrices[64]; + float4 depthparams; +}; + +#endif \ No newline at end of file diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.h b/Source/Core/VideoCommon/Src/PixelShaderGen.h index 5fbf28cd69..d9ce8c5874 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderGen.h +++ b/Source/Core/VideoCommon/Src/PixelShaderGen.h @@ -44,16 +44,16 @@ enum DSTALPHA_MODE }; // Annoying sure, can be removed once we get up to GLSL ~1.3 -const s_svar PSVar_Loc[] = { {I_COLORS, C_COLORS, 4 }, - {I_KCOLORS, C_KCOLORS, 4 }, - {I_ALPHA, C_ALPHA, 1 }, - {I_TEXDIMS, C_TEXDIMS, 8 }, - {I_ZBIAS , C_ZBIAS, 2 }, - {I_INDTEXSCALE , C_INDTEXSCALE, 2 }, - {I_INDTEXMTX, C_INDTEXMTX, 6 }, - {I_FOG, C_FOG, 3 }, - {I_PLIGHTS, C_PLIGHTS, 40 }, - {I_PMATERIALS, C_PMATERIALS, 4 }, +const s_svar PSVar_Loc[] = { {C_COLORS, 4 }, + {C_KCOLORS, 4 }, + {C_ALPHA, 1 }, + {C_TEXDIMS, 8 }, + {C_ZBIAS, 2 }, + {C_INDTEXSCALE, 2 }, + {C_INDTEXMTX, 6 }, + {C_FOG, 3 }, + {C_PLIGHTS, 40 }, + {C_PMATERIALS, 4 }, }; #pragma pack(1) diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index aef4baa14c..3a13e287aa 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -29,19 +29,40 @@ static u32 lastTexDims[8]; // width | height << 16 | wrap_s << 28 | wrap_t << 30 static u32 lastZBias; static int nMaterialsChanged; +PixelShaderConstants PixelShaderManager::constants; +bool PixelShaderManager::dirty; + inline void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) { - g_renderer->SetPSConstant4f(const_number, f1, f2, f3, f4); + float4* c = (float4*) &PixelShaderManager::constants; + c[const_number][0] = f1; + c[const_number][1] = f2; + c[const_number][2] = f3; + c[const_number][3] = f4; + PixelShaderManager::dirty = true; } inline void SetPSConstant4fv(unsigned int const_number, const float *f) { - g_renderer->SetPSConstant4fv(const_number, f); + float4* c = (float4*) &PixelShaderManager::constants; + c[const_number][0] = f[0]; + c[const_number][1] = f[1]; + c[const_number][2] = f[2]; + c[const_number][3] = f[3]; + PixelShaderManager::dirty = true; } inline void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { - g_renderer->SetMultiPSConstant4fv(const_number, count, f); + float4* c = (float4*) &PixelShaderManager::constants; + for(u32 i=0; iSetMultiPSConstant4fv(0, sizeof(constants)/16, (float*) &constants); + dirty = false; + } } void PixelShaderManager::SetPSTextureDims(int texid) @@ -495,7 +524,9 @@ void PixelShaderManager::DoState(PointerWrap &p) p.Do(lastAlpha); p.Do(lastTexDims); p.Do(lastZBias); - + p.Do(constants); + p.Do(dirty); + if (p.GetMode() == PointerWrap::MODE_READ) { Dirty(); diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.h b/Source/Core/VideoCommon/Src/PixelShaderManager.h index 7f63fb3f46..856b76d8d7 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.h +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.h @@ -8,9 +8,12 @@ #include "BPMemory.h" #include "XFMemory.h" #include "PixelShaderGen.h" +#include "ConstantManager.h" class PointerWrap; + + // The non-API dependent parts. class PixelShaderManager { @@ -41,6 +44,9 @@ public: static void SetColorMatrix(const float* pmatrix); static void InvalidateXFRange(int start, int end); static void SetMaterialColorChanged(int index); + + static PixelShaderConstants constants; + static bool dirty; }; diff --git a/Source/Core/VideoCommon/Src/RenderBase.h b/Source/Core/VideoCommon/Src/RenderBase.h index 7d9f3f857c..08ed80343d 100644 --- a/Source/Core/VideoCommon/Src/RenderBase.h +++ b/Source/Core/VideoCommon/Src/RenderBase.h @@ -116,14 +116,7 @@ public: static void StorePixelFormat(unsigned int new_format) { prev_efb_format = new_format; } // TODO: doesn't belong here - virtual void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) = 0; - virtual void SetPSConstant4fv(unsigned int const_number, const float *f) = 0; virtual void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0; - - // TODO: doesn't belong here - virtual void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) = 0; - virtual void SetVSConstant4fv(unsigned int const_number, const float *f) = 0; - virtual void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) = 0; virtual void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0; protected: diff --git a/Source/Core/VideoCommon/Src/TextureConversionShader.cpp b/Source/Core/VideoCommon/Src/TextureConversionShader.cpp index 7916e47c12..9b6c8762ff 100644 --- a/Source/Core/VideoCommon/Src/TextureConversionShader.cpp +++ b/Source/Core/VideoCommon/Src/TextureConversionShader.cpp @@ -867,10 +867,4 @@ const char *GenerateEncodingShader(u32 format,API_TYPE ApiType) return text; } -void SetShaderParameters(float width, float height, float offsetX, float offsetY, float widthStride, float heightStride,float buffW,float buffH) -{ - g_renderer->SetPSConstant4f(C_COLORMATRIX, widthStride, heightStride, buffW, buffH); - g_renderer->SetPSConstant4f(C_COLORMATRIX + 1, width, (height - 1), offsetX, offsetY); -} - } // namespace diff --git a/Source/Core/VideoCommon/Src/TextureConversionShader.h b/Source/Core/VideoCommon/Src/TextureConversionShader.h index aa42726b2c..843c5ef7ee 100644 --- a/Source/Core/VideoCommon/Src/TextureConversionShader.h +++ b/Source/Core/VideoCommon/Src/TextureConversionShader.h @@ -15,8 +15,6 @@ u16 GetEncodedSampleCount(u32 format); const char *GenerateEncodingShader(u32 format, API_TYPE ApiType = API_OPENGL); -void SetShaderParameters(float width, float height, float offsetX, float offsetY, float widthStride, float heightStride,float buffW = 0.0f,float buffH = 0.0f); - } #endif // _TEXTURECONVERSIONSHADER_H_ diff --git a/Source/Core/VideoCommon/Src/VertexShaderGen.h b/Source/Core/VideoCommon/Src/VertexShaderGen.h index 0ec703c07f..c5f32c741d 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderGen.h +++ b/Source/Core/VideoCommon/Src/VertexShaderGen.h @@ -53,15 +53,15 @@ #define C_DEPTHPARAMS (C_POSTTRANSFORMMATRICES + 64) #define C_VENVCONST_END (C_DEPTHPARAMS + 1) -const s_svar VSVar_Loc[] = { {I_POSNORMALMATRIX, C_POSNORMALMATRIX, 6 }, - {I_PROJECTION , C_PROJECTION, 4 }, - {I_MATERIALS, C_MATERIALS, 4 }, - {I_LIGHTS, C_LIGHTS, 40 }, - {I_TEXMATRICES, C_TEXMATRICES, 24 }, - {I_TRANSFORMMATRICES , C_TRANSFORMMATRICES, 64 }, - {I_NORMALMATRICES , C_NORMALMATRICES, 32 }, - {I_POSTTRANSFORMMATRICES, C_POSTTRANSFORMMATRICES, 64 }, - {I_DEPTHPARAMS, C_DEPTHPARAMS, 1 }, +const s_svar VSVar_Loc[] = { {C_POSNORMALMATRIX, 6 }, + {C_PROJECTION, 4 }, + {C_MATERIALS, 4 }, + {C_LIGHTS, 40 }, + {C_TEXMATRICES, 24 }, + {C_TRANSFORMMATRICES, 64 }, + {C_NORMALMATRICES, 32 }, + {C_POSTTRANSFORMMATRICES, 64 }, + {C_DEPTHPARAMS, 1 }, }; #pragma pack(1) diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp index c07286d58f..016fb517e4 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp @@ -36,6 +36,9 @@ static Matrix33 s_viewInvRotationMatrix; static float s_fViewTranslationVector[3]; static float s_fViewRotation[2]; +VertexShaderConstants VertexShaderManager::constants; +bool VertexShaderManager::dirty; + void UpdateViewport(Matrix44& vpCorrection); void UpdateViewportWithCorrection() @@ -45,22 +48,48 @@ void UpdateViewportWithCorrection() inline void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) { - g_renderer->SetVSConstant4f(const_number, f1, f2, f3, f4); + float4* c = (float4*) &VertexShaderManager::constants; + c[const_number][0] = f1; + c[const_number][1] = f2; + c[const_number][2] = f3; + c[const_number][3] = f4; + VertexShaderManager::dirty = true; } inline void SetVSConstant4fv(unsigned int const_number, const float *f) { - g_renderer->SetVSConstant4fv(const_number, f); + float4* c = (float4*) &VertexShaderManager::constants; + c[const_number][0] = f[0]; + c[const_number][1] = f[1]; + c[const_number][2] = f[2]; + c[const_number][3] = f[3]; + VertexShaderManager::dirty = true; } inline void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) { - g_renderer->SetMultiVSConstant3fv(const_number, count, f); + float4* c = (float4*) &VertexShaderManager::constants; + for(u32 i=0; iSetMultiVSConstant4fv(const_number, count, f); + float4* c = (float4*) &VertexShaderManager::constants; + for(u32 i=0; i= 0) { @@ -488,6 +520,12 @@ void VertexShaderManager::SetConstants() SetMultiVSConstant4fv(C_PROJECTION, 4, correctedMtx.data); } } + + if(dirty) + { + dirty = false; + g_renderer->SetMultiVSConstant4fv(0, sizeof(constants)/16, (float*) &constants); + } } void VertexShaderManager::InvalidateXFRange(int start, int end) @@ -669,6 +707,8 @@ void VertexShaderManager::DoState(PointerWrap &p) p.Do(s_viewInvRotationMatrix); p.Do(s_fViewTranslationVector); p.Do(s_fViewRotation); + p.Do(constants); + p.Do(dirty); if (p.GetMode() == PointerWrap::MODE_READ) { diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.h b/Source/Core/VideoCommon/Src/VertexShaderManager.h index b4c5d3907c..d681092902 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.h +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.h @@ -6,6 +6,7 @@ #define _VERTEXSHADERMANAGER_H #include "VertexShaderGen.h" +#include "ConstantManager.h" class PointerWrap; @@ -35,6 +36,9 @@ public: static void TranslateView(float x, float y, float z = 0.0f); static void RotateView(float x, float y); static void ResetView(); + + static VertexShaderConstants constants; + static bool dirty; }; #endif // _VERTEXSHADERMANAGER_H diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h index 175bd8a5b0..54a2504631 100644 --- a/Source/Core/VideoCommon/Src/VideoCommon.h +++ b/Source/Core/VideoCommon/Src/VideoCommon.h @@ -134,7 +134,6 @@ inline unsigned int GetPow2(unsigned int val) } struct s_svar { - const char *name; const unsigned int reg; const unsigned int size; }; From 7c14463d11f816b1dd0cd2efd9bbe018f4d64a4a Mon Sep 17 00:00:00 2001 From: degasus Date: Mon, 7 Oct 2013 17:19:47 +0200 Subject: [PATCH 2/9] ogl: implement useful constant buffer upload this will remove the additional memcpy introduced in my last commit --- .../OGL/Src/PixelShaderCache.cpp | 15 --- .../OGL/Src/ProgramShaderCache.cpp | 108 ++++++++++++------ .../OGL/Src/ProgramShaderCache.h | 9 +- .../OGL/Src/VertexShaderCache.cpp | 14 --- Source/Core/VideoCommon/Src/PixelShaderGen.h | 13 --- .../VideoCommon/Src/PixelShaderManager.cpp | 5 +- Source/Core/VideoCommon/Src/VertexShaderGen.h | 11 -- .../VideoCommon/Src/VertexShaderManager.cpp | 5 +- Source/Core/VideoCommon/Src/VideoCommon.h | 5 - 9 files changed, 75 insertions(+), 110 deletions(-) diff --git a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp index 0635003dfd..ba6a0b2e97 100644 --- a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp @@ -27,20 +27,5 @@ namespace OGL // Renderer functions void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiPSConstant4fv(const_number, f, count); - return; - } - - ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); - for (unsigned int a = 0; a < 10; ++a) - { - u32 offset = PSVar_Loc[a].reg - const_number; - if(offset >= count) return; - u32 size = std::min(tmp.shader.UniformSize[a], count-offset); - if(size > 0) - glUniform4fv(tmp.shader.UniformLocations[a], size, f + 4*offset); - } } } // namespace OGL diff --git a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp index 94b9502d2f..0904ef41eb 100644 --- a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp @@ -10,18 +10,16 @@ #include "Statistics.h" #include "ImageWrite.h" #include "Render.h" +#include "PixelShaderManager.h" +#include "VertexShaderManager.h" namespace OGL { static const u32 UBO_LENGTH = 32*1024*1024; -GLintptr ProgramShaderCache::s_vs_data_size; -GLintptr ProgramShaderCache::s_ps_data_size; -GLintptr ProgramShaderCache::s_vs_data_offset; -u8 *ProgramShaderCache::s_ubo_buffer; u32 ProgramShaderCache::s_ubo_buffer_size; -bool ProgramShaderCache::s_ubo_dirty; +s32 ProgramShaderCache::s_ubo_align; static StreamBuffer *s_buffer; static int num_failures = 0; @@ -36,6 +34,10 @@ UidChecker ProgramShaderCache::vertex_uid_chec static char s_glsl_header[1024] = ""; + + +// Annoying sure, can be removed once we drop our UBO workaround + const char *UniformNames[NUM_UNIFORMS] = { // PIXEL SHADER UNIFORMS @@ -61,6 +63,37 @@ const char *UniformNames[NUM_UNIFORMS] = I_DEPTHPARAMS, }; +struct s_svar +{ + const unsigned int reg; + const unsigned int size; +}; + +const s_svar PSVar_Loc[] = { {C_COLORS, 4 }, + {C_KCOLORS, 4 }, + {C_ALPHA, 1 }, + {C_TEXDIMS, 8 }, + {C_ZBIAS, 2 }, + {C_INDTEXSCALE, 2 }, + {C_INDTEXMTX, 6 }, + {C_FOG, 3 }, + {C_PLIGHTS, 40 }, + {C_PMATERIALS, 4 }, + }; + +const s_svar VSVar_Loc[] = { {C_POSNORMALMATRIX, 6 }, + {C_PROJECTION, 4 }, + {C_MATERIALS, 4 }, + {C_LIGHTS, 40 }, + {C_TEXMATRICES, 24 }, + {C_TRANSFORMMATRICES, 64 }, + {C_NORMALMATRICES, 32 }, + {C_POSTTRANSFORMMATRICES, 64 }, + {C_DEPTHPARAMS, 1 }, + }; + +// End of UBO workaround + void SHADER::SetProgramVariables() { // glsl shader must be bind to set samplers @@ -162,30 +195,43 @@ void SHADER::Bind() } } - -void ProgramShaderCache::SetMultiPSConstant4fv(unsigned int offset, const float *f, unsigned int count) -{ - s_ubo_dirty = true; - memcpy(s_ubo_buffer+(offset*4*sizeof(float)), f, count*4*sizeof(float)); -} - -void ProgramShaderCache::SetMultiVSConstant4fv(unsigned int offset, const float *f, unsigned int count) -{ - s_ubo_dirty = true; - memcpy(s_ubo_buffer+(offset*4*sizeof(float))+s_vs_data_offset, f, count*4*sizeof(float)); -} - void ProgramShaderCache::UploadConstants() { - if(s_ubo_dirty) { - s_buffer->Alloc(s_ubo_buffer_size); - size_t offset = s_buffer->Upload(s_ubo_buffer, s_ubo_buffer_size); - glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->getBuffer(), offset, s_ps_data_size); - glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->getBuffer(), offset + s_vs_data_offset, s_vs_data_size); - s_ubo_dirty = false; + if(g_ActiveConfig.backend_info.bSupportsGLSLUBO) + { + if(PixelShaderManager::dirty || VertexShaderManager::dirty) + { + s_buffer->Alloc(s_ubo_buffer_size); + + size_t offset = s_buffer->Upload((u8*)&PixelShaderManager::constants, ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align)); + glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->getBuffer(), offset, sizeof(PixelShaderConstants)); + offset = s_buffer->Upload((u8*)&VertexShaderManager::constants, ROUND_UP(sizeof(VertexShaderConstants), s_ubo_align)); + glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->getBuffer(), offset, sizeof(VertexShaderConstants)); + + PixelShaderManager::dirty = false; + VertexShaderManager::dirty = false; + + ADDSTAT(stats.thisFrame.bytesUniformStreamed, s_ubo_buffer_size); + } + } + else + { + // UBO workaround + // this must be updated per shader switch, so also update it when it's not dirty + for (unsigned int a = 0; a < 10; ++a) + { + if(last_entry->shader.UniformSize[a] > 0) + glUniform4fv(last_entry->shader.UniformLocations[a], last_entry->shader.UniformSize[a], (float*) &PixelShaderManager::constants + 4*PSVar_Loc[a].reg); + } + for (unsigned int a = 0; a < 9; ++a) + { + if(last_entry->shader.UniformSize[a+10] > 0) + glUniform4fv(last_entry->shader.UniformLocations[a+10], last_entry->shader.UniformSize[a+10], (float*) &VertexShaderManager::constants + 4*VSVar_Loc[a].reg); + } ADDSTAT(stats.thisFrame.bytesUniformStreamed, s_ubo_buffer_size); } + } GLuint ProgramShaderCache::GetCurrentProgram(void) @@ -419,22 +465,14 @@ void ProgramShaderCache::Init(void) // then the UBO will fail. if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) { - GLint Align; - glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &Align); + glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &s_ubo_align); - s_ps_data_size = C_PENVCONST_END * sizeof(float) * 4; - s_vs_data_size = C_VENVCONST_END * sizeof(float) * 4; - s_vs_data_offset = ROUND_UP(s_ps_data_size, Align); - s_ubo_buffer_size = ROUND_UP(s_ps_data_size, Align) + ROUND_UP(s_vs_data_size, Align); + s_ubo_buffer_size = ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align) + ROUND_UP(sizeof(VertexShaderConstants), s_ubo_align); // We multiply by *4*4 because we need to get down to basic machine units. // So multiply by four to get how many floats we have from vec4s // Then once more to get bytes s_buffer = new StreamBuffer(GL_UNIFORM_BUFFER, UBO_LENGTH); - - s_ubo_buffer = new u8[s_ubo_buffer_size]; - memset(s_ubo_buffer, 0, s_ubo_buffer_size); - s_ubo_dirty = true; } // Read our shader cache, only if supported @@ -509,8 +547,6 @@ void ProgramShaderCache::Shutdown(void) { delete s_buffer; s_buffer = 0; - delete [] s_ubo_buffer; - s_ubo_buffer = 0; } } diff --git a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.h b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.h index 6c1350fe34..d0c792aaa0 100644 --- a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.h +++ b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.h @@ -87,9 +87,6 @@ public: static bool CompileShader(SHADER &shader, const char* vcode, const char* pcode); static GLuint CompileSingleShader(GLuint type, const char *code); - - static void SetMultiPSConstant4fv(unsigned int offset, const float *f, unsigned int count); - static void SetMultiVSConstant4fv(unsigned int offset, const float *f, unsigned int count); static void UploadConstants(); static void Init(void); @@ -110,12 +107,8 @@ private: static UidChecker pixel_uid_checker; static UidChecker vertex_uid_checker; - static GLintptr s_vs_data_size; - static GLintptr s_ps_data_size; - static GLintptr s_vs_data_offset; - static u8 *s_ubo_buffer; static u32 s_ubo_buffer_size; - static bool s_ubo_dirty; + static s32 s_ubo_align; }; } // namespace OGL diff --git a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp index 09f2368bad..c2c49b8505 100644 --- a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp @@ -26,20 +26,6 @@ namespace OGL void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { - if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) - { - ProgramShaderCache::SetMultiVSConstant4fv(const_number, f, count); - return; - } - ProgramShaderCache::PCacheEntry tmp = ProgramShaderCache::GetShaderProgram(); - for (unsigned int a = 0; a < 9; ++a) - { - u32 offset = VSVar_Loc[a].reg - const_number; - if(offset >= count) return; - u32 size = std::min(tmp.shader.UniformSize[a+10], count-offset); - if(size > 0) - glUniform4fv(tmp.shader.UniformLocations[a+10], size, f + 4*offset); - } } } // namespace OGL diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.h b/Source/Core/VideoCommon/Src/PixelShaderGen.h index d9ce8c5874..b73b17168c 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderGen.h +++ b/Source/Core/VideoCommon/Src/PixelShaderGen.h @@ -43,19 +43,6 @@ enum DSTALPHA_MODE DSTALPHA_DUAL_SOURCE_BLEND // Use dual-source blending }; -// Annoying sure, can be removed once we get up to GLSL ~1.3 -const s_svar PSVar_Loc[] = { {C_COLORS, 4 }, - {C_KCOLORS, 4 }, - {C_ALPHA, 1 }, - {C_TEXDIMS, 8 }, - {C_ZBIAS, 2 }, - {C_INDTEXSCALE, 2 }, - {C_INDTEXMTX, 6 }, - {C_FOG, 3 }, - {C_PLIGHTS, 40 }, - {C_PMATERIALS, 4 }, - }; - #pragma pack(1) struct pixel_shader_uid_data { diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 3a13e287aa..970bdb6e58 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -95,9 +95,6 @@ void PixelShaderManager::Shutdown() void PixelShaderManager::SetConstants(u32 components) { - if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO) - dirty = true; - for (int i = 0; i < 2; ++i) { if (s_nColorsChanged[i]) @@ -359,7 +356,7 @@ void PixelShaderManager::SetConstants(u32 components) } } - if(dirty) + if(dirty && g_ActiveConfig.backend_info.APIType != API_OPENGL) { g_renderer->SetMultiPSConstant4fv(0, sizeof(constants)/16, (float*) &constants); dirty = false; diff --git a/Source/Core/VideoCommon/Src/VertexShaderGen.h b/Source/Core/VideoCommon/Src/VertexShaderGen.h index c5f32c741d..667df311c2 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderGen.h +++ b/Source/Core/VideoCommon/Src/VertexShaderGen.h @@ -53,17 +53,6 @@ #define C_DEPTHPARAMS (C_POSTTRANSFORMMATRICES + 64) #define C_VENVCONST_END (C_DEPTHPARAMS + 1) -const s_svar VSVar_Loc[] = { {C_POSNORMALMATRIX, 6 }, - {C_PROJECTION, 4 }, - {C_MATERIALS, 4 }, - {C_LIGHTS, 40 }, - {C_TEXMATRICES, 24 }, - {C_TRANSFORMMATRICES, 64 }, - {C_NORMALMATRICES, 32 }, - {C_POSTTRANSFORMMATRICES, 64 }, - {C_DEPTHPARAMS, 1 }, - }; - #pragma pack(1) struct vertex_shader_uid_data diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp index 016fb517e4..20c4994cf8 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp @@ -225,9 +225,6 @@ void VertexShaderManager::Dirty() // TODO: A cleaner way to control the matrices without making a mess in the parameters field void VertexShaderManager::SetConstants() { - if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO) - dirty = true; - if (nTransformMatricesChanged[0] >= 0) { int startn = nTransformMatricesChanged[0] / 4; @@ -521,7 +518,7 @@ void VertexShaderManager::SetConstants() } } - if(dirty) + if(dirty && g_ActiveConfig.backend_info.APIType != API_OPENGL) { dirty = false; g_renderer->SetMultiVSConstant4fv(0, sizeof(constants)/16, (float*) &constants); diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h index 54a2504631..ef36b1fed6 100644 --- a/Source/Core/VideoCommon/Src/VideoCommon.h +++ b/Source/Core/VideoCommon/Src/VideoCommon.h @@ -132,10 +132,5 @@ inline unsigned int GetPow2(unsigned int val) ++ret; return ret; } -struct s_svar -{ - const unsigned int reg; - const unsigned int size; -}; #endif // _VIDEOCOMMON_H From 6e2fe72b8fe0bfd13171b43bcbff40b20d15737e Mon Sep 17 00:00:00 2001 From: degasus Date: Mon, 7 Oct 2013 17:52:22 +0200 Subject: [PATCH 3/9] D3D: also uses VideoCommon constant buffer handling As now both backends uses the VideoCommon one, the old setting API was removed. --- .../D3D/Src/PixelShaderCache.cpp | 23 +++-------- Source/Core/VideoBackends/D3D/Src/Render.h | 3 -- .../D3D/Src/VertexShaderCache.cpp | 39 +++---------------- Source/Core/VideoBackends/OGL/CMakeLists.txt | 2 - Source/Core/VideoBackends/OGL/OGL.vcxproj | 4 +- .../OGL/Src/PixelShaderCache.cpp | 31 --------------- Source/Core/VideoBackends/OGL/Src/Render.h | 3 -- .../OGL/Src/VertexShaderCache.cpp | 31 --------------- .../VideoCommon/Src/PixelShaderManager.cpp | 6 --- Source/Core/VideoCommon/Src/RenderBase.h | 4 -- .../VideoCommon/Src/VertexShaderManager.cpp | 6 --- 11 files changed, 13 insertions(+), 139 deletions(-) delete mode 100644 Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp delete mode 100644 Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp diff --git a/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp index 8109d7fd20..04a1722d04 100644 --- a/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp @@ -14,15 +14,12 @@ #include "Globals.h" #include "PixelShaderGen.h" #include "PixelShaderCache.h" +#include "PixelShaderManager.h" #include "ConfigManager.h" extern int frameCount; -// See comment near the bottom of this file. -float psconstants[C_PENVCONST_END*4]; -bool pscbufchanged = true; - namespace DX11 { @@ -339,15 +336,15 @@ ID3D11PixelShader* PixelShaderCache::GetClearProgram() ID3D11Buffer* &PixelShaderCache::GetConstantBuffer() { // TODO: divide the global variables of the generated shaders into about 5 constant buffers to speed this up - if (pscbufchanged) + if (PixelShaderManager::dirty) { D3D11_MAPPED_SUBRESOURCE map; D3D::context->Map(pscbuf, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); - memcpy(map.pData, psconstants, sizeof(psconstants)); + memcpy(map.pData, &PixelShaderManager::constants, sizeof(PixelShaderConstants)); D3D::context->Unmap(pscbuf, 0); - pscbufchanged = false; + PixelShaderManager::dirty = false; - ADDSTAT(stats.thisFrame.bytesUniformStreamed, sizeof(psconstants)); + ADDSTAT(stats.thisFrame.bytesUniformStreamed, sizeof(PixelShaderConstants)); } return pscbuf; } @@ -364,7 +361,7 @@ public: void PixelShaderCache::Init() { - unsigned int cbsize = ((sizeof(psconstants))&(~0xf))+0x10; // must be a multiple of 16 + unsigned int cbsize = ((sizeof(PixelShaderConstants))&(~0xf))+0x10; // must be a multiple of 16 D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE); D3D::device->CreateBuffer(&cbdesc, NULL, &pscbuf); CHECK(pscbuf!=NULL, "Create pixel shader constant buffer"); @@ -536,12 +533,4 @@ bool PixelShaderCache::InsertByteCode(const PixelShaderUid &uid, const void* byt return true; } -// These are "callbacks" from VideoCommon and thus must be outside namespace DX11. -// This will have to be changed when we merge. -void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float* f) -{ - memcpy(psconstants, f, sizeof(float)*4*count); - pscbufchanged = true; -} - } // DX11 diff --git a/Source/Core/VideoBackends/D3D/Src/Render.h b/Source/Core/VideoBackends/D3D/Src/Render.h index c0090cd2f2..39b5b90d81 100644 --- a/Source/Core/VideoBackends/D3D/Src/Render.h +++ b/Source/Core/VideoBackends/D3D/Src/Render.h @@ -51,9 +51,6 @@ public: bool SaveScreenshot(const std::string &filename, const TargetRectangle &rc); static bool CheckForResize(); - - void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); - void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); }; } diff --git a/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp index 6f3c4051b1..28a03b3bca 100644 --- a/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp +++ b/Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp @@ -12,14 +12,10 @@ #include "D3DShader.h" #include "Globals.h" #include "VertexShaderCache.h" +#include "VertexShaderManager.h" #include "ConfigManager.h" -// See comment near the bottom of this file -static unsigned int vs_constant_offset_table[C_VENVCONST_END]; -float vsconstants[C_VENVCONST_END*4]; -bool vscbufchanged = true; - namespace DX11 { VertexShaderCache::VSCache VertexShaderCache::vshaders; @@ -44,15 +40,15 @@ ID3D11Buffer* vscbuf = NULL; ID3D11Buffer* &VertexShaderCache::GetConstantBuffer() { // TODO: divide the global variables of the generated shaders into about 5 constant buffers to speed this up - if (vscbufchanged) + if (VertexShaderManager::dirty) { D3D11_MAPPED_SUBRESOURCE map; D3D::context->Map(vscbuf, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); - memcpy(map.pData, vsconstants, sizeof(vsconstants)); + memcpy(map.pData, &VertexShaderManager::constants, sizeof(VertexShaderConstants)); D3D::context->Unmap(vscbuf, 0); - vscbufchanged = false; + VertexShaderManager::dirty = false; - ADDSTAT(stats.thisFrame.bytesUniformStreamed, sizeof(vsconstants)); + ADDSTAT(stats.thisFrame.bytesUniformStreamed, sizeof(VertexShaderConstants)); } return vscbuf; } @@ -116,7 +112,7 @@ void VertexShaderCache::Init() { "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; - unsigned int cbsize = ((sizeof(vsconstants))&(~0xf))+0x10; // must be a multiple of 16 + unsigned int cbsize = ((sizeof(VertexShaderConstants))&(~0xf))+0x10; // must be a multiple of 16 D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE); HRESULT hr = D3D::device->CreateBuffer(&cbdesc, NULL, &vscbuf); CHECK(hr==S_OK, "Create vertex shader constant buffer (size=%u)", cbsize); @@ -141,19 +137,6 @@ void VertexShaderCache::Init() Clear(); - // these values are hardcoded, they depend on internal D3DCompile behavior - // TODO: Do this with D3DReflect or something instead - unsigned int k; - for (k = 0;k < 6;k++) vs_constant_offset_table[C_POSNORMALMATRIX+k] = 0+4*k; - for (k = 0;k < 4;k++) vs_constant_offset_table[C_PROJECTION+k] = 24+4*k; - for (k = 0;k < 4;k++) vs_constant_offset_table[C_MATERIALS+k] = 40+4*k; - for (k = 0;k < 40;k++) vs_constant_offset_table[C_LIGHTS+k] = 56+4*k; - for (k = 0;k < 24;k++) vs_constant_offset_table[C_TEXMATRICES+k] = 216+4*k; - for (k = 0;k < 64;k++) vs_constant_offset_table[C_TRANSFORMMATRICES+k] = 312+4*k; - for (k = 0;k < 32;k++) vs_constant_offset_table[C_NORMALMATRICES+k] = 568+4*k; - for (k = 0;k < 64;k++) vs_constant_offset_table[C_POSTTRANSFORMMATRICES+k] = 696+4*k; - vs_constant_offset_table[C_DEPTHPARAMS] = 952; - if (!File::Exists(File::GetUserPath(D_SHADERCACHE_IDX))) File::CreateDir(File::GetUserPath(D_SHADERCACHE_IDX).c_str()); @@ -277,14 +260,4 @@ bool VertexShaderCache::InsertByteCode(const VertexShaderUid &uid, D3DBlob* bcod return true; } -// These are "callbacks" from VideoCommon and thus must be outside namespace DX11. -// This will have to be changed when we merge. - -// TODO: fetch directly from VideoCommon -void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float* f) -{ - memcpy(&vsconstants[vs_constant_offset_table[const_number]], f, sizeof(float)*4*count); - vscbufchanged = true; -} - } // namespace DX11 diff --git a/Source/Core/VideoBackends/OGL/CMakeLists.txt b/Source/Core/VideoBackends/OGL/CMakeLists.txt index f3d7ce4e4f..3e1d2aaa60 100644 --- a/Source/Core/VideoBackends/OGL/CMakeLists.txt +++ b/Source/Core/VideoBackends/OGL/CMakeLists.txt @@ -3,7 +3,6 @@ set(SRCS Src/FramebufferManager.cpp Src/main.cpp Src/NativeVertexFormat.cpp Src/PerfQuery.cpp - Src/PixelShaderCache.cpp Src/PostProcessing.cpp Src/ProgramShaderCache.cpp Src/RasterFont.cpp @@ -12,7 +11,6 @@ set(SRCS Src/FramebufferManager.cpp Src/StreamBuffer.cpp Src/TextureCache.cpp Src/TextureConverter.cpp - Src/VertexShaderCache.cpp Src/VertexManager.cpp) set(LIBS videocommon diff --git a/Source/Core/VideoBackends/OGL/OGL.vcxproj b/Source/Core/VideoBackends/OGL/OGL.vcxproj index 69e23065c5..46113f53ce 100644 --- a/Source/Core/VideoBackends/OGL/OGL.vcxproj +++ b/Source/Core/VideoBackends/OGL/OGL.vcxproj @@ -151,7 +151,6 @@ - @@ -169,7 +168,6 @@ - @@ -203,4 +201,4 @@ - \ No newline at end of file + diff --git a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp deleted file mode 100644 index ba6a0b2e97..0000000000 --- a/Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 -// Refer to the license.txt file included. - -#include "Globals.h" - -#include "GLUtil.h" - -#include - -#include "Statistics.h" -#include "VideoConfig.h" -#include "ImageWrite.h" -#include "Common.h" -#include "Render.h" -#include "VertexShaderGen.h" -#include "ProgramShaderCache.h" -#include "PixelShaderManager.h" -#include "OnScreenDisplay.h" -#include "StringUtil.h" -#include "FileUtil.h" -#include "Debugger.h" - -namespace OGL -{ - -// Renderer functions -void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) -{ -} -} // namespace OGL diff --git a/Source/Core/VideoBackends/OGL/Src/Render.h b/Source/Core/VideoBackends/OGL/Src/Render.h index 6216097e79..8c6a8ca8f8 100644 --- a/Source/Core/VideoBackends/OGL/Src/Render.h +++ b/Source/Core/VideoBackends/OGL/Src/Render.h @@ -81,9 +81,6 @@ public: bool SaveScreenshot(const std::string &filename, const TargetRectangle &rc); - void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); - void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); - private: void UpdateEFBCache(EFBAccessType type, u32 cacheRectIdx, const EFBRectangle& efbPixelRc, const TargetRectangle& targetPixelRc, const u32* data); }; diff --git a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp deleted file mode 100644 index c2c49b8505..0000000000 --- a/Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 -// Refer to the license.txt file included. - -#include - -#include "Globals.h" -#include "VideoConfig.h" -#include "Statistics.h" - -#include "GLUtil.h" - -#include "Render.h" -#include "VertexShaderGen.h" -#include "VertexShaderManager.h" -#include "ProgramShaderCache.h" -#include "VertexManager.h" -#include "VertexLoader.h" -#include "XFMemory.h" -#include "ImageWrite.h" -#include "FileUtil.h" -#include "Debugger.h" - -namespace OGL -{ - -void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) -{ -} - -} // namespace OGL diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 970bdb6e58..46672758e4 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -355,12 +355,6 @@ void PixelShaderManager::SetConstants(u32 components) nMaterialsChanged = 0; } } - - if(dirty && g_ActiveConfig.backend_info.APIType != API_OPENGL) - { - g_renderer->SetMultiPSConstant4fv(0, sizeof(constants)/16, (float*) &constants); - dirty = false; - } } void PixelShaderManager::SetPSTextureDims(int texid) diff --git a/Source/Core/VideoCommon/Src/RenderBase.h b/Source/Core/VideoCommon/Src/RenderBase.h index 08ed80343d..4e093700a9 100644 --- a/Source/Core/VideoCommon/Src/RenderBase.h +++ b/Source/Core/VideoCommon/Src/RenderBase.h @@ -115,10 +115,6 @@ public: static unsigned int GetPrevPixelFormat() { return prev_efb_format; } static void StorePixelFormat(unsigned int new_format) { prev_efb_format = new_format; } - // TODO: doesn't belong here - virtual void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0; - virtual void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) = 0; - protected: static void CalculateTargetScale(int x, int y, int &scaledX, int &scaledY); diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp index 20c4994cf8..91be3597cd 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp @@ -517,12 +517,6 @@ void VertexShaderManager::SetConstants() SetMultiVSConstant4fv(C_PROJECTION, 4, correctedMtx.data); } } - - if(dirty && g_ActiveConfig.backend_info.APIType != API_OPENGL) - { - dirty = false; - g_renderer->SetMultiVSConstant4fv(0, sizeof(constants)/16, (float*) &constants); - } } void VertexShaderManager::InvalidateXFRange(int start, int end) From 15ed0ea9cf1588fc076b89374ead8ab610c093bb Mon Sep 17 00:00:00 2001 From: degasus Date: Mon, 7 Oct 2013 19:04:03 +0200 Subject: [PATCH 4/9] videoCommon: remove not supported constant types I'm pretty sure GPUs can read u8 values, but this isn't exported by the API. But hey, see unpackSnorm4x8 :-) --- Source/Core/VideoCommon/Src/ConstantManager.h | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/Source/Core/VideoCommon/Src/ConstantManager.h b/Source/Core/VideoCommon/Src/ConstantManager.h index f86d12e2db..bd28ea8731 100644 --- a/Source/Core/VideoCommon/Src/ConstantManager.h +++ b/Source/Core/VideoCommon/Src/ConstantManager.h @@ -7,12 +7,8 @@ // all constant buffer attributes must be 16 bytes aligned, so this are the only allowed components: typedef float float4[4]; -typedef u8 uchar16[16]; -typedef s8 schar16[16]; -typedef u16 ushort8[8]; -typedef s16 sshort8[8]; typedef u32 uint4[4]; -typedef s32 sint4[4]; +typedef s32 int4[4]; struct PixelShaderConstants { From cc6c454898486f17f10cfd7a0ed88c7605588437 Mon Sep 17 00:00:00 2001 From: degasus Date: Mon, 7 Oct 2013 21:57:18 +0200 Subject: [PATCH 5/9] VideoCommon: refactor PixelShaderManager setters The old way was to use a dirty flag per setter. Now we just update the const buffer per setter directly. The old optimization isn't needed any more as the setters don't call the backend any more. The follow parts are rewritten: Alpha ZTextureType zbias FogParam FogColor Color TexDim IndMatrix MaterialColor FogRangeAdjust Lights --- Source/Core/VideoCommon/Src/BPStructs.cpp | 31 +- .../VideoCommon/Src/PixelShaderManager.cpp | 468 +++++------------- .../Core/VideoCommon/Src/PixelShaderManager.h | 4 +- .../VideoCommon/Src/VertexShaderManager.cpp | 2 +- .../VideoCommon/Src/VertexShaderManager.h | 2 +- Source/Core/VideoCommon/Src/XFStructs.cpp | 8 +- 6 files changed, 157 insertions(+), 358 deletions(-) diff --git a/Source/Core/VideoCommon/Src/BPStructs.cpp b/Source/Core/VideoCommon/Src/BPStructs.cpp index 9f885e7953..785546fea7 100644 --- a/Source/Core/VideoCommon/Src/BPStructs.cpp +++ b/Source/Core/VideoCommon/Src/BPStructs.cpp @@ -168,12 +168,16 @@ void BPWritten(const BPCmd& bp) case BPMEM_IND_MTXA+6: case BPMEM_IND_MTXB+6: case BPMEM_IND_MTXC+6: - PixelShaderManager::SetIndMatrixChanged((bp.address - BPMEM_IND_MTXA) / 3); + if(bp.changes) + PixelShaderManager::SetIndMatrixChanged((bp.address - BPMEM_IND_MTXA) / 3); break; case BPMEM_RAS1_SS0: // Index Texture Coordinate Scale 0 - PixelShaderManager::SetIndTexScaleChanged(0x03); + if(bp.changes) + PixelShaderManager::SetIndTexScaleChanged(0x03); + break; case BPMEM_RAS1_SS1: // Index Texture Coordinate Scale 1 - PixelShaderManager::SetIndTexScaleChanged(0x0c); + if(bp.changes) + PixelShaderManager::SetIndTexScaleChanged(0x0c); break; // ---------------- // Scissor Control @@ -220,7 +224,8 @@ void BPWritten(const BPCmd& bp) case BPMEM_CONSTANTALPHA: // Set Destination Alpha { PRIM_LOG("constalpha: alp=%d, en=%d", bpmem.dstalpha.alpha, bpmem.dstalpha.enable); - PixelShaderManager::SetDestAlpha(bpmem.dstalpha); + if(bp.changes & 0xFF) + PixelShaderManager::SetDestAlpha(bpmem.dstalpha); if(bp.changes & 0x100) SetBlendMode(); break; @@ -341,29 +346,32 @@ void BPWritten(const BPCmd& bp) case BPMEM_FOGRANGE+3: case BPMEM_FOGRANGE+4: case BPMEM_FOGRANGE+5: - if (!GetConfig(CONFIG_DISABLEFOG)) + if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes) PixelShaderManager::SetFogRangeAdjustChanged(); break; case BPMEM_FOGPARAM0: case BPMEM_FOGBMAGNITUDE: case BPMEM_FOGBEXPONENT: case BPMEM_FOGPARAM3: - if (!GetConfig(CONFIG_DISABLEFOG)) + if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes) PixelShaderManager::SetFogParamChanged(); break; case BPMEM_FOGCOLOR: // Fog Color - if (!GetConfig(CONFIG_DISABLEFOG)) + if (!GetConfig(CONFIG_DISABLEFOG) && bp.changes) PixelShaderManager::SetFogColorChanged(); break; case BPMEM_ALPHACOMPARE: // Compare Alpha Values PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", bpmem.alpha_test.ref0, bpmem.alpha_test.ref1, bpmem.alpha_test.comp0, bpmem.alpha_test.comp1, bpmem.alpha_test.logic); - PixelShaderManager::SetAlpha(bpmem.alpha_test); - g_renderer->SetColorMask(); + if(bp.changes & 0xFFFF) + PixelShaderManager::SetAlpha(bpmem.alpha_test); + if(bp.changes) + g_renderer->SetColorMask(); break; case BPMEM_BIAS: // BIAS PRIM_LOG("ztex bias=0x%x", bpmem.ztex1.bias); - PixelShaderManager::SetZTextureBias(bpmem.ztex1.bias); + if(bp.changes) + PixelShaderManager::SetZTextureBias(bpmem.ztex1.bias); break; case BPMEM_ZTEX2: // Z Texture type { @@ -573,7 +581,8 @@ void BPWritten(const BPCmd& bp) case BPMEM_SU_TSIZE+12: case BPMEM_SU_SSIZE+14: case BPMEM_SU_TSIZE+14: - PixelShaderManager::SetTexCoordChanged((bp.address - BPMEM_SU_SSIZE) >> 1); + if(bp.changes) + PixelShaderManager::SetTexCoordChanged((bp.address - BPMEM_SU_SSIZE) >> 1); break; // ------------------------ // BPMEM_TX_SETMODE0 - (Texture lookup and filtering mode) LOD/BIAS Clamp, MaxAnsio, LODBIAS, DiagLoad, Min Filter, Mag Filter, Wrap T, S diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 46672758e4..0f749a1d49 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -11,80 +11,22 @@ #include "VideoConfig.h" #include "RenderBase.h" -static int s_nColorsChanged[2]; // 0 - regular colors, 1 - k colors -static int s_nIndTexMtxChanged; -static bool s_bAlphaChanged; -static bool s_bZBiasChanged; -static bool s_bZTextureTypeChanged; -static bool s_bDepthRangeChanged; -static bool s_bFogColorChanged; -static bool s_bFogParamChanged; static bool s_bFogRangeAdjustChanged; static int nLightsChanged[2]; // min,max -static float lastRGBAfull[2][4][4]; -static u8 s_nTexDimsChanged; -static u8 s_nIndTexScaleChanged; -static u32 lastAlpha; -static u32 lastTexDims[8]; // width | height << 16 | wrap_s << 28 | wrap_t << 30 -static u32 lastZBias; -static int nMaterialsChanged; PixelShaderConstants PixelShaderManager::constants; bool PixelShaderManager::dirty; -inline void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - float4* c = (float4*) &PixelShaderManager::constants; - c[const_number][0] = f1; - c[const_number][1] = f2; - c[const_number][2] = f3; - c[const_number][3] = f4; - PixelShaderManager::dirty = true; -} - -inline void SetPSConstant4fv(unsigned int const_number, const float *f) -{ - float4* c = (float4*) &PixelShaderManager::constants; - c[const_number][0] = f[0]; - c[const_number][1] = f[1]; - c[const_number][2] = f[2]; - c[const_number][3] = f[3]; - PixelShaderManager::dirty = true; -} - -inline void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) -{ - float4* c = (float4*) &PixelShaderManager::constants; - for(u32 i=0; i>8)&0xff)/255.0f, 0, ((lastAlpha>>16)&0xff)/255.0f); - s_bAlphaChanged = false; - } - - if (s_bZTextureTypeChanged) - { - float ftemp[4]; - switch (bpmem.ztex2.type) - { - case 0: - // 8 bits - ftemp[0] = 0; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 255.0f/16777215.0f; - break; - case 1: - // 16 bits - ftemp[0] = 255.0f/16777215.0f; ftemp[1] = 0; ftemp[2] = 0; ftemp[3] = 65280.0f/16777215.0f; - break; - case 2: - // 24 bits - ftemp[0] = 16711680.0f/16777215.0f; ftemp[1] = 65280.0f/16777215.0f; ftemp[2] = 255.0f/16777215.0f; ftemp[3] = 0; - break; - } - SetPSConstant4fv(C_ZBIAS, ftemp); - s_bZTextureTypeChanged = false; - } - - if (s_bZBiasChanged || s_bDepthRangeChanged) - { - // reversed gxsetviewport(xorig, yorig, width, height, nearz, farz) - // [0] = width/2 - // [1] = height/2 - // [2] = 16777215 * (farz - nearz) - // [3] = xorig + width/2 + 342 - // [4] = yorig + height/2 + 342 - // [5] = 16777215 * farz - - //ERROR_LOG("pixel=%x,%x, bias=%x\n", bpmem.zcontrol.pixel_format, bpmem.ztex2.type, lastZBias); - SetPSConstant4f(C_ZBIAS+1, xfregs.viewport.farZ / 16777216.0f, xfregs.viewport.zRange / 16777216.0f, 0, (float)(lastZBias)/16777215.0f); - s_bZBiasChanged = s_bDepthRangeChanged = false; - } - - // indirect incoming texture scales - if (s_nIndTexScaleChanged) - { - // set as two sets of vec4s, each containing S and T of two ind stages. - float f[8]; - - if (s_nIndTexScaleChanged & 0x03) - { - for (u32 i = 0; i < 2; ++i) - { - f[2 * i] = bpmem.texscale[0].getScaleS(i & 1); - f[2 * i + 1] = bpmem.texscale[0].getScaleT(i & 1); - PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]); - } - SetPSConstant4fv(C_INDTEXSCALE, f); - } - - if (s_nIndTexScaleChanged & 0x0c) - { - for (u32 i = 2; i < 4; ++i) - { - f[2 * i] = bpmem.texscale[1].getScaleS(i & 1); - f[2 * i + 1] = bpmem.texscale[1].getScaleT(i & 1); - PRIM_LOG("tex indscale%d: %f %f\n", i, f[2 * i], f[2 * i + 1]); - } - SetPSConstant4fv(C_INDTEXSCALE+1, &f[4]); - } - s_nIndTexScaleChanged = 0; - } - - if (s_nIndTexMtxChanged) - { - for (int i = 0; i < 3; ++i) - { - if (s_nIndTexMtxChanged & (1 << i)) - { - int scale = ((u32)bpmem.indmtx[i].col0.s0 << 0) | - ((u32)bpmem.indmtx[i].col1.s1 << 2) | - ((u32)bpmem.indmtx[i].col2.s2 << 4); - float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f; - - // xyz - static matrix - // TODO w - dynamic matrix scale / 256...... somehow / 4 works better - // rev 2972 - now using / 256.... verify that this works - SetPSConstant4f(C_INDTEXMTX + 2 * i, - bpmem.indmtx[i].col0.ma * fscale, - bpmem.indmtx[i].col1.mc * fscale, - bpmem.indmtx[i].col2.me * fscale, - fscale * 4.0f); - SetPSConstant4f(C_INDTEXMTX + 2 * i + 1, - bpmem.indmtx[i].col0.mb * fscale, - bpmem.indmtx[i].col1.md * fscale, - bpmem.indmtx[i].col2.mf * fscale, - fscale * 4.0f); - - PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n", - i, 1024.0f*fscale, - bpmem.indmtx[i].col0.ma * fscale, bpmem.indmtx[i].col1.mc * fscale, bpmem.indmtx[i].col2.me * fscale, - bpmem.indmtx[i].col0.mb * fscale, bpmem.indmtx[i].col1.md * fscale, bpmem.indmtx[i].col2.mf * fscale); - - s_nIndTexMtxChanged &= ~(1 << i); - } - } - } - - if (s_bFogColorChanged) - { - SetPSConstant4f(C_FOG, bpmem.fog.color.r / 255.0f, bpmem.fog.color.g / 255.0f, bpmem.fog.color.b / 255.0f, 0); - s_bFogColorChanged = false; - } - - if (s_bFogParamChanged) - { - if(!g_ActiveConfig.bDisableFog) - { - //downscale magnitude to 0.24 bits - float b = (float)bpmem.fog.b_magnitude / 0xFFFFFF; - - float b_shf = (float)(1 << bpmem.fog.b_shift); - SetPSConstant4f(C_FOG + 1, bpmem.fog.a.GetA(), b, bpmem.fog.c_proj_fsel.GetC(), b_shf); - } - else - SetPSConstant4f(C_FOG + 1, 0.0, 1.0, 0.0, 1.0); - - s_bFogParamChanged = false; - } - if (s_bFogRangeAdjustChanged) { + // set by two components, so keep changed flag here + // TODO: try to split both registers and move this logic to the shader if(!g_ActiveConfig.bDisableFog && bpmem.fogRange.Base.Enabled == 1) { //bpmem.fogRange.Base.Center : center of the viewport in x axis. observation: bpmem.fogRange.Base.Center = realcenter + 342; @@ -267,12 +53,17 @@ void PixelShaderManager::SetConstants(u32 components) // they always seems to be larger than 256 so my theory is : // they are the coefficients from the center to the border of the screen // so to simplify I use the hi coefficient as K in the shader taking 256 as the scale - SetPSConstant4f(C_FOG + 2, ScreenSpaceCenter, (float)Renderer::EFBToScaledX((int)(2.0f * xfregs.viewport.wd)), bpmem.fogRange.K[4].HI / 256.0f,0.0f); + constants.fog[2][0] = ScreenSpaceCenter; + constants.fog[2][1] = Renderer::EFBToScaledX((int)(2.0f * xfregs.viewport.wd)); + constants.fog[2][2] = bpmem.fogRange.K[4].HI / 256.0f; } else { - SetPSConstant4f(C_FOG + 2, 0.0f, 1.0f, 1.0f, 0.0f); // Need to update these values for older hardware that fails to divide by zero in shaders. + constants.fog[2][0] = 0; + constants.fog[2][1] = 1; + constants.fog[2][2] = 1; } + dirty = true; s_bFogRangeAdjustChanged = false; } @@ -289,12 +80,10 @@ void PixelShaderManager::SetConstants(u32 components) for (int i = istart; i < iend; ++i) { u32 color = *(const u32*)(xfmemptr + 3); - float NormalizationCoef = 1 / 255.0f; - SetPSConstant4f(C_PLIGHTS + 5 * i, - ((color >> 24) & 0xFF) * NormalizationCoef, - ((color >> 16) & 0xFF) * NormalizationCoef, - ((color >> 8) & 0xFF) * NormalizationCoef, - ((color) & 0xFF) * NormalizationCoef); + constants.plights[5*i][0] = ((color >> 24) & 0xFF) / 255.0f; + constants.plights[5*i][1] = ((color >> 16) & 0xFF) / 255.0f; + constants.plights[5*i][2] = ((color >> 8) & 0xFF) / 255.0f; + constants.plights[5*i][3] = ((color) & 0xFF) / 255.0f; xfmemptr += 4; for (int j = 0; j < 4; ++j, xfmemptr += 3) @@ -303,174 +92,180 @@ void PixelShaderManager::SetConstants(u32 components) fabs(xfmemptr[0]) < 0.00001f && fabs(xfmemptr[1]) < 0.00001f && fabs(xfmemptr[2]) < 0.00001f) - { // dist attenuation, make sure not equal to 0!!! - SetPSConstant4f(C_PLIGHTS+5*i+j+1, 0.00001f, xfmemptr[1], xfmemptr[2], 0); - } + constants.plights[5*i+j+1][0] = 0.00001f; else - { - SetPSConstant4fv(C_PLIGHTS+5*i+j+1, xfmemptr); - } + constants.plights[5*i+j+1][0] = xfmemptr[0]; + constants.plights[5*i+j+1][1] = xfmemptr[1]; + constants.plights[5*i+j+1][2] = xfmemptr[2]; } } + dirty = true; nLightsChanged[0] = nLightsChanged[1] = -1; } - - if (nMaterialsChanged) - { - float GC_ALIGNED16(material[4]); - float NormalizationCoef = 1 / 255.0f; - - for (int i = 0; i < 2; ++i) - { - if (nMaterialsChanged & (1 << i)) - { - u32 data = *(xfregs.ambColor + i); - - material[0] = ((data >> 24) & 0xFF) * NormalizationCoef; - material[1] = ((data >> 16) & 0xFF) * NormalizationCoef; - material[2] = ((data >> 8) & 0xFF) * NormalizationCoef; - material[3] = ( data & 0xFF) * NormalizationCoef; - - SetPSConstant4fv(C_PMATERIALS + i, material); - } - } - - for (int i = 0; i < 2; ++i) - { - if (nMaterialsChanged & (1 << (i + 2))) - { - u32 data = *(xfregs.matColor + i); - - material[0] = ((data >> 24) & 0xFF) * NormalizationCoef; - material[1] = ((data >> 16) & 0xFF) * NormalizationCoef; - material[2] = ((data >> 8) & 0xFF) * NormalizationCoef; - material[3] = ( data & 0xFF) * NormalizationCoef; - - SetPSConstant4fv(C_PMATERIALS + i + 2, material); - } - } - - nMaterialsChanged = 0; - } } } -void PixelShaderManager::SetPSTextureDims(int texid) -{ - // texdims.xy are reciprocals of the real texture dimensions - // texdims.zw are the scaled dimensions - float fdims[4]; - - TCoordInfo& tc = bpmem.texcoords[texid]; - fdims[0] = 1.0f / (float)(lastTexDims[texid] & 0xffff); - fdims[1] = 1.0f / (float)((lastTexDims[texid] >> 16) & 0xfff); - fdims[2] = (float)(tc.s.scale_minus_1 + 1); - fdims[3] = (float)(tc.t.scale_minus_1 + 1); - - PRIM_LOG("texdims%d: %f %f %f %f\n", texid, fdims[0], fdims[1], fdims[2], fdims[3]); - SetPSConstant4fv(C_TEXDIMS + texid, fdims); -} - // This one is high in profiles (0.5%). // TODO: Move conversion out, only store the raw color value // and update it when the shader constant is set, only. // TODO: Conversion should be checked in the context of tev_fixes.. void PixelShaderManager::SetColorChanged(int type, int num, bool high) { - float *pf = &lastRGBAfull[type][num][0]; - + float4* c = type ? constants.kcolors : constants.colors; if (!high) { - int r = bpmem.tevregs[num].low.a; - int a = bpmem.tevregs[num].low.b; - pf[0] = (float)r * (1.0f / 255.0f); - pf[3] = (float)a * (1.0f / 255.0f); + c[num][0] = bpmem.tevregs[num].low.a / 255.0f; + c[num][3] = bpmem.tevregs[num].low.b / 255.0f; } else { - int b = bpmem.tevregs[num].high.a; - int g = bpmem.tevregs[num].high.b; - pf[1] = (float)g * (1.0f / 255.0f); - pf[2] = (float)b * (1.0f / 255.0f); + c[num][2] = bpmem.tevregs[num].high.a / 255.0f; + c[num][1] = bpmem.tevregs[num].high.b / 255.0f; } - - s_nColorsChanged[type] |= 1 << num; - PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, pf[0], pf[1], pf[2], pf[3]); + dirty = true; + + PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, c[num][0], c[num][1], c[num][2], c[num][3]); } void PixelShaderManager::SetAlpha(const AlphaTest& alpha) { - if ((alpha.hex & 0xffff) != lastAlpha) - { - lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff); - s_bAlphaChanged = true; - } + constants.alpha[0] = alpha.ref0 / 255.0f; + constants.alpha[1] = alpha.ref1 / 255.0f; + dirty = true; } void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha) { - if (alpha.alpha != (lastAlpha >> 16)) - { - lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16); - s_bAlphaChanged = true; - } + constants.alpha[3] = alpha.alpha; + dirty = true; } void PixelShaderManager::SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt) { - u32 wh = width | (height << 16) | (wraps << 28) | (wrapt << 30); - if (lastTexDims[texmapid] != wh) - { - lastTexDims[texmapid] = wh; - s_nTexDimsChanged |= 1 << texmapid; - } + // TODO: move this check out to callee. There we could just call this function on texture changes + // or better, use textureSize() in glsl + if(constants.texdims[texmapid][0] != 1.0f/width || constants.texdims[texmapid][1] != 1.0f/height) + dirty = true; + + constants.texdims[texmapid][0] = 1.0f/width; + constants.texdims[texmapid][1] = 1.0f/height; } void PixelShaderManager::SetZTextureBias(u32 bias) { - if (lastZBias != bias) - { - s_bZBiasChanged = true; - lastZBias = bias; - } + constants.zbias[1][3] = bias/16777215.0f; + dirty = true; } void PixelShaderManager::SetViewportChanged() { - s_bDepthRangeChanged = true; + constants.zbias[1][0] = xfregs.viewport.farZ / 16777216.0f; + constants.zbias[1][1] = xfregs.viewport.zRange / 16777216.0f; + dirty = true; + s_bFogRangeAdjustChanged = true; // TODO: Shouldn't be necessary with an accurate fog range adjust implementation } void PixelShaderManager::SetIndTexScaleChanged(u8 stagemask) { - s_nIndTexScaleChanged |= stagemask; + bool high_stage = stagemask == 0x0c; + constants.indtexscale[high_stage][0] = bpmem.texscale[high_stage].getScaleS(0); + constants.indtexscale[high_stage][1] = bpmem.texscale[high_stage].getScaleT(0); + constants.indtexscale[high_stage][2] = bpmem.texscale[high_stage].getScaleS(1); + constants.indtexscale[high_stage][3] = bpmem.texscale[high_stage].getScaleT(1); + dirty = true; } void PixelShaderManager::SetIndMatrixChanged(int matrixidx) { - s_nIndTexMtxChanged |= 1 << matrixidx; + int scale = ((u32)bpmem.indmtx[matrixidx].col0.s0 << 0) | + ((u32)bpmem.indmtx[matrixidx].col1.s1 << 2) | + ((u32)bpmem.indmtx[matrixidx].col2.s2 << 4); + float fscale = powf(2.0f, (float)(scale - 17)) / 1024.0f; + + // xyz - static matrix + // TODO w - dynamic matrix scale / 256...... somehow / 4 works better + // rev 2972 - now using / 256.... verify that this works + constants.indtexmts[2*matrixidx][0] = bpmem.indmtx[matrixidx].col0.ma * fscale; + constants.indtexmts[2*matrixidx][1] = bpmem.indmtx[matrixidx].col1.mc * fscale; + constants.indtexmts[2*matrixidx][2] = bpmem.indmtx[matrixidx].col2.me * fscale; + constants.indtexmts[2*matrixidx][3] = fscale * 4.0f; + constants.indtexmts[2*matrixidx+1][0] = bpmem.indmtx[matrixidx].col0.mb * fscale; + constants.indtexmts[2*matrixidx+1][1] = bpmem.indmtx[matrixidx].col1.md * fscale; + constants.indtexmts[2*matrixidx+1][2] = bpmem.indmtx[matrixidx].col2.mf * fscale; + constants.indtexmts[2*matrixidx+1][3] = fscale * 4.0f; + dirty = true; + + PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n", + matrixidx, 1024.0f*fscale, + bpmem.indmtx[matrixidx].col0.ma * fscale, bpmem.indmtx[matrixidx].col1.mc * fscale, bpmem.indmtx[matrixidx].col2.me * fscale, + bpmem.indmtx[matrixidx].col0.mb * fscale, bpmem.indmtx[matrixidx].col1.md * fscale, bpmem.indmtx[matrixidx].col2.mf * fscale); + } void PixelShaderManager::SetZTextureTypeChanged() { - s_bZTextureTypeChanged = true; + switch (bpmem.ztex2.type) + { + case TEV_ZTEX_TYPE_U8: + constants.zbias[0][0] = 0; + constants.zbias[0][1] = 0; + constants.zbias[0][2] = 0; + constants.zbias[0][3] = 255.0f/16777215.0f; + break; + case TEV_ZTEX_TYPE_U16: + constants.zbias[0][0] = 255.0f/16777215.0f; + constants.zbias[0][1] = 0; + constants.zbias[0][2] = 0; + constants.zbias[0][3] = 65280.0f/16777215.0f; + break; + case TEV_ZTEX_TYPE_U24: + constants.zbias[0][0] = 16711680.0f/16777215.0f; + constants.zbias[0][1] = 65280.0f/16777215.0f; + constants.zbias[0][2] = 255.0f/16777215.0f; + constants.zbias[0][3] = 0; + break; + default: + break; + } + dirty = true; } void PixelShaderManager::SetTexCoordChanged(u8 texmapid) { - s_nTexDimsChanged |= 1 << texmapid; + TCoordInfo& tc = bpmem.texcoords[texmapid]; + constants.texdims[texmapid][2] = tc.s.scale_minus_1 + 1; + constants.texdims[texmapid][3] = tc.t.scale_minus_1 + 1; + dirty = true; } void PixelShaderManager::SetFogColorChanged() { - s_bFogColorChanged = true; + constants.fog[0][0] = bpmem.fog.color.r / 255.0f; + constants.fog[0][1] = bpmem.fog.color.g / 255.0f; + constants.fog[0][2] = bpmem.fog.color.b / 255.0f; + dirty = true; } void PixelShaderManager::SetFogParamChanged() { - s_bFogParamChanged = true; + if(!g_ActiveConfig.bDisableFog) + { + constants.fog[1][0] = bpmem.fog.a.GetA(); + constants.fog[1][1] = (float)bpmem.fog.b_magnitude / 0xFFFFFF; + constants.fog[1][2] = bpmem.fog.c_proj_fsel.GetC(); + constants.fog[1][3] = 1 << bpmem.fog.b_shift; + } + else + { + constants.fog[1][0] = 0; + constants.fog[1][1] = 1; + constants.fog[1][2] = 0; + constants.fog[1][3] = 1; + } + dirty = true; } void PixelShaderManager::SetFogRangeAdjustChanged() @@ -478,12 +273,6 @@ void PixelShaderManager::SetFogRangeAdjustChanged() s_bFogRangeAdjustChanged = true; } -void PixelShaderManager::SetColorMatrix(const float* pmatrix) -{ - SetMultiPSConstant4fv(C_COLORMATRIX,7,pmatrix); - s_nColorsChanged[0] = s_nColorsChanged[1] = 15; -} - void PixelShaderManager::InvalidateXFRange(int start, int end) { if (start < XFMEM_LIGHTS_END && end > XFMEM_LIGHTS) @@ -504,17 +293,20 @@ void PixelShaderManager::InvalidateXFRange(int start, int end) } } -void PixelShaderManager::SetMaterialColorChanged(int index) +void PixelShaderManager::SetMaterialColorChanged(int index, u32 color) { - nMaterialsChanged |= (1 << index); + if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + { + constants.pmaterials[index][0] = ((color >> 24) & 0xFF) / 255.0f; + constants.pmaterials[index][1] = ((color >> 16) & 0xFF) / 255.0f; + constants.pmaterials[index][2] = ((color >> 8) & 0xFF) / 255.0f; + constants.pmaterials[index][3] = ( color & 0xFF) / 255.0f; + dirty = true; + } } void PixelShaderManager::DoState(PointerWrap &p) { - p.Do(lastRGBAfull); - p.Do(lastAlpha); - p.Do(lastTexDims); - p.Do(lastZBias); p.Do(constants); p.Do(dirty); diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.h b/Source/Core/VideoCommon/Src/PixelShaderManager.h index 856b76d8d7..64ffbb59fd 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.h +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.h @@ -17,7 +17,6 @@ class PointerWrap; // The non-API dependent parts. class PixelShaderManager { - static void SetPSTextureDims(int texid); public: static void Init(); static void Dirty(); @@ -41,9 +40,8 @@ public: static void SetFogColorChanged(); static void SetFogParamChanged(); static void SetFogRangeAdjustChanged(); - static void SetColorMatrix(const float* pmatrix); static void InvalidateXFRange(int start, int end); - static void SetMaterialColorChanged(int index); + static void SetMaterialColorChanged(int index, u32 color); static PixelShaderConstants constants; static bool dirty; diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp index 91be3597cd..0698f7b472 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp @@ -643,7 +643,7 @@ void VertexShaderManager::SetProjectionChanged() bProjectionChanged = true; } -void VertexShaderManager::SetMaterialColorChanged(int index) +void VertexShaderManager::SetMaterialColorChanged(int index, u32 color) { nMaterialsChanged |= (1 << index); } diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.h b/Source/Core/VideoCommon/Src/VertexShaderManager.h index d681092902..60e23902f1 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.h +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.h @@ -31,7 +31,7 @@ public: static void SetTexMatrixChangedB(u32 value); static void SetViewportChanged(); static void SetProjectionChanged(); - static void SetMaterialColorChanged(int index); + static void SetMaterialColorChanged(int index, u32 color); static void TranslateView(float x, float y, float z = 0.0f); static void RotateView(float x, float y); diff --git a/Source/Core/VideoCommon/Src/XFStructs.cpp b/Source/Core/VideoCommon/Src/XFStructs.cpp index a2f2097e07..7d806fcabe 100644 --- a/Source/Core/VideoCommon/Src/XFStructs.cpp +++ b/Source/Core/VideoCommon/Src/XFStructs.cpp @@ -60,8 +60,8 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData) if (xfregs.ambColor[chan] != newValue) { VertexManager::Flush(); - VertexShaderManager::SetMaterialColorChanged(chan); - PixelShaderManager::SetMaterialColorChanged(chan); + VertexShaderManager::SetMaterialColorChanged(chan, newValue); + PixelShaderManager::SetMaterialColorChanged(chan, newValue); } break; } @@ -73,8 +73,8 @@ void XFRegWritten(int transferSize, u32 baseAddress, u32 *pData) if (xfregs.matColor[chan] != newValue) { VertexManager::Flush(); - VertexShaderManager::SetMaterialColorChanged(chan + 2); - PixelShaderManager::SetMaterialColorChanged(chan + 2); + VertexShaderManager::SetMaterialColorChanged(chan + 2, newValue); + PixelShaderManager::SetMaterialColorChanged(chan + 2, newValue); } break; } From 5de7ac47919a0ecc09b078c55f094106a7564397 Mon Sep 17 00:00:00 2001 From: degasus Date: Tue, 8 Oct 2013 14:34:42 +0200 Subject: [PATCH 6/9] OGL: update ubo workaround --- .../OGL/Src/ProgramShaderCache.cpp | 52 +++++++++---------- .../OGL/Src/TextureConverter.cpp | 2 +- Source/Core/VideoCommon/Src/ConstantManager.h | 2 +- Source/Core/VideoCommon/Src/PixelShaderGen.h | 1 + .../VideoCommon/Src/PixelShaderManager.cpp | 16 +++--- 5 files changed, 35 insertions(+), 38 deletions(-) diff --git a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp index 0904ef41eb..51f41c063b 100644 --- a/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp +++ b/Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp @@ -63,34 +63,30 @@ const char *UniformNames[NUM_UNIFORMS] = I_DEPTHPARAMS, }; -struct s_svar -{ - const unsigned int reg; - const unsigned int size; +const static int PSVar_Loc[] = { + offsetof(PixelShaderConstants, colors)/16, + offsetof(PixelShaderConstants, kcolors)/16, + offsetof(PixelShaderConstants, alpha)/16, + offsetof(PixelShaderConstants, texdims)/16, + offsetof(PixelShaderConstants, zbias)/16, + offsetof(PixelShaderConstants, indtexscale)/16, + offsetof(PixelShaderConstants, indtexmtx)/16, + offsetof(PixelShaderConstants, fog)/16, + offsetof(PixelShaderConstants, plights)/16, + offsetof(PixelShaderConstants, pmaterials)/16, }; -const s_svar PSVar_Loc[] = { {C_COLORS, 4 }, - {C_KCOLORS, 4 }, - {C_ALPHA, 1 }, - {C_TEXDIMS, 8 }, - {C_ZBIAS, 2 }, - {C_INDTEXSCALE, 2 }, - {C_INDTEXMTX, 6 }, - {C_FOG, 3 }, - {C_PLIGHTS, 40 }, - {C_PMATERIALS, 4 }, - }; - -const s_svar VSVar_Loc[] = { {C_POSNORMALMATRIX, 6 }, - {C_PROJECTION, 4 }, - {C_MATERIALS, 4 }, - {C_LIGHTS, 40 }, - {C_TEXMATRICES, 24 }, - {C_TRANSFORMMATRICES, 64 }, - {C_NORMALMATRICES, 32 }, - {C_POSTTRANSFORMMATRICES, 64 }, - {C_DEPTHPARAMS, 1 }, - }; +const static int VSVar_Loc[] = { + offsetof(VertexShaderConstants, posnormalmatrix)/16, + offsetof(VertexShaderConstants, projection)/16, + offsetof(VertexShaderConstants, materials)/16, + offsetof(VertexShaderConstants, lights)/16, + offsetof(VertexShaderConstants, texmatrices)/16, + offsetof(VertexShaderConstants, transformmatrices)/16, + offsetof(VertexShaderConstants, normalmatrices)/16, + offsetof(VertexShaderConstants, posttransformmatrices)/16, + offsetof(VertexShaderConstants, depthparams)/16, +}; // End of UBO workaround @@ -221,12 +217,12 @@ void ProgramShaderCache::UploadConstants() for (unsigned int a = 0; a < 10; ++a) { if(last_entry->shader.UniformSize[a] > 0) - glUniform4fv(last_entry->shader.UniformLocations[a], last_entry->shader.UniformSize[a], (float*) &PixelShaderManager::constants + 4*PSVar_Loc[a].reg); + glUniform4fv(last_entry->shader.UniformLocations[a], last_entry->shader.UniformSize[a], (float*) &PixelShaderManager::constants + 4*PSVar_Loc[a]); } for (unsigned int a = 0; a < 9; ++a) { if(last_entry->shader.UniformSize[a+10] > 0) - glUniform4fv(last_entry->shader.UniformLocations[a+10], last_entry->shader.UniformSize[a+10], (float*) &VertexShaderManager::constants + 4*VSVar_Loc[a].reg); + glUniform4fv(last_entry->shader.UniformLocations[a+10], last_entry->shader.UniformSize[a+10], (float*) &VertexShaderManager::constants + 4*VSVar_Loc[a]); } ADDSTAT(stats.thisFrame.bytesUniformStreamed, s_ubo_buffer_size); diff --git a/Source/Core/VideoBackends/OGL/Src/TextureConverter.cpp b/Source/Core/VideoBackends/OGL/Src/TextureConverter.cpp index 693784054e..b2104af66a 100644 --- a/Source/Core/VideoBackends/OGL/Src/TextureConverter.cpp +++ b/Source/Core/VideoBackends/OGL/Src/TextureConverter.cpp @@ -324,7 +324,7 @@ int EncodeToRamFromTexture(u32 address,GLuint source_texture, bool bFromZBuffer, }; texconv_shader.Bind(); - glUniform4fv(texconv_shader.UniformLocations[C_COLORS], 2, params); + glUniform4fv(texconv_shader.UniformLocations[0], 2, params); TargetRectangle scaledSource; scaledSource.top = 0; diff --git a/Source/Core/VideoCommon/Src/ConstantManager.h b/Source/Core/VideoCommon/Src/ConstantManager.h index bd28ea8731..3c09c2007e 100644 --- a/Source/Core/VideoCommon/Src/ConstantManager.h +++ b/Source/Core/VideoCommon/Src/ConstantManager.h @@ -18,7 +18,7 @@ struct PixelShaderConstants float4 texdims[8]; float4 zbias[2]; float4 indtexscale[2]; - float4 indtexmts[6]; + float4 indtexmtx[6]; float4 fog[3]; // For pixel lighting diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.h b/Source/Core/VideoCommon/Src/PixelShaderGen.h index b73b17168c..983e304998 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderGen.h +++ b/Source/Core/VideoCommon/Src/PixelShaderGen.h @@ -21,6 +21,7 @@ #define I_PLIGHTS "cPLights" #define I_PMATERIALS "cPmtrl" +// TODO: get rid of them as they aren't used #define C_COLORMATRIX 0 // 0 #define C_COLORS 0 // 0 #define C_KCOLORS (C_COLORS + 4) // 4 diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 0f749a1d49..8afcb4429b 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -188,14 +188,14 @@ void PixelShaderManager::SetIndMatrixChanged(int matrixidx) // xyz - static matrix // TODO w - dynamic matrix scale / 256...... somehow / 4 works better // rev 2972 - now using / 256.... verify that this works - constants.indtexmts[2*matrixidx][0] = bpmem.indmtx[matrixidx].col0.ma * fscale; - constants.indtexmts[2*matrixidx][1] = bpmem.indmtx[matrixidx].col1.mc * fscale; - constants.indtexmts[2*matrixidx][2] = bpmem.indmtx[matrixidx].col2.me * fscale; - constants.indtexmts[2*matrixidx][3] = fscale * 4.0f; - constants.indtexmts[2*matrixidx+1][0] = bpmem.indmtx[matrixidx].col0.mb * fscale; - constants.indtexmts[2*matrixidx+1][1] = bpmem.indmtx[matrixidx].col1.md * fscale; - constants.indtexmts[2*matrixidx+1][2] = bpmem.indmtx[matrixidx].col2.mf * fscale; - constants.indtexmts[2*matrixidx+1][3] = fscale * 4.0f; + constants.indtexmtx[2*matrixidx][0] = bpmem.indmtx[matrixidx].col0.ma * fscale; + constants.indtexmtx[2*matrixidx][1] = bpmem.indmtx[matrixidx].col1.mc * fscale; + constants.indtexmtx[2*matrixidx][2] = bpmem.indmtx[matrixidx].col2.me * fscale; + constants.indtexmtx[2*matrixidx][3] = fscale * 4.0f; + constants.indtexmtx[2*matrixidx+1][0] = bpmem.indmtx[matrixidx].col0.mb * fscale; + constants.indtexmtx[2*matrixidx+1][1] = bpmem.indmtx[matrixidx].col1.md * fscale; + constants.indtexmtx[2*matrixidx+1][2] = bpmem.indmtx[matrixidx].col2.mf * fscale; + constants.indtexmtx[2*matrixidx+1][3] = fscale * 4.0f; dirty = true; PRIM_LOG("indmtx%d: scale=%f, mat=(%f %f %f; %f %f %f)\n", From 0b2fb548c3fff6866359f656f202d6d3c8b125d5 Mon Sep 17 00:00:00 2001 From: degasus Date: Tue, 8 Oct 2013 23:58:51 +0200 Subject: [PATCH 7/9] VideoCommon: remove SetVSConstant4f --- Source/Core/VideoCommon/Src/VertexShaderGen.h | 1 + .../VideoCommon/Src/VertexShaderManager.cpp | 135 ++++++------------ 2 files changed, 45 insertions(+), 91 deletions(-) diff --git a/Source/Core/VideoCommon/Src/VertexShaderGen.h b/Source/Core/VideoCommon/Src/VertexShaderGen.h index 667df311c2..9664e92359 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderGen.h +++ b/Source/Core/VideoCommon/Src/VertexShaderGen.h @@ -42,6 +42,7 @@ #define I_POSTTRANSFORMMATRICES "cpostmtx" #define I_DEPTHPARAMS "cDepth" // farZ, zRange, scaled viewport width, scaled viewport height +//TODO: get rid of them, they aren't used at all #define C_POSNORMALMATRIX 0 #define C_PROJECTION (C_POSNORMALMATRIX + 6) #define C_MATERIALS (C_PROJECTION + 4) diff --git a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp index 0698f7b472..e603e6e6c4 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderManager.cpp @@ -46,52 +46,6 @@ void UpdateViewportWithCorrection() UpdateViewport(s_viewportCorrection); } -inline void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) -{ - float4* c = (float4*) &VertexShaderManager::constants; - c[const_number][0] = f1; - c[const_number][1] = f2; - c[const_number][2] = f3; - c[const_number][3] = f4; - VertexShaderManager::dirty = true; -} - -inline void SetVSConstant4fv(unsigned int const_number, const float *f) -{ - float4* c = (float4*) &VertexShaderManager::constants; - c[const_number][0] = f[0]; - c[const_number][1] = f[1]; - c[const_number][2] = f[2]; - c[const_number][3] = f[3]; - VertexShaderManager::dirty = true; -} - -inline void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) -{ - float4* c = (float4*) &VertexShaderManager::constants; - for(u32 i=0; i> 24) & 0xFF) * NormalizationCoef, - ((color >> 16) & 0xFF) * NormalizationCoef, - ((color >> 8) & 0xFF) * NormalizationCoef, - ((color) & 0xFF) * NormalizationCoef); + constants.lights[5*i][0] = ((color >> 24) & 0xFF) / 255.0f; + constants.lights[5*i][1] = ((color >> 16) & 0xFF) / 255.0f; + constants.lights[5*i][2] = ((color >> 8) & 0xFF) / 255.0f; + constants.lights[5*i][3] = ((color) & 0xFF) / 255.0f; xfmemptr += 4; for (int j = 0; j < 4; ++j, xfmemptr += 3) @@ -278,35 +233,30 @@ void VertexShaderManager::SetConstants() fabs(xfmemptr[2]) < 0.00001f) { // dist attenuation, make sure not equal to 0!!! - SetVSConstant4f(C_LIGHTS+5*i+j+1, 0.00001f, xfmemptr[1], xfmemptr[2], 0); + constants.lights[5*i+j+1][0] = 0.00001f; } else - { - SetVSConstant4fv(C_LIGHTS+5*i+j+1, xfmemptr); - } + constants.lights[5*i+j+1][0] = xfmemptr[0]; + constants.lights[5*i+j+1][1] = xfmemptr[1]; + constants.lights[5*i+j+1][2] = xfmemptr[2]; } } + dirty = true; nLightsChanged[0] = nLightsChanged[1] = -1; } if (nMaterialsChanged) { - float GC_ALIGNED16(material[4]); - float NormalizationCoef = 1 / 255.0f; - for (int i = 0; i < 2; ++i) { if (nMaterialsChanged & (1 << i)) { u32 data = *(xfregs.ambColor + i); - - material[0] = ((data >> 24) & 0xFF) * NormalizationCoef; - material[1] = ((data >> 16) & 0xFF) * NormalizationCoef; - material[2] = ((data >> 8) & 0xFF) * NormalizationCoef; - material[3] = ( data & 0xFF) * NormalizationCoef; - - SetVSConstant4fv(C_MATERIALS + i, material); + constants.materials[i][0] = ((data >> 24) & 0xFF) / 255.0f; + constants.materials[i][1] = ((data >> 16) & 0xFF) / 255.0f; + constants.materials[i][2] = ((data >> 8) & 0xFF) / 255.0f; + constants.materials[i][3] = ( data & 0xFF) / 255.0f; } } @@ -315,15 +265,13 @@ void VertexShaderManager::SetConstants() if (nMaterialsChanged & (1 << (i + 2))) { u32 data = *(xfregs.matColor + i); - - material[0] = ((data >> 24) & 0xFF) * NormalizationCoef; - material[1] = ((data >> 16) & 0xFF) * NormalizationCoef; - material[2] = ((data >> 8) & 0xFF) * NormalizationCoef; - material[3] = ( data & 0xFF) * NormalizationCoef; - - SetVSConstant4fv(C_MATERIALS + i + 2, material); + constants.materials[i+2][0] = ((data >> 24) & 0xFF) / 255.0f; + constants.materials[i+2][1] = ((data >> 16) & 0xFF) / 255.0f; + constants.materials[i+2][2] = ((data >> 8) & 0xFF) / 255.0f; + constants.materials[i+2][3] = ( data & 0xFF) / 255.0f; } } + dirty = true; nMaterialsChanged = 0; } @@ -335,8 +283,11 @@ void VertexShaderManager::SetConstants() const float *pos = (const float *)xfmem + MatrixIndexA.PosNormalMtxIdx * 4; const float *norm = (const float *)xfmem + XFMEM_NORMALMATRICES + 3 * (MatrixIndexA.PosNormalMtxIdx & 31); - SetMultiVSConstant4fv(C_POSNORMALMATRIX, 3, pos); - SetMultiVSConstant3fv(C_POSNORMALMATRIX + 3, 3, norm); + memcpy(constants.posnormalmatrix, pos, 3*16); + memcpy(constants.posnormalmatrix[3], norm, 12); + memcpy(constants.posnormalmatrix[4], norm+3, 12); + memcpy(constants.posnormalmatrix[5], norm+6, 12); + dirty = true; } if (bTexMatricesChanged[0]) @@ -350,8 +301,9 @@ void VertexShaderManager::SetConstants() for (int i = 0; i < 4; ++i) { - SetMultiVSConstant4fv(C_TEXMATRICES + 3 * i, 3, fptrs[i]); + memcpy(constants.texmatrices[3*i], fptrs[i], 3*16); } + dirty = true; } if (bTexMatricesChanged[1]) @@ -364,18 +316,19 @@ void VertexShaderManager::SetConstants() for (int i = 0; i < 4; ++i) { - SetMultiVSConstant4fv(C_TEXMATRICES+3 * i + 12, 3, fptrs[i]); + memcpy(constants.texmatrices[3*i+12], fptrs[i], 3*16); } + dirty = true; } if (bViewportChanged) { bViewportChanged = false; - SetVSConstant4f(C_DEPTHPARAMS, - xfregs.viewport.farZ / 16777216.0f, - xfregs.viewport.zRange / 16777216.0f, - -1.f / (float)g_renderer->EFBToScaledX((int)ceil(2.0f * xfregs.viewport.wd)), - 1.f / (float)g_renderer->EFBToScaledY((int)ceil(-2.0f * xfregs.viewport.ht))); + constants.depthparams[0] = xfregs.viewport.farZ / 16777216.0f; + constants.depthparams[1] = xfregs.viewport.zRange / 16777216.0f; + constants.depthparams[2] = -1.f / g_renderer->EFBToScaledX(ceilf(2.0f * xfregs.viewport.wd)); + constants.depthparams[3] = 1.f / g_renderer->EFBToScaledY(ceilf(-2.0f * xfregs.viewport.ht)); + dirty = true; // This is so implementation-dependent that we can't have it here. UpdateViewport(s_viewportCorrection); bProjectionChanged = true; @@ -504,8 +457,7 @@ void VertexShaderManager::SetConstants() Matrix44::Set(mtxB, g_fProjectionMatrix); Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA - - SetMultiVSConstant4fv(C_PROJECTION, 4, mtxB.data); + memcpy(constants.projection, mtxB.data, 4*16); } else { @@ -514,8 +466,9 @@ void VertexShaderManager::SetConstants() Matrix44 correctedMtx; Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx); - SetMultiVSConstant4fv(C_PROJECTION, 4, correctedMtx.data); + memcpy(constants.projection, correctedMtx.data, 4*16); } + dirty = true; } } From 50c404ce4af8f256aeac1c6764c0d92e675afab9 Mon Sep 17 00:00:00 2001 From: degasus Date: Wed, 9 Oct 2013 16:33:45 +0200 Subject: [PATCH 8/9] VideoCommon: fix dstAlpha --- Source/Core/VideoCommon/Src/PixelShaderManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 8afcb4429b..15d7e5def1 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -138,7 +138,7 @@ void PixelShaderManager::SetAlpha(const AlphaTest& alpha) void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha) { - constants.alpha[3] = alpha.alpha; + constants.alpha[3] = alpha.alpha / 255.0f; dirty = true; } From 2754c1132ee1f3e4cf1045bd50b77425cd308411 Mon Sep 17 00:00:00 2001 From: degasus Date: Sat, 12 Oct 2013 17:56:41 +0200 Subject: [PATCH 9/9] VideoCommon: reimplement Dirty() in PixelShaderManager This isn't needed in VertexShaderManager as it's still in the old dirty flag way. But it's very importend for PixelShaderManager as some float4s aren't initialized as 0.0f --- Source/Core/VideoCommon/Src/BPStructs.cpp | 14 ++-- .../VideoCommon/Src/PixelShaderManager.cpp | 71 ++++++++++++------- .../Core/VideoCommon/Src/PixelShaderManager.h | 10 +-- 3 files changed, 58 insertions(+), 37 deletions(-) diff --git a/Source/Core/VideoCommon/Src/BPStructs.cpp b/Source/Core/VideoCommon/Src/BPStructs.cpp index 785546fea7..cc169ffe8f 100644 --- a/Source/Core/VideoCommon/Src/BPStructs.cpp +++ b/Source/Core/VideoCommon/Src/BPStructs.cpp @@ -173,11 +173,11 @@ void BPWritten(const BPCmd& bp) break; case BPMEM_RAS1_SS0: // Index Texture Coordinate Scale 0 if(bp.changes) - PixelShaderManager::SetIndTexScaleChanged(0x03); + PixelShaderManager::SetIndTexScaleChanged(false); break; case BPMEM_RAS1_SS1: // Index Texture Coordinate Scale 1 if(bp.changes) - PixelShaderManager::SetIndTexScaleChanged(0x0c); + PixelShaderManager::SetIndTexScaleChanged(true); break; // ---------------- // Scissor Control @@ -225,7 +225,7 @@ void BPWritten(const BPCmd& bp) { PRIM_LOG("constalpha: alp=%d, en=%d", bpmem.dstalpha.alpha, bpmem.dstalpha.enable); if(bp.changes & 0xFF) - PixelShaderManager::SetDestAlpha(bpmem.dstalpha); + PixelShaderManager::SetDestAlpha(); if(bp.changes & 0x100) SetBlendMode(); break; @@ -364,14 +364,14 @@ void BPWritten(const BPCmd& bp) PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", bpmem.alpha_test.ref0, bpmem.alpha_test.ref1, bpmem.alpha_test.comp0, bpmem.alpha_test.comp1, bpmem.alpha_test.logic); if(bp.changes & 0xFFFF) - PixelShaderManager::SetAlpha(bpmem.alpha_test); + PixelShaderManager::SetAlpha(); if(bp.changes) g_renderer->SetColorMask(); break; case BPMEM_BIAS: // BIAS PRIM_LOG("ztex bias=0x%x", bpmem.ztex1.bias); if(bp.changes) - PixelShaderManager::SetZTextureBias(bpmem.ztex1.bias); + PixelShaderManager::SetZTextureBias(); break; case BPMEM_ZTEX2: // Z Texture type { @@ -636,9 +636,9 @@ void BPWritten(const BPCmd& bp) // don't compare with changes! int num = (bp.address >> 1) & 0x3; if ((bp.address & 1) == 0) - PixelShaderManager::SetColorChanged(bpmem.tevregs[num].low.type, num, false); + PixelShaderManager::SetColorChanged(bpmem.tevregs[num].low.type, num); else - PixelShaderManager::SetColorChanged(bpmem.tevregs[num].high.type, num, true); + PixelShaderManager::SetColorChanged(bpmem.tevregs[num].high.type, num); } break; diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp index 15d7e5def1..c773e734d6 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.cpp @@ -27,7 +27,35 @@ void PixelShaderManager::Dirty() { s_bFogRangeAdjustChanged = true; nLightsChanged[0] = 0; nLightsChanged[1] = 0x80; - dirty = true; + + SetColorChanged(0, 0); + SetColorChanged(0, 1); + SetColorChanged(0, 2); + SetColorChanged(0, 3); + SetColorChanged(1, 0); + SetColorChanged(1, 1); + SetColorChanged(1, 2); + SetColorChanged(1, 3); + SetAlpha(); + SetDestAlpha(); + SetZTextureBias(); + SetViewportChanged(); + SetIndTexScaleChanged(false); + SetIndTexScaleChanged(true); + SetIndMatrixChanged(0); + SetIndMatrixChanged(1); + SetIndMatrixChanged(2); + SetZTextureTypeChanged(); + SetTexCoordChanged(0); + SetTexCoordChanged(1); + SetTexCoordChanged(2); + SetTexCoordChanged(3); + SetTexCoordChanged(4); + SetTexCoordChanged(5); + SetTexCoordChanged(6); + SetTexCoordChanged(7); + SetFogColorChanged(); + SetFogParamChanged(); } void PixelShaderManager::Shutdown() @@ -111,34 +139,28 @@ void PixelShaderManager::SetConstants(u32 components) // TODO: Move conversion out, only store the raw color value // and update it when the shader constant is set, only. // TODO: Conversion should be checked in the context of tev_fixes.. -void PixelShaderManager::SetColorChanged(int type, int num, bool high) +void PixelShaderManager::SetColorChanged(int type, int num) { float4* c = type ? constants.kcolors : constants.colors; - if (!high) - { - c[num][0] = bpmem.tevregs[num].low.a / 255.0f; - c[num][3] = bpmem.tevregs[num].low.b / 255.0f; - } - else - { - c[num][2] = bpmem.tevregs[num].high.a / 255.0f; - c[num][1] = bpmem.tevregs[num].high.b / 255.0f; - } + c[num][0] = bpmem.tevregs[num].low.a / 255.0f; + c[num][3] = bpmem.tevregs[num].low.b / 255.0f; + c[num][2] = bpmem.tevregs[num].high.a / 255.0f; + c[num][1] = bpmem.tevregs[num].high.b / 255.0f; dirty = true; PRIM_LOG("pixel %scolor%d: %f %f %f %f\n", type?"k":"", num, c[num][0], c[num][1], c[num][2], c[num][3]); } -void PixelShaderManager::SetAlpha(const AlphaTest& alpha) +void PixelShaderManager::SetAlpha() { - constants.alpha[0] = alpha.ref0 / 255.0f; - constants.alpha[1] = alpha.ref1 / 255.0f; + constants.alpha[0] = bpmem.alpha_test.ref0 / 255.0f; + constants.alpha[1] = bpmem.alpha_test.ref1 / 255.0f; dirty = true; } -void PixelShaderManager::SetDestAlpha(const ConstantAlpha& alpha) +void PixelShaderManager::SetDestAlpha() { - constants.alpha[3] = alpha.alpha / 255.0f; + constants.alpha[3] = bpmem.dstalpha.alpha / 255.0f; dirty = true; } @@ -153,9 +175,9 @@ void PixelShaderManager::SetTexDims(int texmapid, u32 width, u32 height, u32 wra constants.texdims[texmapid][1] = 1.0f/height; } -void PixelShaderManager::SetZTextureBias(u32 bias) +void PixelShaderManager::SetZTextureBias() { - constants.zbias[1][3] = bias/16777215.0f; + constants.zbias[1][3] = bpmem.ztex1.bias/16777215.0f; dirty = true; } @@ -168,13 +190,12 @@ void PixelShaderManager::SetViewportChanged() s_bFogRangeAdjustChanged = true; // TODO: Shouldn't be necessary with an accurate fog range adjust implementation } -void PixelShaderManager::SetIndTexScaleChanged(u8 stagemask) +void PixelShaderManager::SetIndTexScaleChanged(bool high) { - bool high_stage = stagemask == 0x0c; - constants.indtexscale[high_stage][0] = bpmem.texscale[high_stage].getScaleS(0); - constants.indtexscale[high_stage][1] = bpmem.texscale[high_stage].getScaleT(0); - constants.indtexscale[high_stage][2] = bpmem.texscale[high_stage].getScaleS(1); - constants.indtexscale[high_stage][3] = bpmem.texscale[high_stage].getScaleT(1); + constants.indtexscale[high][0] = bpmem.texscale[high].getScaleS(0); + constants.indtexscale[high][1] = bpmem.texscale[high].getScaleT(0); + constants.indtexscale[high][2] = bpmem.texscale[high].getScaleS(1); + constants.indtexscale[high][3] = bpmem.texscale[high].getScaleT(1); dirty = true; } diff --git a/Source/Core/VideoCommon/Src/PixelShaderManager.h b/Source/Core/VideoCommon/Src/PixelShaderManager.h index 64ffbb59fd..c68ae569a2 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderManager.h +++ b/Source/Core/VideoCommon/Src/PixelShaderManager.h @@ -26,16 +26,16 @@ public: static void SetConstants(u32 components); // sets pixel shader constants // constant management, should be called after memory is committed - static void SetColorChanged(int type, int index, bool high); - static void SetAlpha(const AlphaTest& alpha); - static void SetDestAlpha(const ConstantAlpha& alpha); + static void SetColorChanged(int type, int index); + static void SetAlpha(); + static void SetDestAlpha(); static void SetTexDims(int texmapid, u32 width, u32 height, u32 wraps, u32 wrapt); - static void SetZTextureBias(u32 bias); + static void SetZTextureBias(); static void SetViewportChanged(); static void SetIndMatrixChanged(int matrixidx); static void SetTevKSelChanged(int id); static void SetZTextureTypeChanged(); - static void SetIndTexScaleChanged(u8 stagemask); + static void SetIndTexScaleChanged(bool high); static void SetTexCoordChanged(u8 texmapid); static void SetFogColorChanged(); static void SetFogParamChanged();