preserve-emulation/ppsspp
1
0 Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-10-26 11:48:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

D3D: Use fixed constant registers for pixel shader constants

Browse Source
This commit is contained in:
Henrik Rydgard committed 2014-09-10 12:59:33 +02:00
1 parent 14c8733def
commit d2d563cd2c
4 files changed
+62 -75
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

GPU/Directx9/PixelShaderGeneratorDX9.cpp
+16 -18
View File
@@ -219,15 +219,16 @@ void GenerateFragmentShaderDX9(char *buffer) {
WRITE(p, "sampler tex: register(s0);\n");
if (enableAlphaTest || enableColorTest) {
WRITE(p, "float4 u_alphacolorref;\n");
WRITE(p, "float4 u_alphacolormask;\n");
WRITE(p, "float4 u_alphacolorref : register(c%i);\n", CONST_PS_ALPHACOLORREF);
WRITE(p, "float4 u_alphacolormask : register(c%i);\n", CONST_PS_ALPHACOLORMASK);
}
if (gstate.isTextureMapEnabled() && gstate.getTextureFunction() == GE_TEXFUNC_BLEND) {
WRITE(p, "float3 u_texenv : register(c%i);\n", CONST_PS_TEXENV);
}
if (gstate.isTextureMapEnabled() && gstate.getTextureFunction() == GE_TEXFUNC_BLEND)
WRITE(p, "float3 u_texenv;\n");
if (enableFog) {
WRITE(p, "float3 u_fogcolor;\n");
WRITE(p, "float3 u_fogcolor : register(c%i);\n", CONST_PS_FOGCOLOR);
}
if (enableAlphaTest) {
WRITE(p, "float roundAndScaleTo255f(float x) { return floor(x * 255.0f + 0.5f); }\n");
@@ -236,26 +237,23 @@ void GenerateFragmentShaderDX9(char *buffer) {
WRITE(p, "float3 roundAndScaleTo255v(float3 x) { return floor(x * 255.0f + 0.5f); }\n");
}
WRITE(p, " struct PS_IN \n");
WRITE(p, " { \n");
if (doTexture)
{
WRITE(p, " struct PS_IN {\n");
if (doTexture) {
if (doTextureProjection)
WRITE(p, " float3 v_texcoord: TEXCOORD0; \n");
WRITE(p, " float3 v_texcoord: TEXCOORD0;\n");
else
WRITE(p, " float2 v_texcoord: TEXCOORD0; \n");
WRITE(p, " float2 v_texcoord: TEXCOORD0;\n");
}
WRITE(p, " float4 v_color0: COLOR0; \n");
WRITE(p, " float4 v_color0: COLOR0;\n");
if (lmode) {
WRITE(p, " float3 v_color1: COLOR1; \n");
WRITE(p, " float3 v_color1: COLOR1;\n");
}
if (enableFog) {
WRITE(p, "float2 v_fogdepth: TEXCOORD1;\n");
}
WRITE(p, " }; \n");
WRITE(p, " \n");
WRITE(p, " float4 main( PS_IN In ) : COLOR \n");
WRITE(p, " { \n");
WRITE(p, " };\n\n");
WRITE(p, " float4 main( PS_IN In ) : COLOR\n");
WRITE(p, " {\n");
if (gstate.isModeClear()) {
// Clear mode does not allow any fancy shading.
GPU/Directx9/PixelShaderGeneratorDX9.h
+5
View File
@@ -53,4 +53,9 @@ bool IsAlphaTestAgainstZero();
bool IsAlphaTestTriviallyTrue();
bool IsColorTestTriviallyTrue();
#define CONST_PS_TEXENV 0
#define CONST_PS_ALPHACOLORREF 1
#define CONST_PS_ALPHACOLORMASK 2
#define CONST_PS_FOGCOLOR 3
};
GPU/Directx9/ShaderManagerDX9.cpp
+24 -33
View File
@@ -70,7 +70,6 @@ PSShader::PSShader(const char *code, bool useHWTransform) : failed_(false), useH
DEBUG_LOG(G3D, "Compiled shader:\n%s\n", (const char *)code);
}
u_tex = GetConstantByName("tex");
u_texenv = GetConstantByName("u_texenv");
u_fogcolor = GetConstantByName("u_fogcolor");
u_alphacolorref = GetConstantByName("u_alphacolorref");
@@ -198,13 +197,9 @@ LinkedShaderDX9::LinkedShaderDX9(VSShader *vs, PSShader *fs, u32 vertType, bool
m_vs = vs;
m_fs = fs;
//glUseProgram(program);
pD3Ddevice->SetPixelShader(fs->shader);
pD3Ddevice->SetVertexShader(vs->shader);
// Default uniform values
//glUniform1i(u_tex, 0);
// The rest, use the "dirty" mechanism.
dirtyUniforms = DIRTY_ALL;
use();
@@ -214,11 +209,27 @@ LinkedShaderDX9::~LinkedShaderDX9() {
// glDeleteProgram(program);
}
void VSShader::SetFloatArray(D3DXHANDLE uniform, const float* pArray, int len) {
constant->SetFloatArray(pD3Ddevice, uniform, pArray, len);
void PSShader::SetColorUniform3(int creg, u32 color) {
const float col[4] = {
((color & 0xFF)) / 255.0f,
((color & 0xFF00) >> 8) / 255.0f,
((color & 0xFF0000) >> 16) / 255.0f,
0.0f
};
pD3Ddevice->SetPixelShaderConstantF(creg, col, 1);
}
void PSShader::SetFloatArray(D3DXHANDLE uniform, const float* pArray, int len) {
void PSShader::SetColorUniform3Alpha255(int creg, u32 color, u8 alpha) {
const float col[4] = {
(float)((color & 0xFF)),
(float)((color & 0xFF00) >> 8),
(float)((color & 0xFF0000) >> 16),
(float)alpha,
};
pD3Ddevice->SetPixelShaderConstantF(creg, col, 1);
}
void VSShader::SetFloatArray(D3DXHANDLE uniform, const float* pArray, int len) {
constant->SetFloatArray(pD3Ddevice, uniform, pArray, len);
}
@@ -226,7 +237,6 @@ void VSShader::SetFloat(D3DXHANDLE uniform, float value) {
constant->SetFloat(pD3Ddevice, uniform, value);
}
// Utility
void VSShader::SetColorUniform3(D3DXHANDLE uniform, u32 color) {
const float col[4] = {
@@ -237,15 +247,6 @@ void VSShader::SetColorUniform3(D3DXHANDLE uniform, u32 color) {
SetFloatArray(uniform, col, 4);
}
void PSShader::SetColorUniform3(D3DXHANDLE uniform, u32 color) {
const float col[4] = {
((color & 0xFF)) / 255.0f,
((color & 0xFF00) >> 8) / 255.0f,
((color & 0xFF0000) >> 16) / 255.0f
};
SetFloatArray(uniform, col, 4);
}
void VSShader::SetFloat24Uniform3(D3DXHANDLE uniform, const u32 data[3]) {
const u32 col[4] = {
data[0] >> 8, data[1] >> 8, data[2] >> 8,
@@ -263,16 +264,6 @@ void VSShader::SetColorUniform3Alpha(D3DXHANDLE uniform, u32 color, u8 alpha) {
SetFloatArray(uniform, col, 4);
}
void PSShader::SetColorUniform3Alpha255(D3DXHANDLE uniform, u32 color, u8 alpha) {
const float col[4] = {
(float)((color & 0xFF)),
(float)((color & 0xFF00) >> 8),
(float)((color & 0xFF0000) >> 16),
(float)alpha,
};
SetFloatArray(uniform, col, 4);
}
void VSShader::SetColorUniform3ExtraFloat(D3DXHANDLE uniform, u32 color, float extra) {
const float col[4] = {
((color & 0xFF)) / 255.0f,
@@ -321,16 +312,16 @@ void LinkedShaderDX9::use() {
void PSShader::updateUniforms(int dirtyUniforms) {
if (u_texenv != 0 && (dirtyUniforms & DIRTY_TEXENV)) {
SetColorUniform3(u_texenv, gstate.texenvcolor);
SetColorUniform3(CONST_PS_TEXENV, gstate.texenvcolor);
}
if (u_alphacolorref != 0 && (dirtyUniforms & DIRTY_ALPHACOLORREF)) {
SetColorUniform3Alpha255(u_alphacolorref, gstate.getColorTestRef(), gstate.getAlphaTestRef());
SetColorUniform3Alpha255(CONST_PS_ALPHACOLORREF, gstate.getColorTestRef(), gstate.getAlphaTestRef());
}
if (u_alphacolormask != 0 && (dirtyUniforms & DIRTY_ALPHACOLORMASK)) {
SetColorUniform3(u_alphacolormask, gstate.colortestmask);
SetColorUniform3(CONST_PS_ALPHACOLORMASK, gstate.colortestmask);
}
if (u_fogcolor != 0 && (dirtyUniforms & DIRTY_FOGCOLOR)) {
SetColorUniform3(u_fogcolor, gstate.fogcolor);
SetColorUniform3(CONST_PS_FOGCOLOR, gstate.fogcolor);
}
}
@@ -629,4 +620,4 @@ LinkedShaderDX9 *ShaderManagerDX9::ApplyShader(int prim, u32 vertType) {
return ls;
}
};
} // namespace
GPU/Directx9/ShaderManagerDX9.h
+17 -24
View File
@@ -60,18 +60,6 @@ public:
PSShader *m_fs;
u32 dirtyUniforms;
// Present attributes in the shader.
int attrMask; // 1 << ATTR_ ... or-ed together.
// Pre-fetched attrs and uniforms
D3DXHANDLE a_position;
D3DXHANDLE a_color0;
D3DXHANDLE a_color1;
D3DXHANDLE a_texcoord;
D3DXHANDLE a_normal;
D3DXHANDLE a_weight0123;
D3DXHANDLE a_weight4567;
};
// Will reach 32 bits soon :P
@@ -79,12 +67,12 @@ enum
{
DIRTY_PROJMATRIX = (1 << 0),
DIRTY_PROJTHROUGHMATRIX = (1 << 1),
DIRTY_FOGCOLOR = (1 << 2),
DIRTY_FOGCOEF = (1 << 3),
DIRTY_TEXENV = (1 << 4),
DIRTY_ALPHACOLORREF = (1 << 5),
DIRTY_COLORREF = (1 << 6),
DIRTY_ALPHACOLORMASK = (1 << 7),
DIRTY_FOGCOLOR = (1 << 2),
DIRTY_FOGCOEF = (1 << 3),
DIRTY_TEXENV = (1 << 4),
DIRTY_ALPHACOLORREF = (1 << 5),
DIRTY_COLORREF = (1 << 6),
DIRTY_ALPHACOLORMASK = (1 << 7),
DIRTY_LIGHT0 = (1 << 8),
DIRTY_LIGHT1 = (1 << 9),
DIRTY_LIGHT2 = (1 << 10),
@@ -110,6 +98,13 @@ enum
DIRTY_BONEMATRIX6 = (1 << 30),
DIRTY_BONEMATRIX7 = (1 << 31),
DIRTY_VSHADER_UNIFORMS = DIRTY_PROJMATRIX | DIRTY_PROJTHROUGHMATRIX | DIRTY_FOGCOEF | DIRTY_LIGHT0 | DIRTY_LIGHT1 | DIRTY_LIGHT2 | DIRTY_LIGHT3 |
DIRTY_MATDIFFUSE | DIRTY_MATSPECULAR | DIRTY_MATEMISSIVE | DIRTY_AMBIENT | DIRTY_MATAMBIENTALPHA | DIRTY_MATERIAL | DIRTY_UVSCALEOFFSET |
DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_TEXMATRIX |
DIRTY_BONEMATRIX0 | DIRTY_BONEMATRIX1 | DIRTY_BONEMATRIX2 | DIRTY_BONEMATRIX3 | DIRTY_BONEMATRIX4 | DIRTY_BONEMATRIX5 | DIRTY_BONEMATRIX6 | DIRTY_BONEMATRIX7,
DIRTY_PSHADER_UNIFORMS = DIRTY_FOGCOLOR | DIRTY_TEXENV | DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK,
DIRTY_ALL = 0xFFFFFFFF
};
@@ -127,23 +122,21 @@ public:
void updateUniforms(int dirtyUniforms);
void SetFloatArray(D3DXHANDLE uniform, const float* pArray, int len);
void SetColorUniform3Alpha255(D3DXHANDLE uniform, u32 color, u8 alpha);
void SetColorUniform3(D3DXHANDLE uniform, u32 color);
void SetColorUniform3Alpha255(int creg, u32 color, u8 alpha);
void SetColorUniform3(int creg, u32 color);
D3DXHANDLE GetConstantByName(LPCSTR pName);
LPDIRECT3DPIXELSHADER9 shader;
LPD3DXCONSTANTTABLE constant;
protected:
std::string source_;
bool failed_;
bool useHWTransform_;
D3DXHANDLE u_tex;
D3DXHANDLE u_texenv;
// Fragment processing inputs
D3DXHANDLE u_texenv;
D3DXHANDLE u_alphacolorref;
D3DXHANDLE u_alphacolormask;
D3DXHANDLE u_fogcolor;