diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.cpp b/Source/Core/VideoCommon/Src/PixelShaderGen.cpp index bc7a12304f..bc7b8cc375 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderGen.cpp +++ b/Source/Core/VideoCommon/Src/PixelShaderGen.cpp @@ -509,122 +509,117 @@ static void BuildSwapModeTable() } } +const char* WriteRegister(API_TYPE ApiType, const char *prefix, const u32 num) +{ + if(ApiType == API_GLSL) + return ""; // Nothing to do here + static char result[64]; + sprintf(result, " : register(%s%d)", prefix, num); + return result; +} + const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType, u32 components) { - setlocale(LC_NUMERIC, "C"); // Reset locale for compilation - text[sizeof(text) - 1] = 0x7C; // canary - - BuildSwapModeTable(); // Needed for WriteStage - int numStages = bpmem.genMode.numtevstages + 1; - int numTexgen = bpmem.genMode.numtexgens; - - char *p = text; - WRITE(p, "//Pixel Shader for TEV stages\n"); - WRITE(p, "//%i TEV stages, %i texgens, XXX IND stages\n", - numStages, numTexgen/*, bpmem.genMode.numindstages*/); - - int nIndirectStagesUsed = 0; - if (bpmem.genMode.numindstages > 0) - { - for (int i = 0; i < numStages; ++i) - { - if (bpmem.tevind[i].IsActive() && bpmem.tevind[i].bt < bpmem.genMode.numindstages) - nIndirectStagesUsed |= 1 << bpmem.tevind[i].bt; - } - } - DepthTextureEnable = (bpmem.ztex2.op != ZTEXTURE_DISABLE && !bpmem.zcontrol.zcomploc && bpmem.zmode.testenable && bpmem.zmode.updateenable) || g_ActiveConfig.bEnablePerPixelDepth ; - // Declare samplers - - if(ApiType != API_D3D11) - { - WRITE(p, "uniform sampler2D "); - } - else - { - WRITE(p, "sampler "); - } - - bool bfirst = true; - for (int i = 0; i < 8; ++i) - { - WRITE(p, "%s samp%d : register(s%d)", bfirst?"":",", i, i); - bfirst = false; - } - WRITE(p, ";\n"); - if(ApiType == API_D3D11) - { - WRITE(p, "Texture2D "); - bfirst = true; - for (int i = 0; i < 8; ++i) - { - WRITE(p, "%s Tex%d : register(t%d)", bfirst?"":",", i, i); - bfirst = false; - } - WRITE(p, ";\n"); - } - - WRITE(p, "\n"); - - WRITE(p, "uniform float4 " I_COLORS"[4] : register(c%d);\n", C_COLORS); - WRITE(p, "uniform float4 " I_KCOLORS"[4] : register(c%d);\n", C_KCOLORS); - WRITE(p, "uniform float4 " I_ALPHA"[1] : register(c%d);\n", C_ALPHA); - WRITE(p, "uniform float4 " I_TEXDIMS"[8] : register(c%d);\n", C_TEXDIMS); - WRITE(p, "uniform float4 " I_ZBIAS"[2] : register(c%d);\n", C_ZBIAS); - WRITE(p, "uniform float4 " I_INDTEXSCALE"[2] : register(c%d);\n", C_INDTEXSCALE); - WRITE(p, "uniform float4 " I_INDTEXMTX"[6] : register(c%d);\n", C_INDTEXMTX); - WRITE(p, "uniform float4 " I_FOG"[3] : register(c%d);\n", C_FOG); + WRITE(p, "uniform float4 "I_COLORS"[4] %s;\n", WriteRegister(ApiType, "c", C_COLORS)); + WRITE(p, "uniform float4 "I_KCOLORS"[4] %s;\n", WriteRegister(ApiType, "c", C_KCOLORS)); + WRITE(p, "uniform float4 "I_ALPHA"[1] %s;\n", WriteRegister(ApiType, "c", C_ALPHA)); + WRITE(p, "uniform float4 "I_TEXDIMS"[8] %s;\n", WriteRegister(ApiType, "c", C_TEXDIMS)); + WRITE(p, "uniform float4 "I_ZBIAS"[2] %s;\n", WriteRegister(ApiType, "c", C_ZBIAS)); + WRITE(p, "uniform float4 "I_INDTEXSCALE"[2] %s;\n", WriteRegister(ApiType, "c", C_INDTEXSCALE)); + WRITE(p, "uniform float4 "I_INDTEXMTX"[6] %s;\n", WriteRegister(ApiType, "c", C_INDTEXMTX)); + WRITE(p, "uniform float4 "I_FOG"[3] %s;\n", WriteRegister(ApiType, "c", C_FOG)); if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) { - WRITE(p,"typedef struct { float4 col; float4 cosatt; float4 distatt; float4 pos; float4 dir; } Light;\n"); - WRITE(p,"typedef struct { Light lights[8]; } s_" I_PLIGHTS";\n"); - WRITE(p, "uniform s_" I_PLIGHTS" " I_PLIGHTS" : register(c%d);\n", C_PLIGHTS); - WRITE(p, "typedef struct { float4 C0, C1, C2, C3; } s_" I_PMATERIALS";\n"); - WRITE(p, "uniform s_" I_PMATERIALS" " I_PMATERIALS" : register(c%d);\n", C_PMATERIALS); + WRITE(p, "uniform float4 "I_PLIGHTS"[40] %s;\n", WriteRegister(ApiType, "c", C_PLIGHTS)); + WRITE(p, "uniform float4 "I_PMATERIALS"[4] %s;\n", WriteRegister(ApiType, "c", C_PMATERIALS)); } - WRITE(p, "void main(\n"); - if(ApiType != API_D3D11) - { - WRITE(p, " out float4 ocol0 : COLOR0,%s%s\n in float4 rawpos : %s,\n", - dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND ? "\n out float4 ocol1 : COLOR1," : "", - DepthTextureEnable ? "\n out float depth : DEPTH," : "", - ApiType & API_OPENGL ? "WPOS" : ApiType & API_D3D9_SM20 ? "POSITION" : "VPOS"); - } - else - { - WRITE(p, " out float4 ocol0 : SV_Target0,%s%s\n in float4 rawpos : SV_Position,\n", - dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND ? "\n out float4 ocol1 : SV_Target1," : "", - DepthTextureEnable ? "\n out float depth : SV_Depth," : ""); - } - - WRITE(p, " in float4 colors_0 : COLOR0,\n"); - WRITE(p, " in float4 colors_1 : COLOR1"); - - // compute window position if needed because binding semantic WPOS is not widely supported - if (numTexgen < 7) - { - for (int i = 0; i < numTexgen; ++i) - WRITE(p, ",\n in float3 uv%d : TEXCOORD%d", i, i); - WRITE(p, ",\n in float4 clipPos : TEXCOORD%d", numTexgen); - if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) - WRITE(p, ",\n in float4 Normal : TEXCOORD%d", numTexgen + 1); - } - else - { - // wpos is in w of first 4 texcoords - if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + if(ApiType != API_GLSL) + { + WRITE(p, "void main(\n"); + if(ApiType != API_D3D11) { - for (int i = 0; i < 8; ++i) - WRITE(p, ",\n in float4 uv%d : TEXCOORD%d", i, i); + WRITE(p, " out float4 ocol0 : COLOR0,%s%s\n in float4 rawpos : %s,\n", + dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND ? "\n out float4 ocol1 : COLOR1," : "", + DepthTextureEnable ? "\n out float depth : DEPTH," : "", + ApiType & API_OPENGL ? "WPOS" : ApiType & API_D3D9_SM20 ? "POSITION" : "VPOS"); } else { - for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) - WRITE(p, ",\n in float%d uv%d : TEXCOORD%d", i < 4 ? 4 : 3 , i, i); + WRITE(p, " out float4 ocol0 : SV_Target0,%s%s\n in float4 rawpos : SV_Position,\n", + dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND ? "\n out float4 ocol1 : SV_Target1," : "", + DepthTextureEnable ? "\n out float depth : SV_Depth," : ""); } + + WRITE(p, " in float4 colors_0 : COLOR0,\n"); + WRITE(p, " in float4 colors_1 : COLOR1"); + + // compute window position if needed because binding semantic WPOS is not widely supported + if (numTexgen < 7) + { + for (int i = 0; i < numTexgen; ++i) + WRITE(p, ",\n in float3 uv%d : TEXCOORD%d", i, i); + WRITE(p, ",\n in float4 clipPos : TEXCOORD%d", numTexgen); + if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + WRITE(p, ",\n in float4 Normal : TEXCOORD%d", numTexgen + 1); + } + else + { + // wpos is in w of first 4 texcoords + if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + { + for (int i = 0; i < 8; ++i) + WRITE(p, ",\n in float4 uv%d : TEXCOORD%d", i, i); + } + else + { + for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) + WRITE(p, ",\n in float%d uv%d : TEXCOORD%d", i < 4 ? 4 : 3 , i, i); + } + } + WRITE(p, " ) {\n"); + } + else + { + // GLSL doesn't do main arguments + // Once we switch to GLSL 1.3 we will bind a lot of these. + + WRITE(p, " float4 ocol0;\n"); + if(dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND) + WRITE(p, " float4 ocol1;\n"); // Will be supported later + if(DepthTextureEnable) + WRITE(p, " float depth;\n"); // TODO: Passed to Vertex Shader right? + WRITE(p, " float4 rawpos = gl_FragCoord;\n"); + + WRITE(p, " float4 colors_0 = gl_Color;\n"); + WRITE(p, " float4 colors_1 = gl_SecondaryColor;\n"); + + // compute window position if needed because binding semantic WPOS is not widely supported + if (numTexgen < 7) + { + for (int i = 0; i < numTexgen; ++i) + WRITE(p, " float3 uv%d = gl_TexCoord[%d].xyz;\n", i, i); + WRITE(p, " float4 clipPos = gl_TexCoord[%d];\n", numTexgen); + if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + WRITE(p, " float4 Normal = gl_TexCoord[%d];\n", numTexgen + 1); + } + else + { + // wpos is in w of first 4 texcoords + if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) + { + for (int i = 0; i < 8; ++i) + WRITE(p, " float4 uv%d = gl_TexCoord[%d];\n", i, i); + } + else + { + for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) + WRITE(p, " float%d uv%d = gl_TexCoord[%d]%s;\n", i < 4 ? 4 : 3 , i, i, i < 4 ? ".xyz" : ""); + } + } + WRITE(p, "void main()\n{\n"); } - WRITE(p, " ) {\n"); char* pmainstart = p; int Pretest = AlphaPreTest(); @@ -633,12 +628,14 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType if (!Pretest) { // alpha test will always fail, so restart the shader and just make it an empty function + WRITE(p, "ocol0 = 0;\n"); if(DepthTextureEnable) WRITE(p, "depth = 1.f;\n"); if(dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND) WRITE(p, "ocol1 = 0;\n"); - WRITE(p, "discard;\n"); + if(ApiType == API_GLSL) + WRITE(p, "gl_FragData[0] = ocol0;\n"); if(ApiType != API_D3D11) WRITE(p, "return;\n"); } @@ -763,6 +760,25 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType if(Pretest == -1) { WriteAlphaTest(p, ApiType, dstAlphaMode); + // alpha test will always fail, so restart the shader and just make it an empty function + /* p = pmainstart; + WRITE(p, "ocol0 = 0;\n"); + if(DepthTextureEnable) + WRITE(p, "depth = 1.f;\n"); + if(dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND) + WRITE(p, "ocol1 = 0;\n"); + if(ApiType == API_GLSL) + { + // Once we switch to GLSL 1.3 and bind variables, we won't need to do this + WRITE(p, "gl_FragData[0] = ocol0;\n"); + if(DepthTextureEnable) + WRITE(p, "gl_FragDepth = depth;\n"); + if(dstAlphaMode == DSTALPHA_DUAL_SOURCE_BLEND) + ; // TODO: Will do this later + } + WRITE(p, "discard;\n"); + if(ApiType != API_D3D11) + WRITE(p, "return;\n");*/ } if((bpmem.fog.c_proj_fsel.fsel != 0) || DepthTextureEnable) @@ -805,6 +821,13 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType WRITE(p, " ocol1 = ocol0;\n"); // ...and the alpha from ocol0 will be written to the framebuffer. WRITE(p, " ocol0.a = " I_ALPHA"[0].a;\n"); + + if(ApiType == API_GLSL) + { + if(DepthTextureEnable) + WRITE(p, "gl_FragDepth = depth;\n"); + WRITE(p, "gl_FragData[0] = ocol0;\n"); + } } WRITE(p, "}\n"); diff --git a/Source/Core/VideoCommon/Src/PixelShaderGen.h b/Source/Core/VideoCommon/Src/PixelShaderGen.h index 31242a916e..589fc927bc 100644 --- a/Source/Core/VideoCommon/Src/PixelShaderGen.h +++ b/Source/Core/VideoCommon/Src/PixelShaderGen.h @@ -47,6 +47,19 @@ #define PIXELSHADERUID_MAX_VALUES 70 #define PIXELSHADERUID_MAX_VALUES_SAFE 120 +// 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 }, + }; + // DO NOT make anything in this class virtual. template class _PIXELSHADERUID diff --git a/Source/Core/VideoCommon/Src/VertexShaderGen.cpp b/Source/Core/VideoCommon/Src/VertexShaderGen.cpp index 07ace04b97..55f81002ba 100644 --- a/Source/Core/VideoCommon/Src/VertexShaderGen.cpp +++ b/Source/Core/VideoCommon/Src/VertexShaderGen.cpp @@ -130,7 +130,7 @@ static char text[16384]; #define WRITE p+=sprintf -char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type) +char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE ApiType) { WRITE(p, "struct VS_OUTPUT {\n"); WRITE(p, " float4 pos : POSITION;\n"); @@ -161,7 +161,10 @@ char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type) return p; } -const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type) +extern const char* WriteRegister(API_TYPE ApiType, const char *prefix, const u32 num); + + +const char *GenerateVertexShaderCode(u32 components, API_TYPE ApiType) { setlocale(LC_NUMERIC, "C"); // Reset locale for compilation text[sizeof(text) - 1] = 0x7C; // canary @@ -169,7 +172,7 @@ const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type) _assert_(bpmem.genMode.numtexgens == xfregs.numTexGen.numTexGens); _assert_(bpmem.genMode.numcolchans == xfregs.numChan.numColorChans); - bool is_d3d = (api_type & API_D3D9 || api_type == API_D3D11); + bool is_d3d = (ApiType & API_D3D9 || ApiType == API_D3D11); u32 lightMask = 0; if (xfregs.numChan.numColorChans > 0) lightMask |= xfregs.color[0].GetFullLightMask() | xfregs.alpha[0].GetFullLightMask(); @@ -178,78 +181,109 @@ const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type) char *p = text; WRITE(p, "//Vertex Shader: comp:%x, \n", components); - WRITE(p, "typedef struct { float4 T0, T1, T2; float4 N0, N1, N2; } s_" I_POSNORMALMATRIX";\n" - "typedef struct { float4 t; } FLT4;\n" - "typedef struct { FLT4 T[24]; } s_" I_TEXMATRICES";\n" - "typedef struct { FLT4 T[64]; } s_" I_TRANSFORMMATRICES";\n" - "typedef struct { FLT4 T[32]; } s_" I_NORMALMATRICES";\n" - "typedef struct { FLT4 T[64]; } s_" I_POSTTRANSFORMMATRICES";\n" - "typedef struct { float4 col; float4 cosatt; float4 distatt; float4 pos; float4 dir; } Light;\n" - "typedef struct { Light lights[8]; } s_" I_LIGHTS";\n" - "typedef struct { float4 C0, C1, C2, C3; } s_" I_MATERIALS";\n" - "typedef struct { float4 T0, T1, T2, T3; } s_" I_PROJECTION";\n" - ); - - p = GenerateVSOutputStruct(p, components, api_type); - - // uniforms - - WRITE(p, "uniform s_" I_TRANSFORMMATRICES" " I_TRANSFORMMATRICES" : register(c%d);\n", C_TRANSFORMMATRICES); - WRITE(p, "uniform s_" I_TEXMATRICES" " I_TEXMATRICES" : register(c%d);\n", C_TEXMATRICES); // also using tex matrices - WRITE(p, "uniform s_" I_NORMALMATRICES" " I_NORMALMATRICES" : register(c%d);\n", C_NORMALMATRICES); - WRITE(p, "uniform s_" I_POSNORMALMATRIX" " I_POSNORMALMATRIX" : register(c%d);\n", C_POSNORMALMATRIX); - WRITE(p, "uniform s_" I_POSTTRANSFORMMATRICES" " I_POSTTRANSFORMMATRICES" : register(c%d);\n", C_POSTTRANSFORMMATRICES); - WRITE(p, "uniform s_" I_LIGHTS" " I_LIGHTS" : register(c%d);\n", C_LIGHTS); - WRITE(p, "uniform s_" I_MATERIALS" " I_MATERIALS" : register(c%d);\n", C_MATERIALS); - WRITE(p, "uniform s_" I_PROJECTION" " I_PROJECTION" : register(c%d);\n", C_PROJECTION); - WRITE(p, "uniform float4 " I_DEPTHPARAMS" : register(c%d);\n", C_DEPTHPARAMS); - - WRITE(p, "VS_OUTPUT main(\n"); - // inputs - if (components & VB_HAS_NRM0) - WRITE(p, " float3 rawnorm0 : NORMAL0,\n"); - if (components & VB_HAS_NRM1) { - if (is_d3d) - WRITE(p, " float3 rawnorm1 : NORMAL1,\n"); - else - WRITE(p, " float3 rawnorm1 : ATTR%d,\n", SHADER_NORM1_ATTRIB); + if(ApiType == API_GLSL) + { + // A few required defines and ones that will make our lives a lot easier + WRITE(p, "#version 120\n"); + // Silly differences + WRITE(p, "#define float2 vec2\n"); + WRITE(p, "#define float3 vec3\n"); + WRITE(p, "#define float4 vec4\n"); + + // cg to glsl function translation + WRITE(p, "#define frac(x) fract(x)\n"); + WRITE(p, "#define saturate(x) clamp(x, 0.0f, 1.0f)\n"); + WRITE(p, "#define lerp(x, y, z) mix(x, y, z)\n"); } - if (components & VB_HAS_NRM2) { - if (is_d3d) - WRITE(p, " float3 rawnorm2 : NORMAL2,\n"); - else - WRITE(p, " float3 rawnorm2 : ATTR%d,\n", SHADER_NORM2_ATTRIB); - } - if (components & VB_HAS_COL0) - WRITE(p, " float4 color0 : COLOR0,\n"); - if (components & VB_HAS_COL1) - WRITE(p, " float4 color1 : COLOR1,\n"); - for (int i = 0; i < 8; ++i) { - u32 hastexmtx = (components & (VB_HAS_TEXMTXIDX0< class _VERTEXSHADERUID { diff --git a/Source/Core/VideoCommon/Src/VideoCommon.h b/Source/Core/VideoCommon/Src/VideoCommon.h index f067fb9d6b..a4bfaddd1f 100644 --- a/Source/Core/VideoCommon/Src/VideoCommon.h +++ b/Source/Core/VideoCommon/Src/VideoCommon.h @@ -152,5 +152,11 @@ 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 diff --git a/Source/Core/VideoCommon/Src/VideoConfig.cpp b/Source/Core/VideoCommon/Src/VideoConfig.cpp index 6d240ba357..c972d46716 100644 --- a/Source/Core/VideoCommon/Src/VideoConfig.cpp +++ b/Source/Core/VideoCommon/Src/VideoConfig.cpp @@ -141,6 +141,7 @@ void VideoConfig::GameIniLoad(const char *ini_file) iniFile.GetIfExists("Video_Settings", "DisableFog", &bDisableFog); iniFile.GetIfExists("Video_Settings", "EnableOpenCL", &bEnableOpenCL); iniFile.GetIfExists("Video_Settings", "OMPDecoder", &bOMPDecoder); + iniFile.GetIfExists("Video_Settings", "UseGLSL", &bUseGLSL); iniFile.GetIfExists("Video_Enhancements", "ForceFiltering", &bForceFiltering); iniFile.GetIfExists("Video_Enhancements", "MaxAnisotropy", &iMaxAnisotropy); // NOTE - this is x in (1 << x) @@ -173,6 +174,7 @@ void VideoConfig::VerifyValidity() if (!backend_info.bSupports3DVision) b3DVision = false; if (!backend_info.bSupportsFormatReinterpretation) bEFBEmulateFormatChanges = false; if (!backend_info.bSupportsPixelLighting) bEnablePixelLighting = false; + if (!backend_info.bSupportsGLSL) bUseGLSL = false; } void VideoConfig::Save(const char *ini_file) @@ -214,6 +216,7 @@ void VideoConfig::Save(const char *ini_file) iniFile.Set("Settings", "Wireframe", bWireFrame); iniFile.Set("Settings", "DstAlphaPass", bDstAlphaPass); iniFile.Set("Settings", "DisableFog", bDisableFog); + iniFile.Set("Settings", "bUseGLSL", bUseGLSL); iniFile.Set("Settings", "EnableOpenCL", bEnableOpenCL); iniFile.Set("Settings", "OMPDecoder", bOMPDecoder); @@ -276,6 +279,7 @@ void VideoConfig::GameIniSave(const char* default_ini, const char* game_ini) SET_IF_DIFFERS("Video_Settings", "DisableFog", bDisableFog); SET_IF_DIFFERS("Video_Settings", "EnableOpenCL", bEnableOpenCL); SET_IF_DIFFERS("Video_Settings", "OMPDecoder", bOMPDecoder); + SET_IF_DIFFERS("Video_Settings", "UseGLSL", bUseGLSL); SET_IF_DIFFERS("Video_Enhancements", "ForceFiltering", bForceFiltering); SET_IF_DIFFERS("Video_Enhancements", "MaxAnisotropy", iMaxAnisotropy); // NOTE - this is x in (1 << x) diff --git a/Source/Core/VideoCommon/Src/VideoConfig.h b/Source/Core/VideoCommon/Src/VideoConfig.h index e71c7356a9..1130df7b8e 100644 --- a/Source/Core/VideoCommon/Src/VideoConfig.h +++ b/Source/Core/VideoCommon/Src/VideoConfig.h @@ -103,6 +103,7 @@ struct VideoConfig bool bWireFrame; bool bDstAlphaPass; bool bDisableFog; + bool bUseGLSL; // Utility bool bDumpTextures; @@ -162,6 +163,7 @@ struct VideoConfig bool bSupportsDualSourceBlend; // only supported by D3D11 and OpenGL bool bSupportsFormatReinterpretation; bool bSupportsPixelLighting; + bool bSupportsGLSL; } backend_info; }; diff --git a/Source/Plugins/Plugin_VideoDX11/Src/main.cpp b/Source/Plugins/Plugin_VideoDX11/Src/main.cpp index cb348b8684..a79dc3b136 100644 --- a/Source/Plugins/Plugin_VideoDX11/Src/main.cpp +++ b/Source/Plugins/Plugin_VideoDX11/Src/main.cpp @@ -94,6 +94,7 @@ void InitBackendInfo() g_Config.backend_info.bSupportsDualSourceBlend = true; g_Config.backend_info.bSupportsFormatReinterpretation = true; g_Config.backend_info.bSupportsPixelLighting = true; + g_Config.backend_info.bSupportsGLSL = false; IDXGIFactory* factory; IDXGIAdapter* ad; diff --git a/Source/Plugins/Plugin_VideoDX9/Src/main.cpp b/Source/Plugins/Plugin_VideoDX9/Src/main.cpp index 5aeca6751d..7b0338a54c 100644 --- a/Source/Plugins/Plugin_VideoDX9/Src/main.cpp +++ b/Source/Plugins/Plugin_VideoDX9/Src/main.cpp @@ -96,6 +96,7 @@ void InitBackendInfo() g_Config.backend_info.bSupports3DVision = true; g_Config.backend_info.bSupportsDualSourceBlend = false; g_Config.backend_info.bSupportsFormatReinterpretation = true; + g_Config.backend_info.bSupportsGLSL = false; g_Config.backend_info.bSupportsPixelLighting = C_PLIGHTS + 40 <= maxConstants && C_PMATERIALS + 4 <= maxConstants; diff --git a/Source/Plugins/Plugin_VideoOGL/CMakeLists.txt b/Source/Plugins/Plugin_VideoOGL/CMakeLists.txt index b506087106..4c4bbbe649 100644 --- a/Source/Plugins/Plugin_VideoOGL/CMakeLists.txt +++ b/Source/Plugins/Plugin_VideoOGL/CMakeLists.txt @@ -4,6 +4,7 @@ set(SRCS Src/FramebufferManager.cpp Src/NativeVertexFormat.cpp Src/PixelShaderCache.cpp Src/PostProcessing.cpp + Src/ProgramShaderCache.cpp Src/RasterFont.cpp Src/Render.cpp Src/TextureCache.cpp diff --git a/Source/Plugins/Plugin_VideoOGL/Src/NativeVertexFormat.cpp b/Source/Plugins/Plugin_VideoOGL/Src/NativeVertexFormat.cpp index ae20649433..b5ba60e632 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/NativeVertexFormat.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/NativeVertexFormat.cpp @@ -19,6 +19,7 @@ #include "x64Emitter.h" #include "ABI.h" #include "MemoryUtil.h" +#include "ProgramShaderCache.h" #include "VertexShaderGen.h" #include "CPMemory.h" @@ -191,8 +192,15 @@ void GLVertexFormat::SetupVertexPointers() { if (vtx_decl.num_normals >= 1) { glNormalPointer(VarToGL(vtx_decl.normal_gl_type), vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.normal_offset[0])); if (vtx_decl.num_normals == 3) { - glVertexAttribPointer(SHADER_NORM1_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.normal_offset[1])); - glVertexAttribPointer(SHADER_NORM2_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.normal_offset[2])); + GLint varLocation1 = SHADER_NORM1_ATTRIB, varLocation2 = SHADER_NORM2_ATTRIB; + if(g_ActiveConfig.bUseGLSL){ + varLocation1 = OGL::ProgramShaderCache::GetAttr(0); + varLocation2 = OGL::ProgramShaderCache::GetAttr(1); + } + if(varLocation1 > 0) + glVertexAttribPointer(varLocation1, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.normal_offset[1])); + if(varLocation2 > 0) + glVertexAttribPointer(varLocation2, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.normal_offset[2])); } } @@ -216,7 +224,11 @@ void GLVertexFormat::SetupVertexPointers() { } if (vtx_decl.posmtx_offset != -1) { - glVertexAttribPointer(SHADER_POSMTX_ATTRIB, 4, GL_UNSIGNED_BYTE, GL_FALSE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.posmtx_offset)); + GLint varLocation = SHADER_POSMTX_ATTRIB; + if(g_ActiveConfig.bUseGLSL) + varLocation = OGL::ProgramShaderCache::GetAttr(2); + if(varLocation > 0) + glVertexAttribPointer(varLocation, 4, GL_UNSIGNED_BYTE, GL_FALSE, vtx_decl.stride, (void *)(VertexManager::s_pBaseBufferPointer + vtx_decl.posmtx_offset)); } #endif } diff --git a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp index 61e41008b3..37e65e2c88 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp @@ -27,6 +27,7 @@ #include "Common.h" #include "Render.h" #include "VertexShaderGen.h" +#include "ProgramShaderCache.h" #include "PixelShaderCache.h" #include "PixelShaderManager.h" #include "FileUtil.h" @@ -47,208 +48,225 @@ bool PixelShaderCache::ShaderEnabled; PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry = NULL; PIXELSHADERUID PixelShaderCache::last_uid; +void(*pSetPSConstant4f)(unsigned int, float, float, float, float); +void(*pSetPSConstant4fv)(unsigned int, const float*); +void(*pSetMultiPSConstant4fv)(unsigned int, unsigned int, const float*); + GLuint PixelShaderCache::GetDepthMatrixProgram() { - return s_DepthMatrixProgram; + return s_DepthMatrixProgram; } GLuint PixelShaderCache::GetColorMatrixProgram() { - return s_ColorMatrixProgram; + return s_ColorMatrixProgram; } void PixelShaderCache::Init() { - glEnable(GL_FRAGMENT_PROGRAM_ARB); - ShaderEnabled = true; - CurrentShader = 0; - last_entry = NULL; - GL_REPORT_ERRORD(); + glEnable(GL_FRAGMENT_PROGRAM_ARB); + ShaderEnabled = true; + CurrentShader = 0; + last_entry = NULL; + GL_REPORT_ERRORD(); - s_displayCompileAlert = true; + s_displayCompileAlert = true; - glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, (GLint *)&s_nMaxPixelInstructions); - - if(s_nMaxPixelInstructions == 0) // Some combination of drivers and hardware returns zero for some reason. - s_nMaxPixelInstructions = 4096; - if (strstr((const char*)glGetString(GL_VENDOR), "Humper") != NULL) s_nMaxPixelInstructions = 4096; + if(g_ActiveConfig.bUseGLSL) + { + pSetPSConstant4f = SetGLSLPSConstant4f; + pSetPSConstant4fv = SetGLSLPSConstant4fv; + pSetMultiPSConstant4fv = SetMultiGLSLPSConstant4fv; + } + else + { + pSetPSConstant4f = SetCGPSConstant4f; + pSetPSConstant4fv = SetCGPSConstant4fv; + pSetMultiPSConstant4fv = SetMultiCGPSConstant4fv; + } + + glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, (GLint *)&s_nMaxPixelInstructions); + + if(s_nMaxPixelInstructions == 0) // Some combination of drivers and hardware returns zero for some reason. + s_nMaxPixelInstructions = 4096; + if (strstr((const char*)glGetString(GL_VENDOR), "Humper") != NULL) s_nMaxPixelInstructions = 4096; #if CG_VERSION_NUM == 2100 - if (strstr((const char*)glGetString(GL_VENDOR), "ATI") != NULL) - { - s_nMaxPixelInstructions = 4096; - } + if (strstr((const char*)glGetString(GL_VENDOR), "ATI") != NULL) + { + s_nMaxPixelInstructions = 4096; + } #endif - int maxinst, maxattribs; - glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, (GLint *)&maxinst); - glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, (GLint *)&maxattribs); - INFO_LOG(VIDEO, "pixel max_alu=%d, max_inst=%d, max_attrib=%d", s_nMaxPixelInstructions, maxinst, maxattribs); - - char pmatrixprog[2048]; - sprintf(pmatrixprog, "!!ARBfp1.0" - "TEMP R0;\n" - "TEMP R1;\n" - "PARAM K0 = { 0.5, 0.5, 0.5, 0.5};\n" - "TEX R0, fragment.texcoord[0], texture[0], RECT;\n" - "MUL R0, R0, program.env[%d];\n" - "ADD R0, R0, K0;\n" - "FLR R0, R0;\n" - "MUL R0, R0, program.env[%d];\n" - "DP4 R1.x, R0, program.env[%d];\n" - "DP4 R1.y, R0, program.env[%d];\n" - "DP4 R1.z, R0, program.env[%d];\n" - "DP4 R1.w, R0, program.env[%d];\n" - "ADD result.color, R1, program.env[%d];\n" - "END\n",C_COLORMATRIX+5,C_COLORMATRIX+6, C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4); - glGenProgramsARB(1, &s_ColorMatrixProgram); - SetCurrentShader(s_ColorMatrixProgram); - glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog); + int maxinst, maxattribs; + glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, (GLint *)&maxinst); + glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, (GLint *)&maxattribs); + INFO_LOG(VIDEO, "pixel max_alu=%d, max_inst=%d, max_attrib=%d", s_nMaxPixelInstructions, maxinst, maxattribs); - GLenum err = GL_REPORT_ERROR(); - if (err != GL_NO_ERROR) { - ERROR_LOG(VIDEO, "Failed to create color matrix fragment program"); - glDeleteProgramsARB(1, &s_ColorMatrixProgram); - s_ColorMatrixProgram = 0; - } + char pmatrixprog[2048]; + sprintf(pmatrixprog, "!!ARBfp1.0" + "TEMP R0;\n" + "TEMP R1;\n" + "PARAM K0 = { 0.5, 0.5, 0.5, 0.5};\n" + "TEX R0, fragment.texcoord[0], texture[0], RECT;\n" + "MUL R0, R0, program.env[%d];\n" + "ADD R0, R0, K0;\n" + "FLR R0, R0;\n" + "MUL R0, R0, program.env[%d];\n" + "DP4 R1.x, R0, program.env[%d];\n" + "DP4 R1.y, R0, program.env[%d];\n" + "DP4 R1.z, R0, program.env[%d];\n" + "DP4 R1.w, R0, program.env[%d];\n" + "ADD result.color, R1, program.env[%d];\n" + "END\n",C_COLORMATRIX+5,C_COLORMATRIX+6, C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4); + glGenProgramsARB(1, &s_ColorMatrixProgram); + SetCurrentShader(s_ColorMatrixProgram); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog); - sprintf(pmatrixprog, "!!ARBfp1.0\n" - "TEMP R0;\n" - "TEMP R1;\n" - "TEMP R2;\n" - //16777215/16777216*256, 1/255, 256, 0 - "PARAM K0 = { 255.99998474121, 0.003921568627451, 256.0, 0.0};\n" - "PARAM K1 = { 15.0, 0.066666666666, 0.0, 0.0};\n" - //sample the depth value - "TEX R2, fragment.texcoord[0], texture[0], RECT;\n" + GLenum err = GL_REPORT_ERROR(); + if (err != GL_NO_ERROR) { + ERROR_LOG(VIDEO, "Failed to create color matrix fragment program"); + glDeleteProgramsARB(1, &s_ColorMatrixProgram); + s_ColorMatrixProgram = 0; + } - //scale from [0*16777216..1*16777216] to - //[0*16777215..1*16777215], multiply by 256 - "MUL R0, R2.x, K0.x;\n" // *16777215/16777216*256 + sprintf(pmatrixprog, "!!ARBfp1.0\n" + "TEMP R0;\n" + "TEMP R1;\n" + "TEMP R2;\n" + //16777215/16777216*256, 1/255, 256, 0 + "PARAM K0 = { 255.99998474121, 0.003921568627451, 256.0, 0.0};\n" + "PARAM K1 = { 15.0, 0.066666666666, 0.0, 0.0};\n" + //sample the depth value + "TEX R2, fragment.texcoord[0], texture[0], RECT;\n" - //It is easy to get bad results due to low precision - //here, for example converting like this: - //MUL R0,R0,{ 65536, 256, 1, 16777216 } - //FRC R0,R0 - //gives {?, 128/255, 254/255, ?} for depth value 254/255 - //on some gpus + //scale from [0*16777216..1*16777216] to + //[0*16777215..1*16777215], multiply by 256 + "MUL R0, R2.x, K0.x;\n" // *16777215/16777216*256 - "FLR R0.x,R0;\n" //bits 31..24 + //It is easy to get bad results due to low precision + //here, for example converting like this: + //MUL R0,R0,{ 65536, 256, 1, 16777216 } + //FRC R0,R0 + //gives {?, 128/255, 254/255, ?} for depth value 254/255 + //on some gpus - "SUB R0.yzw,R0,R0.x;\n" //subtract bits 31..24 from rest - "MUL R0.yzw,R0,K0.z;\n" // *256 - "FLR R0.y,R0;\n" //bits 23..16 + "FLR R0.x,R0;\n" //bits 31..24 - "SUB R0.zw,R0,R0.y;\n" //subtract bits 23..16 from rest - "MUL R0.zw,R0,K0.z;\n" // *256 - "FLR R0.z,R0;\n" //bits 15..8 + "SUB R0.yzw,R0,R0.x;\n" //subtract bits 31..24 from rest + "MUL R0.yzw,R0,K0.z;\n" // *256 + "FLR R0.y,R0;\n" //bits 23..16 - "MOV R0.w,R0.x;\n" //duplicate bit 31..24 - - "MUL R0,R0,K0.y;\n" // /255 + "SUB R0.zw,R0,R0.y;\n" //subtract bits 23..16 from rest + "MUL R0.zw,R0,K0.z;\n" // *256 + "FLR R0.z,R0;\n" //bits 15..8 - "MUL R0.w,R0,K1.x;\n" // *15 - "FLR R0.w,R0;\n" //bits 31..28 - "MUL R0.w,R0,K1.y;\n" // /15 + "MOV R0.w,R0.x;\n" //duplicate bit 31..24 - "DP4 R1.x, R0, program.env[%d];\n" - "DP4 R1.y, R0, program.env[%d];\n" - "DP4 R1.z, R0, program.env[%d];\n" - "DP4 R1.w, R0, program.env[%d];\n" - "ADD result.color, R1, program.env[%d];\n" - "END\n", C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4); - glGenProgramsARB(1, &s_DepthMatrixProgram); - SetCurrentShader(s_DepthMatrixProgram); - glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog); + "MUL R0,R0,K0.y;\n" // /255 + + "MUL R0.w,R0,K1.x;\n" // *15 + "FLR R0.w,R0;\n" //bits 31..28 + "MUL R0.w,R0,K1.y;\n" // /15 + + "DP4 R1.x, R0, program.env[%d];\n" + "DP4 R1.y, R0, program.env[%d];\n" + "DP4 R1.z, R0, program.env[%d];\n" + "DP4 R1.w, R0, program.env[%d];\n" + "ADD result.color, R1, program.env[%d];\n" + "END\n", C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4); + glGenProgramsARB(1, &s_DepthMatrixProgram); + SetCurrentShader(s_DepthMatrixProgram); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog); + + err = GL_REPORT_ERROR(); + if (err != GL_NO_ERROR) { + ERROR_LOG(VIDEO, "Failed to create depth matrix fragment program"); + glDeleteProgramsARB(1, &s_DepthMatrixProgram); + s_DepthMatrixProgram = 0; + } - err = GL_REPORT_ERROR(); - if (err != GL_NO_ERROR) { - ERROR_LOG(VIDEO, "Failed to create depth matrix fragment program"); - glDeleteProgramsARB(1, &s_DepthMatrixProgram); - s_DepthMatrixProgram = 0; - } - } void PixelShaderCache::Shutdown() { - glDeleteProgramsARB(1, &s_ColorMatrixProgram); - s_ColorMatrixProgram = 0; + glDeleteProgramsARB(1, &s_ColorMatrixProgram); + s_ColorMatrixProgram = 0; glDeleteProgramsARB(1, &s_DepthMatrixProgram); - s_DepthMatrixProgram = 0; - PSCache::iterator iter = PixelShaders.begin(); - for (; iter != PixelShaders.end(); iter++) - iter->second.Destroy(); - PixelShaders.clear(); + s_DepthMatrixProgram = 0; + PSCache::iterator iter = PixelShaders.begin(); + for (; iter != PixelShaders.end(); iter++) + iter->second.Destroy(); + PixelShaders.clear(); } FRAGMENTSHADER* PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) { - PIXELSHADERUID uid; - GetPixelShaderId(&uid, dstAlphaMode, components); - - // Check if the shader is already set - if (last_entry) - { - if (uid == last_uid) - { - GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); - ValidatePixelShaderIDs(API_OPENGL, last_entry->safe_uid, last_entry->shader.strprog, dstAlphaMode, components); - return &last_entry->shader; - } - } + PIXELSHADERUID uid; + GetPixelShaderId(&uid, dstAlphaMode, components); - last_uid = uid; + // Check if the shader is already set + if (last_entry) + { + if (uid == last_uid) + { + GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); + ValidatePixelShaderIDs(API_OPENGL, last_entry->safe_uid, last_entry->shader.strprog, dstAlphaMode, components); + return &last_entry->shader; + } + } - PSCache::iterator iter = PixelShaders.find(uid); - if (iter != PixelShaders.end()) - { - PSCacheEntry &entry = iter->second; - last_entry = &entry; + last_uid = uid; - GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); - ValidatePixelShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, dstAlphaMode, components); - return &last_entry->shader; - } + PSCache::iterator iter = PixelShaders.find(uid); + if (iter != PixelShaders.end()) + { + PSCacheEntry &entry = iter->second; + last_entry = &entry; - // Make an entry in the table - PSCacheEntry& newentry = PixelShaders[uid]; - last_entry = &newentry; - const char *code = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components); + GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); + ValidatePixelShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, dstAlphaMode, components); + return &last_entry->shader; + } - if (g_ActiveConfig.bEnableShaderDebugging && code) - { - GetSafePixelShaderId(&newentry.safe_uid, dstAlphaMode, components); - newentry.shader.strprog = code; - } + // Make an entry in the table + PSCacheEntry& newentry = PixelShaders[uid]; + last_entry = &newentry; + const char *code = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components); + + if (g_ActiveConfig.bEnableShaderDebugging && code) + { + GetSafePixelShaderId(&newentry.safe_uid, dstAlphaMode, components); + newentry.shader.strprog = code; + } #if defined(_DEBUG) || defined(DEBUGFAST) - if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) { - static int counter = 0; - char szTemp[MAX_PATH]; - sprintf(szTemp, "%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++); - - SaveData(szTemp, code); - } + if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) { + static int counter = 0; + char szTemp[MAX_PATH]; + sprintf(szTemp, "%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++); + + SaveData(szTemp, code); + } #endif - if (!code || !CompilePixelShader(newentry.shader, code)) { - GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true); - return NULL; - } - - INCSTAT(stats.numPixelShadersCreated); - SETSTAT(stats.numPixelShadersAlive, PixelShaders.size()); - GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); - return &last_entry->shader; + if (!code || !CompilePixelShader(newentry.shader, code)) { + GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true); + return NULL; + } + + INCSTAT(stats.numPixelShadersCreated); + SETSTAT(stats.numPixelShadersAlive, PixelShaders.size()); + GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); + return &last_entry->shader; } bool PixelShaderCache::CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrprogram) { - GLenum err = GL_REPORT_ERROR(); - if (err != GL_NO_ERROR) - { - ERROR_LOG(VIDEO, "glError %08x before PS!", err); - } + GLenum err = GL_REPORT_ERROR(); + if (err != GL_NO_ERROR) + { + ERROR_LOG(VIDEO, "glError %08x before PS!", err); + } #if defined HAVE_CG && HAVE_CG char stropt[128]; @@ -323,50 +341,134 @@ bool PixelShaderCache::CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrpr cgDestroyProgram(tempprog); #endif - return true; + return true; } //Disable Fragment programs and reset the selected Program void PixelShaderCache::DisableShader() { - if(ShaderEnabled) - { - glDisable(GL_FRAGMENT_PROGRAM_ARB); - ShaderEnabled = false; - } + if(ShaderEnabled) + { + glDisable(GL_FRAGMENT_PROGRAM_ARB); + ShaderEnabled = false; + } } //bind a program if is diferent from the binded oone void PixelShaderCache::SetCurrentShader(GLuint Shader) { - if(!ShaderEnabled) - { - glEnable(GL_FRAGMENT_PROGRAM_ARB); - ShaderEnabled = true; - } - if(CurrentShader != Shader) - { - if(Shader != 0) - CurrentShader = Shader; - glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, CurrentShader); - } + if(!ShaderEnabled) + { + glEnable(GL_FRAGMENT_PROGRAM_ARB); + ShaderEnabled = true; + } + if(CurrentShader != Shader) + { + if(Shader != 0) + CurrentShader = Shader; + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, CurrentShader); + } +} +// GLSL Specific +void PixelShaderCache::SetPSSampler(const char * name, unsigned int Tex) +{ + PROGRAMSHADER tmp = ProgramShaderCache::GetShaderProgram(); + for(int a = 0; a < NUM_UNIFORMS; ++a) + if(!strcmp(name, UniformNames[a])) + { + if(tmp.UniformLocations[a] == -1) + return; + else + { + glUniform1i(tmp.UniformLocations[a], Tex); + return; + } + } +} +void SetPSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1) +{ + PROGRAMSHADER tmp = ProgramShaderCache::GetShaderProgram(); + for(int a = 0; a < NUM_UNIFORMS; ++a) + if(!strcmp(name, UniformNames[a])) + { + if(tmp.UniformLocations[a] == -1) + return; + else + { + glUniform4fv(tmp.UniformLocations[a] + offset, count, f); + return; + } + } +} +void SetGLSLPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) +{ + float f[4] = { f1, f2, f3, f4 }; + 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 SetGLSLPSConstant4fv(unsigned int const_number, const float *f) +{ + 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 SetMultiGLSLPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) +{ + 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; + } + } +} +// CG Specific +void SetCGPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) +{ + float f[4] = { f1, f2, f3, f4 }; + glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number, f); +} + +void SetCGPSConstant4fv(unsigned int const_number, const float *f) +{ + glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number, f); +} + +void SetMultiCGPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) +{ + for (unsigned int i = 0; i < count; i++,f+=4) + glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number + i, f); +} +// Renderer functions void Renderer::SetPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) { - float f[4] = { f1, f2, f3, f4 }; - glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number, f); + pSetPSConstant4f(const_number, f1, f2, f3, f4); } void Renderer::SetPSConstant4fv(unsigned int const_number, const float *f) { - glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number, f); + pSetPSConstant4fv(const_number, f); } void Renderer::SetMultiPSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { - for (unsigned int i = 0; i < count; i++,f+=4) - glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, const_number + i, f); + pSetMultiPSConstant4fv(const_number, count, f); } - } // namespace OGL diff --git a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h index f528eeb35b..9d61d7229a 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h +++ b/Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.h @@ -73,6 +73,8 @@ class PixelShaderCache public: static void Init(); static void Shutdown(); + // This is a GLSL only function + static void SetPSSampler(const char * name, unsigned int Tex); static FRAGMENTSHADER* SetShader(DSTALPHA_MODE dstAlphaMode, u32 components); static bool CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrprogram); @@ -85,7 +87,15 @@ public: static void DisableShader(); }; +// GLSL Specific +void SetGLSLPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); +void SetGLSLPSConstant4fv(unsigned int const_number, const float *f); +void SetMultiGLSLPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); +//CG Specific +void SetCGPSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); +void SetCGPSConstant4fv(unsigned int const_number, const float *f); +void SetMultiCGPSConstant4fv(unsigned int const_number, unsigned int count, const float *f); } // namespace OGL #endif // _PIXELSHADERCACHE_H_ diff --git a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp new file mode 100644 index 0000000000..fc056aed63 --- /dev/null +++ b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.cpp @@ -0,0 +1,150 @@ +// Copyright (C) 2003 Dolphin Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official SVN repository and contact information can be found at +// http://code.google.com/p/dolphin-emu/ +#include "ProgramShaderCache.h" + +namespace OGL +{ + GLuint ProgramShaderCache::CurrentFShader = 0, ProgramShaderCache::CurrentVShader = 0, ProgramShaderCache::CurrentProgram = 0; + ProgramShaderCache::PCache ProgramShaderCache::pshaders; + + std::pair ProgramShaderCache::CurrentShaderProgram; + const char *UniformNames[NUM_UNIFORMS] = { + // SAMPLERS + "samp0","samp1","samp2","samp3","samp4","samp5","samp6","samp7", + // PIXEL SHADER UNIFORMS + I_COLORS, + I_KCOLORS, + I_ALPHA, + I_TEXDIMS, + I_ZBIAS , + I_INDTEXSCALE , + I_INDTEXMTX, + I_FOG, + I_PLIGHTS, + I_PMATERIALS, + // VERTEX SHADER UNIFORMS + I_POSNORMALMATRIX, + I_PROJECTION , + I_MATERIALS, + I_LIGHTS, + I_TEXMATRICES, + I_TRANSFORMMATRICES , + I_NORMALMATRICES , + I_POSTTRANSFORMMATRICES, + I_DEPTHPARAMS, + }; + + void ProgramShaderCache::SetBothShaders(GLuint PS, GLuint VS) + { + PROGRAMUID uid; + CurrentFShader = PS; + CurrentVShader = VS; + + + GetProgramShaderId(&uid, CurrentVShader, CurrentFShader); + + if(uid.uid.id == 0) + { + CurrentProgram = 0; + glUseProgram(0); + return; + } + + // Fragment shaders can survive without Vertex Shaders + // We have a valid fragment shader, let's create our program + std::pair ShaderPair = std::make_pair(uid.uid.psid, uid.uid.vsid); + PCache::iterator iter = pshaders.find(ShaderPair); + if (iter != pshaders.end()) + { + PCacheEntry &entry = iter->second; + glUseProgram(entry.program.glprogid); + CurrentShaderProgram = ShaderPair; + CurrentProgram = entry.program.glprogid; + return; + } + PCacheEntry entry; + entry.program.vsid = CurrentVShader; + entry.program.psid = CurrentFShader; + entry.program.glprogid = glCreateProgram(); + + // Right, the program is created now + // Let's attach everything + if(entry.program.vsid != 0) // attaching zero vertex shader makes it freak out + glAttachShader(entry.program.glprogid, entry.program.vsid); + glAttachShader(entry.program.glprogid, entry.program.psid); + glLinkProgram(entry.program.glprogid); + //checkForGLError("linking program"); + glUseProgram(entry.program.glprogid); + //checkForGLError("using program"); + + // We cache our uniform locations for now + // Once we move up to a newer version of GLSL, ~1.30 + // We can remove this + + //For some reason this fails on my hardware + //glGetUniformIndices(entry.program.glprogid, NUM_UNIFORMS, UniformNames, entry.program.UniformLocations); + //Got to do it this crappy way. + for(int a = 0; a < NUM_UNIFORMS; ++a) + entry.program.UniformLocations[a] = glGetUniformLocation(entry.program.glprogid, UniformNames[a]); + + // Need to get some attribute locations + if(uid.uid.vsid != 0) // We have no vertex Shader + { + entry.program.attrLoc[0] = glGetAttribLocation(entry.program.glprogid, "rawnorm1"); + entry.program.attrLoc[1] = glGetAttribLocation(entry.program.glprogid, "rawnorm2"); + entry.program.attrLoc[2] = glGetAttribLocation(entry.program.glprogid, "fposmtx"); + if(entry.program.attrLoc[0] > 0) + glEnableVertexAttribArray(entry.program.attrLoc[0]); + if(entry.program.attrLoc[1] > 0) + glEnableVertexAttribArray(entry.program.attrLoc[1]); + if(entry.program.attrLoc[2] > 0) + glEnableVertexAttribArray(entry.program.attrLoc[2]); + } + else + entry.program.attrLoc[0] = entry.program.attrLoc[1] = entry.program.attrLoc[2] = 0; + + + pshaders[ShaderPair] = entry; + CurrentShaderProgram = ShaderPair; + CurrentProgram = entry.program.glprogid; + } + + GLuint ProgramShaderCache::GetCurrentProgram(void) { return CurrentProgram; } + + GLint ProgramShaderCache::GetAttr(int num) + { + return pshaders[CurrentShaderProgram].program.attrLoc[num]; + } + PROGRAMSHADER ProgramShaderCache::GetShaderProgram() + { + return pshaders[CurrentShaderProgram].program; + } + + void ProgramShaderCache::Shutdown(void) + { + PCache::iterator iter = pshaders.begin(); + for (; iter != pshaders.end(); iter++) + iter->second.Destroy(); + pshaders.clear(); + } +} + +void GetProgramShaderId(PROGRAMUID *uid, GLuint _v, GLuint _p) +{ + uid->uid.vsid = _v; + uid->uid.psid = _p; +} diff --git a/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h new file mode 100644 index 0000000000..53abe440f5 --- /dev/null +++ b/Source/Plugins/Plugin_VideoOGL/Src/ProgramShaderCache.h @@ -0,0 +1,108 @@ +// Copyright (C) 2003 Dolphin Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official SVN repository and contact information can be found at +// http://code.google.com/p/dolphin-emu/ + +#ifndef _ProgramShaderCache_H_ +#define _ProgramShaderCache_H_ + +#include "GLUtil.h" + +#include "VertexShaderCache.h" +#include "PixelShaderCache.h" +#include "PixelShaderGen.h" +#include "VertexShaderGen.h" + + union PID + { + struct { + GLuint vsid, psid; + }; + u64 id; + }; + +class PROGRAMUID +{ +public: + + PID uid; + + PROGRAMUID() + { + uid.id = 0; + } + + PROGRAMUID(const PROGRAMUID& r) + { + uid.id = r.uid.id; + } + PROGRAMUID(GLuint _v, GLuint _p) + { + uid.vsid = _v; + uid.psid = _p; + } + + int GetNumValues() const + { + return uid.id; + } +}; +void GetProgramShaderId(PROGRAMUID *uid, GLuint _v, GLuint _p); + +namespace OGL +{ +#define NUM_UNIFORMS 27 +extern const char *UniformNames[NUM_UNIFORMS]; + + +struct PROGRAMSHADER +{ + PROGRAMSHADER() : glprogid(0), vsid(0), psid(0){} + GLuint glprogid; // opengl program id + GLuint vsid, psid; + GLint attrLoc[3]; + GLint UniformLocations[NUM_UNIFORMS]; +}; + + +class ProgramShaderCache +{ + struct PCacheEntry + { + PROGRAMSHADER program; + int frameCount; + PCacheEntry() : frameCount(0) {} + void Destroy() { + glDeleteProgram(program.glprogid); + program.glprogid = 0; + } + }; + typedef std::map, PCacheEntry> PCache; + + static PCache pshaders; + static GLuint CurrentFShader, CurrentVShader, CurrentProgram; + static std::pair CurrentShaderProgram; +public: + static PROGRAMSHADER GetShaderProgram(); + static GLint GetAttr(int num); + static void SetBothShaders(GLuint PS, GLuint VS); + static GLuint GetCurrentProgram(void); + static void Shutdown(void); + +}; + +} // namespace OGL + +#endif diff --git a/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp b/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp index a6121e1436..ae99669636 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/Render.cpp @@ -45,6 +45,7 @@ #include "DLCache.h" #include "PixelShaderCache.h" #include "PixelShaderManager.h" +#include "ProgramShaderCache.h" #include "VertexShaderCache.h" #include "VertexShaderManager.h" #include "VertexLoaderManager.h" @@ -1407,8 +1408,13 @@ void Renderer::ResetAPIState() { // Gets us to a reasonably sane state where it's possible to do things like // image copies with textured quads, etc. - VertexShaderCache::DisableShader(); - PixelShaderCache::DisableShader(); + if(g_ActiveConfig.bUseGLSL) + ProgramShaderCache::SetBothShaders(0, 0); + else + { + VertexShaderCache::DisableShader(); + PixelShaderCache::DisableShader(); + } glDisable(GL_SCISSOR_TEST); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); @@ -1430,8 +1436,13 @@ void Renderer::RestoreAPIState() glPolygonMode(GL_FRONT_AND_BACK, g_ActiveConfig.bWireFrame ? GL_LINE : GL_FILL); - VertexShaderCache::SetCurrentShader(0); - PixelShaderCache::SetCurrentShader(0); + if(g_ActiveConfig.bUseGLSL) + ProgramShaderCache::SetBothShaders(0, 0); + else + { + VertexShaderCache::SetCurrentShader(0); + PixelShaderCache::SetCurrentShader(0); + } } void Renderer::SetGenerationMode() diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp index 0a37b0e654..597bfbba49 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexManager.cpp @@ -33,6 +33,7 @@ #include "PixelShaderManager.h" #include "VertexShaderCache.h" #include "VertexShaderManager.h" +#include "ProgramShaderCache.h" #include "VertexShaderGen.h" #include "VertexLoader.h" #include "VertexManager.h" @@ -168,10 +169,6 @@ void VertexManager::vFlush() } } - // set global constants - VertexShaderManager::SetConstants(); - PixelShaderManager::SetConstants(); - bool useDstAlpha = !g_ActiveConfig.bDstAlphaPass && bpmem.dstalpha.enable && bpmem.blendmode.alphaupdate && bpmem.zcontrol.pixel_format == PIXELFMT_RGBA6_Z24; @@ -204,8 +201,18 @@ void VertexManager::vFlush() FRAGMENTSHADER* ps = PixelShaderCache::SetShader(DSTALPHA_NONE,g_nativeVertexFmt->m_components); #endif VERTEXSHADER* vs = VertexShaderCache::SetShader(g_nativeVertexFmt->m_components); - if (ps) PixelShaderCache::SetCurrentShader(ps->glprogid); // Lego Star Wars crashes here. - if (vs) VertexShaderCache::SetCurrentShader(vs->glprogid); + + if(g_ActiveConfig.bUseGLSL) + ProgramShaderCache::SetBothShaders(ps->glprogid, vs->glprogid); + else + { + if (ps) PixelShaderCache::SetCurrentShader(ps->glprogid); // Lego Star Wars crashes here. + if (vs) VertexShaderCache::SetCurrentShader(vs->glprogid); + } + + // set global constants + VertexShaderManager::SetConstants(); + PixelShaderManager::SetConstants(); Draw(); @@ -213,7 +220,13 @@ void VertexManager::vFlush() if (useDstAlpha && !dualSourcePossible) { ps = PixelShaderCache::SetShader(DSTALPHA_ALPHA_PASS,g_nativeVertexFmt->m_components); - if (ps) PixelShaderCache::SetCurrentShader(ps->glprogid); + if(g_ActiveConfig.bUseGLSL) + { + ProgramShaderCache::SetBothShaders(ps->glprogid, 0); + PixelShaderManager::SetConstants(); // Need to set these again + } + else + if (ps) PixelShaderCache::SetCurrentShader(ps->glprogid); // only update alpha glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp index dbbb7ee29b..a7b1c68e7a 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp @@ -26,6 +26,7 @@ #include "Render.h" #include "VertexShaderGen.h" #include "VertexShaderManager.h" +#include "ProgramShaderCache.h" #include "VertexShaderCache.h" #include "VertexManager.h" #include "VertexLoader.h" @@ -45,194 +46,293 @@ VertexShaderCache::VSCacheEntry* VertexShaderCache::last_entry = NULL; VERTEXSHADERUID VertexShaderCache::last_uid; static int s_nMaxVertexInstructions; - +void (*pSetVSConstant4f)(unsigned int, float, float, float, float); +void (*pSetVSConstant4fv)(unsigned int, const float*); +void (*pSetMultiVSConstant4fv)(unsigned int, unsigned int, const float*); +void (*pSetMultiVSConstant3fv)(unsigned int, unsigned int, const float*); void VertexShaderCache::Init() { - glEnable(GL_VERTEX_PROGRAM_ARB); - ShaderEnabled = true; - CurrentShader = 0; - last_entry = NULL; + glEnable(GL_VERTEX_PROGRAM_ARB); + ShaderEnabled = true; + CurrentShader = 0; + last_entry = NULL; - glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, (GLint *)&s_nMaxVertexInstructions); - if (strstr((const char*)glGetString(GL_VENDOR), "Humper") != NULL) s_nMaxVertexInstructions = 4096; + if(g_ActiveConfig.bUseGLSL) + { + pSetVSConstant4f = SetGLSLVSConstant4f; + pSetVSConstant4fv = SetGLSLVSConstant4fv; + pSetMultiVSConstant4fv = SetMultiGLSLVSConstant4fv; + pSetMultiVSConstant3fv = SetMultiGLSLVSConstant3fv; + } + else + { + pSetVSConstant4f = SetCGVSConstant4f; + pSetVSConstant4fv = SetCGVSConstant4fv; + pSetMultiVSConstant4fv = SetMultiCGVSConstant4fv; + pSetMultiVSConstant3fv = SetMultiCGVSConstant3fv; + } + + glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, (GLint *)&s_nMaxVertexInstructions); + if (strstr((const char*)glGetString(GL_VENDOR), "Humper") != NULL) s_nMaxVertexInstructions = 4096; #if CG_VERSION_NUM == 2100 - if (strstr((const char*)glGetString(GL_VENDOR), "ATI") != NULL) - { - s_nMaxVertexInstructions = 4096; - } + if (strstr((const char*)glGetString(GL_VENDOR), "ATI") != NULL) + { + s_nMaxVertexInstructions = 4096; + } #endif } void VertexShaderCache::Shutdown() { - for (VSCache::iterator iter = vshaders.begin(); iter != vshaders.end(); ++iter) - iter->second.Destroy(); - vshaders.clear(); + for (VSCache::iterator iter = vshaders.begin(); iter != vshaders.end(); ++iter) + iter->second.Destroy(); + vshaders.clear(); } VERTEXSHADER* VertexShaderCache::SetShader(u32 components) { - VERTEXSHADERUID uid; - GetVertexShaderId(&uid, components); - if (last_entry) - { - if (uid == last_uid) - { - GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); - ValidateVertexShaderIDs(API_OPENGL, vshaders[uid].safe_uid, vshaders[uid].shader.strprog, components); - return &last_entry->shader; - } - } + VERTEXSHADERUID uid; + GetVertexShaderId(&uid, components); + if (last_entry) + { + if (uid == last_uid) + { + GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); + ValidateVertexShaderIDs(API_OPENGL, vshaders[uid].safe_uid, vshaders[uid].shader.strprog, components); + return &last_entry->shader; + } + } - last_uid = uid; + last_uid = uid; - VSCache::iterator iter = vshaders.find(uid); - if (iter != vshaders.end()) - { - VSCacheEntry &entry = iter->second; - last_entry = &entry; + VSCache::iterator iter = vshaders.find(uid); + if (iter != vshaders.end()) + { + VSCacheEntry &entry = iter->second; + last_entry = &entry; - GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); - ValidateVertexShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, components); - return &last_entry->shader; - } + GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); + ValidateVertexShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, components); + return &last_entry->shader; + } - // Make an entry in the table - VSCacheEntry& entry = vshaders[uid]; - last_entry = &entry; - const char *code = GenerateVertexShaderCode(components, API_OPENGL); - GetSafeVertexShaderId(&entry.safe_uid, components); + // Make an entry in the table + VSCacheEntry& entry = vshaders[uid]; + last_entry = &entry; + const char *code = GenerateVertexShaderCode(components, API_OPENGL); + GetSafeVertexShaderId(&entry.safe_uid, components); #if defined(_DEBUG) || defined(DEBUGFAST) - if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) { - static int counter = 0; - char szTemp[MAX_PATH]; - sprintf(szTemp, "%svs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++); + if (g_ActiveConfig.iLog & CONF_SAVESHADERS && code) { + static int counter = 0; + char szTemp[MAX_PATH]; + sprintf(szTemp, "%svs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++); - SaveData(szTemp, code); - } + SaveData(szTemp, code); + } #endif - if (!code || !VertexShaderCache::CompileVertexShader(entry.shader, code)) { - GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true); - return NULL; - } + if (!code || !VertexShaderCache::CompileVertexShader(entry.shader, code)) { + GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true); + return NULL; + } - INCSTAT(stats.numVertexShadersCreated); - SETSTAT(stats.numVertexShadersAlive, vshaders.size()); - GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); - return &last_entry->shader; + INCSTAT(stats.numVertexShadersCreated); + SETSTAT(stats.numVertexShadersAlive, vshaders.size()); + GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); + return &last_entry->shader; } bool VertexShaderCache::CompileVertexShader(VERTEXSHADER& vs, const char* pstrprogram) { - // Reset GL error before compiling shaders. Yeah, we need to investigate the causes of these. - GLenum err = GL_REPORT_ERROR(); - if (err != GL_NO_ERROR) - { - ERROR_LOG(VIDEO, "glError %08x before VS!", err); - } + // Reset GL error before compiling shaders. Yeah, we need to investigate the causes of these. + GLenum err = GL_REPORT_ERROR(); + if (err != GL_NO_ERROR) + { + ERROR_LOG(VIDEO, "glError %08x before VS!", err); + } #if defined HAVE_CG && HAVE_CG - char stropt[64]; - sprintf(stropt, "MaxLocalParams=256,MaxInstructions=%d", s_nMaxVertexInstructions); - const char *opts[] = {"-profileopts", stropt, "-O2", "-q", NULL}; - CGprogram tempprog = cgCreateProgram(g_cgcontext, CG_SOURCE, pstrprogram, g_cgvProf, "main", opts); - if (!cgIsProgram(tempprog)) { - static int num_failures = 0; - char szTemp[MAX_PATH]; - sprintf(szTemp, "%sbad_vs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++); - std::ofstream file(szTemp); - file << pstrprogram; - file.close(); + char stropt[64]; + sprintf(stropt, "MaxLocalParams=256,MaxInstructions=%d", s_nMaxVertexInstructions); + const char *opts[] = {"-profileopts", stropt, "-O2", "-q", NULL}; + CGprogram tempprog = cgCreateProgram(g_cgcontext, CG_SOURCE, pstrprogram, g_cgvProf, "main", opts); + if (!cgIsProgram(tempprog)) { + static int num_failures = 0; + char szTemp[MAX_PATH]; + sprintf(szTemp, "%sbad_vs_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++); + std::ofstream file(szTemp); + file << pstrprogram; + file.close(); - PanicAlert("Failed to compile vertex shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%d):\n%s", - szTemp, - g_cgfProf, - cgGetLastListing(g_cgcontext)); + PanicAlert("Failed to compile vertex shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%d):\n%s", + szTemp, + g_cgfProf, + cgGetLastListing(g_cgcontext)); cgDestroyProgram(tempprog); - ERROR_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext)); - ERROR_LOG(VIDEO, "%s", pstrprogram); - return false; - } + ERROR_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext)); + ERROR_LOG(VIDEO, "%s", pstrprogram); + return false; + } - if (cgGetError() != CG_NO_ERROR) - { - WARN_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext)); - WARN_LOG(VIDEO, "%s", pstrprogram); - } + if (cgGetError() != CG_NO_ERROR) + { + WARN_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext)); + WARN_LOG(VIDEO, "%s", pstrprogram); + } - // This looks evil - we modify the program through the const char * we got from cgGetProgramString! - // It SHOULD not have any nasty side effects though - but you never know... - char *pcompiledprog = (char*)cgGetProgramString(tempprog, CG_COMPILED_PROGRAM); - char *plocal = strstr(pcompiledprog, "program.local"); - while (plocal != NULL) { - const char* penv = " program.env"; - memcpy(plocal, penv, 13); - plocal = strstr(plocal + 13, "program.local"); - } - glGenProgramsARB(1, &vs.glprogid); - SetCurrentShader(vs.glprogid); + // This looks evil - we modify the program through the const char * we got from cgGetProgramString! + // It SHOULD not have any nasty side effects though - but you never know... + char *pcompiledprog = (char*)cgGetProgramString(tempprog, CG_COMPILED_PROGRAM); + char *plocal = strstr(pcompiledprog, "program.local"); + while (plocal != NULL) { + const char* penv = " program.env"; + memcpy(plocal, penv, 13); + plocal = strstr(plocal + 13, "program.local"); + } + glGenProgramsARB(1, &vs.glprogid); + SetCurrentShader(vs.glprogid); - glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pcompiledprog), pcompiledprog); - err = GL_REPORT_ERROR(); - if (err != GL_NO_ERROR) { - ERROR_LOG(VIDEO, "%s", pstrprogram); - ERROR_LOG(VIDEO, "%s", pcompiledprog); - } + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pcompiledprog), pcompiledprog); + err = GL_REPORT_ERROR(); + if (err != GL_NO_ERROR) { + ERROR_LOG(VIDEO, "%s", pstrprogram); + ERROR_LOG(VIDEO, "%s", pcompiledprog); + } - cgDestroyProgram(tempprog); + cgDestroyProgram(tempprog); #endif - if (g_ActiveConfig.bEnableShaderDebugging) - vs.strprog = pstrprogram; + if (g_ActiveConfig.bEnableShaderDebugging) + vs.strprog = pstrprogram; - return true; + return true; } void VertexShaderCache::DisableShader() { - if (ShaderEnabled) - { - glDisable(GL_VERTEX_PROGRAM_ARB); - ShaderEnabled = false; - } + if (ShaderEnabled) + { + glDisable(GL_VERTEX_PROGRAM_ARB); + ShaderEnabled = false; + } } void VertexShaderCache::SetCurrentShader(GLuint Shader) { - if (!ShaderEnabled) - { - glEnable(GL_VERTEX_PROGRAM_ARB); - ShaderEnabled= true; - } - if (CurrentShader != Shader) - { - if(Shader != 0) - CurrentShader = Shader; - glBindProgramARB(GL_VERTEX_PROGRAM_ARB, CurrentShader); - } + if (!ShaderEnabled) + { + glEnable(GL_VERTEX_PROGRAM_ARB); + ShaderEnabled= true; + } + if (CurrentShader != Shader) + { + if(Shader != 0) + CurrentShader = Shader; + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, CurrentShader); + } } - -void Renderer::SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) +// GLSL Specific +void SetVSConstant4fvByName(const char * name, unsigned int offset, const float *f, const unsigned int count = 1) { - glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, const_number, f1, f2, f3, f4); + PROGRAMSHADER tmp = ProgramShaderCache::GetShaderProgram(); + for(int a = 0; a < NUM_UNIFORMS; ++a) + if(!strcmp(name, UniformNames[a])) + { + if(tmp.UniformLocations[a] == -1) + return; + else + { + glUniform4fv(tmp.UniformLocations[a] + offset, count, f); + return; + } + } } - -void Renderer::SetVSConstant4fv(unsigned int const_number, const float *f) +void SetGLSLVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) { - glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, const_number, f); + float buf[4]; + buf[0] = f1; + buf[1] = f2; + buf[2] = f3; + buf[3] = f4; + 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::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) +void SetGLSLVSConstant4fv(unsigned int const_number, const float *f) +{ + 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 SetMultiGLSLVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) +{ + 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 SetMultiGLSLVSConstant3fv(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; + } + 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; + } + } +} + +// CG Specific +void SetCGVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) +{ + glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, const_number, f1, f2, f3, f4); +} + +void SetCGVSConstant4fv(unsigned int const_number, const float *f) +{ + glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, const_number, f); +} + +void SetMultiCGVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) { if(GLEW_EXT_gpu_program_parameters) { - glProgramEnvParameters4fvEXT(GL_VERTEX_PROGRAM_ARB, const_number, count, f); + glProgramEnvParameters4fvEXT(GL_VERTEX_PROGRAM_ARB, const_number, count, f); } else { @@ -241,32 +341,54 @@ void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int cou } } -void Renderer::SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) +void SetMultiCGVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) { - if(GLEW_EXT_gpu_program_parameters) - { + if(GLEW_EXT_gpu_program_parameters) + { 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; - } + { + buf[4*i ] = *f++; + buf[4*i+1] = *f++; + buf[4*i+2] = *f++; + buf[4*i+3] = 0.f; + } glProgramEnvParameters4fvEXT(GL_VERTEX_PROGRAM_ARB, const_number, count, buf); } else { for (unsigned int i = 0; i < count; i++) - { - float buf[4]; - buf[0] = *f++; - buf[1] = *f++; - buf[2] = *f++; - buf[3] = 0.f; - glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, const_number + i, buf); - } + { + float buf[4]; + buf[0] = *f++; + buf[1] = *f++; + buf[2] = *f++; + buf[3] = 0.f; + glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, const_number + i, buf); + } } } +// Renderer Functions +void Renderer::SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4) +{ + pSetVSConstant4f(const_number, f1, f2, f3, f4); +} + +void Renderer::SetVSConstant4fv(unsigned int const_number, const float *f) +{ + pSetVSConstant4fv(const_number, f); +} + +void Renderer::SetMultiVSConstant4fv(unsigned int const_number, unsigned int count, const float *f) +{ + pSetMultiVSConstant4fv(const_number, count, f); +} + +void Renderer::SetMultiVSConstant3fv(unsigned int const_number, unsigned int count, const float *f) +{ + pSetMultiVSConstant3fv(const_number, count, f); +} + + } // namespace OGL diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h index 6f4cbe25c2..e398a801ff 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h @@ -70,7 +70,17 @@ public: static void DisableShader(); }; +// GLSL Specific +void SetGLSLVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); +void SetGLSLVSConstant4fv(unsigned int const_number, const float *f); +void SetMultiGLSLVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); +void SetMultiGLSLVSConstant3fv(unsigned int const_number, unsigned int count, const float *f); +// CG Specific +void SetCGVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4); +void SetCGVSConstant4fv(unsigned int const_number, const float *f); +void SetMultiCGVSConstant4fv(unsigned int const_number, unsigned int count, const float *f); +void SetMultiCGVSConstant3fv(unsigned int const_number, unsigned int count, const float *f); } // namespace OGL #endif // _VERTEXSHADERCACHE_H_ diff --git a/Source/Plugins/Plugin_VideoOGL/Src/main.cpp b/Source/Plugins/Plugin_VideoOGL/Src/main.cpp index 543fb9824d..572c1fbbe9 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/main.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/main.cpp @@ -135,6 +135,7 @@ void InitBackendInfo() g_Config.backend_info.bSupportsDualSourceBlend = false; // supported, but broken g_Config.backend_info.bSupportsFormatReinterpretation = false; g_Config.backend_info.bSupportsPixelLighting = true; + g_Config.backend_info.bSupportsGLSL = true; // aamodes const char* caamodes[] = {"None", "2x", "4x", "8x", "8x CSAA", "8xQ CSAA", "16x CSAA", "16xQ CSAA"};