Emulator-Archive/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-02-17 04:39:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move uniform dirty-flag to gstate_c, opening up for other uses.

Browse Source
This commit is contained in:
Henrik Rydgard 2017-01-23 23:15:54 +01:00
parent 83b4be6848
commit b423998c36
17 changed files with 331 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
GPU/Common/ShaderCommon.h
View File

@ -94,11 +94,6 @@ enum : uint64_t {
class ShaderManagerCommon {
public:
ShaderManagerCommon() : globalDirty_(DIRTY_ALL) {}
ShaderManagerCommon() {}
virtual ~ShaderManagerCommon() {}
void DirtyUniform(u64 what) {
globalDirty_ |= what;
}
protected:
uint64_t globalDirty_;
};

18
GPU/Directx9/FramebufferDX9.cpp
View File

@ -390,11 +390,11 @@ namespace DX9 {
// ugly...
if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}
@ -447,11 +447,11 @@ namespace DX9 {
// ugly...
if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}
@ -465,11 +465,11 @@ namespace DX9 {
// ugly...
if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}

363
GPU/Directx9/GPU_DX9.cpp
View File

@ -55,22 +55,23 @@ enum {
FLAG_FLUSHBEFOREONCHANGE = 2,
FLAG_EXECUTE = 4, // needs to actually be executed. unused for now.
FLAG_EXECUTEONCHANGE = 8,
FLAG_ANY_EXECUTE = 4 | 8,
FLAG_READS_PC = 16,
FLAG_WRITES_PC = 32,
FLAG_DIRTYONCHANGE = 64, // NOTE: Either this or FLAG_EXECUTE*, not both!
};
struct CommandTableEntry {
u8 cmd;
u8 flags;
uint8_t cmd;
uint8_t flags;
uint64_t dirtyUniform;
GPU_DX9::CmdFunc func;
};
static const CommandTableEntry commandTable[] = {
// Changes that dirty the framebuffer
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_FramebufType},
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FramebufType},
{GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE},
@ -84,80 +85,80 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE},
// Changes that dirty texture scaling.
{ GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexMapMode },
{ GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexMapMode },
{ GE_CMD_TEXSCALEU, FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexScaleU },
{ GE_CMD_TEXSCALEV, FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexScaleV },
{ GE_CMD_TEXOFFSETU, FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexOffsetU },
{ GE_CMD_TEXOFFSETV, FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexOffsetV },
{ GE_CMD_TEXSCALEU, FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexScaleU },
{ GE_CMD_TEXSCALEV, FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexScaleV },
{ GE_CMD_TEXOFFSETU, FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexOffsetU },
{ GE_CMD_TEXOFFSETV, FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexOffsetV },
// Changes that dirty the current texture. Really should be possible to avoid executing these if we compile
// by adding some more flags.
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &GPU_DX9::Execute_TexSize0},
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexFormat},
{GE_CMD_TEXLEVEL, FLAG_EXECUTE, &GPU_DX9::Execute_TexLevel},
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddr0},
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_DX9::Execute_TexSize0},
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexSizeN},
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexFormat},
{GE_CMD_TEXLEVEL, FLAG_EXECUTE, 0, &GPU_DX9::Execute_TexLevel},
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddr0},
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexBufwN},
{GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ClutFormat},
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ClutFormat},
// These affect the fragment shader so need flushing.
{GE_CMD_CLEARMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXTUREMAPENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexParamType},
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexParamType},
{GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_SHADEMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXFUNC, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTEST, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ALPHATESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ColorTestMask},
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ColorTestMask},
// These change the vertex shader so need flushing.
{GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTINGENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTENABLE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LIGHTENABLE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LIGHTENABLE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LIGHTENABLE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LIGHTTYPE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LIGHTTYPE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LIGHTTYPE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LIGHTTYPE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LIGHTENABLE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LIGHTENABLE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LIGHTENABLE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LIGHTENABLE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LIGHTTYPE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LIGHTTYPE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LIGHTTYPE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LIGHTTYPE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_MATERIALUPDATE, FLAG_FLUSHBEFOREONCHANGE},
// This changes both shaders so need flushing.
{GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexParamType},
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexParamType},
// Uniform changes
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_TexEnvColor},
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexEnvColor},
// Simple render state changes. Handled in StateMapping.cpp.
{GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE},
@ -166,7 +167,7 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_CULLFACEENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_DITHERENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_STENCILOP, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_StencilTest},
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_StencilTest},
{GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE},
@ -202,21 +203,21 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Viewport.
{GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ViewportType},
{GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Region
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Region},
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Region},
// Scissor
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Scissor},
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Scissor},
// These dirty various vertex shader uniforms. Could embed information about that in this table and call dirtyuniform directly, hm...
{GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
@ -229,67 +230,67 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
// These precompute a value. not sure if worth it. Also dirty uniforms, which could be table-ized to avoid execute.
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Light3Param},
// Ignored commands
{GE_CMD_CLIPENABLE, 0},
@ -316,24 +317,24 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC},
{GE_CMD_RET, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC},
{GE_CMD_END, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC}, // Flush?
{GE_CMD_VADDR, FLAG_EXECUTE, &GPU_DX9::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, &GPU_DX9::Execute_Iaddr},
{GE_CMD_VADDR, FLAG_EXECUTE, 0, &GPU_DX9::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, 0, &GPU_DX9::Execute_Iaddr},
{GE_CMD_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC}, // EXECUTE
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, &GPU_DX9::Execute_BoundingBox}, // + FLUSHBEFORE when we implement... or not, do we need to?
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, 0, &GPU_DX9::Execute_BoundingBox}, // + FLUSHBEFORE when we implement... or not, do we need to?
// Changing the vertex type requires us to flush.
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GPU_DX9::Execute_VertexType},
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_VertexType},
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &GPU_DX9::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &GPU_DX9::Execute_Spline},
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &GPU_DX9::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &GPU_DX9::Execute_Spline},
// These two are actually processed in CMD_END.
{GE_CMD_SIGNAL, FLAG_FLUSHBEFORE},
{GE_CMD_FINISH, FLAG_FLUSHBEFORE},
// Changes that trigger data copies. Only flushing on change for LOADCLUT must be a bit of a hack...
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &GPU_DX9::Execute_LoadClut},
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC, &GPUCommon::Execute_BlockTransferStart},
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_DX9::Execute_LoadClut},
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_BlockTransferStart},
// We don't use the dither table.
{GE_CMD_DITH0},
@ -342,16 +343,16 @@ static const CommandTableEntry commandTable[] = {
{GE_CMD_DITH3},
// These handle their own flushing.
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, &GPUCommon::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, &GPUCommon::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, &GPUCommon::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, &GPUCommon::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, &GPUCommon::Execute_BoneMtxData},
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_BoneMtxData},
// Vertex Screen/Texture/Color
{ GE_CMD_VSCX, FLAG_EXECUTE },
@ -707,7 +708,7 @@ void GPU_DX9::Execute_Iaddr(u32 op, u32 diff) {
void GPU_DX9::Execute_VertexType(u32 op, u32 diff) {
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
@ -719,11 +720,11 @@ void GPU_DX9::Execute_VertexTypeSkinning(u32 op, u32 diff) {
Flush();
gstate.vertType ^= diff;
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
// In this case, we may be doing weights and morphs.
// Update any bone matrix uniforms so it uses them correctly.
if ((op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
shaderManager_->DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.deferredVertTypeDirty = 0;
}
}
@ -893,7 +894,7 @@ void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) {
switch (op >> 24) {
case GE_CMD_VIEWPORTZSCALE:
case GE_CMD_VIEWPORTZCENTER:
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE);
break;
}
}
@ -915,27 +916,27 @@ void GPU_DX9::Execute_FramebufType(u32 op, u32 diff) {
void GPU_DX9::Execute_TexScaleU(u32 op, u32 diff) {
gstate_c.uv.uScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexScaleV(u32 op, u32 diff) {
gstate_c.uv.vScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexOffsetU(u32 op, u32 diff) {
gstate_c.uv.uOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexOffsetV(u32 op, u32 diff) {
gstate_c.uv.vOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexAddr0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexAddrN(u32 op, u32 diff) {
@ -956,7 +957,7 @@ void GPU_DX9::Execute_TexSize0(u32 op, u32 diff) {
if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
@ -971,7 +972,7 @@ void GPU_DX9::Execute_TexFormat(u32 op, u32 diff) {
}
void GPU_DX9::Execute_TexMapMode(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_DX9::Execute_TexParamType(u32 op, u32 diff) {
@ -979,7 +980,7 @@ void GPU_DX9::Execute_TexParamType(u32 op, u32 diff) {
}
void GPU_DX9::Execute_TexEnvColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_TEXENV);
gstate_c.DirtyUniform(DIRTY_TEXENV);
}
void GPU_DX9::Execute_TexLevel(u32 op, u32 diff) {
@ -1007,64 +1008,64 @@ void GPU_DX9::Execute_ClutFormat(u32 op, u32 diff) {
}
void GPU_DX9::Execute_Ambient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
gstate_c.DirtyUniform(DIRTY_AMBIENT);
}
void GPU_DX9::Execute_MaterialDiffuse(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
gstate_c.DirtyUniform(DIRTY_MATDIFFUSE);
}
void GPU_DX9::Execute_MaterialEmissive(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
gstate_c.DirtyUniform(DIRTY_MATEMISSIVE);
}
void GPU_DX9::Execute_MaterialAmbient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA);
}
void GPU_DX9::Execute_MaterialSpecular(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
gstate_c.DirtyUniform(DIRTY_MATSPECULAR);
}
void GPU_DX9::Execute_Light0Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
gstate_c.DirtyUniform(DIRTY_LIGHT0);
}
void GPU_DX9::Execute_Light1Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
gstate_c.DirtyUniform(DIRTY_LIGHT1);
}
void GPU_DX9::Execute_Light2Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
gstate_c.DirtyUniform(DIRTY_LIGHT2);
}
void GPU_DX9::Execute_Light3Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
gstate_c.DirtyUniform(DIRTY_LIGHT3);
}
void GPU_DX9::Execute_FogColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
gstate_c.DirtyUniform(DIRTY_FOGCOLOR);
}
void GPU_DX9::Execute_FogCoef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
gstate_c.DirtyUniform(DIRTY_FOGCOEF);
}
void GPU_DX9::Execute_ColorTestMask(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_DX9::Execute_AlphaTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_DX9::Execute_StencilTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);
gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE);
}
void GPU_DX9::Execute_ColorRef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
}
void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
@ -1123,17 +1124,17 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_FOGCOLOR:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
gstate_c.DirtyUniform(DIRTY_FOGCOLOR);
break;
case GE_CMD_FOG1:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
gstate_c.DirtyUniform(DIRTY_FOGCOEF);
break;
case GE_CMD_FOG2:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
gstate_c.DirtyUniform(DIRTY_FOGCOEF);
break;
case GE_CMD_FOGENABLE:
@ -1253,29 +1254,29 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_AMBIENTCOLOR:
case GE_CMD_AMBIENTALPHA:
if (diff)
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
gstate_c.DirtyUniform(DIRTY_AMBIENT);
break;
case GE_CMD_MATERIALDIFFUSE:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
gstate_c.DirtyUniform(DIRTY_MATDIFFUSE);
break;
case GE_CMD_MATERIALEMISSIVE:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
gstate_c.DirtyUniform(DIRTY_MATEMISSIVE);
break;
case GE_CMD_MATERIALAMBIENT:
case GE_CMD_MATERIALALPHA:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA);
break;
case GE_CMD_MATERIALSPECULAR:
case GE_CMD_MATERIALSPECULARCOEF:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
gstate_c.DirtyUniform(DIRTY_MATSPECULAR);
break;
case GE_CMD_LIGHTTYPE0:
@ -1292,7 +1293,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_LDC0:
case GE_CMD_LSC0:
if (diff)
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
gstate_c.DirtyUniform(DIRTY_LIGHT0);
break;
case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1:
@ -1304,7 +1305,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_LDC1:
case GE_CMD_LSC1:
if (diff)
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
gstate_c.DirtyUniform(DIRTY_LIGHT1);
break;
case GE_CMD_LX2:case GE_CMD_LY2:case GE_CMD_LZ2:
case GE_CMD_LDX2:case GE_CMD_LDY2:case GE_CMD_LDZ2:
@ -1315,7 +1316,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_LDC2:
case GE_CMD_LSC2:
if (diff)
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
gstate_c.DirtyUniform(DIRTY_LIGHT2);
break;
case GE_CMD_LX3:case GE_CMD_LY3:case GE_CMD_LZ3:
case GE_CMD_LDX3:case GE_CMD_LDY3:case GE_CMD_LDZ3:
@ -1326,7 +1327,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_LDC3:
case GE_CMD_LSC3:
if (diff)
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
gstate_c.DirtyUniform(DIRTY_LIGHT3);
break;
case GE_CMD_VIEWPORTXSCALE:
@ -1380,7 +1381,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
case GE_CMD_COLORTEST:
case GE_CMD_COLORTESTMASK:
if (diff)
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
break;
case GE_CMD_ALPHATEST:
@ -1389,12 +1390,12 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) {
// Intentional fallthrough.
case GE_CMD_COLORREF:
if (diff)
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
break;
case GE_CMD_TEXENVCOLOR:
if (diff)
shaderManager_->DirtyUniform(DIRTY_TEXENV);
gstate_c.DirtyUniform(DIRTY_TEXENV);
break;
case GE_CMD_TEXFUNC:

22
GPU/Directx9/ShaderManagerDX9.cpp
View File

@ -522,7 +522,7 @@ void ShaderManagerDX9::Clear() {
}
fsCache_.clear();
vsCache_.clear();
globalDirty_ = 0xFFFFFFFF;
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
lastFSID_.clear();
lastVSID_.clear();
DirtyShader();
@ -539,7 +539,7 @@ void ShaderManagerDX9::DirtyShader() {
lastVSID_.clear();
lastVShader_ = nullptr;
lastPShader_ = nullptr;
globalDirty_ = 0xFFFFFFFF;
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
}
void ShaderManagerDX9::DirtyLastShader() { // disables vertex arrays
@ -557,10 +557,11 @@ VSShader *ShaderManagerDX9::ApplyShader(int prim, u32 vertType) {
// Just update uniforms if this is the same shader as last time.
if (lastVShader_ != nullptr && lastPShader_ != nullptr && VSID == lastVSID_ && FSID == lastFSID_) {
if (globalDirty_) {
PSUpdateUniforms(globalDirty_);
VSUpdateUniforms(globalDirty_);
globalDirty_ = 0;
uint64_t dirtyUniforms = gstate_c.GetDirtyUniforms();
if (dirtyUniforms) {
PSUpdateUniforms(dirtyUniforms);
VSUpdateUniforms(dirtyUniforms);
gstate_c.CleanUniforms();
}
return lastVShader_; // Already all set.
}
@ -608,10 +609,11 @@ VSShader *ShaderManagerDX9::ApplyShader(int prim, u32 vertType) {
lastFSID_ = FSID;
if (globalDirty_) {
PSUpdateUniforms(globalDirty_);
VSUpdateUniforms(globalDirty_);
globalDirty_ = 0;
uint64_t dirtyUniforms = gstate_c.GetDirtyUniforms();
if (dirtyUniforms) {
PSUpdateUniforms(dirtyUniforms);
VSUpdateUniforms(dirtyUniforms);
gstate_c.CleanUniforms();
}
pD3Ddevice->SetPixelShader(fs->shader);

10
GPU/Directx9/StateMappingDX9.cpp
View File

@ -111,7 +111,7 @@ bool DrawEngineDX9::ApplyShaderBlending() {
fboTexNeedBind_ = true;
shaderManager_->DirtyUniform(DIRTY_SHADERBLEND);
gstate_c.DirtyUniform(DIRTY_SHADERBLEND);
return true;
}
@ -131,7 +131,7 @@ void DrawEngineDX9::ApplyDrawState(int prim) {
if (gstate_c.needShaderTexClamp) {
// We will rarely need to set this, so let's do it every time on use rather than in runloop.
// Most of the time non-framebuffer textures will be used which can be clamped themselves.
shaderManager_->DirtyUniform(DIRTY_TEXCLAMP);
gstate_c.DirtyUniform(DIRTY_TEXCLAMP);
}
}
@ -174,7 +174,7 @@ void DrawEngineDX9::ApplyDrawState(int prim) {
dxBlendFactorLookup[(size_t)blendState.srcColor], dxBlendFactorLookup[(size_t)blendState.dstColor],
dxBlendFactorLookup[(size_t)blendState.srcAlpha], dxBlendFactorLookup[(size_t)blendState.dstAlpha]);
if (blendState.dirtyShaderBlend) {
shaderManager_->DirtyUniform(DIRTY_SHADERBLEND);
gstate_c.DirtyUniform(DIRTY_SHADERBLEND);
}
if (blendState.useBlendColor) {
dxstate.blendColor.setDWORD(blendState.blendColor);
@ -297,10 +297,10 @@ void DrawEngineDX9::ApplyDrawState(int prim) {
dxstate.viewport.set(vpAndScissor.viewportX, vpAndScissor.viewportY, vpAndScissor.viewportW, vpAndScissor.viewportH, depthMin, depthMax);
if (vpAndScissor.dirtyProj) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
if (vpAndScissor.dirtyDepth) {
shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_DEPTHRANGE);
}
}

6
GPU/GLES/FramebufferManagerGLES.cpp
View File

@ -647,7 +647,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferCreated(VirtualFramebuffer *
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}
@ -710,7 +710,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferSwitched(VirtualFramebuffer
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}
@ -724,7 +724,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferUpdated(VirtualFramebuffer *
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX);
}
}

77
GPU/GLES/GPU_GLES.cpp
View File

@ -56,16 +56,15 @@ enum {
FLAG_FLUSHBEFOREONCHANGE = 2,
FLAG_EXECUTE = 4, // needs to actually be executed. unused for now.
FLAG_EXECUTEONCHANGE = 8,
FLAG_ANY_EXECUTE = 4 | 8,
FLAG_READS_PC = 16,
FLAG_WRITES_PC = 32,
FLAG_DIRTYONCHANGE = 64,
FLAG_DIRTYONCHANGE = 64, // NOTE: Either this or FLAG_EXECUTE*, not both!
};
struct CommandTableEntry {
u8 cmd;
u8 flags;
u32 dirtyUniform;
uint8_t cmd;
uint8_t flags;
uint64_t dirtyUniform;
GPU_GLES::CmdFunc func;
};
@ -769,7 +768,7 @@ void GPU_GLES::BeginFrameInternal() {
shaderManagerGL_->DirtyShader();
// Not sure if this is really needed.
shaderManager_->DirtyUniform(DIRTY_ALL);
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
framebufferManagerGL_->BeginFrame();
}
@ -966,7 +965,7 @@ void GPU_GLES::Execute_Prim(u32 op, u32 diff) {
void GPU_GLES::Execute_VertexType(u32 op, u32 diff) {
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
@ -978,11 +977,11 @@ void GPU_GLES::Execute_VertexTypeSkinning(u32 op, u32 diff) {
Flush();
gstate.vertType ^= diff;
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
// In this case, we may be doing weights and morphs.
// Update any bone matrix uniforms so it uses them correctly.
if ((op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
shaderManager_->DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.deferredVertTypeDirty = 0;
}
}
@ -1027,7 +1026,7 @@ void GPU_GLES::Execute_Bezier(u32 op, u32 diff) {
if (g_Config.bHardwareTessellation && g_Config.bHardwareTransform && !g_Config.bSoftwareRendering) {
gstate_c.bezier = true;
if (gstate_c.bezier_count_u != bz_ucount) {
shaderManager_->DirtyUniform(DIRTY_BEZIERCOUNTU);
gstate_c.DirtyUniform(DIRTY_BEZIERCOUNTU);
gstate_c.bezier_count_u = bz_ucount;
}
}
@ -1084,19 +1083,19 @@ void GPU_GLES::Execute_Spline(u32 op, u32 diff) {
if (g_Config.bHardwareTessellation && g_Config.bHardwareTransform && !g_Config.bSoftwareRendering) {
gstate_c.spline = true;
if (gstate_c.spline_count_u != sp_ucount) {
shaderManager_->DirtyUniform(DIRTY_SPLINECOUNTU);
gstate_c.DirtyUniform(DIRTY_SPLINECOUNTU);
gstate_c.spline_count_u = sp_ucount;
}
if (gstate_c.spline_count_v != sp_vcount) {
shaderManager_->DirtyUniform(DIRTY_SPLINECOUNTV);
gstate_c.DirtyUniform(DIRTY_SPLINECOUNTV);
gstate_c.spline_count_v = sp_vcount;
}
if (gstate_c.spline_type_u != sp_utype) {
shaderManager_->DirtyUniform(DIRTY_SPLINETYPEU);
gstate_c.DirtyUniform(DIRTY_SPLINETYPEU);
gstate_c.spline_type_u = sp_utype;
}
if (gstate_c.spline_type_v != sp_vtype) {
shaderManager_->DirtyUniform(DIRTY_SPLINETYPEV);
gstate_c.DirtyUniform(DIRTY_SPLINETYPEV);
gstate_c.spline_type_v = sp_vtype;
}
}
@ -1134,32 +1133,32 @@ void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) {
void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_DEPTHRANGE);
}
void GPU_GLES::Execute_TexScaleU(u32 op, u32 diff) {
gstate_c.uv.uScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexScaleV(u32 op, u32 diff) {
gstate_c.uv.vScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexOffsetU(u32 op, u32 diff) {
gstate_c.uv.uOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexOffsetV(u32 op, u32 diff) {
gstate_c.uv.vOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexAddr0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexAddrN(u32 op, u32 diff) {
@ -1180,7 +1179,7 @@ void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) {
if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
@ -1195,7 +1194,7 @@ void GPU_GLES::Execute_TexFormat(u32 op, u32 diff) {
}
void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) {
@ -1203,7 +1202,7 @@ void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) {
}
void GPU_GLES::Execute_TexEnvColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_TEXENV);
gstate_c.DirtyUniform(DIRTY_TEXENV);
}
void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) {
@ -1231,64 +1230,64 @@ void GPU_GLES::Execute_ClutFormat(u32 op, u32 diff) {
}
void GPU_GLES::Execute_Ambient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
gstate_c.DirtyUniform(DIRTY_AMBIENT);
}
void GPU_GLES::Execute_MaterialDiffuse(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
gstate_c.DirtyUniform(DIRTY_MATDIFFUSE);
}
void GPU_GLES::Execute_MaterialEmissive(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
gstate_c.DirtyUniform(DIRTY_MATEMISSIVE);
}
void GPU_GLES::Execute_MaterialAmbient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA);
}
void GPU_GLES::Execute_MaterialSpecular(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
gstate_c.DirtyUniform(DIRTY_MATSPECULAR);
}
void GPU_GLES::Execute_Light0Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
gstate_c.DirtyUniform(DIRTY_LIGHT0);
}
void GPU_GLES::Execute_Light1Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
gstate_c.DirtyUniform(DIRTY_LIGHT1);
}
void GPU_GLES::Execute_Light2Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
gstate_c.DirtyUniform(DIRTY_LIGHT2);
}
void GPU_GLES::Execute_Light3Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
gstate_c.DirtyUniform(DIRTY_LIGHT3);
}
void GPU_GLES::Execute_FogColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
gstate_c.DirtyUniform(DIRTY_FOGCOLOR);
}
void GPU_GLES::Execute_FogCoef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
gstate_c.DirtyUniform(DIRTY_FOGCOEF);
}
void GPU_GLES::Execute_ColorTestMask(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_GLES::Execute_AlphaTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_GLES::Execute_StencilTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);
gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE);
}
void GPU_GLES::Execute_ColorRef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
}
void GPU_GLES::Execute_Generic(u32 op, u32 diff) {

15
GPU/GLES/ShaderManagerGLES.cpp
View File

@ -314,7 +314,7 @@ LinkedShader::LinkedShader(ShaderID VSID, Shader *vs, ShaderID FSID, Shader *fs,
glUniform1i(u_tess_col_tex, 5); // Texture unit 5
}
// The rest, use the "dirty" mechanism.
dirtyUniforms = DIRTY_ALL;
dirtyUniforms = DIRTY_ALL_UNIFORMS;
}
LinkedShader::~LinkedShader() {
@ -772,7 +772,7 @@ void ShaderManagerGLES::Clear() {
linkedShaderCache_.clear();
fsCache_.clear();
vsCache_.clear();
globalDirty_ = DIRTY_ALL;
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
lastFSID_.set_invalid();
lastVSID_.set_invalid();
DirtyShader();
@ -788,7 +788,7 @@ void ShaderManagerGLES::DirtyShader() {
lastFSID_.set_invalid();
lastVSID_.set_invalid();
DirtyLastShader();
globalDirty_ = DIRTY_ALL;
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
shaderSwitchDirty_ = 0;
}
@ -813,11 +813,12 @@ Shader *ShaderManagerGLES::CompileVertexShader(ShaderID VSID) {
}
Shader *ShaderManagerGLES::ApplyVertexShader(int prim, u32 vertType, ShaderID *VSID) {
if (globalDirty_) {
uint64_t dirty = gstate_c.GetDirtyUniforms();
if (dirty) {
if (lastShader_)
lastShader_->dirtyUniforms |= globalDirty_;
shaderSwitchDirty_ |= globalDirty_;
globalDirty_ = 0;
lastShader_->dirtyUniforms |= dirty;
shaderSwitchDirty_ |= dirty;
gstate_c.CleanUniforms();
}
bool useHWTransform = CanUseHardwareTransform(prim);

4
GPU/GLES/ShaderManagerGLES.h
View File

@ -55,8 +55,8 @@ public:
bool useHWTransform_;
uint32_t program;
u64 availableUniforms;
u64 dirtyUniforms;
uint64_t availableUniforms;
uint64_t dirtyUniforms;
// Present attributes in the shader.
int attrMask; // 1 << ATTR_ ... or-ed together.

10
GPU/GLES/StateMappingGLES.cpp
View File

@ -144,7 +144,7 @@ bool DrawEngineGLES::ApplyShaderBlending() {
fboTexNeedBind_ = true;
shaderManager_->DirtyUniform(DIRTY_SHADERBLEND);
gstate_c.DirtyUniform(DIRTY_SHADERBLEND);
return true;
}
@ -166,7 +166,7 @@ void DrawEngineGLES::ApplyDrawState(int prim) {
if (gstate_c.needShaderTexClamp) {
// We will rarely need to set this, so let's do it every time on use rather than in runloop.
// Most of the time non-framebuffer textures will be used which can be clamped themselves.
shaderManager_->DirtyUniform(DIRTY_TEXCLAMP);
gstate_c.DirtyUniform(DIRTY_TEXCLAMP);
}
}
@ -207,7 +207,7 @@ void DrawEngineGLES::ApplyDrawState(int prim) {
glBlendFactorLookup[(size_t)blendState.srcColor], glBlendFactorLookup[(size_t)blendState.dstColor],
glBlendFactorLookup[(size_t)blendState.srcAlpha], glBlendFactorLookup[(size_t)blendState.dstAlpha]);
if (blendState.dirtyShaderBlend) {
shaderManager_->DirtyUniform(DIRTY_SHADERBLEND);
gstate_c.DirtyUniform(DIRTY_SHADERBLEND);
}
if (blendState.useBlendColor) {
uint32_t color = blendState.blendColor;
@ -368,10 +368,10 @@ void DrawEngineGLES::ApplyDrawState(int prim) {
glstate.depthRange.set(vpAndScissor.depthRangeMin, vpAndScissor.depthRangeMax);
if (vpAndScissor.dirtyProj) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
if (vpAndScissor.dirtyDepth) {
shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_DEPTHRANGE);
}
}

22
GPU/GPUCommon.cpp
View File

@ -1208,7 +1208,7 @@ void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) {
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
gstate_c.DirtyUniform(DIRTY_WORLDMATRIX);
}
if (++i >= end) {
break;
@ -1230,7 +1230,7 @@ void GPUCommon::Execute_WorldMtxData(u32 op, u32 diff) {
if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) {
Flush();
((u32 *)gstate.worldMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
gstate_c.DirtyUniform(DIRTY_WORLDMATRIX);
}
num++;
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0xF);
@ -1248,7 +1248,7 @@ void GPUCommon::Execute_ViewMtxNum(u32 op, u32 diff) {
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
gstate_c.DirtyUniform(DIRTY_VIEWMATRIX);
}
if (++i >= end) {
break;
@ -1270,7 +1270,7 @@ void GPUCommon::Execute_ViewMtxData(u32 op, u32 diff) {
if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) {
Flush();
((u32 *)gstate.viewMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
gstate_c.DirtyUniform(DIRTY_VIEWMATRIX);
}
num++;
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0xF);
@ -1288,7 +1288,7 @@ void GPUCommon::Execute_ProjMtxNum(u32 op, u32 diff) {
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
if (++i >= end) {
break;
@ -1310,7 +1310,7 @@ void GPUCommon::Execute_ProjMtxData(u32 op, u32 diff) {
if (newVal != ((const u32 *)gstate.projMatrix)[num]) {
Flush();
((u32 *)gstate.projMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
num++;
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0xF);
@ -1328,7 +1328,7 @@ void GPUCommon::Execute_TgenMtxNum(u32 op, u32 diff) {
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
gstate_c.DirtyUniform(DIRTY_TEXMATRIX);
}
if (++i >= end) {
break;
@ -1350,7 +1350,7 @@ void GPUCommon::Execute_TgenMtxData(u32 op, u32 diff) {
if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) {
Flush();
((u32 *)gstate.tgenMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
gstate_c.DirtyUniform(DIRTY_TEXMATRIX);
}
num++;
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0xF);
@ -1378,7 +1378,7 @@ void GPUCommon::Execute_BoneMtxNum(u32 op, u32 diff) {
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
}
} else {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
@ -1410,7 +1410,7 @@ void GPUCommon::Execute_BoneMtxData(u32 op, u32 diff) {
// Bone matrices should NOT flush when software skinning is enabled!
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
Flush();
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
} else {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
}
@ -1477,7 +1477,7 @@ void GPUCommon::FastLoadBoneMatrix(u32 target) {
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
Flush();
shaderManager_->DirtyUniform(uniformsToDirty);
gstate_c.DirtyUniform(uniformsToDirty);
} else {
gstate_c.deferredVertTypeDirty |= uniformsToDirty;
}

10
GPU/GPUState.h
View File

@ -23,6 +23,7 @@
#include "GPU/GPU.h"
#include "GPU/ge_constants.h"
#include "Common/Common.h"
#include "GPU/Common/ShaderCommon.h"
class PointerWrap;
@ -487,6 +488,13 @@ struct KnownVertexBounds {
struct GPUStateCache {
bool Supports(int flag) { return (featureFlags & flag) != 0; }
uint64_t GetDirtyUniforms() { return dirty & DIRTY_ALL_UNIFORMS; }
void DirtyUniform(u64 what) {
dirty |= what;
}
void CleanUniforms() {
dirty &= ~DIRTY_ALL_UNIFORMS;
}
u32 featureFlags;
@ -494,6 +502,8 @@ struct GPUStateCache {
u32 indexAddr;
u32 offsetAddr;
uint64_t dirty;
u8 textureChanged;
bool textureFullAlpha;
bool textureSimpleAlpha;

2
GPU/Vulkan/DrawEngineVulkan.cpp
View File

@ -637,7 +637,7 @@ void DrawEngineVulkan::DoFlush(VkCommandBuffer cmd) {
if (gstate_c.needShaderTexClamp) {
// We will rarely need to set this, so let's do it every time on use rather than in runloop.
// Most of the time non-framebuffer textures will be used which can be clamped themselves.
shaderManager_->DirtyUniform(DIRTY_TEXCLAMP);
gstate_c.DirtyUniform(DIRTY_TEXCLAMP);
}
}

6
GPU/Vulkan/FramebufferVulkan.cpp
View File

@ -646,7 +646,7 @@ void FramebufferManagerVulkan::NotifyRenderFramebufferCreated(VirtualFramebuffer
textureCache_->NotifyFramebuffer(vfb->fb_address, vfb, NOTIFY_FB_CREATED);
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
}
@ -695,7 +695,7 @@ void FramebufferManagerVulkan::NotifyRenderFramebufferSwitched(VirtualFramebuffe
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
}
@ -709,7 +709,7 @@ void FramebufferManagerVulkan::NotifyRenderFramebufferUpdated(VirtualFramebuffer
// ugly...
if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) {
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
}

69
GPU/Vulkan/GPU_Vulkan.cpp
View File

@ -50,16 +50,15 @@ enum {
FLAG_FLUSHBEFOREONCHANGE = 2,
FLAG_EXECUTE = 4, // needs to actually be executed. unused for now.
FLAG_EXECUTEONCHANGE = 8,
FLAG_ANY_EXECUTE = 4 | 8,
FLAG_READS_PC = 16,
FLAG_WRITES_PC = 32,
FLAG_DIRTYONCHANGE = 64,
FLAG_DIRTYONCHANGE = 64, // NOTE: Either this or FLAG_EXECUTE*, not both!
};
struct CommandTableEntry {
u8 cmd;
u8 flags;
u64 dirtyFlags;
uint8_t cmd;
uint8_t flags;
uint64_t dirtyFlags;
GPU_Vulkan::CmdFunc func;
};
@ -508,7 +507,7 @@ void GPU_Vulkan::BeginHostFrame() {
framebufferManagerVulkan_->BeginFrameVulkan();
shaderManagerVulkan_->DirtyShader();
shaderManager_->DirtyUniform(DIRTY_ALL);
gstate_c.DirtyUniform(DIRTY_ALL);
if (dumpNextFrame_) {
NOTICE_LOG(G3D, "DUMPING THIS FRAME");
@ -824,7 +823,7 @@ void GPU_Vulkan::Execute_Prim(u32 op, u32 diff) {
void GPU_Vulkan::Execute_VertexType(u32 op, u32 diff) {
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
@ -940,32 +939,32 @@ void GPU_Vulkan::Execute_ViewportType(u32 op, u32 diff) {
void GPU_Vulkan::Execute_ViewportZType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_DEPTHRANGE);
}
void GPU_Vulkan::Execute_TexScaleU(u32 op, u32 diff) {
gstate_c.uv.uScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexScaleV(u32 op, u32 diff) {
gstate_c.uv.vScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexOffsetU(u32 op, u32 diff) {
gstate_c.uv.uOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexOffsetV(u32 op, u32 diff) {
gstate_c.uv.vOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexAddr0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexAddrN(u32 op, u32 diff) {
@ -986,7 +985,7 @@ void GPU_Vulkan::Execute_TexSize0(u32 op, u32 diff) {
if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
@ -1001,7 +1000,7 @@ void GPU_Vulkan::Execute_TexFormat(u32 op, u32 diff) {
}
void GPU_Vulkan::Execute_TexMapMode(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GPU_Vulkan::Execute_TexParamType(u32 op, u32 diff) {
@ -1009,7 +1008,7 @@ void GPU_Vulkan::Execute_TexParamType(u32 op, u32 diff) {
}
void GPU_Vulkan::Execute_TexEnvColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_TEXENV);
gstate_c.DirtyUniform(DIRTY_TEXENV);
}
void GPU_Vulkan::Execute_TexLevel(u32 op, u32 diff) {
@ -1037,64 +1036,64 @@ void GPU_Vulkan::Execute_ClutFormat(u32 op, u32 diff) {
}
void GPU_Vulkan::Execute_Ambient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
gstate_c.DirtyUniform(DIRTY_AMBIENT);
}
void GPU_Vulkan::Execute_MaterialDiffuse(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
gstate_c.DirtyUniform(DIRTY_MATDIFFUSE);
}
void GPU_Vulkan::Execute_MaterialEmissive(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
gstate_c.DirtyUniform(DIRTY_MATEMISSIVE);
}
void GPU_Vulkan::Execute_MaterialAmbient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA);
}
void GPU_Vulkan::Execute_MaterialSpecular(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
gstate_c.DirtyUniform(DIRTY_MATSPECULAR);
}
void GPU_Vulkan::Execute_Light0Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
gstate_c.DirtyUniform(DIRTY_LIGHT0);
}
void GPU_Vulkan::Execute_Light1Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
gstate_c.DirtyUniform(DIRTY_LIGHT1);
}
void GPU_Vulkan::Execute_Light2Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
gstate_c.DirtyUniform(DIRTY_LIGHT2);
}
void GPU_Vulkan::Execute_Light3Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
gstate_c.DirtyUniform(DIRTY_LIGHT3);
}
void GPU_Vulkan::Execute_FogColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
gstate_c.DirtyUniform(DIRTY_FOGCOLOR);
}
void GPU_Vulkan::Execute_FogCoef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
gstate_c.DirtyUniform(DIRTY_FOGCOEF);
}
void GPU_Vulkan::Execute_ColorTestMask(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_Vulkan::Execute_AlphaTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void GPU_Vulkan::Execute_StencilTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);
gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE);
}
void GPU_Vulkan::Execute_ColorRef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF);
}
void GPU_Vulkan::Execute_BoneMtxNum(u32 op, u32 diff) {
@ -1118,7 +1117,7 @@ void GPU_Vulkan::Execute_BoneMtxNum(u32 op, u32 diff) {
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
}
const int count = i;
@ -1136,7 +1135,7 @@ void GPU_Vulkan::Execute_BoneMtxData(u32 op, u32 diff) {
if (num < 96 && newVal != ((const u32 *)gstate.boneMatrix)[num]) {
// Bone matrices should NOT flush when software skinning is enabled!
Flush();
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
((u32 *)gstate.boneMatrix)[num] = newVal;
}
num++;
@ -1682,7 +1681,7 @@ void GPU_Vulkan::FastLoadBoneMatrix(u32 target) {
uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);
}
Flush();
shaderManager_->DirtyUniform(uniformsToDirty);
gstate_c.DirtyUniform(uniformsToDirty);
gstate.FastLoadBoneMatrix(target);
}

8
GPU/Vulkan/ShaderManagerVulkan.cpp
View File

@ -409,7 +409,7 @@ void ShaderManagerVulkan::Clear() {
void ShaderManagerVulkan::ClearShaders() {
Clear();
DirtyShader();
DirtyUniform(0xFFFFFFFF);
gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS);
}
void ShaderManagerVulkan::DirtyShader() {
@ -426,13 +426,13 @@ void ShaderManagerVulkan::DirtyLastShader() { // disables vertex arrays
}
uint32_t ShaderManagerVulkan::UpdateUniforms() {
uint32_t dirty = globalDirty_;
if (globalDirty_) {
uint32_t dirty = gstate_c.GetDirtyUniforms();
if (dirty != 0) {
BaseUpdateUniforms(dirty);
LightUpdateUniforms(dirty);
BoneUpdateUniforms(dirty);
}
globalDirty_ = 0;
gstate_c.CleanUniforms();
return dirty;
}

6
GPU/Vulkan/StateMappingVulkan.cpp
View File

@ -171,7 +171,7 @@ void ConvertStateToVulkanKey(FramebufferManagerVulkan &fbManager, ShaderManagerV
key.destColor = vkBlendFactorLookup[(size_t)blendState.dstColor];
key.destAlpha = vkBlendFactorLookup[(size_t)blendState.dstAlpha];
if (blendState.dirtyShaderBlend) {
shaderManager->DirtyUniform(DIRTY_SHADERBLEND);
gstate_c.DirtyUniform(DIRTY_SHADERBLEND);
}
dynState.useBlendColor = blendState.useBlendColor;
if (blendState.useBlendColor) {
@ -310,7 +310,7 @@ void ConvertStateToVulkanKey(FramebufferManagerVulkan &fbManager, ShaderManagerV
vp.minDepth = vpAndScissor.depthRangeMin;
vp.maxDepth = vpAndScissor.depthRangeMax;
if (vpAndScissor.dirtyProj) {
shaderManager->DirtyUniform(DIRTY_PROJMATRIX);
gstate_c.DirtyUniform(DIRTY_PROJMATRIX);
}
VkRect2D &scissor = dynState.scissor;
@ -325,6 +325,6 @@ void ConvertStateToVulkanKey(FramebufferManagerVulkan &fbManager, ShaderManagerV
if (depthMin < 0.0f) depthMin = 0.0f;
if (depthMax > 1.0f) depthMax = 1.0f;
if (vpAndScissor.dirtyDepth) {
shaderManager->DirtyUniform(DIRTY_DEPTHRANGE);
gstate_c.DirtyUniform(DIRTY_DEPTHRANGE);
}
}