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

VideoCommon: flush vertex manager if components change

This commit is contained in:
Tillmann Karras 2015-11-01 22:39:31 +01:00
parent 491e149545
commit 983978ee66
15 changed files with 56 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
View File

@ -525,14 +525,14 @@ void PixelShaderCache::Shutdown()
g_ps_disk_cache.Close(); g_ps_disk_cache.Close();
} }
bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode)
{ {
PixelShaderUid uid; PixelShaderUid uid;
GetPixelShaderUid(uid, dstAlphaMode, API_D3D, components); GetPixelShaderUid(uid, dstAlphaMode, API_D3D);
if (g_ActiveConfig.bEnableShaderDebugging) if (g_ActiveConfig.bEnableShaderDebugging)
{ {
ShaderCode code; ShaderCode code;
GeneratePixelShaderCode(code, dstAlphaMode, API_D3D, components); GeneratePixelShaderCode(code, dstAlphaMode, API_D3D);
pixel_uid_checker.AddToIndexAndCheck(code, uid, "Pixel", "p"); pixel_uid_checker.AddToIndexAndCheck(code, uid, "Pixel", "p");
} }
@ -562,7 +562,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
// Need to compile a new shader // Need to compile a new shader
ShaderCode code; ShaderCode code;
GeneratePixelShaderCode(code, dstAlphaMode, API_D3D, components); GeneratePixelShaderCode(code, dstAlphaMode, API_D3D);
D3DBlob* pbytecode; D3DBlob* pbytecode;
if (!D3D::CompilePixelShader(code.GetBuffer(), &pbytecode)) if (!D3D::CompilePixelShader(code.GetBuffer(), &pbytecode))

2
Source/Core/VideoBackends/D3D/PixelShaderCache.h
View File

@ -20,7 +20,7 @@ public:
static void Init(); static void Init();
static void Clear(); static void Clear();
static void Shutdown(); static void Shutdown();
static bool SetShader(DSTALPHA_MODE dstAlphaMode, u32 components); // TODO: Should be renamed to LoadShader static bool SetShader(DSTALPHA_MODE dstAlphaMode); // TODO: Should be renamed to LoadShader
static bool InsertByteCode(const PixelShaderUid &uid, const void* bytecode, unsigned int bytecodelen); static bool InsertByteCode(const PixelShaderUid &uid, const void* bytecode, unsigned int bytecodelen);
static ID3D11PixelShader* GetActiveShader() { return last_entry->shader; } static ID3D11PixelShader* GetActiveShader() { return last_entry->shader; }

6
Source/Core/VideoBackends/D3D/VertexManager.cpp
View File

@ -151,16 +151,14 @@ void VertexManager::Draw(u32 stride)
void VertexManager::vFlush(bool useDstAlpha) void VertexManager::vFlush(bool useDstAlpha)
{ {
u32 components = VertexLoaderManager::GetCurrentVertexFormat()->m_components;
if (!PixelShaderCache::SetShader( if (!PixelShaderCache::SetShader(
useDstAlpha ? DSTALPHA_DUAL_SOURCE_BLEND : DSTALPHA_NONE, components)) useDstAlpha ? DSTALPHA_DUAL_SOURCE_BLEND : DSTALPHA_NONE))
{ {
GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");}); GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");});
return; return;
} }
if (!VertexShaderCache::SetShader(components)) if (!VertexShaderCache::SetShader())
{ {
GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");}); GFX_DEBUGGER_PAUSE_LOG_AT(NEXT_ERROR,true,{printf("Fail to set pixel shader\n");});
return; return;

8
Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
View File

@ -184,14 +184,14 @@ void VertexShaderCache::Shutdown()
g_vs_disk_cache.Close(); g_vs_disk_cache.Close();
} }
bool VertexShaderCache::SetShader(u32 components) bool VertexShaderCache::SetShader()
{ {
VertexShaderUid uid; VertexShaderUid uid;
GetVertexShaderUid(uid, components, API_D3D); GetVertexShaderUid(uid, API_D3D);
if (g_ActiveConfig.bEnableShaderDebugging) if (g_ActiveConfig.bEnableShaderDebugging)
{ {
ShaderCode code; ShaderCode code;
GenerateVertexShaderCode(code, components, API_D3D); GenerateVertexShaderCode(code, API_D3D);
vertex_uid_checker.AddToIndexAndCheck(code, uid, "Vertex", "v"); vertex_uid_checker.AddToIndexAndCheck(code, uid, "Vertex", "v");
} }
@ -217,7 +217,7 @@ bool VertexShaderCache::SetShader(u32 components)
} }
ShaderCode code; ShaderCode code;
GenerateVertexShaderCode(code, components, API_D3D); GenerateVertexShaderCode(code, API_D3D);
D3DBlob* pbytecode = nullptr; D3DBlob* pbytecode = nullptr;
D3D::CompileVertexShader(code.GetBuffer(), &pbytecode); D3D::CompileVertexShader(code.GetBuffer(), &pbytecode);

2
Source/Core/VideoBackends/D3D/VertexShaderCache.h
View File

@ -19,7 +19,7 @@ public:
static void Init(); static void Init();
static void Clear(); static void Clear();
static void Shutdown(); static void Shutdown();
static bool SetShader(u32 components); // TODO: Should be renamed to LoadShader static bool SetShader(); // TODO: Should be renamed to LoadShader
static ID3D11VertexShader* GetActiveShader() { return last_entry->shader; } static ID3D11VertexShader* GetActiveShader() { return last_entry->shader; }
static D3DBlob* GetActiveShaderBytecode() { return last_entry->bytecode; } static D3DBlob* GetActiveShaderBytecode() { return last_entry->bytecode; }

18
Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
View File

@ -176,10 +176,10 @@ void ProgramShaderCache::UploadConstants()
} }
} }
SHADER* ProgramShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components, u32 primitive_type) SHADER* ProgramShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 primitive_type)
{ {
SHADERUID uid; SHADERUID uid;
GetShaderId(&uid, dstAlphaMode, components, primitive_type); GetShaderId(&uid, dstAlphaMode, primitive_type);
// Check if the shader is already set // Check if the shader is already set
if (last_entry) if (last_entry)
@ -214,8 +214,8 @@ SHADER* ProgramShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components
ShaderCode vcode; ShaderCode vcode;
ShaderCode pcode; ShaderCode pcode;
ShaderCode gcode; ShaderCode gcode;
GenerateVertexShaderCode(vcode, components, API_OPENGL); GenerateVertexShaderCode(vcode, API_OPENGL);
GeneratePixelShaderCode(pcode, dstAlphaMode, API_OPENGL, components); GeneratePixelShaderCode(pcode, dstAlphaMode, API_OPENGL);
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders && !uid.guid.GetUidData()->IsPassthrough()) if (g_ActiveConfig.backend_info.bSupportsGeometryShaders && !uid.guid.GetUidData()->IsPassthrough())
GenerateGeometryShaderCode(gcode, primitive_type, API_OPENGL); GenerateGeometryShaderCode(gcode, primitive_type, API_OPENGL);
@ -396,20 +396,20 @@ GLuint ProgramShaderCache::CompileSingleShader(GLuint type, const char* code)
return result; return result;
} }
void ProgramShaderCache::GetShaderId(SHADERUID* uid, DSTALPHA_MODE dstAlphaMode, u32 components, u32 primitive_type) void ProgramShaderCache::GetShaderId(SHADERUID* uid, DSTALPHA_MODE dstAlphaMode, u32 primitive_type)
{ {
GetPixelShaderUid(uid->puid, dstAlphaMode, API_OPENGL, components); GetPixelShaderUid(uid->puid, dstAlphaMode, API_OPENGL);
GetVertexShaderUid(uid->vuid, components, API_OPENGL); GetVertexShaderUid(uid->vuid, API_OPENGL);
GetGeometryShaderUid(uid->guid, primitive_type, API_OPENGL); GetGeometryShaderUid(uid->guid, primitive_type, API_OPENGL);
if (g_ActiveConfig.bEnableShaderDebugging) if (g_ActiveConfig.bEnableShaderDebugging)
{ {
ShaderCode pcode; ShaderCode pcode;
GeneratePixelShaderCode(pcode, dstAlphaMode, API_OPENGL, components); GeneratePixelShaderCode(pcode, dstAlphaMode, API_OPENGL);
pixel_uid_checker.AddToIndexAndCheck(pcode, uid->puid, "Pixel", "p"); pixel_uid_checker.AddToIndexAndCheck(pcode, uid->puid, "Pixel", "p");
ShaderCode vcode; ShaderCode vcode;
GenerateVertexShaderCode(vcode, components, API_OPENGL); GenerateVertexShaderCode(vcode, API_OPENGL);
vertex_uid_checker.AddToIndexAndCheck(vcode, uid->vuid, "Vertex", "v"); vertex_uid_checker.AddToIndexAndCheck(vcode, uid->vuid, "Vertex", "v");
ShaderCode gcode; ShaderCode gcode;

4
Source/Core/VideoBackends/OGL/ProgramShaderCache.h
View File

@ -88,8 +88,8 @@ public:
static PCacheEntry GetShaderProgram(); static PCacheEntry GetShaderProgram();
static SHADER* SetShader(DSTALPHA_MODE dstAlphaMode, u32 components, u32 primitive_type); static SHADER* SetShader(DSTALPHA_MODE dstAlphaMode, u32 primitive_type);
static void GetShaderId(SHADERUID *uid, DSTALPHA_MODE dstAlphaMode, u32 components, u32 primitive_type); static void GetShaderId(SHADERUID *uid, DSTALPHA_MODE dstAlphaMode, u32 primitive_type);
static bool CompileShader(SHADER &shader, const char* vcode, const char* pcode, const char* gcode = nullptr); static bool CompileShader(SHADER &shader, const char* vcode, const char* pcode, const char* gcode = nullptr);
static GLuint CompileSingleShader(GLuint type, const char *code); static GLuint CompileSingleShader(GLuint type, const char *code);

6
Source/Core/VideoBackends/OGL/VertexManager.cpp
View File

@ -160,11 +160,11 @@ void VertexManager::vFlush(bool useDstAlpha)
// the same pass as regular rendering. // the same pass as regular rendering.
if (useDstAlpha && dualSourcePossible) if (useDstAlpha && dualSourcePossible)
{ {
ProgramShaderCache::SetShader(DSTALPHA_DUAL_SOURCE_BLEND, nativeVertexFmt->m_components, current_primitive_type); ProgramShaderCache::SetShader(DSTALPHA_DUAL_SOURCE_BLEND, current_primitive_type);
} }
else else
{ {
ProgramShaderCache::SetShader(DSTALPHA_NONE, nativeVertexFmt->m_components, current_primitive_type); ProgramShaderCache::SetShader(DSTALPHA_NONE, current_primitive_type);
} }
// upload global constants // upload global constants
@ -178,7 +178,7 @@ void VertexManager::vFlush(bool useDstAlpha)
// run through vertex groups again to set alpha // run through vertex groups again to set alpha
if (useDstAlpha && !dualSourcePossible) if (useDstAlpha && !dualSourcePossible)
{ {
ProgramShaderCache::SetShader(DSTALPHA_ALPHA_PASS, nativeVertexFmt->m_components, current_primitive_type); ProgramShaderCache::SetShader(DSTALPHA_ALPHA_PASS, current_primitive_type);
// only update alpha // only update alpha
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);

3
Source/Core/VideoCommon/NativeVertexFormat.h
View File

@ -114,9 +114,6 @@ public:
u32 GetVertexStride() const { return vtx_decl.stride; } u32 GetVertexStride() const { return vtx_decl.stride; }
const PortableVertexDeclaration& GetVertexDeclaration() const { return vtx_decl; } const PortableVertexDeclaration& GetVertexDeclaration() const { return vtx_decl; }
// TODO: move this under private:
u32 m_components; // VB_HAS_X. Bitmask telling what vertex components are present.
protected: protected:
// Let subclasses construct. // Let subclasses construct.
NativeVertexFormat() {} NativeVertexFormat() {}

17
Source/Core/VideoCommon/PixelShaderGen.cpp
View File

@ -14,6 +14,7 @@
#include "VideoCommon/LightingShaderGen.h" #include "VideoCommon/LightingShaderGen.h"
#include "VideoCommon/NativeVertexFormat.h" #include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/PixelShaderGen.h" #include "VideoCommon/PixelShaderGen.h"
#include "VideoCommon/VertexLoaderManager.h"
#include "VideoCommon/VertexShaderGen.h" #include "VideoCommon/VertexShaderGen.h"
#include "VideoCommon/VideoConfig.h" #include "VideoCommon/VideoConfig.h"
#include "VideoCommon/XFMemory.h" // for texture projection mode #include "VideoCommon/XFMemory.h" // for texture projection mode
@ -165,8 +166,9 @@ template<class T> static inline void WriteAlphaTest(T& out, pixel_shader_uid_dat
template<class T> static inline void WriteFog(T& out, pixel_shader_uid_data* uid_data); template<class T> static inline void WriteFog(T& out, pixel_shader_uid_data* uid_data);
template<class T> template<class T>
static inline void GeneratePixelShader(T& out, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components) static inline void GeneratePixelShader(T& out, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType)
{ {
const u32 components = VertexLoaderManager::g_current_components;
// Non-uid template parameters will write to the dummy data (=> gets optimized out) // Non-uid template parameters will write to the dummy data (=> gets optimized out)
pixel_shader_uid_data dummy_data; pixel_shader_uid_data dummy_data;
pixel_shader_uid_data* uid_data = out.template GetUidData<pixel_shader_uid_data>(); pixel_shader_uid_data* uid_data = out.template GetUidData<pixel_shader_uid_data>();
@ -1168,18 +1170,17 @@ static inline void WriteFog(T& out, pixel_shader_uid_data* uid_data)
out.Write("\tprev.rgb = (prev.rgb * (256 - ifog) + " I_FOGCOLOR".rgb * ifog) >> 8;\n"); out.Write("\tprev.rgb = (prev.rgb * (256 - ifog) + " I_FOGCOLOR".rgb * ifog) >> 8;\n");
} }
void GetPixelShaderUid(PixelShaderUid& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components) void GetPixelShaderUid(PixelShaderUid& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType)
{ {
GeneratePixelShader<PixelShaderUid>(object, dstAlphaMode, ApiType, components); GeneratePixelShader<PixelShaderUid>(object, dstAlphaMode, ApiType);
} }
void GeneratePixelShaderCode(ShaderCode& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components) void GeneratePixelShaderCode(ShaderCode& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType)
{ {
GeneratePixelShader<ShaderCode>(object, dstAlphaMode, ApiType, components); GeneratePixelShader<ShaderCode>(object, dstAlphaMode, ApiType);
} }
void GetPixelShaderConstantProfile(PixelShaderConstantProfile& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components) void GetPixelShaderConstantProfile(PixelShaderConstantProfile& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType)
{ {
GeneratePixelShader<PixelShaderConstantProfile>(object, dstAlphaMode, ApiType, components); GeneratePixelShader<PixelShaderConstantProfile>(object, dstAlphaMode, ApiType);
} }

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

@ -116,6 +116,6 @@ struct pixel_shader_uid_data
typedef ShaderUid<pixel_shader_uid_data> PixelShaderUid; typedef ShaderUid<pixel_shader_uid_data> PixelShaderUid;
typedef ShaderConstantProfile PixelShaderConstantProfile; // TODO: Obsolete typedef ShaderConstantProfile PixelShaderConstantProfile; // TODO: Obsolete
void GeneratePixelShaderCode(ShaderCode& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components); void GeneratePixelShaderCode(ShaderCode& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType);
void GetPixelShaderUid(PixelShaderUid& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components); void GetPixelShaderUid(PixelShaderUid& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType);
void GetPixelShaderConstantProfile(PixelShaderConstantProfile& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components); void GetPixelShaderConstantProfile(PixelShaderConstantProfile& object, DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType);

8
Source/Core/VideoCommon/VertexLoaderManager.cpp
View File

@ -32,6 +32,7 @@ u32 position_matrix_index[3];
typedef std::unordered_map<PortableVertexDeclaration, std::unique_ptr<NativeVertexFormat>> NativeVertexFormatMap; typedef std::unordered_map<PortableVertexDeclaration, std::unique_ptr<NativeVertexFormat>> NativeVertexFormatMap;
static NativeVertexFormatMap s_native_vertex_map; static NativeVertexFormatMap s_native_vertex_map;
static NativeVertexFormat* s_current_vtx_fmt; static NativeVertexFormat* s_current_vtx_fmt;
u32 g_current_components;
typedef std::unordered_map<VertexLoaderUID, std::unique_ptr<VertexLoaderBase>> VertexLoaderMap; typedef std::unordered_map<VertexLoaderUID, std::unique_ptr<VertexLoaderBase>> VertexLoaderMap;
static std::mutex s_vertex_loader_map_lock; static std::mutex s_vertex_loader_map_lock;
@ -153,7 +154,6 @@ static VertexLoaderBase* RefreshLoader(int vtx_attr_group, bool preprocess = fal
{ {
native.reset(g_vertex_manager->CreateNativeVertexFormat()); native.reset(g_vertex_manager->CreateNativeVertexFormat());
native->Initialize(format); native->Initialize(format);
native->m_components = loader->m_native_components;
} }
loader->m_native_vertex_format = native.get(); loader->m_native_vertex_format = native.get();
} }
@ -185,9 +185,13 @@ int RunVertices(int vtx_attr_group, int primitive, int count, DataReader src, bo
return size; return size;
// If the native vertex format changed, force a flush. // If the native vertex format changed, force a flush.
if (loader->m_native_vertex_format != s_current_vtx_fmt) if (loader->m_native_vertex_format != s_current_vtx_fmt ||
loader->m_native_components != g_current_components)
{
VertexManager::Flush(); VertexManager::Flush();
}
s_current_vtx_fmt = loader->m_native_vertex_format; s_current_vtx_fmt = loader->m_native_vertex_format;
g_current_components = loader->m_native_components;
// if cull mode is CULL_ALL, tell VertexManager to skip triangles and quads. // if cull mode is CULL_ALL, tell VertexManager to skip triangles and quads.
// They still need to go through vertex loading, because we need to calculate a zfreeze refrence slope. // They still need to go through vertex loading, because we need to calculate a zfreeze refrence slope.

3
Source/Core/VideoCommon/VertexLoaderManager.h
View File

@ -33,5 +33,8 @@ namespace VertexLoaderManager
// These arrays are in reverse order. // These arrays are in reverse order.
extern float position_cache[3][4]; extern float position_cache[3][4];
extern u32 position_matrix_index[3]; extern u32 position_matrix_index[3];
// VB_HAS_X. Bitmask telling what vertex components are present.
extern u32 g_current_components;
} }

12
Source/Core/VideoCommon/VertexShaderGen.cpp
View File

@ -9,14 +9,16 @@
#include "VideoCommon/DriverDetails.h" #include "VideoCommon/DriverDetails.h"
#include "VideoCommon/LightingShaderGen.h" #include "VideoCommon/LightingShaderGen.h"
#include "VideoCommon/NativeVertexFormat.h" #include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/VertexLoaderManager.h"
#include "VideoCommon/VertexShaderGen.h" #include "VideoCommon/VertexShaderGen.h"
#include "VideoCommon/VideoConfig.h" #include "VideoCommon/VideoConfig.h"
static char text[16768]; static char text[16768];
template<class T> template<class T>
static inline void GenerateVertexShader(T& out, u32 components, API_TYPE api_type) static inline void GenerateVertexShader(T& out, API_TYPE api_type)
{ {
const u32 components = VertexLoaderManager::g_current_components;
// Non-uid template parameters will write to the dummy data (=> gets optimized out) // Non-uid template parameters will write to the dummy data (=> gets optimized out)
vertex_shader_uid_data dummy_data; vertex_shader_uid_data dummy_data;
vertex_shader_uid_data* uid_data = out.template GetUidData<vertex_shader_uid_data>(); vertex_shader_uid_data* uid_data = out.template GetUidData<vertex_shader_uid_data>();
@ -394,12 +396,12 @@ static inline void GenerateVertexShader(T& out, u32 components, API_TYPE api_typ
} }
} }
void GetVertexShaderUid(VertexShaderUid& object, u32 components, API_TYPE api_type) void GetVertexShaderUid(VertexShaderUid& object, API_TYPE api_type)
{ {
GenerateVertexShader<VertexShaderUid>(object, components, api_type); GenerateVertexShader<VertexShaderUid>(object, api_type);
} }
void GenerateVertexShaderCode(ShaderCode& object, u32 components, API_TYPE api_type) void GenerateVertexShaderCode(ShaderCode& object, API_TYPE api_type)
{ {
GenerateVertexShader<ShaderCode>(object, components, api_type); GenerateVertexShader<ShaderCode>(object, api_type);
} }

4
Source/Core/VideoCommon/VertexShaderGen.h
View File

@ -60,5 +60,5 @@ struct vertex_shader_uid_data
typedef ShaderUid<vertex_shader_uid_data> VertexShaderUid; typedef ShaderUid<vertex_shader_uid_data> VertexShaderUid;
void GetVertexShaderUid(VertexShaderUid& object, u32 components, API_TYPE api_type); void GetVertexShaderUid(VertexShaderUid& object, API_TYPE api_type);
void GenerateVertexShaderCode(ShaderCode& object, u32 components, API_TYPE api_type); void GenerateVertexShaderCode(ShaderCode& object, API_TYPE api_type);