dolphin-emu/dolphin
1
0
Fork 1
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-09-13 03:30:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

Improve the shader UID debugging stuff and merge it to VideoCommon, effectively enabling it in D3D9 and D3D11 as well.

Browse Source
This commit is contained in:
NeoBrainX
2011-09-09 00:32:04 +02:00
parent 349a3ae91d
commit b28348066e
16 changed files with 614 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/Common/Src/MsgHandler.cpp
View File

@@ -53,7 +53,7 @@ bool MsgAlert(bool yes_no, int Style, const char* format, ...)
{ {
// Read message and write it to the log // Read message and write it to the log
std::string caption; std::string caption;
char buffer[4096]; char buffer[2048];
static std::string info_caption; static std::string info_caption;
static std::string warn_caption; static std::string warn_caption;

45
Source/Core/VideoCommon/Src/PixelShaderGen.cpp
View File

@@ -241,6 +241,39 @@ void GetSafePixelShaderId(PIXELSHADERUIDSAFE *uid, DSTALPHA_MODE dstAlphaMode)
_assert_((ptr - uid->values) == uid->GetNumValues()); _assert_((ptr - uid->values) == uid->GetNumValues());
} }
void ValidatePixelShaderIDs(API_TYPE api, PIXELSHADERUIDSAFE old_id, const std::string& old_code, DSTALPHA_MODE dstAlphaMode, u32 components)
{
PIXELSHADERUIDSAFE new_id;
GetSafePixelShaderId(&new_id, dstAlphaMode);
if (!(old_id == new_id))
{
std::string new_code(GeneratePixelShaderCode(dstAlphaMode, api, components));
if (old_code != new_code)
{
_assert_(old_id.GetNumValues() == new_id.GetNumValues());
char msg[8192];
char* ptr = msg;
ptr += sprintf(ptr, "Pixel shader IDs matched but unique IDs did not!\nUnique IDs (old <-> new):\n");
const int N = new_id.GetNumValues();
for (int i = 0; i < N/2; ++i)
ptr += sprintf(ptr, "%02d, %08X %08X | %08X %08X\n", 2*i, old_id.values[2*i], old_id.values[2*i+1],
new_id.values[2*i], new_id.values[2*i+1]);
if (N % 2)
ptr += sprintf(ptr, "%02d, %08X | %08X\n", N-1, old_id.values[N-1], new_id.values[N-1]);
static int num_failures = 0;
char szTemp[MAX_PATH];
sprintf(szTemp, "%spsuid_mismatch_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file(szTemp);
file << msg;
file.close();
PanicAlert("Unique pixel shader ID mismatch!\n\nReport this to the devs, along with the contents of %s.", szTemp);
}
}
}
// old tev->pixelshader notes // old tev->pixelshader notes
// //
@@ -594,12 +627,12 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType
WRITE(p, " float4 c0 = "I_COLORS"[1], c1 = "I_COLORS"[2], c2 = "I_COLORS"[3], prev = float4(0.0f, 0.0f, 0.0f, 0.0f), textemp = float4(0.0f, 0.0f, 0.0f, 0.0f), rastemp = float4(0.0f, 0.0f, 0.0f, 0.0f), konsttemp = float4(0.0f, 0.0f, 0.0f, 0.0f);\n" WRITE(p, " float4 c0 = "I_COLORS"[1], c1 = "I_COLORS"[2], c2 = "I_COLORS"[3], prev = float4(0.0f, 0.0f, 0.0f, 0.0f), textemp = float4(0.0f, 0.0f, 0.0f, 0.0f), rastemp = float4(0.0f, 0.0f, 0.0f, 0.0f), konsttemp = float4(0.0f, 0.0f, 0.0f, 0.0f);\n"
" float3 comp16 = float3(1.0f, 255.0f, 0.0f), comp24 = float3(1.0f, 255.0f, 255.0f*255.0f);\n" " float3 comp16 = float3(1.0f, 255.0f, 0.0f), comp24 = float3(1.0f, 255.0f, 255.0f*255.0f);\n"
" float4 alphabump=float4(0.0f,0.0f,0.0f,0.0f);\n" " float4 alphabump=float4(0.0f,0.0f,0.0f,0.0f);\n"
" float3 tevcoord=float3(0.0f, 0.0f, 0.0f);\n" " float3 tevcoord=float3(0.0f, 0.0f, 0.0f);\n"
" float2 wrappedcoord=float2(0.0f,0.0f), tempcoord=float2(0.0f,0.0f);\n" " float2 wrappedcoord=float2(0.0f,0.0f), tempcoord=float2(0.0f,0.0f);\n"
" float4 cc0=float4(0.0f,0.0f,0.0f,0.0f), cc1=float4(0.0f,0.0f,0.0f,0.0f);\n" " float4 cc0=float4(0.0f,0.0f,0.0f,0.0f), cc1=float4(0.0f,0.0f,0.0f,0.0f);\n"
" float4 cc2=float4(0.0f,0.0f,0.0f,0.0f), cprev=float4(0.0f,0.0f,0.0f,0.0f);\n" " float4 cc2=float4(0.0f,0.0f,0.0f,0.0f), cprev=float4(0.0f,0.0f,0.0f,0.0f);\n"
" float4 crastemp=float4(0.0f,0.0f,0.0f,0.0f),ckonsttemp=float4(0.0f,0.0f,0.0f,0.0f);\n\n"); " float4 crastemp=float4(0.0f,0.0f,0.0f,0.0f),ckonsttemp=float4(0.0f,0.0f,0.0f,0.0f);\n\n");
if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting)
{ {

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

@@ -123,6 +123,9 @@ const char *GeneratePixelShaderCode(DSTALPHA_MODE dstAlphaMode, API_TYPE ApiType
void GetPixelShaderId(PIXELSHADERUID *uid, DSTALPHA_MODE dstAlphaMode); void GetPixelShaderId(PIXELSHADERUID *uid, DSTALPHA_MODE dstAlphaMode);
void GetSafePixelShaderId(PIXELSHADERUIDSAFE *uid, DSTALPHA_MODE dstAlphaMode); void GetSafePixelShaderId(PIXELSHADERUIDSAFE *uid, DSTALPHA_MODE dstAlphaMode);
// Used to make sure that our optimized pixel shader IDs don't lose any possible shader code changes
void ValidatePixelShaderIDs(API_TYPE api, PIXELSHADERUIDSAFE old_id, const std::string& old_code, DSTALPHA_MODE dstAlphaMode, u32 components);
extern PIXELSHADERUID last_pixel_shader_uid; extern PIXELSHADERUID last_pixel_shader_uid;
#endif // GCOGL_PIXELSHADER_H #endif // GCOGL_PIXELSHADER_H

968
Source/Core/VideoCommon/Src/VertexShaderGen.cpp
View File

@@ -1,466 +1,502 @@
// Copyright (C) 2003 Dolphin Project. // Copyright (C) 2003 Dolphin Project.
// This program is free software: you can redistribute it and/or modify // 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 // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0. // the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details. // GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program. // A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/ // If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at // Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/ // http://code.google.com/p/dolphin-emu/
#include <math.h> #include <math.h>
#include <locale.h> #include <locale.h>
#include "NativeVertexFormat.h" #include "NativeVertexFormat.h"
#include "BPMemory.h" #include "BPMemory.h"
#include "CPMemory.h" #include "CPMemory.h"
#include "LightingShaderGen.h" #include "LightingShaderGen.h"
#include "VertexShaderGen.h" #include "VertexShaderGen.h"
#include "VideoConfig.h" #include "VideoConfig.h"
VERTEXSHADERUID last_vertex_shader_uid; VERTEXSHADERUID last_vertex_shader_uid;
// Mash together all the inputs that contribute to the code of a generated vertex shader into // Mash together all the inputs that contribute to the code of a generated vertex shader into
// a unique identifier, basically containing all the bits. Yup, it's a lot .... // a unique identifier, basically containing all the bits. Yup, it's a lot ....
void GetVertexShaderId(VERTEXSHADERUID *uid, u32 components) void GetVertexShaderId(VERTEXSHADERUID *uid, u32 components)
{ {
uid->values[0] = components | uid->values[0] = components |
(xfregs.numTexGen.numTexGens << 23) | (xfregs.numTexGen.numTexGens << 23) |
(xfregs.numChan.numColorChans << 27) | (xfregs.numChan.numColorChans << 27) |
(xfregs.dualTexTrans.enabled << 29); (xfregs.dualTexTrans.enabled << 29);
for (int i = 0; i < xfregs.numChan.numColorChans; ++i) { for (int i = 0; i < xfregs.numChan.numColorChans; ++i) {
uid->values[1+i] = xfregs.color[i].enablelighting ? uid->values[1+i] = xfregs.color[i].enablelighting ?
(u32)xfregs.color[i].hex : (u32)xfregs.color[i].hex :
(u32)xfregs.color[i].matsource; (u32)xfregs.color[i].matsource;
uid->values[1+i] |= (xfregs.alpha[i].enablelighting ? uid->values[1+i] |= (xfregs.alpha[i].enablelighting ?
(u32)xfregs.alpha[i].hex : (u32)xfregs.alpha[i].hex :
(u32)xfregs.alpha[i].matsource) << 15; (u32)xfregs.alpha[i].matsource) << 15;
} }
uid->values[2] |= (g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) << 31; uid->values[2] |= (g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) << 31;
u32 *pcurvalue = &uid->values[3]; u32 *pcurvalue = &uid->values[3];
for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) { for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) {
TexMtxInfo tinfo = xfregs.texMtxInfo[i]; TexMtxInfo tinfo = xfregs.texMtxInfo[i];
if (tinfo.texgentype != XF_TEXGEN_EMBOSS_MAP) if (tinfo.texgentype != XF_TEXGEN_EMBOSS_MAP)
tinfo.hex &= 0x7ff; tinfo.hex &= 0x7ff;
if (tinfo.texgentype != XF_TEXGEN_REGULAR) if (tinfo.texgentype != XF_TEXGEN_REGULAR)
tinfo.projection = 0; tinfo.projection = 0;
u32 val = ((tinfo.hex >> 1) & 0x1ffff); u32 val = ((tinfo.hex >> 1) & 0x1ffff);
if (xfregs.dualTexTrans.enabled && tinfo.texgentype == XF_TEXGEN_REGULAR) { if (xfregs.dualTexTrans.enabled && tinfo.texgentype == XF_TEXGEN_REGULAR) {
// rewrite normalization and post index // rewrite normalization and post index
val |= ((u32)xfregs.postMtxInfo[i].index << 17) | ((u32)xfregs.postMtxInfo[i].normalize << 23); val |= ((u32)xfregs.postMtxInfo[i].index << 17) | ((u32)xfregs.postMtxInfo[i].normalize << 23);
} }
switch (i & 3) { switch (i & 3) {
case 0: pcurvalue[0] |= val; break; case 0: pcurvalue[0] |= val; break;
case 1: pcurvalue[0] |= val << 24; pcurvalue[1] = val >> 8; ++pcurvalue; break; case 1: pcurvalue[0] |= val << 24; pcurvalue[1] = val >> 8; ++pcurvalue; break;
case 2: pcurvalue[0] |= val << 16; pcurvalue[1] = val >> 16; ++pcurvalue; break; case 2: pcurvalue[0] |= val << 16; pcurvalue[1] = val >> 16; ++pcurvalue; break;
case 3: pcurvalue[0] |= val << 8; ++pcurvalue; break; case 3: pcurvalue[0] |= val << 8; ++pcurvalue; break;
} }
} }
} }
void GetSafeVertexShaderId(VERTEXSHADERUIDSAFE *uid, u32 components) void GetSafeVertexShaderId(VERTEXSHADERUIDSAFE *uid, u32 components)
{ {
// Just store all used registers here without caring whether we need all bits or less. // Just store all used registers here without caring whether we need all bits or less.
u32* ptr = uid->values; u32* ptr = uid->values;
*ptr++ = components; *ptr++ = components;
*ptr++ = xfregs.numTexGen.hex; *ptr++ = xfregs.numTexGen.hex;
*ptr++ = xfregs.numChan.hex; *ptr++ = xfregs.numChan.hex;
*ptr++ = xfregs.dualTexTrans.hex; *ptr++ = xfregs.dualTexTrans.hex;
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
*ptr++ = xfregs.color[i].hex; *ptr++ = xfregs.color[i].hex;
*ptr++ = xfregs.alpha[i].hex; *ptr++ = xfregs.alpha[i].hex;
} }
*ptr++ = g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting; *ptr++ = g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting;
for (unsigned int i = 0; i < 8; ++i) { for (unsigned int i = 0; i < 8; ++i) {
*ptr++ = xfregs.texMtxInfo[i].hex; *ptr++ = xfregs.texMtxInfo[i].hex;
*ptr++ = xfregs.postMtxInfo[i].hex; *ptr++ = xfregs.postMtxInfo[i].hex;
} }
_assert_((ptr - uid->values) == uid->GetNumValues()); _assert_((ptr - uid->values) == uid->GetNumValues());
} }
static char text[16384];
void ValidateVertexShaderIDs(API_TYPE api, VERTEXSHADERUIDSAFE old_id, const std::string& old_code, u32 components)
#define WRITE p+=sprintf {
VERTEXSHADERUIDSAFE new_id;
char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type) GetSafeVertexShaderId(&new_id, components);
{
WRITE(p, "struct VS_OUTPUT {\n"); if (!(old_id == new_id))
WRITE(p, " float4 pos : POSITION;\n"); {
WRITE(p, " float4 colors_0 : COLOR0;\n"); std::string new_code(GenerateVertexShaderCode(components, api));
WRITE(p, " float4 colors_1 : COLOR1;\n"); if (old_code != new_code)
{
if (xfregs.numTexGen.numTexGens < 7) { _assert_(old_id.GetNumValues() == new_id.GetNumValues());
for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i)
WRITE(p, " float3 tex%d : TEXCOORD%d;\n", i, i); char msg[8192];
WRITE(p, " float4 clipPos : TEXCOORD%d;\n", xfregs.numTexGen.numTexGens); char* ptr = msg;
if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) ptr += sprintf(ptr, "Vertex shader IDs matched but unique IDs did not!\nUnique IDs (old <-> new):\n");
WRITE(p, " float4 Normal : TEXCOORD%d;\n", xfregs.numTexGen.numTexGens + 1); const int N = new_id.GetNumValues();
} else { for (int i = 0; i < N/2; ++i)
// clip position is in w of first 4 texcoords ptr += sprintf(ptr, "%02d, %08X %08X | %08X %08X\n", 2*i, old_id.values[2*i], old_id.values[2*i+1],
if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) new_id.values[2*i], new_id.values[2*i+1]);
{ if (N % 2)
for (int i = 0; i < 8; ++i) ptr += sprintf(ptr, "%02d, %08X | %08X\n", N-1, old_id.values[N-1], new_id.values[N-1]);
WRITE(p, " float4 tex%d : TEXCOORD%d;\n", i, i);
} static int num_failures = 0;
else char szTemp[MAX_PATH];
{ sprintf(szTemp, "%svsuid_mismatch_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) std::ofstream file(szTemp);
WRITE(p, " float%d tex%d : TEXCOORD%d;\n", i < 4 ? 4 : 3 , i, i); file << msg;
} file.close();
}
WRITE(p, "};\n"); PanicAlert("Unique pixel shader ID mismatch!\n\nReport this to the devs, along with the contents of %s.", szTemp);
}
return p; }
} }
const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type)
{ static char text[16384];
setlocale(LC_NUMERIC, "C"); // Reset locale for compilation
text[sizeof(text) - 1] = 0x7C; // canary #define WRITE p+=sprintf
_assert_(bpmem.genMode.numtexgens == xfregs.numTexGen.numTexGens); char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type)
_assert_(bpmem.genMode.numcolchans == xfregs.numChan.numColorChans); {
WRITE(p, "struct VS_OUTPUT {\n");
bool is_d3d = (api_type & API_D3D9 || api_type == API_D3D11); WRITE(p, " float4 pos : POSITION;\n");
u32 lightMask = 0; WRITE(p, " float4 colors_0 : COLOR0;\n");
if (xfregs.numChan.numColorChans > 0) WRITE(p, " float4 colors_1 : COLOR1;\n");
lightMask |= xfregs.color[0].GetFullLightMask() | xfregs.alpha[0].GetFullLightMask();
if (xfregs.numChan.numColorChans > 1) if (xfregs.numTexGen.numTexGens < 7) {
lightMask |= xfregs.color[1].GetFullLightMask() | xfregs.alpha[1].GetFullLightMask(); for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i)
WRITE(p, " float3 tex%d : TEXCOORD%d;\n", i, i);
char *p = text; WRITE(p, " float4 clipPos : TEXCOORD%d;\n", xfregs.numTexGen.numTexGens);
WRITE(p, "//Vertex Shader: comp:%x, \n", components); if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting)
WRITE(p, "typedef struct { float4 T0, T1, T2; float4 N0, N1, N2; } s_"I_POSNORMALMATRIX";\n" WRITE(p, " float4 Normal : TEXCOORD%d;\n", xfregs.numTexGen.numTexGens + 1);
"typedef struct { float4 t; } FLT4;\n" } else {
"typedef struct { FLT4 T[24]; } s_"I_TEXMATRICES";\n" // clip position is in w of first 4 texcoords
"typedef struct { FLT4 T[64]; } s_"I_TRANSFORMMATRICES";\n" if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting)
"typedef struct { FLT4 T[32]; } s_"I_NORMALMATRICES";\n" {
"typedef struct { FLT4 T[64]; } s_"I_POSTTRANSFORMMATRICES";\n" for (int i = 0; i < 8; ++i)
"typedef struct { float4 col; float4 cosatt; float4 distatt; float4 pos; float4 dir; } Light;\n" WRITE(p, " float4 tex%d : TEXCOORD%d;\n", i, i);
"typedef struct { Light lights[8]; } s_"I_LIGHTS";\n" }
"typedef struct { float4 C0, C1, C2, C3; } s_"I_MATERIALS";\n" else
"typedef struct { float4 T0, T1, T2, T3; } s_"I_PROJECTION";\n" {
); for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i)
WRITE(p, " float%d tex%d : TEXCOORD%d;\n", i < 4 ? 4 : 3 , i, i);
p = GenerateVSOutputStruct(p, components, api_type); }
}
// uniforms WRITE(p, "};\n");
WRITE(p, "uniform s_"I_TRANSFORMMATRICES" "I_TRANSFORMMATRICES" : register(c%d);\n", C_TRANSFORMMATRICES); return p;
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); const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type)
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); setlocale(LC_NUMERIC, "C"); // Reset locale for compilation
WRITE(p, "uniform s_"I_MATERIALS" "I_MATERIALS" : register(c%d);\n", C_MATERIALS); text[sizeof(text) - 1] = 0x7C; // canary
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); _assert_(bpmem.genMode.numtexgens == xfregs.numTexGen.numTexGens);
_assert_(bpmem.genMode.numcolchans == xfregs.numChan.numColorChans);
WRITE(p, "VS_OUTPUT main(\n");
bool is_d3d = (api_type & API_D3D9 || api_type == API_D3D11);
// inputs u32 lightMask = 0;
if (components & VB_HAS_NRM0) if (xfregs.numChan.numColorChans > 0)
WRITE(p, " float3 rawnorm0 : NORMAL0,\n"); lightMask |= xfregs.color[0].GetFullLightMask() | xfregs.alpha[0].GetFullLightMask();
if (components & VB_HAS_NRM1) { if (xfregs.numChan.numColorChans > 1)
if (is_d3d) lightMask |= xfregs.color[1].GetFullLightMask() | xfregs.alpha[1].GetFullLightMask();
WRITE(p, " float3 rawnorm1 : NORMAL1,\n");
else char *p = text;
WRITE(p, " float3 rawnorm1 : ATTR%d,\n", SHADER_NORM1_ATTRIB); WRITE(p, "//Vertex Shader: comp:%x, \n", components);
} WRITE(p, "typedef struct { float4 T0, T1, T2; float4 N0, N1, N2; } s_"I_POSNORMALMATRIX";\n"
if (components & VB_HAS_NRM2) { "typedef struct { float4 t; } FLT4;\n"
if (is_d3d) "typedef struct { FLT4 T[24]; } s_"I_TEXMATRICES";\n"
WRITE(p, " float3 rawnorm2 : NORMAL2,\n"); "typedef struct { FLT4 T[64]; } s_"I_TRANSFORMMATRICES";\n"
else "typedef struct { FLT4 T[32]; } s_"I_NORMALMATRICES";\n"
WRITE(p, " float3 rawnorm2 : ATTR%d,\n", SHADER_NORM2_ATTRIB); "typedef struct { FLT4 T[64]; } s_"I_POSTTRANSFORMMATRICES";\n"
} "typedef struct { float4 col; float4 cosatt; float4 distatt; float4 pos; float4 dir; } Light;\n"
if (components & VB_HAS_COL0) "typedef struct { Light lights[8]; } s_"I_LIGHTS";\n"
WRITE(p, " float4 color0 : COLOR0,\n"); "typedef struct { float4 C0, C1, C2, C3; } s_"I_MATERIALS";\n"
if (components & VB_HAS_COL1) "typedef struct { float4 T0, T1, T2, T3; } s_"I_PROJECTION";\n"
WRITE(p, " float4 color1 : COLOR1,\n"); );
for (int i = 0; i < 8; ++i) {
u32 hastexmtx = (components & (VB_HAS_TEXMTXIDX0<<i)); p = GenerateVSOutputStruct(p, components, api_type);
if ((components & (VB_HAS_UV0<<i)) || hastexmtx)
WRITE(p, " float%d tex%d : TEXCOORD%d,\n", hastexmtx ? 3 : 2, i, i); // uniforms
}
if (components & VB_HAS_POSMTXIDX) { WRITE(p, "uniform s_"I_TRANSFORMMATRICES" "I_TRANSFORMMATRICES" : register(c%d);\n", C_TRANSFORMMATRICES);
if (is_d3d) 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, " float4 blend_indices : BLENDINDICES,\n"); 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);
else WRITE(p, "uniform s_"I_LIGHTS" "I_LIGHTS" : register(c%d);\n", C_LIGHTS);
WRITE(p, " float fposmtx : ATTR%d,\n", SHADER_POSMTX_ATTRIB); 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, " float4 rawpos : POSITION) {\n"); WRITE(p, "uniform float4 "I_DEPTHPARAMS" : register(c%d);\n", C_DEPTHPARAMS);
WRITE(p, "VS_OUTPUT o;\n");
WRITE(p, "VS_OUTPUT main(\n");
// transforms
if (components & VB_HAS_POSMTXIDX) // inputs
{ if (components & VB_HAS_NRM0)
if (api_type & API_D3D9) WRITE(p, " float3 rawnorm0 : NORMAL0,\n");
{ if (components & VB_HAS_NRM1) {
WRITE(p, "int4 indices = D3DCOLORtoUBYTE4(blend_indices);\n"); if (is_d3d)
WRITE(p, "int posmtx = indices.x;\n"); WRITE(p, " float3 rawnorm1 : NORMAL1,\n");
} else
else if (api_type == API_D3D11) WRITE(p, " float3 rawnorm1 : ATTR%d,\n", SHADER_NORM1_ATTRIB);
{ }
WRITE(p, "int posmtx = blend_indices.x * 255.0f;\n"); if (components & VB_HAS_NRM2) {
} if (is_d3d)
else WRITE(p, " float3 rawnorm2 : NORMAL2,\n");
{ else
WRITE(p, "int posmtx = fposmtx;\n"); WRITE(p, " float3 rawnorm2 : ATTR%d,\n", SHADER_NORM2_ATTRIB);
} }
if (components & VB_HAS_COL0)
WRITE(p, "float4 pos = float4(dot("I_TRANSFORMMATRICES".T[posmtx].t, rawpos), dot("I_TRANSFORMMATRICES".T[posmtx+1].t, rawpos), dot("I_TRANSFORMMATRICES".T[posmtx+2].t, rawpos), 1);\n"); WRITE(p, " float4 color0 : COLOR0,\n");
if (components & VB_HAS_COL1)
if (components & VB_HAS_NRMALL) { WRITE(p, " float4 color1 : COLOR1,\n");
WRITE(p, "int normidx = posmtx >= 32 ? (posmtx-32) : posmtx;\n"); for (int i = 0; i < 8; ++i) {
WRITE(p, "float3 N0 = "I_NORMALMATRICES".T[normidx].t.xyz, N1 = "I_NORMALMATRICES".T[normidx+1].t.xyz, N2 = "I_NORMALMATRICES".T[normidx+2].t.xyz;\n"); u32 hastexmtx = (components & (VB_HAS_TEXMTXIDX0<<i));
} if ((components & (VB_HAS_UV0<<i)) || hastexmtx)
WRITE(p, " float%d tex%d : TEXCOORD%d,\n", hastexmtx ? 3 : 2, i, i);
if (components & VB_HAS_NRM0) }
WRITE(p, "float3 _norm0 = normalize(float3(dot(N0, rawnorm0), dot(N1, rawnorm0), dot(N2, rawnorm0)));\n"); if (components & VB_HAS_POSMTXIDX) {
if (components & VB_HAS_NRM1) if (is_d3d)
WRITE(p, "float3 _norm1 = float3(dot(N0, rawnorm1), dot(N1, rawnorm1), dot(N2, rawnorm1));\n"); {
if (components & VB_HAS_NRM2) WRITE(p, " float4 blend_indices : BLENDINDICES,\n");
WRITE(p, "float3 _norm2 = float3(dot(N0, rawnorm2), dot(N1, rawnorm2), dot(N2, rawnorm2));\n"); }
} else
else WRITE(p, " float fposmtx : ATTR%d,\n", SHADER_POSMTX_ATTRIB);
{ }
WRITE(p, "float4 pos = float4(dot("I_POSNORMALMATRIX".T0, rawpos), dot("I_POSNORMALMATRIX".T1, rawpos), dot("I_POSNORMALMATRIX".T2, rawpos), 1.0f);\n"); WRITE(p, " float4 rawpos : POSITION) {\n");
if (components & VB_HAS_NRM0) WRITE(p, "VS_OUTPUT o;\n");
WRITE(p, "float3 _norm0 = normalize(float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm0), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm0), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm0)));\n");
if (components & VB_HAS_NRM1) // transforms
WRITE(p, "float3 _norm1 = float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm1), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm1), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm1));\n"); if (components & VB_HAS_POSMTXIDX)
if (components & VB_HAS_NRM2) {
WRITE(p, "float3 _norm2 = float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm2), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm2), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm2));\n"); if (api_type & API_D3D9)
} {
WRITE(p, "int4 indices = D3DCOLORtoUBYTE4(blend_indices);\n");
if (!(components & VB_HAS_NRM0)) WRITE(p, "int posmtx = indices.x;\n");
WRITE(p, "float3 _norm0 = float3(0.0f, 0.0f, 0.0f);\n"); }
else if (api_type == API_D3D11)
{
WRITE(p, "int posmtx = blend_indices.x * 255.0f;\n");
WRITE(p, "o.pos = float4(dot("I_PROJECTION".T0, pos), dot("I_PROJECTION".T1, pos), dot("I_PROJECTION".T2, pos), dot("I_PROJECTION".T3, pos));\n"); }
else
WRITE(p, "float4 mat, lacc;\n" {
"float3 ldir, h;\n" WRITE(p, "int posmtx = fposmtx;\n");
"float dist, dist2, attn;\n"); }
if(xfregs.numChan.numColorChans == 0) WRITE(p, "float4 pos = float4(dot("I_TRANSFORMMATRICES".T[posmtx].t, rawpos), dot("I_TRANSFORMMATRICES".T[posmtx+1].t, rawpos), dot("I_TRANSFORMMATRICES".T[posmtx+2].t, rawpos), 1);\n");
{
if (components & VB_HAS_COL0) if (components & VB_HAS_NRMALL) {
WRITE(p, "o.colors_0 = color0;\n"); WRITE(p, "int normidx = posmtx >= 32 ? (posmtx-32) : posmtx;\n");
else WRITE(p, "float3 N0 = "I_NORMALMATRICES".T[normidx].t.xyz, N1 = "I_NORMALMATRICES".T[normidx+1].t.xyz, N2 = "I_NORMALMATRICES".T[normidx+2].t.xyz;\n");
WRITE(p, "o.colors_0 = float4(1.0f, 1.0f, 1.0f, 1.0f);\n"); }
}
if (components & VB_HAS_NRM0)
p = GenerateLightingShader(p, components, I_MATERIALS, I_LIGHTS, "color", "o.colors_"); WRITE(p, "float3 _norm0 = normalize(float3(dot(N0, rawnorm0), dot(N1, rawnorm0), dot(N2, rawnorm0)));\n");
if (components & VB_HAS_NRM1)
if(xfregs.numChan.numColorChans < 2) WRITE(p, "float3 _norm1 = float3(dot(N0, rawnorm1), dot(N1, rawnorm1), dot(N2, rawnorm1));\n");
{ if (components & VB_HAS_NRM2)
if (components & VB_HAS_COL1) WRITE(p, "float3 _norm2 = float3(dot(N0, rawnorm2), dot(N1, rawnorm2), dot(N2, rawnorm2));\n");
WRITE(p, "o.colors_1 = color1;\n"); }
else else
WRITE(p, "o.colors_1 = o.colors_0;\n"); {
} WRITE(p, "float4 pos = float4(dot("I_POSNORMALMATRIX".T0, rawpos), dot("I_POSNORMALMATRIX".T1, rawpos), dot("I_POSNORMALMATRIX".T2, rawpos), 1.0f);\n");
// special case if only pos and tex coord 0 and tex coord input is AB11 if (components & VB_HAS_NRM0)
// donko - this has caused problems in some games. removed for now. WRITE(p, "float3 _norm0 = normalize(float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm0), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm0), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm0)));\n");
bool texGenSpecialCase = false; if (components & VB_HAS_NRM1)
/*bool texGenSpecialCase = WRITE(p, "float3 _norm1 = float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm1), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm1), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm1));\n");
((g_VtxDesc.Hex & 0x60600L) == g_VtxDesc.Hex) && // only pos and tex coord 0 if (components & VB_HAS_NRM2)
(g_VtxDesc.Tex0Coord != NOT_PRESENT) && WRITE(p, "float3 _norm2 = float3(dot("I_POSNORMALMATRIX".N0.xyz, rawnorm2), dot("I_POSNORMALMATRIX".N1.xyz, rawnorm2), dot("I_POSNORMALMATRIX".N2.xyz, rawnorm2));\n");
(xfregs.texcoords[0].texmtxinfo.inputform == XF_TEXINPUT_AB11); }
*/
if (!(components & VB_HAS_NRM0))
// transform texcoords WRITE(p, "float3 _norm0 = float3(0.0f, 0.0f, 0.0f);\n");
WRITE(p, "float4 coord = float4(0.0f, 0.0f, 1.0f, 1.0f);\n");
for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) {
TexMtxInfo& texinfo = xfregs.texMtxInfo[i];
WRITE(p, "o.pos = float4(dot("I_PROJECTION".T0, pos), dot("I_PROJECTION".T1, pos), dot("I_PROJECTION".T2, pos), dot("I_PROJECTION".T3, pos));\n");
WRITE(p, "{\n");
WRITE(p, "coord = float4(0.0f, 0.0f, 1.0f, 1.0f);\n"); WRITE(p, "float4 mat, lacc;\n"
switch (texinfo.sourcerow) { "float3 ldir, h;\n"
case XF_SRCGEOM_INROW: "float dist, dist2, attn;\n");
_assert_( texinfo.inputform == XF_TEXINPUT_ABC1 );
WRITE(p, "coord = rawpos;\n"); // pos.w is 1 if(xfregs.numChan.numColorChans == 0)
break; {
case XF_SRCNORMAL_INROW: if (components & VB_HAS_COL0)
if (components & VB_HAS_NRM0) { WRITE(p, "o.colors_0 = color0;\n");
_assert_( texinfo.inputform == XF_TEXINPUT_ABC1 ); else
WRITE(p, "coord = float4(rawnorm0.xyz, 1.0f);\n"); WRITE(p, "o.colors_0 = float4(1.0f, 1.0f, 1.0f, 1.0f);\n");
} }
break;
case XF_SRCCOLORS_INROW: p = GenerateLightingShader(p, components, I_MATERIALS, I_LIGHTS, "color", "o.colors_");
_assert_( texinfo.texgentype == XF_TEXGEN_COLOR_STRGBC0 || texinfo.texgentype == XF_TEXGEN_COLOR_STRGBC1 );
break; if(xfregs.numChan.numColorChans < 2)
case XF_SRCBINORMAL_T_INROW: {
if (components & VB_HAS_NRM1) { if (components & VB_HAS_COL1)
_assert_( texinfo.inputform == XF_TEXINPUT_ABC1 ); WRITE(p, "o.colors_1 = color1;\n");
WRITE(p, "coord = float4(rawnorm1.xyz, 1.0f);\n"); else
} WRITE(p, "o.colors_1 = o.colors_0;\n");
break; }
case XF_SRCBINORMAL_B_INROW: // special case if only pos and tex coord 0 and tex coord input is AB11
if (components & VB_HAS_NRM2) { // donko - this has caused problems in some games. removed for now.
_assert_( texinfo.inputform == XF_TEXINPUT_ABC1 ); bool texGenSpecialCase = false;
WRITE(p, "coord = float4(rawnorm2.xyz, 1.0f);\n"); /*bool texGenSpecialCase =
} ((g_VtxDesc.Hex & 0x60600L) == g_VtxDesc.Hex) && // only pos and tex coord 0
break; (g_VtxDesc.Tex0Coord != NOT_PRESENT) &&
default: (xfregs.texcoords[0].texmtxinfo.inputform == XF_TEXINPUT_AB11);
_assert_(texinfo.sourcerow <= XF_SRCTEX7_INROW); */
if (components & (VB_HAS_UV0<<(texinfo.sourcerow - XF_SRCTEX0_INROW)) )
WRITE(p, "coord = float4(tex%d.x, tex%d.y, 1.0f, 1.0f);\n", texinfo.sourcerow - XF_SRCTEX0_INROW, texinfo.sourcerow - XF_SRCTEX0_INROW); // transform texcoords
break; WRITE(p, "float4 coord = float4(0.0f, 0.0f, 1.0f, 1.0f);\n");
} for (unsigned int i = 0; i < xfregs.numTexGen.numTexGens; ++i) {
TexMtxInfo& texinfo = xfregs.texMtxInfo[i];
// first transformation
switch (texinfo.texgentype) { WRITE(p, "{\n");
case XF_TEXGEN_EMBOSS_MAP: // calculate tex coords into bump map WRITE(p, "coord = float4(0.0f, 0.0f, 1.0f, 1.0f);\n");
switch (texinfo.sourcerow) {
if (components & (VB_HAS_NRM1|VB_HAS_NRM2)) { case XF_SRCGEOM_INROW:
// transform the light dir into tangent space _assert_( texinfo.inputform == XF_TEXINPUT_ABC1 );
WRITE(p, "ldir = normalize("I_LIGHTS".lights[%d].pos.xyz - pos.xyz);\n", texinfo.embosslightshift); WRITE(p, "coord = rawpos;\n"); // pos.w is 1
WRITE(p, "o.tex%d.xyz = o.tex%d.xyz + float3(dot(ldir, _norm1), dot(ldir, _norm2), 0.0f);\n", i, texinfo.embosssourceshift); break;
} case XF_SRCNORMAL_INROW:
else if (components & VB_HAS_NRM0) {
{ _assert_( texinfo.inputform == XF_TEXINPUT_ABC1 );
_assert_(0); // should have normals WRITE(p, "coord = float4(rawnorm0.xyz, 1.0f);\n");
WRITE(p, "o.tex%d.xyz = o.tex%d.xyz;\n", i, texinfo.embosssourceshift); }
} break;
case XF_SRCCOLORS_INROW:
break; _assert_( texinfo.texgentype == XF_TEXGEN_COLOR_STRGBC0 || texinfo.texgentype == XF_TEXGEN_COLOR_STRGBC1 );
case XF_TEXGEN_COLOR_STRGBC0: break;
_assert_(texinfo.sourcerow == XF_SRCCOLORS_INROW); case XF_SRCBINORMAL_T_INROW:
WRITE(p, "o.tex%d.xyz = float3(o.colors_0.x, o.colors_0.y, 1);\n", i); if (components & VB_HAS_NRM1) {
break; _assert_( texinfo.inputform == XF_TEXINPUT_ABC1 );
case XF_TEXGEN_COLOR_STRGBC1: WRITE(p, "coord = float4(rawnorm1.xyz, 1.0f);\n");
_assert_(texinfo.sourcerow == XF_SRCCOLORS_INROW); }
WRITE(p, "o.tex%d.xyz = float3(o.colors_1.x, o.colors_1.y, 1);\n", i); break;
break; case XF_SRCBINORMAL_B_INROW:
case XF_TEXGEN_REGULAR: if (components & VB_HAS_NRM2) {
default: _assert_( texinfo.inputform == XF_TEXINPUT_ABC1 );
if (components & (VB_HAS_TEXMTXIDX0<<i)) { WRITE(p, "coord = float4(rawnorm2.xyz, 1.0f);\n");
if (texinfo.projection == XF_TEXPROJ_STQ) }
WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+1].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+2].t));\n", i, i, i, i); break;
else { default:
WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+1].t), 1);\n", i, i, i); _assert_(texinfo.sourcerow <= XF_SRCTEX7_INROW);
} if (components & (VB_HAS_UV0<<(texinfo.sourcerow - XF_SRCTEX0_INROW)) )
} WRITE(p, "coord = float4(tex%d.x, tex%d.y, 1.0f, 1.0f);\n", texinfo.sourcerow - XF_SRCTEX0_INROW, texinfo.sourcerow - XF_SRCTEX0_INROW);
else { break;
if (texinfo.projection == XF_TEXPROJ_STQ) }
WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t));\n", i, 3*i, 3*i+1, 3*i+2);
else // first transformation
WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t), 1);\n", i, 3*i, 3*i+1); switch (texinfo.texgentype) {
} case XF_TEXGEN_EMBOSS_MAP: // calculate tex coords into bump map
break;
} if (components & (VB_HAS_NRM1|VB_HAS_NRM2)) {
// transform the light dir into tangent space
if (xfregs.dualTexTrans.enabled && texinfo.texgentype == XF_TEXGEN_REGULAR) { // only works for regular tex gen types? WRITE(p, "ldir = normalize("I_LIGHTS".lights[%d].pos.xyz - pos.xyz);\n", texinfo.embosslightshift);
const PostMtxInfo& postInfo = xfregs.postMtxInfo[i]; WRITE(p, "o.tex%d.xyz = o.tex%d.xyz + float3(dot(ldir, _norm1), dot(ldir, _norm2), 0.0f);\n", i, texinfo.embosssourceshift);
}
int postidx = postInfo.index; else
WRITE(p, "float4 P0 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n" {
"float4 P1 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n" _assert_(0); // should have normals
"float4 P2 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n", WRITE(p, "o.tex%d.xyz = o.tex%d.xyz;\n", i, texinfo.embosssourceshift);
postidx&0x3f, (postidx+1)&0x3f, (postidx+2)&0x3f); }
if (texGenSpecialCase) { break;
// no normalization case XF_TEXGEN_COLOR_STRGBC0:
// q of input is 1 _assert_(texinfo.sourcerow == XF_SRCCOLORS_INROW);
// q of output is unknown WRITE(p, "o.tex%d.xyz = float3(o.colors_0.x, o.colors_0.y, 1);\n", i);
break;
// multiply by postmatrix case XF_TEXGEN_COLOR_STRGBC1:
WRITE(p, "o.tex%d.xyz = float3(dot(P0.xy, o.tex%d.xy) + P0.z + P0.w, dot(P1.xy, o.tex%d.xy) + P1.z + P1.w, 0.0f);\n", i, i, i); _assert_(texinfo.sourcerow == XF_SRCCOLORS_INROW);
} WRITE(p, "o.tex%d.xyz = float3(o.colors_1.x, o.colors_1.y, 1);\n", i);
else break;
{ case XF_TEXGEN_REGULAR:
if (postInfo.normalize) default:
WRITE(p, "o.tex%d.xyz = normalize(o.tex%d.xyz);\n", i, i); if (components & (VB_HAS_TEXMTXIDX0<<i)) {
if (texinfo.projection == XF_TEXPROJ_STQ)
// multiply by postmatrix WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+1].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+2].t));\n", i, i, i, i);
WRITE(p, "o.tex%d.xyz = float3(dot(P0.xyz, o.tex%d.xyz) + P0.w, dot(P1.xyz, o.tex%d.xyz) + P1.w, dot(P2.xyz, o.tex%d.xyz) + P2.w);\n", i, i, i, i); else {
} WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z].t), dot(coord, "I_TRANSFORMMATRICES".T[tex%d.z+1].t), 1);\n", i, i, i);
} }
}
WRITE(p, "}\n"); else {
} if (texinfo.projection == XF_TEXPROJ_STQ)
WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t));\n", i, 3*i, 3*i+1, 3*i+2);
// clipPos/w needs to be done in pixel shader, not here else
if (xfregs.numTexGen.numTexGens < 7) { WRITE(p, "o.tex%d.xyz = float3(dot(coord, "I_TEXMATRICES".T[%d].t), dot(coord, "I_TEXMATRICES".T[%d].t), 1);\n", i, 3*i, 3*i+1);
WRITE(p, "o.clipPos = float4(pos.x,pos.y,o.pos.z,o.pos.w);\n"); }
} else { break;
WRITE(p, "o.tex0.w = pos.x;\n"); }
WRITE(p, "o.tex1.w = pos.y;\n");
WRITE(p, "o.tex2.w = o.pos.z;\n"); if (xfregs.dualTexTrans.enabled && texinfo.texgentype == XF_TEXGEN_REGULAR) { // only works for regular tex gen types?
WRITE(p, "o.tex3.w = o.pos.w;\n"); const PostMtxInfo& postInfo = xfregs.postMtxInfo[i];
}
int postidx = postInfo.index;
if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting) WRITE(p, "float4 P0 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n"
{ "float4 P1 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n"
if (xfregs.numTexGen.numTexGens < 7) { "float4 P2 = "I_POSTTRANSFORMMATRICES".T[%d].t;\n",
WRITE(p, "o.Normal = float4(_norm0.x,_norm0.y,_norm0.z,pos.z);\n"); postidx&0x3f, (postidx+1)&0x3f, (postidx+2)&0x3f);
} else {
WRITE(p, "o.tex4.w = _norm0.x;\n"); if (texGenSpecialCase) {
WRITE(p, "o.tex5.w = _norm0.y;\n"); // no normalization
WRITE(p, "o.tex6.w = _norm0.z;\n"); // q of input is 1
if (xfregs.numTexGen.numTexGens < 8) // q of output is unknown
WRITE(p, "o.tex7 = pos.xyzz;\n");
else // multiply by postmatrix
WRITE(p, "o.tex7.w = pos.z;\n"); WRITE(p, "o.tex%d.xyz = float3(dot(P0.xy, o.tex%d.xy) + P0.z + P0.w, dot(P1.xy, o.tex%d.xy) + P1.z + P1.w, 0.0f);\n", i, i, i);
} }
if (components & VB_HAS_COL0) else
WRITE(p, "o.colors_0 = color0;\n"); {
if (postInfo.normalize)
if (components & VB_HAS_COL1) WRITE(p, "o.tex%d.xyz = normalize(o.tex%d.xyz);\n", i, i);
WRITE(p, "o.colors_1 = color1;\n");
} // multiply by postmatrix
WRITE(p, "o.tex%d.xyz = float3(dot(P0.xyz, o.tex%d.xyz) + P0.w, dot(P1.xyz, o.tex%d.xyz) + P1.w, dot(P2.xyz, o.tex%d.xyz) + P2.w);\n", i, i, i, i);
//write the true depth value, if the game uses depth textures pixel shaders will override with the correct values }
//if not early z culling will improve speed }
if (is_d3d)
{ WRITE(p, "}\n");
WRITE(p, "o.pos.z = "I_DEPTHPARAMS".x * o.pos.w + o.pos.z * "I_DEPTHPARAMS".y;\n"); }
}
else // clipPos/w needs to be done in pixel shader, not here
{ if (xfregs.numTexGen.numTexGens < 7) {
// this results in a scale from -1..0 to -1..1 after perspective WRITE(p, "o.clipPos = float4(pos.x,pos.y,o.pos.z,o.pos.w);\n");
// divide } else {
WRITE(p, "o.pos.z = o.pos.w + o.pos.z * 2.0f;\n"); WRITE(p, "o.tex0.w = pos.x;\n");
WRITE(p, "o.tex1.w = pos.y;\n");
// Sonic Unleashed puts its final rendering at the near or WRITE(p, "o.tex2.w = o.pos.z;\n");
// far plane of the viewing frustrum(actually box, they use WRITE(p, "o.tex3.w = o.pos.w;\n");
// orthogonal projection for that), and we end up putting it }
// just beyond, and the rendering gets clipped away. (The
// primitive gets dropped) if(g_ActiveConfig.bEnablePixelLighting && g_ActiveConfig.backend_info.bSupportsPixelLighting)
WRITE(p, "o.pos.z = o.pos.z * 1048575.0f/1048576.0f;\n"); {
if (xfregs.numTexGen.numTexGens < 7) {
// the next steps of the OGL pipeline are: WRITE(p, "o.Normal = float4(_norm0.x,_norm0.y,_norm0.z,pos.z);\n");
// (x_c,y_c,z_c,w_c) = o.pos //switch to OGL spec terminology } else {
// clipping to -w_c <= (x_c,y_c,z_c) <= w_c WRITE(p, "o.tex4.w = _norm0.x;\n");
// (x_d,y_d,z_d) = (x_c,y_c,z_c)/w_c//perspective divide WRITE(p, "o.tex5.w = _norm0.y;\n");
// z_w = (f-n)/2*z_d + (n+f)/2 WRITE(p, "o.tex6.w = _norm0.z;\n");
// z_w now contains the value to go to the 0..1 depth buffer if (xfregs.numTexGen.numTexGens < 8)
WRITE(p, "o.tex7 = pos.xyzz;\n");
//trying to get the correct semantic while not using glDepthRange else
//seems to get rather complicated WRITE(p, "o.tex7.w = pos.z;\n");
} }
if (components & VB_HAS_COL0)
WRITE(p, "return o;\n}\n"); WRITE(p, "o.colors_0 = color0;\n");
if (components & VB_HAS_COL1)
if (text[sizeof(text) - 1] != 0x7C) WRITE(p, "o.colors_1 = color1;\n");
PanicAlert("VertexShader generator - buffer too small, canary has been eaten!"); }
setlocale(LC_NUMERIC, ""); // restore locale
return text; //write the true depth value, if the game uses depth textures pixel shaders will override with the correct values
} //if not early z culling will improve speed
if (is_d3d)
{
WRITE(p, "o.pos.z = "I_DEPTHPARAMS".x * o.pos.w + o.pos.z * "I_DEPTHPARAMS".y;\n");
}
else
{
// this results in a scale from -1..0 to -1..1 after perspective
// divide
WRITE(p, "o.pos.z = o.pos.w + o.pos.z * 2.0f;\n");
// Sonic Unleashed puts its final rendering at the near or
// far plane of the viewing frustrum(actually box, they use
// orthogonal projection for that), and we end up putting it
// just beyond, and the rendering gets clipped away. (The
// primitive gets dropped)
WRITE(p, "o.pos.z = o.pos.z * 1048575.0f/1048576.0f;\n");
// the next steps of the OGL pipeline are:
// (x_c,y_c,z_c,w_c) = o.pos //switch to OGL spec terminology
// clipping to -w_c <= (x_c,y_c,z_c) <= w_c
// (x_d,y_d,z_d) = (x_c,y_c,z_c)/w_c//perspective divide
// z_w = (f-n)/2*z_d + (n+f)/2
// z_w now contains the value to go to the 0..1 depth buffer
//trying to get the correct semantic while not using glDepthRange
//seems to get rather complicated
}
WRITE(p, "return o;\n}\n");
if (text[sizeof(text) - 1] != 0x7C)
PanicAlert("VertexShader generator - buffer too small, canary has been eaten!");
setlocale(LC_NUMERIC, ""); // restore locale
return text;
}

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

@@ -109,9 +109,13 @@ typedef _VERTEXSHADERUID<true> VERTEXSHADERUIDSAFE;
// components is included in the uid. // components is included in the uid.
char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type); char* GenerateVSOutputStruct(char* p, u32 components, API_TYPE api_type);
const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type); const char *GenerateVertexShaderCode(u32 components, API_TYPE api_type);
void GetVertexShaderId(VERTEXSHADERUID *uid, u32 components); void GetVertexShaderId(VERTEXSHADERUID *uid, u32 components);
void GetSafeVertexShaderId(VERTEXSHADERUIDSAFE *uid, u32 components); void GetSafeVertexShaderId(VERTEXSHADERUIDSAFE *uid, u32 components);
// Used to make sure that our optimized vertex shader IDs don't lose any possible shader code changes
void ValidateVertexShaderIDs(API_TYPE api, VERTEXSHADERUIDSAFE old_id, const std::string& old_code, u32 components);
extern VERTEXSHADERUID last_vertex_shader_uid; extern VERTEXSHADERUID last_vertex_shader_uid;
#endif // GCOGL_VERTEXSHADER_H #endif // GCOGL_VERTEXSHADER_H

13
Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.cpp
View File

@@ -461,6 +461,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
{ {
PSCache::const_iterator iter = PixelShaders.find(uid); PSCache::const_iterator iter = PixelShaders.find(uid);
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true);
ValidatePixelShaderIDs(API_D3D11, PixelShaders[uid].safe_uid, PixelShaders[uid].code, dstAlphaMode, components);
return (iter != PixelShaders.end() && iter->second.shader); return (iter != PixelShaders.end() && iter->second.shader);
} }
@@ -476,6 +477,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
last_entry = &entry; last_entry = &entry;
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE,true);
ValidatePixelShaderIDs(API_D3D11, entry.safe_uid, entry.code, dstAlphaMode, components);
return (entry.shader != NULL); return (entry.shader != NULL);
} }
@@ -494,10 +496,17 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
g_ps_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size()); g_ps_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());
g_ps_disk_cache.Sync(); g_ps_disk_cache.Sync();
bool result = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size()); bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size());
pbytecode->Release(); pbytecode->Release();
if (success)
{
PixelShaders[uid].code = code;
GetSafePixelShaderId(&PixelShaders[uid].safe_uid, dstAlphaMode);
}
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
return result; return success;
} }
bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen) bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const void* bytecode, unsigned int bytecodelen)

3
Source/Plugins/Plugin_VideoDX11/Src/PixelShaderCache.h
View File

@@ -55,6 +55,9 @@ private:
ID3D11PixelShader* shader; ID3D11PixelShader* shader;
int frameCount; int frameCount;
PIXELSHADERUIDSAFE safe_uid;
std::string code;
PSCacheEntry() : shader(NULL), frameCount(0) {} PSCacheEntry() : shader(NULL), frameCount(0) {}
void Destroy() { SAFE_RELEASE(shader); } void Destroy() { SAFE_RELEASE(shader); }
}; };

13
Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.cpp
View File

@@ -205,6 +205,7 @@ bool VertexShaderCache::SetShader(u32 components)
if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount) if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount)
{ {
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_D3D11, vshaders[uid].safe_uid, vshaders[uid].code, components);
return (vshaders[uid].shader != NULL); return (vshaders[uid].shader != NULL);
} }
@@ -218,6 +219,7 @@ bool VertexShaderCache::SetShader(u32 components)
last_entry = &entry; last_entry = &entry;
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_D3D11, entry.safe_uid, entry.code, components);
return (entry.shader != NULL); return (entry.shader != NULL);
} }
@@ -235,10 +237,17 @@ bool VertexShaderCache::SetShader(u32 components)
g_vs_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size()); g_vs_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());
g_vs_disk_cache.Sync(); g_vs_disk_cache.Sync();
bool result = InsertByteCode(uid, pbytecode); bool success = InsertByteCode(uid, pbytecode);
pbytecode->Release(); pbytecode->Release();
if (success)
{
vshaders[uid].code = code;
GetSafeVertexShaderId(&vshaders[uid].safe_uid, components);
}
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
return result; return success;
} }
bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, D3DBlob* bcodeblob) bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, D3DBlob* bcodeblob)

3
Source/Plugins/Plugin_VideoDX11/Src/VertexShaderCache.h
View File

@@ -53,6 +53,9 @@ private:
D3DBlob* bytecode; // needed to initialize the input layout D3DBlob* bytecode; // needed to initialize the input layout
int frameCount; int frameCount;
VERTEXSHADERUIDSAFE safe_uid;
std::string code;
VSCacheEntry() : shader(NULL), bytecode(NULL), frameCount(0) {} VSCacheEntry() : shader(NULL), bytecode(NULL), frameCount(0) {}
void SetByteCode(D3DBlob* blob) void SetByteCode(D3DBlob* blob)
{ {

13
Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.cpp
View File

@@ -334,6 +334,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
{ {
PSCache::const_iterator iter = PixelShaders.find(uid); PSCache::const_iterator iter = PixelShaders.find(uid);
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
ValidatePixelShaderIDs(API_D3D9, PixelShaders[uid].safe_uid, PixelShaders[uid].code, dstAlphaMode, components);
return (iter != PixelShaders.end() && iter->second.shader); return (iter != PixelShaders.end() && iter->second.shader);
} }
@@ -350,11 +351,11 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
if (entry.shader) D3D::SetPixelShader(entry.shader); if (entry.shader) D3D::SetPixelShader(entry.shader);
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
ValidatePixelShaderIDs(API_D3D9, entry.safe_uid, entry.code, dstAlphaMode, components);
return (entry.shader != NULL); return (entry.shader != NULL);
} }
// Need to compile a new shader // Need to compile a new shader
const char *code = GeneratePixelShaderCode(dstAlphaMode, ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30, components); const char *code = GeneratePixelShaderCode(dstAlphaMode, ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30, components);
@@ -384,11 +385,17 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
g_ps_disk_cache.Sync(); g_ps_disk_cache.Sync();
// And insert it into the shader cache. // And insert it into the shader cache.
bool result = InsertByteCode(uid, bytecode, bytecodelen, true); bool success = InsertByteCode(uid, bytecode, bytecodelen, true);
delete [] bytecode; delete [] bytecode;
if (success)
{
PixelShaders[uid].code = code;
GetSafePixelShaderId(&PixelShaders[uid].safe_uid, dstAlphaMode);
}
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
return result; return success;
} }
bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate) bool PixelShaderCache::InsertByteCode(const PIXELSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate)

3
Source/Plugins/Plugin_VideoDX9/Src/PixelShaderCache.h
View File

@@ -42,6 +42,9 @@ private:
bool owns_shader; bool owns_shader;
int frameCount; int frameCount;
PIXELSHADERUIDSAFE safe_uid;
std::string code;
PSCacheEntry() : shader(NULL), owns_shader(true), frameCount(0) {} PSCacheEntry() : shader(NULL), owns_shader(true), frameCount(0) {}
void Destroy() void Destroy()
{ {

11
Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.cpp
View File

@@ -187,6 +187,7 @@ bool VertexShaderCache::SetShader(u32 components)
if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount) if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount)
{ {
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_D3D9, vshaders[uid].safe_uid, vshaders[uid].code, components);
return (vshaders[uid].shader != NULL); return (vshaders[uid].shader != NULL);
} }
@@ -201,6 +202,7 @@ bool VertexShaderCache::SetShader(u32 components)
if (entry.shader) D3D::SetVertexShader(entry.shader); if (entry.shader) D3D::SetVertexShader(entry.shader);
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_D3D9, entry.safe_uid, entry.code, components);
return (entry.shader != NULL); return (entry.shader != NULL);
} }
@@ -215,10 +217,15 @@ bool VertexShaderCache::SetShader(u32 components)
g_vs_disk_cache.Append(uid, bytecode, bytecodelen); g_vs_disk_cache.Append(uid, bytecode, bytecodelen);
g_vs_disk_cache.Sync(); g_vs_disk_cache.Sync();
bool result = InsertByteCode(uid, bytecode, bytecodelen, true); bool success = InsertByteCode(uid, bytecode, bytecodelen, true);
if (success)
{
vshaders[uid].code = code;
GetSafeVertexShaderId(&vshaders[uid].safe_uid, components);
}
delete [] bytecode; delete [] bytecode;
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
return result; return success;
} }
bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate) { bool VertexShaderCache::InsertByteCode(const VERTEXSHADERUID &uid, const u8 *bytecode, int bytecodelen, bool activate) {

5
Source/Plugins/Plugin_VideoDX9/Src/VertexShaderCache.h
View File

@@ -35,9 +35,10 @@ private:
{ {
LPDIRECT3DVERTEXSHADER9 shader; LPDIRECT3DVERTEXSHADER9 shader;
int frameCount; int frameCount;
#if defined(_DEBUG) || defined(DEBUGFAST) //#if defined(_DEBUG) || defined(DEBUGFAST)
std::string code; std::string code;
#endif VERTEXSHADERUIDSAFE safe_uid;
//#endif
VSCacheEntry() : shader(NULL), frameCount(0) {} VSCacheEntry() : shader(NULL), frameCount(0) {}
void Destroy() void Destroy()
{ {

41
Source/Plugins/Plugin_VideoOGL/Src/PixelShaderCache.cpp
View File

@@ -184,30 +184,13 @@ void PixelShaderCache::Shutdown()
FRAGMENTSHADER* PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components) FRAGMENTSHADER* PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 components)
{ {
PIXELSHADERUID uid; PIXELSHADERUID uid;
PIXELSHADERUIDSAFE safe_uid;
GetPixelShaderId(&uid, dstAlphaMode); GetPixelShaderId(&uid, dstAlphaMode);
GetSafePixelShaderId(&safe_uid, dstAlphaMode);
// Check if the shader is already set - TODO: Use pShaderLast instead of PixelShaders[uid]? // Check if the shader is already set - TODO: Use pShaderLast instead of PixelShaders[uid]?
if (uid == last_pixel_shader_uid && PixelShaders[uid].frameCount == frameCount) if (uid == last_pixel_shader_uid && PixelShaders[uid].frameCount == frameCount)
{ {
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
ValidatePixelShaderIDs(API_OPENGL, PixelShaders[uid].safe_uid, PixelShaders[uid].code, dstAlphaMode, components);
if (!(safe_uid == PixelShaders[uid].safe_uid))
{
std::string code(GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components));
if (code != PixelShaders[uid].code)
{
char msg[4096];
char* ptr = msg;
ptr += sprintf(ptr, "Mismatch!\nUnique IDs:\n");
for (int i = 0; i < PixelShaders[uid].safe_uid.GetNumValues()/2; ++i)
ptr += sprintf(ptr, "%02d, %08X %08X | %08X %08X\n", 2*i, PixelShaders[uid].safe_uid.values[2*i], PixelShaders[uid].safe_uid.values[2*i+1],
safe_uid.values[2*i], safe_uid.values[2*i+1]);
PanicAlert(msg);
}
}
return pShaderLast; return pShaderLast;
} }
@@ -220,35 +203,19 @@ FRAGMENTSHADER* PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 comp
iter->second.frameCount = frameCount; iter->second.frameCount = frameCount;
PSCacheEntry &entry = iter->second; PSCacheEntry &entry = iter->second;
if (&entry.shader != pShaderLast) if (&entry.shader != pShaderLast)
{
pShaderLast = &entry.shader; pShaderLast = &entry.shader;
}
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
if (!(safe_uid == entry.safe_uid)) ValidatePixelShaderIDs(API_OPENGL, entry.safe_uid, entry.code, dstAlphaMode, components);
{
std::string code(GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components));
if (code != entry.code)
{
char msg[4096];
char *ptr = msg;
ptr += sprintf(ptr, "Mismatch!\nUnique IDs:\n");
for (int i = 0; i < entry.safe_uid.GetNumValues()/2; ++i)
ptr += sprintf(ptr, "%02d\t%08X %08X | %08X %08X\n", 2*i, entry.safe_uid.values[2*i], entry.safe_uid.values[2*i+1],
safe_uid.values[2*i], safe_uid.values[2*i+1]);
PanicAlert(msg);
}
}
return pShaderLast; return pShaderLast;
} }
// Make an entry in the table // Make an entry in the table
PSCacheEntry& newentry = PixelShaders[uid]; PSCacheEntry& newentry = PixelShaders[uid];
newentry.frameCount = frameCount; newentry.frameCount = frameCount;
newentry.safe_uid = safe_uid;
pShaderLast = &newentry.shader; pShaderLast = &newentry.shader;
const char *code = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components); const char *code = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, components);
GetSafePixelShaderId(&newentry.safe_uid, dstAlphaMode);
newentry.code = code; newentry.code = code;
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)

9
Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.cpp
View File

@@ -77,6 +77,7 @@ VERTEXSHADER* VertexShaderCache::SetShader(u32 components)
if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount) if (uid == last_vertex_shader_uid && vshaders[uid].frameCount == frameCount)
{ {
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_OPENGL, vshaders[uid].safe_uid, vshaders[uid].shader.strprog, components);
return pShaderLast; return pShaderLast;
} }
memcpy(&last_vertex_shader_uid, &uid, sizeof(VERTEXSHADERUID)); memcpy(&last_vertex_shader_uid, &uid, sizeof(VERTEXSHADERUID));
@@ -86,11 +87,11 @@ VERTEXSHADER* VertexShaderCache::SetShader(u32 components)
{ {
iter->second.frameCount = frameCount; iter->second.frameCount = frameCount;
VSCacheEntry &entry = iter->second; VSCacheEntry &entry = iter->second;
if (&entry.shader != pShaderLast) { if (&entry.shader != pShaderLast)
pShaderLast = &entry.shader; pShaderLast = &entry.shader;
}
GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true); GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
ValidateVertexShaderIDs(API_OPENGL, entry.safe_uid, entry.shader.strprog, components);
return pShaderLast; return pShaderLast;
} }
@@ -182,9 +183,9 @@ bool VertexShaderCache::CompileVertexShader(VERTEXSHADER& vs, const char* pstrpr
cgDestroyProgram(tempprog); cgDestroyProgram(tempprog);
#endif #endif
#if defined(_DEBUG) || defined(DEBUGFAST) //#if defined(_DEBUG) || defined(DEBUGFAST)
vs.strprog = pstrprogram; vs.strprog = pstrprogram;
#endif //#endif
return true; return true;
} }

5
Source/Plugins/Plugin_VideoOGL/Src/VertexShaderCache.h
View File

@@ -32,9 +32,9 @@ struct VERTEXSHADER
VERTEXSHADER() : glprogid(0) {} VERTEXSHADER() : glprogid(0) {}
GLuint glprogid; // opengl program id GLuint glprogid; // opengl program id
#if defined(_DEBUG) || defined(DEBUGFAST) //#if defined(_DEBUG) || defined(DEBUGFAST)
std::string strprog; std::string strprog;
#endif //#endif
}; };
class VertexShaderCache class VertexShaderCache
@@ -42,6 +42,7 @@ class VertexShaderCache
struct VSCacheEntry struct VSCacheEntry
{ {
VERTEXSHADER shader; VERTEXSHADER shader;
VERTEXSHADERUIDSAFE safe_uid;
int frameCount; int frameCount;
VSCacheEntry() : frameCount(0) {} VSCacheEntry() : frameCount(0) {}
void Destroy() { void Destroy() {