ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'const_buffer_rework'

This commit is contained in:
degasus 2013-10-13 14:14:32 +02:00
parent 0753ce5bda 2754c1132e
commit 4dc1881f58
24 changed files with 392 additions and 893 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
Source/Core/VideoBackends/D3D/Src/PixelShaderCache.cpp
View File

@ -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,50 +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.
// 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);
pscbufchanged = true;
}
} // DX11

9
Source/Core/VideoBackends/D3D/Src/Render.h
View File

@ -51,15 +51,6 @@ public:
bool SaveScreenshot(const std::string &filename, const TargetRectangle &rc);
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);
};
}

64
Source/Core/VideoBackends/D3D/Src/VertexShaderCache.cpp
View File

@ -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,39 +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.
// 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;
}
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

2
Source/Core/VideoBackends/OGL/CMakeLists.txt
View File

@ -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

4
Source/Core/VideoBackends/OGL/OGL.vcxproj
View File

@ -151,7 +151,6 @@
<ClCompile Include="Src\main.cpp" />
<ClCompile Include="Src\NativeVertexFormat.cpp" />
<ClCompile Include="Src\PerfQuery.cpp" />
<ClCompile Include="Src\PixelShaderCache.cpp" />
<ClCompile Include="Src\PostProcessing.cpp" />
<ClCompile Include="Src\ProgramShaderCache.cpp" />
<ClCompile Include="Src\RasterFont.cpp" />
@ -169,7 +168,6 @@
<ClCompile Include="Src\TextureCache.cpp" />
<ClCompile Include="Src\TextureConverter.cpp" />
<ClCompile Include="Src\VertexManager.cpp" />
<ClCompile Include="Src\VertexShaderCache.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Src\FramebufferManager.h" />
@ -203,4 +201,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
</Project>

104
Source/Core/VideoBackends/OGL/Src/PixelShaderCache.cpp
View File

@ -1,104 +0,0 @@
// Copyright 2013 Dolphin Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.
#include "Globals.h"
#include "GLUtil.h"
#include <cmath>
#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
{
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)
{
ProgramShaderCache::SetMultiPSConstant4fv(const_number, f, count);
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, count);
return;
}
}
}
} // namespace OGL

104
Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.cpp
View File

@ -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<VertexShaderUid,VertexShaderCode> 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,33 @@ const char *UniformNames[NUM_UNIFORMS] =
I_DEPTHPARAMS,
};
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 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
void SHADER::SetProgramVariables()
{
// glsl shader must be bind to set samplers
@ -162,30 +191,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]);
}
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]);
}
ADDSTAT(stats.thisFrame.bytesUniformStreamed, s_ubo_buffer_size);
}
}
GLuint ProgramShaderCache::GetCurrentProgram(void)
@ -419,22 +461,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 +543,6 @@ void ProgramShaderCache::Shutdown(void)
{
delete s_buffer;
s_buffer = 0;
delete [] s_ubo_buffer;
s_ubo_buffer = 0;
}
}

9
Source/Core/VideoBackends/OGL/Src/ProgramShaderCache.h
View File

@ -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<PixelShaderUid,PixelShaderCode> pixel_uid_checker;
static UidChecker<VertexShaderUid,VertexShaderCode> 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

9
Source/Core/VideoBackends/OGL/Src/Render.h
View File

@ -81,15 +81,6 @@ 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:
void UpdateEFBCache(EFBAccessType type, u32 cacheRectIdx, const EFBRectangle& efbPixelRc, const TargetRectangle& targetPixelRc, const u32* data);
};

2
Source/Core/VideoBackends/OGL/Src/TextureConverter.cpp
View File

@ -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;

130
Source/Core/VideoBackends/OGL/Src/VertexShaderCache.cpp
View File

@ -1,130 +0,0 @@
// Copyright 2013 Dolphin Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.
#include <math.h>
#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 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)
{
ProgramShaderCache::SetMultiVSConstant4fv(const_number, f, 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, 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;
}
}
}
} // namespace OGL

35
Source/Core/VideoCommon/Src/BPStructs.cpp
View File

@ -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(false);
break;
case BPMEM_RAS1_SS1: // Index Texture Coordinate Scale 1
PixelShaderManager::SetIndTexScaleChanged(0x0c);
if(bp.changes)
PixelShaderManager::SetIndTexScaleChanged(true);
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();
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();
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();
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
@ -627,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;

42
Source/Core/VideoCommon/Src/ConstantManager.h Normal file
View File

@ -0,0 +1,42 @@
// 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 u32 uint4[4];
typedef s32 int4[4];
struct PixelShaderConstants
{
float4 colors[4];
float4 kcolors[4];
float4 alpha;
float4 texdims[8];
float4 zbias[2];
float4 indtexscale[2];
float4 indtexmtx[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

14
Source/Core/VideoCommon/Src/PixelShaderGen.h
View File

@ -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
@ -43,19 +44,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[] = { {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 },
};
#pragma pack(1)
struct pixel_shader_uid_data
{

503
Source/Core/VideoCommon/Src/PixelShaderManager.cpp
View File

@ -11,58 +11,51 @@
#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;
inline void SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
{
g_renderer->SetPSConstant4f(const_number, f1, f2, f3, f4);
}
inline void SetPSConstant4fv(unsigned int const_number, const float *f)
{
g_renderer->SetPSConstant4fv(const_number, f);
}
inline void SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f)
{
g_renderer->SetMultiPSConstant4fv(const_number, count, f);
}
PixelShaderConstants PixelShaderManager::constants;
bool PixelShaderManager::dirty;
void PixelShaderManager::Init()
{
lastAlpha = 0;
memset(lastTexDims, 0, sizeof(lastTexDims));
lastZBias = 0;
memset(lastRGBAfull, 0, sizeof(lastRGBAfull));
memset(&constants, 0, sizeof(constants));
Dirty();
}
void PixelShaderManager::Dirty()
{
s_nColorsChanged[0] = s_nColorsChanged[1] = 15;
s_nTexDimsChanged = 0xFF;
s_nIndTexScaleChanged = 0xFF;
s_nIndTexMtxChanged = 15;
s_bAlphaChanged = s_bZBiasChanged = s_bZTextureTypeChanged = s_bDepthRangeChanged = true;
s_bFogRangeAdjustChanged = s_bFogColorChanged = s_bFogParamChanged = true;
s_bFogRangeAdjustChanged = true;
nLightsChanged[0] = 0; nLightsChanged[1] = 0x80;
nMaterialsChanged = 15;
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()
@ -72,169 +65,10 @@ void PixelShaderManager::Shutdown()
void PixelShaderManager::SetConstants(u32 components)
{
if (g_ActiveConfig.backend_info.APIType == API_OPENGL && !g_ActiveConfig.backend_info.bSupportsGLSLUBO)
Dirty();
for (int i = 0; i < 2; ++i)
{
if (s_nColorsChanged[i])
{
int baseind = i ? C_KCOLORS : C_COLORS;
for (int j = 0; j < 4; ++j)
{
if ((s_nColorsChanged[i] & (1 << j)))
{
SetPSConstant4fv(baseind+j, &lastRGBAfull[i][j][0]);
s_nColorsChanged[i] &= ~(1<<j);
}
}
}
}
if (s_nTexDimsChanged)
{
for (int i = 0; i < 8; ++i)
{
if ((s_nTexDimsChanged & (1<<i)))
{
SetPSTextureDims(i);
s_nTexDimsChanged &= ~(1<<i);
}
}
}
if (s_bAlphaChanged)
{
SetPSConstant4f(C_ALPHA, (lastAlpha&0xff)/255.0f, ((lastAlpha>>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;
@ -247,12 +81,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;
}
@ -269,12 +108,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)
@ -283,174 +120,173 @@ 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)
void PixelShaderManager::SetColorChanged(int type, int num)
{
float *pf = &lastRGBAfull[type][num][0];
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);
}
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);
}
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]);
float4* c = type ? constants.kcolors : constants.colors;
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()
{
if ((alpha.hex & 0xffff) != lastAlpha)
{
lastAlpha = (lastAlpha & ~0xffff) | (alpha.hex & 0xffff);
s_bAlphaChanged = true;
}
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()
{
if (alpha.alpha != (lastAlpha >> 16))
{
lastAlpha = (lastAlpha & ~0xff0000) | ((alpha.hex & 0xff) << 16);
s_bAlphaChanged = true;
}
constants.alpha[3] = bpmem.dstalpha.alpha / 255.0f;
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)
void PixelShaderManager::SetZTextureBias()
{
if (lastZBias != bias)
{
s_bZBiasChanged = true;
lastZBias = bias;
}
constants.zbias[1][3] = bpmem.ztex1.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)
void PixelShaderManager::SetIndTexScaleChanged(bool high)
{
s_nIndTexScaleChanged |= stagemask;
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;
}
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.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",
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()
@ -458,12 +294,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)
@ -484,18 +314,23 @@ 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);
if (p.GetMode() == PointerWrap::MODE_READ)
{
Dirty();

20
Source/Core/VideoCommon/Src/PixelShaderManager.h
View File

@ -8,13 +8,15 @@
#include "BPMemory.h"
#include "XFMemory.h"
#include "PixelShaderGen.h"
#include "ConstantManager.h"
class PointerWrap;
// The non-API dependent parts.
class PixelShaderManager
{
static void SetPSTextureDims(int texid);
public:
static void Init();
static void Dirty();
@ -24,23 +26,25 @@ 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();
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;
};

11
Source/Core/VideoCommon/Src/RenderBase.h
View File

@ -115,17 +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 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:
static void CalculateTargetScale(int x, int y, int &scaledX, int &scaledY);

6
Source/Core/VideoCommon/Src/TextureConversionShader.cpp
View File

@ -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

2
Source/Core/VideoCommon/Src/TextureConversionShader.h
View File

@ -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_

12
Source/Core/VideoCommon/Src/VertexShaderGen.h
View File

@ -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)
@ -53,17 +54,6 @@
#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 },
};
#pragma pack(1)
struct vertex_shader_uid_data

122
Source/Core/VideoCommon/Src/VertexShaderManager.cpp
View File

@ -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()
@ -43,26 +46,6 @@ void UpdateViewportWithCorrection()
UpdateViewport(s_viewportCorrection);
}
inline void SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
{
g_renderer->SetVSConstant4f(const_number, f1, f2, f3, f4);
}
inline void SetVSConstant4fv(unsigned int const_number, const float *f)
{
g_renderer->SetVSConstant4fv(const_number, f);
}
inline void SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f)
{
g_renderer->SetMultiVSConstant3fv(const_number, count, f);
}
inline void SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f)
{
g_renderer->SetMultiVSConstant4fv(const_number, count, f);
}
struct ProjectionHack
{
float sign;
@ -153,6 +136,7 @@ void VertexShaderManager::Init()
memset(&xfregs, 0, sizeof(xfregs));
memset(xfmem, 0, sizeof(xfmem));
memset(&constants, 0 , sizeof(constants));
ResetView();
// TODO: should these go inside ResetView()?
@ -187,21 +171,20 @@ void VertexShaderManager::Dirty()
bProjectionChanged = true;
nMaterialsChanged = 15;
dirty = true;
}
// Syncs the shader constant buffers with xfmem
// 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();
if (nTransformMatricesChanged[0] >= 0)
{
int startn = nTransformMatricesChanged[0] / 4;
int endn = (nTransformMatricesChanged[1] + 3) / 4;
const float* pstart = (const float*)&xfmem[startn * 4];
SetMultiVSConstant4fv(C_TRANSFORMMATRICES + startn, endn - startn, pstart);
memcpy(constants.transformmatrices[startn], &xfmem[startn * 4], (endn - startn) * 16);
dirty = true;
nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1;
}
@ -209,8 +192,11 @@ void VertexShaderManager::SetConstants()
{
int startn = nNormalMatricesChanged[0] / 3;
int endn = (nNormalMatricesChanged[1] + 2) / 3;
const float *pnstart = (const float*)&xfmem[XFMEM_NORMALMATRICES+3*startn];
SetMultiVSConstant3fv(C_NORMALMATRICES + startn, endn - startn, pnstart);
for(int i=startn; i<endn; i++)
{
memcpy(constants.normalmatrices[i], &xfmem[XFMEM_NORMALMATRICES + 3*i], 12);
}
dirty = true;
nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1;
}
@ -218,8 +204,8 @@ void VertexShaderManager::SetConstants()
{
int startn = nPostTransformMatricesChanged[0] / 4;
int endn = (nPostTransformMatricesChanged[1] + 3 ) / 4;
const float* pstart = (const float*)&xfmem[XFMEM_POSTMATRICES + startn * 4];
SetMultiVSConstant4fv(C_POSTTRANSFORMMATRICES + startn, endn - startn, pstart);
memcpy(constants.posttransformmatrices[startn], &xfmem[XFMEM_POSTMATRICES + startn * 4], (endn - startn) * 16);
dirty = true;
nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1;
}
@ -233,12 +219,10 @@ void VertexShaderManager::SetConstants()
for (int i = istart; i < iend; ++i)
{
u32 color = *(const u32*)(xfmemptr + 3);
float NormalizationCoef = 1 / 255.0f;
SetVSConstant4f(C_LIGHTS + 5 * i,
((color >> 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)
@ -249,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;
}
}
@ -286,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;
}
@ -306,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])
@ -321,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])
@ -335,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;
@ -475,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
{
@ -485,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;
}
}
@ -614,7 +596,7 @@ void VertexShaderManager::SetProjectionChanged()
bProjectionChanged = true;
}
void VertexShaderManager::SetMaterialColorChanged(int index)
void VertexShaderManager::SetMaterialColorChanged(int index, u32 color)
{
nMaterialsChanged |= (1 << index);
}
@ -669,6 +651,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)
{

6
Source/Core/VideoCommon/Src/VertexShaderManager.h
View File

@ -6,6 +6,7 @@
#define _VERTEXSHADERMANAGER_H
#include "VertexShaderGen.h"
#include "ConstantManager.h"
class PointerWrap;
@ -30,11 +31,14 @@ 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);
static void ResetView();
static VertexShaderConstants constants;
static bool dirty;
};
#endif // _VERTEXSHADERMANAGER_H

6
Source/Core/VideoCommon/Src/VideoCommon.h
View File

@ -132,11 +132,5 @@ inline unsigned int GetPow2(unsigned int val)
++ret;
return ret;
}
struct s_svar
{
const char *name;
const unsigned int reg;
const unsigned int size;
};
#endif // _VIDEOCOMMON_H

8
Source/Core/VideoCommon/Src/XFStructs.cpp
View File

@ -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;
}