From b423998c36a35be35c5322877cc7637679433c1c Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Mon, 23 Jan 2017 23:15:54 +0100 Subject: [PATCH 01/11] Move uniform dirty-flag to gstate_c, opening up for other uses. --- GPU/Common/ShaderCommon.h | 7 +- GPU/Directx9/FramebufferDX9.cpp | 18 +- GPU/Directx9/GPU_DX9.cpp | 363 ++++++++++++++-------------- GPU/Directx9/ShaderManagerDX9.cpp | 22 +- GPU/Directx9/StateMappingDX9.cpp | 10 +- GPU/GLES/FramebufferManagerGLES.cpp | 6 +- GPU/GLES/GPU_GLES.cpp | 77 +++--- GPU/GLES/ShaderManagerGLES.cpp | 15 +- GPU/GLES/ShaderManagerGLES.h | 4 +- GPU/GLES/StateMappingGLES.cpp | 10 +- GPU/GPUCommon.cpp | 22 +- GPU/GPUState.h | 10 + GPU/Vulkan/DrawEngineVulkan.cpp | 2 +- GPU/Vulkan/FramebufferVulkan.cpp | 6 +- GPU/Vulkan/GPU_Vulkan.cpp | 69 +++--- GPU/Vulkan/ShaderManagerVulkan.cpp | 8 +- GPU/Vulkan/StateMappingVulkan.cpp | 6 +- 17 files changed, 331 insertions(+), 324 deletions(-) diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index 2a5f831439..1e709affaa 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -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_; }; \ No newline at end of file diff --git a/GPU/Directx9/FramebufferDX9.cpp b/GPU/Directx9/FramebufferDX9.cpp index 91a9490c8f..94caae8ba1 100644 --- a/GPU/Directx9/FramebufferDX9.cpp +++ b/GPU/Directx9/FramebufferDX9.cpp @@ -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); } } diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index af27e0ce8a..6fb81eab10 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -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: diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index 808d26e8b0..ce2b50c8d7 100644 --- a/GPU/Directx9/ShaderManagerDX9.cpp +++ b/GPU/Directx9/ShaderManagerDX9.cpp @@ -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); diff --git a/GPU/Directx9/StateMappingDX9.cpp b/GPU/Directx9/StateMappingDX9.cpp index b29aed7062..4167a38c62 100644 --- a/GPU/Directx9/StateMappingDX9.cpp +++ b/GPU/Directx9/StateMappingDX9.cpp @@ -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); } } diff --git a/GPU/GLES/FramebufferManagerGLES.cpp b/GPU/GLES/FramebufferManagerGLES.cpp index 26bb7de215..11d36e7a7c 100644 --- a/GPU/GLES/FramebufferManagerGLES.cpp +++ b/GPU/GLES/FramebufferManagerGLES.cpp @@ -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); } } diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index 979b92af70..f8ee52b7aa 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -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) { diff --git a/GPU/GLES/ShaderManagerGLES.cpp b/GPU/GLES/ShaderManagerGLES.cpp index 7b3f386b3f..6dfe9e2733 100644 --- a/GPU/GLES/ShaderManagerGLES.cpp +++ b/GPU/GLES/ShaderManagerGLES.cpp @@ -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); diff --git a/GPU/GLES/ShaderManagerGLES.h b/GPU/GLES/ShaderManagerGLES.h index af735bcc86..cc7944bd18 100644 --- a/GPU/GLES/ShaderManagerGLES.h +++ b/GPU/GLES/ShaderManagerGLES.h @@ -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. diff --git a/GPU/GLES/StateMappingGLES.cpp b/GPU/GLES/StateMappingGLES.cpp index 1e8daedde0..88b2298220 100644 --- a/GPU/GLES/StateMappingGLES.cpp +++ b/GPU/GLES/StateMappingGLES.cpp @@ -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); } } diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index b62f888b2a..6c05dc0fa2 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -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; } diff --git a/GPU/GPUState.h b/GPU/GPUState.h index 5c430f0876..53b69ff0bb 100644 --- a/GPU/GPUState.h +++ b/GPU/GPUState.h @@ -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; diff --git a/GPU/Vulkan/DrawEngineVulkan.cpp b/GPU/Vulkan/DrawEngineVulkan.cpp index 308ba38a95..d7f865687f 100644 --- a/GPU/Vulkan/DrawEngineVulkan.cpp +++ b/GPU/Vulkan/DrawEngineVulkan.cpp @@ -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); } } diff --git a/GPU/Vulkan/FramebufferVulkan.cpp b/GPU/Vulkan/FramebufferVulkan.cpp index 3e2767061e..c858adfed2 100644 --- a/GPU/Vulkan/FramebufferVulkan.cpp +++ b/GPU/Vulkan/FramebufferVulkan.cpp @@ -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); } } diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 45a10a74cc..6aa99d18d0 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -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); } diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index 05c7e90629..e96b66e7cc 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -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; } diff --git a/GPU/Vulkan/StateMappingVulkan.cpp b/GPU/Vulkan/StateMappingVulkan.cpp index d43f6e475c..88ca99ca03 100644 --- a/GPU/Vulkan/StateMappingVulkan.cpp +++ b/GPU/Vulkan/StateMappingVulkan.cpp @@ -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); } } From 7d60ec73be9562c41ba2a2ab8938dfa68fa7fe7b Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Mon, 23 Jan 2017 23:25:09 +0100 Subject: [PATCH 02/11] Move framebufChanged into the dirty flag field --- GPU/Common/FramebufferCommon.cpp | 2 +- GPU/Common/ShaderCommon.h | 3 +++ GPU/Directx9/FramebufferDX9.cpp | 2 +- GPU/Directx9/GPU_DX9.cpp | 14 +++++++------- GPU/GLES/FramebufferManagerGLES.cpp | 2 +- GPU/GLES/GPU_GLES.cpp | 16 ++++++++-------- GPU/GPUCommon.cpp | 4 ++-- GPU/GPUState.cpp | 2 +- GPU/GPUState.h | 10 +++++++++- GPU/Vulkan/FramebufferVulkan.cpp | 2 +- GPU/Vulkan/GPU_Vulkan.cpp | 16 ++++++++-------- 11 files changed, 42 insertions(+), 31 deletions(-) diff --git a/GPU/Common/FramebufferCommon.cpp b/GPU/Common/FramebufferCommon.cpp index ae7f6e70a6..e4e6c844b5 100644 --- a/GPU/Common/FramebufferCommon.cpp +++ b/GPU/Common/FramebufferCommon.cpp @@ -287,7 +287,7 @@ void GetFramebufferHeuristicInputs(FramebufferHeuristicParams *params, const GPU } VirtualFramebuffer *FramebufferManagerCommon::DoSetRenderFrameBuffer(const FramebufferHeuristicParams ¶ms, u32 skipDrawReason) { - gstate_c.framebufChanged = false; + gstate_c.Clean(DIRTY_FRAMEBUF); // Collect all parameters. This whole function has really become a cesspool of heuristics... // but it appears that's what it takes, unless we emulate VRAM layout more accurately somehow. diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index 1e709affaa..fb513c6455 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -87,6 +87,9 @@ enum : uint64_t { DIRTY_ALL_UNIFORMS = 0x1FFFFFFFFFULL, + // Other dirty elements that aren't uniforms! + DIRTY_FRAMEBUF = 1ULL << 40, + // Now we can add further dirty flags that are not uniforms. DIRTY_ALL = 0xFFFFFFFFFFFFFFFF diff --git a/GPU/Directx9/FramebufferDX9.cpp b/GPU/Directx9/FramebufferDX9.cpp index 94caae8ba1..180dc9c5ff 100644 --- a/GPU/Directx9/FramebufferDX9.cpp +++ b/GPU/Directx9/FramebufferDX9.cpp @@ -1303,7 +1303,7 @@ namespace DX9 { // TODO: It's really bad that we are calling SetRenderFramebuffer here with // all the irrelevant state checking it'll use to decide what to do. Should // do something more focused here. - SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); transformDraw_->Flush(); } diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 6fb81eab10..322eb147c3 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -754,7 +754,7 @@ void GPU_DX9::Execute_Prim(u32 op, u32 diff) { } // This also make skipping drawing very effective. - framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { drawEngine_.SetupVertexDecoder(gstate.vertType); // Rough estimate, not sure what's correct. @@ -801,7 +801,7 @@ void GPU_DX9::Execute_Prim(u32 op, u32 diff) { void GPU_DX9::Execute_Bezier(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -844,7 +844,7 @@ void GPU_DX9::Execute_Bezier(u32 op, u32 diff) { void GPU_DX9::Execute_Spline(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerDX9_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -889,7 +889,7 @@ void GPU_DX9::Execute_Spline(u32 op, u32 diff) { } void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; switch (op >> 24) { case GE_CMD_VIEWPORTZSCALE: @@ -900,17 +900,17 @@ void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { } void GPU_DX9::Execute_Region(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_DX9::Execute_Scissor(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_DX9::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } diff --git a/GPU/GLES/FramebufferManagerGLES.cpp b/GPU/GLES/FramebufferManagerGLES.cpp index 11d36e7a7c..120f403e12 100644 --- a/GPU/GLES/FramebufferManagerGLES.cpp +++ b/GPU/GLES/FramebufferManagerGLES.cpp @@ -1962,7 +1962,7 @@ void FramebufferManagerGLES::FlushBeforeCopy() { // TODO: It's really bad that we are calling SetRenderFramebuffer here with // all the irrelevant state checking it'll use to decide what to do. Should // do something more focused here. - SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); transformDraw_->Flush(); } diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index f8ee52b7aa..05f28f6551 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -921,7 +921,7 @@ void GPU_GLES::Execute_Prim(u32 op, u32 diff) { } // This also makes skipping drawing very effective. - framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { drawEngine_.SetupVertexDecoder(gstate.vertType); // Rough estimate, not sure what's correct. @@ -989,7 +989,7 @@ void GPU_GLES::Execute_VertexTypeSkinning(u32 op, u32 diff) { void GPU_GLES::Execute_Bezier(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -1043,7 +1043,7 @@ void GPU_GLES::Execute_Bezier(u32 op, u32 diff) { void GPU_GLES::Execute_Spline(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -1111,27 +1111,27 @@ void GPU_GLES::Execute_Spline(u32 op, u32 diff) { } void GPU_GLES::Execute_Region(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_GLES::Execute_Scissor(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_GLES::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); } diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index 6c05dc0fa2..76b6fdcdf0 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -1071,7 +1071,7 @@ void GPUCommon::Execute_End(u32 op, u32 diff) { void GPUCommon::Execute_Bezier(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManager_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -1114,7 +1114,7 @@ void GPUCommon::Execute_Bezier(u32 op, u32 diff) { void GPUCommon::Execute_Spline(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManager_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; diff --git a/GPU/GPUState.cpp b/GPU/GPUState.cpp index f63eac714c..78b2687936 100644 --- a/GPU/GPUState.cpp +++ b/GPU/GPUState.cpp @@ -219,7 +219,6 @@ void GPUStateCache::DoState(PointerWrap &p) { textureChanged = TEXCHANGE_UPDATED; textureFullAlpha = old.textureFullAlpha; vertexFullAlpha = old.vertexFullAlpha; - framebufChanged = old.framebufChanged; skipDrawReason = old.skipDrawReason; uv = old.uv; } else { @@ -230,6 +229,7 @@ void GPUStateCache::DoState(PointerWrap &p) { p.Do(textureChanged); p.Do(textureFullAlpha); p.Do(vertexFullAlpha); + bool framebufChanged; // legacy p.Do(framebufChanged); p.Do(skipDrawReason); diff --git a/GPU/GPUState.h b/GPU/GPUState.h index 53b69ff0bb..8e99b6c31e 100644 --- a/GPU/GPUState.h +++ b/GPU/GPUState.h @@ -492,9 +492,18 @@ struct GPUStateCache { void DirtyUniform(u64 what) { dirty |= what; } + void Dirty(u64 what) { + dirty |= what; + } void CleanUniforms() { dirty &= ~DIRTY_ALL_UNIFORMS; } + void Clean(u64 what) { + dirty &= ~what; + } + bool IsDirty(u64 what) const { + return (dirty & what) != 0ULL; + } u32 featureFlags; @@ -508,7 +517,6 @@ struct GPUStateCache { bool textureFullAlpha; bool textureSimpleAlpha; bool vertexFullAlpha; - bool framebufChanged; int skipDrawReason; diff --git a/GPU/Vulkan/FramebufferVulkan.cpp b/GPU/Vulkan/FramebufferVulkan.cpp index c858adfed2..217e1a0dc2 100644 --- a/GPU/Vulkan/FramebufferVulkan.cpp +++ b/GPU/Vulkan/FramebufferVulkan.cpp @@ -1628,7 +1628,7 @@ void FramebufferManagerVulkan::FlushBeforeCopy() { // TODO: It's really bad that we are calling SetRenderFramebuffer here with // all the irrelevant state checking it'll use to decide what to do. Should // do something more focused here. - SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); drawEngine_->Flush(curCmd_); } diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 6aa99d18d0..4eab1a2447 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -778,7 +778,7 @@ void GPU_Vulkan::Execute_Prim(u32 op, u32 diff) { } // This also makes skipping drawing very effective. - framebufferManager_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { drawEngine_.SetupVertexDecoder(gstate.vertType); @@ -829,7 +829,7 @@ void GPU_Vulkan::Execute_VertexType(u32 op, u32 diff) { void GPU_Vulkan::Execute_Bezier(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManager_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -872,7 +872,7 @@ void GPU_Vulkan::Execute_Bezier(u32 op, u32 diff) { void GPU_Vulkan::Execute_Spline(u32 op, u32 diff) { // This also make skipping drawing very effective. - framebufferManager_->SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason); + framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason); if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) { // TODO: Should this eat some cycles? Probably yes. Not sure if important. return; @@ -917,27 +917,27 @@ void GPU_Vulkan::Execute_Spline(u32 op, u32 diff) { } void GPU_Vulkan::Execute_Region(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_Vulkan::Execute_Scissor(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_Vulkan::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_Vulkan::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; } void GPU_Vulkan::Execute_ViewportZType(u32 op, u32 diff) { - gstate_c.framebufChanged = true; + gstate_c.Dirty(DIRTY_FRAMEBUF); gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); } From c289a2c7bf16811ca833055341008d802df28cf3 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 09:31:36 +0100 Subject: [PATCH 03/11] Split TextureChanged into two bools, so we can later convert to dirtyflags --- GPU/Directx9/DrawEngineDX9.cpp | 2 +- GPU/Directx9/GPU_DX9.cpp | 38 ++++++++++++++--------------- GPU/Directx9/StateMappingDX9.cpp | 5 ++-- GPU/Directx9/TextureCacheDX9.cpp | 4 ++-- GPU/GLES/DrawEngineGLES.cpp | 2 +- GPU/GLES/GPU_GLES.cpp | 41 ++++++++++++++++---------------- GPU/GLES/StateMappingGLES.cpp | 20 ++++++++-------- GPU/GLES/TextureCacheGLES.cpp | 2 +- GPU/GLES/TextureCacheGLES.h | 2 +- GPU/GPUCommon.cpp | 5 ++-- GPU/GPUState.cpp | 15 +++++++----- GPU/GPUState.h | 10 +++----- GPU/Null/NullGpu.cpp | 6 ++--- GPU/Vulkan/DrawEngineVulkan.cpp | 9 +++---- GPU/Vulkan/GPU_Vulkan.cpp | 40 +++++++++++++++---------------- GPU/Vulkan/TextureCacheVulkan.h | 2 +- 16 files changed, 101 insertions(+), 102 deletions(-) diff --git a/GPU/Directx9/DrawEngineDX9.cpp b/GPU/Directx9/DrawEngineDX9.cpp index 493c6f2ad8..7e21583849 100644 --- a/GPU/Directx9/DrawEngineDX9.cpp +++ b/GPU/Directx9/DrawEngineDX9.cpp @@ -313,7 +313,7 @@ void DrawEngineDX9::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, in if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; Flush(); } } diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 322eb147c3..7286ce59af 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -644,7 +644,7 @@ void GPU_DX9::CopyDisplayToOutputInternal() { // shaderManager_->EndFrame(); shaderManagerDX9_->DirtyLastShader(); - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } // Maybe should write this in ASM... @@ -890,7 +890,7 @@ void GPU_DX9::Execute_Spline(u32 op, u32 diff) { void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; switch (op >> 24) { case GE_CMD_VIEWPORTZSCALE: case GE_CMD_VIEWPORTZCENTER: @@ -901,17 +901,17 @@ void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { void GPU_DX9::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_TexScaleU(u32 op, u32 diff) { @@ -935,40 +935,40 @@ void GPU_DX9::Execute_TexOffsetV(u32 op, u32 diff) { } void GPU_DX9::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_DX9::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) { + if (diff || (gstate_c.textureParamsChanged || gstate_c.textureImageChanged)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } } void GPU_DX9::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_DX9::Execute_TexMapMode(u32 op, u32 diff) { @@ -976,7 +976,7 @@ void GPU_DX9::Execute_TexMapMode(u32 op, u32 diff) { } void GPU_DX9::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_TexEnvColor(u32 op, u32 diff) { @@ -993,17 +993,17 @@ void GPU_DX9::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_DX9::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; textureCacheDX9_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); // This could be used to "dirty" textures with clut. } void GPU_DX9::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; // This could be used to "dirty" textures with clut. } @@ -1116,7 +1116,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_TEXTUREMAPENABLE: if (diff) - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; break; case GE_CMD_LIGHTINGENABLE: @@ -1599,7 +1599,7 @@ void GPU_DX9::DoState(PointerWrap &p) { textureCacheDX9_->Clear(true); drawEngine_.ClearTrackedVertexArrays(); - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; framebufferManagerDX9_->DestroyAllFBOs(true); shaderManagerDX9_->ClearCache(true); } diff --git a/GPU/Directx9/StateMappingDX9.cpp b/GPU/Directx9/StateMappingDX9.cpp index 4167a38c62..717a8e749a 100644 --- a/GPU/Directx9/StateMappingDX9.cpp +++ b/GPU/Directx9/StateMappingDX9.cpp @@ -125,9 +125,10 @@ inline void DrawEngineDX9::ResetShaderBlending() { void DrawEngineDX9::ApplyDrawState(int prim) { // TODO: All this setup is soon so expensive that we'll need dirty flags, or simply do it in the command writes where we detect dirty by xoring. Silly to do all this work on every drawcall. - if (gstate_c.textureChanged != TEXCHANGE_UNCHANGED && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); - gstate_c.textureChanged = TEXCHANGE_UNCHANGED; + gstate_c.textureImageChanged = false; + gstate_c.textureParamsChanged = false; 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. diff --git a/GPU/Directx9/TextureCacheDX9.cpp b/GPU/Directx9/TextureCacheDX9.cpp index fa7e12cea7..4be51ae27d 100644 --- a/GPU/Directx9/TextureCacheDX9.cpp +++ b/GPU/Directx9/TextureCacheDX9.cpp @@ -127,7 +127,7 @@ void TextureCacheDX9::DeleteTexture(TexCache::iterator it) { void TextureCacheDX9::ForgetLastTexture() { lastBoundTexture = INVALID_TEX; - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } // Removes old textures. @@ -931,7 +931,7 @@ void TextureCacheDX9::SetTexture(bool force) { // Always rehash in this case, if one changed the rest all probably did. rehash = true; entry->status &= ~TexCacheEntry::STATUS_CLUT_RECHECK; - } else if ((gstate_c.textureChanged & TEXCHANGE_UPDATED) == 0) { + } else if (!gstate_c.textureImageChanged) { // Okay, just some parameter change - the data didn't change, no need to rehash. rehash = false; } diff --git a/GPU/GLES/DrawEngineGLES.cpp b/GPU/GLES/DrawEngineGLES.cpp index 35f660f2c8..586c301703 100644 --- a/GPU/GLES/DrawEngineGLES.cpp +++ b/GPU/GLES/DrawEngineGLES.cpp @@ -337,7 +337,7 @@ void DrawEngineGLES::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, i if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; Flush(); } } diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index 05f28f6551..fae0215582 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -831,7 +831,8 @@ void GPU_GLES::CopyDisplayToOutputInternal() { #endif #endif - gstate_c.textureChanged = TEXCHANGE_UPDATED; + // Wait, why? + gstate_c.textureImageChanged = true; } // Maybe should write this in ASM... @@ -1112,27 +1113,27 @@ void GPU_GLES::Execute_Spline(u32 op, u32 diff) { void GPU_GLES::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); } @@ -1157,40 +1158,40 @@ void GPU_GLES::Execute_TexOffsetV(u32 op, u32 diff) { } void GPU_GLES::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_GLES::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) { + if (diff || (gstate_c.textureImageChanged || gstate_c.textureParamsChanged)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } } void GPU_GLES::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) { @@ -1198,7 +1199,7 @@ void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) { } void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_TexEnvColor(u32 op, u32 diff) { @@ -1215,18 +1216,16 @@ void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; textureCacheGL_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); - // This could be used to "dirty" textures with clut. } void GPU_GLES::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; - // This could be used to "dirty" textures with clut. + gstate_c.textureParamsChanged = true; } void GPU_GLES::Execute_Ambient(u32 op, u32 diff) { @@ -1885,7 +1884,7 @@ void GPU_GLES::DoState(PointerWrap &p) { depalShaderCache_.Clear(); drawEngine_.ClearTrackedVertexArrays(); - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; framebufferManagerGL_->DestroyAllFBOs(true); shaderManagerGL_->ClearCache(true); } diff --git a/GPU/GLES/StateMappingGLES.cpp b/GPU/GLES/StateMappingGLES.cpp index 88b2298220..b5458e21ec 100644 --- a/GPU/GLES/StateMappingGLES.cpp +++ b/GPU/GLES/StateMappingGLES.cpp @@ -157,12 +157,12 @@ inline void DrawEngineGLES::ResetShaderBlending() { } } +// TODO: All this setup is so expensive that we'll need dirty flags, or simply do it in the command writes where we detect dirty by xoring. Silly to do all this work on every drawcall. void DrawEngineGLES::ApplyDrawState(int prim) { - // TODO: All this setup is so expensive that we'll need dirty flags, or simply do it in the command writes where we detect dirty by xoring. Silly to do all this work on every drawcall. - - if (gstate_c.textureChanged != TEXCHANGE_UNCHANGED && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); - gstate_c.textureChanged = TEXCHANGE_UNCHANGED; + gstate_c.textureImageChanged = false; + gstate_c.textureParamsChanged = false; 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. @@ -174,18 +174,12 @@ void DrawEngineGLES::ApplyDrawState(int prim) { PROFILE_THIS_SCOPE("applydrawstate"); bool useBufferedRendering = g_Config.iRenderingMode != FB_NON_BUFFERED_MODE; - gstate_c.allowShaderBlend = !g_Config.bDisableSlowFramebufEffects; // Do the large chunks of state conversion. We might be able to hide these two behind a dirty-flag each, // to avoid recomputing heavy stuff unnecessarily every draw call. GenericBlendState blendState; ConvertBlendState(blendState, gstate_c.allowShaderBlend); - ViewportAndScissor vpAndScissor; - ConvertViewportAndScissor(useBufferedRendering, - framebufferManager_->GetRenderWidth(), framebufferManager_->GetRenderHeight(), - framebufferManager_->GetTargetBufferWidth(), framebufferManager_->GetTargetBufferHeight(), - vpAndScissor); if (blendState.applyShaderBlending) { if (ApplyShaderBlending()) { @@ -351,6 +345,12 @@ void DrawEngineGLES::ApplyDrawState(int prim) { } } + ViewportAndScissor vpAndScissor; + ConvertViewportAndScissor(useBufferedRendering, + framebufferManager_->GetRenderWidth(), framebufferManager_->GetRenderHeight(), + framebufferManager_->GetTargetBufferWidth(), framebufferManager_->GetTargetBufferHeight(), + vpAndScissor); + if (vpAndScissor.scissorEnable) { glstate.scissorTest.enable(); if (!useBufferedRendering) { diff --git a/GPU/GLES/TextureCacheGLES.cpp b/GPU/GLES/TextureCacheGLES.cpp index dd14f7a19e..43c165dbe3 100644 --- a/GPU/GLES/TextureCacheGLES.cpp +++ b/GPU/GLES/TextureCacheGLES.cpp @@ -1034,7 +1034,7 @@ void TextureCacheGLES::SetTexture(bool force) { // Always rehash in this case, if one changed the rest all probably did. rehash = true; entry->status &= ~TexCacheEntry::STATUS_CLUT_RECHECK; - } else if ((gstate_c.textureChanged & TEXCHANGE_UPDATED) == 0) { + } else if (!gstate_c.textureImageChanged) { // Okay, just some parameter change - the data didn't change, no need to rehash. rehash = false; } diff --git a/GPU/GLES/TextureCacheGLES.h b/GPU/GLES/TextureCacheGLES.h index 5d9987d2eb..3dbe7168b2 100644 --- a/GPU/GLES/TextureCacheGLES.h +++ b/GPU/GLES/TextureCacheGLES.h @@ -75,7 +75,7 @@ public: void ForgetLastTexture() { lastBoundTexture = -1; - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } u32 AllocTextureName(); diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index 76b6fdcdf0..ff9e5cb324 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -787,7 +787,8 @@ void GPUCommon::ProcessDLQueueInternal() { UpdateTickEstimate(std::max(busyTicks, startingTicks + cyclesExecuted)); // Game might've written new texture data. - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; + gstate_c.textureParamsChanged = true; // Seems to be correct behaviour to process the list anyway? if (startingTicks < busyTicks) { @@ -1193,7 +1194,7 @@ void GPUCommon::Execute_BlockTransferStart(u32 op, u32 diff) { DoBlockTransfer(gstate_c.skipDrawReason); // Fixes Gran Turismo's funky text issue, since it overwrites the current texture. - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) { diff --git a/GPU/GPUState.cpp b/GPU/GPUState.cpp index 78b2687936..1f6d2a9877 100644 --- a/GPU/GPUState.cpp +++ b/GPU/GPUState.cpp @@ -216,7 +216,8 @@ void GPUStateCache::DoState(PointerWrap &p) { vertexAddr = old.vertexAddr; indexAddr = old.indexAddr; offsetAddr = old.offsetAddr; - textureChanged = TEXCHANGE_UPDATED; + textureImageChanged = true; + textureParamsChanged = true; textureFullAlpha = old.textureFullAlpha; vertexFullAlpha = old.vertexFullAlpha; skipDrawReason = old.skipDrawReason; @@ -226,19 +227,21 @@ void GPUStateCache::DoState(PointerWrap &p) { p.Do(indexAddr); p.Do(offsetAddr); - p.Do(textureChanged); + int textureChanged = 0; + p.Do(textureChanged); // legacy + textureImageChanged = true; + textureParamsChanged = true; p.Do(textureFullAlpha); p.Do(vertexFullAlpha); - bool framebufChanged; // legacy + bool framebufChanged = false; // legacy p.Do(framebufChanged); p.Do(skipDrawReason); p.Do(uv); - // No longer relevant. Remove when creating the next version. - bool oldFlipTexture; - p.Do(oldFlipTexture); + bool oldFlipTexture = false; + p.Do(oldFlipTexture); // legacy } // needShaderTexClamp and bgraTexture don't need to be saved. diff --git a/GPU/GPUState.h b/GPU/GPUState.h index 8e99b6c31e..88660beaa3 100644 --- a/GPU/GPUState.h +++ b/GPU/GPUState.h @@ -441,12 +441,6 @@ struct UVScale { float uOff, vOff; }; -enum TextureChangeReason { - TEXCHANGE_UNCHANGED = 0x00, - TEXCHANGE_UPDATED = 0x01, - TEXCHANGE_PARAMSONLY = 0x02, -}; - #define FLAG_BIT(x) (1 << x) // Some of these are OpenGL-specific even though this file is neutral, unfortunately. @@ -513,7 +507,9 @@ struct GPUStateCache { uint64_t dirty; - u8 textureChanged; + bool textureImageChanged; + bool textureParamsChanged; + bool textureFullAlpha; bool textureSimpleAlpha; bool vertexFullAlpha; diff --git a/GPU/Null/NullGpu.cpp b/GPU/Null/NullGpu.cpp index 58cde7ca75..49e3a0e8c2 100644 --- a/GPU/Null/NullGpu.cpp +++ b/GPU/Null/NullGpu.cpp @@ -214,7 +214,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { break; case GE_CMD_TEXADDR0: - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; case GE_CMD_TEXADDR1: case GE_CMD_TEXADDR2: case GE_CMD_TEXADDR3: @@ -226,7 +226,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { break; case GE_CMD_TEXBUFWIDTH0: - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; case GE_CMD_TEXBUFWIDTH1: case GE_CMD_TEXBUFWIDTH2: case GE_CMD_TEXBUFWIDTH3: @@ -342,7 +342,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { } case GE_CMD_TEXSIZE0: - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; gstate_c.curTextureWidth = 1 << (gstate.texsize[0] & 0xf); gstate_c.curTextureHeight = 1 << ((gstate.texsize[0]>>8) & 0xf); //fall thru - ignoring the mipmap sizes for now diff --git a/GPU/Vulkan/DrawEngineVulkan.cpp b/GPU/Vulkan/DrawEngineVulkan.cpp index d7f865687f..aeae2146e4 100644 --- a/GPU/Vulkan/DrawEngineVulkan.cpp +++ b/GPU/Vulkan/DrawEngineVulkan.cpp @@ -361,7 +361,7 @@ void DrawEngineVulkan::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; Flush(cmd_); } } @@ -600,7 +600,7 @@ void DrawEngineVulkan::DirtyAllUBOs() { dirtyUniforms_ = DIRTY_BASE_UNIFORMS | DIRTY_LIGHT_UNIFORMS | DIRTY_BONE_UNIFORMS; imageView = VK_NULL_HANDLE; sampler = VK_NULL_HANDLE; - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } //void DrawEngineVulkan::ApplyDrawStateLate() { @@ -630,10 +630,11 @@ void DrawEngineVulkan::DoFlush(VkCommandBuffer cmd) { FrameData *frame = &frame_[curFrame_ & 1]; bool textureNeedsApply = false; - if (gstate_c.textureChanged != TEXCHANGE_UNCHANGED && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); textureNeedsApply = true; - gstate_c.textureChanged = TEXCHANGE_UNCHANGED; + gstate_c.textureImageChanged = false; + gstate_c.textureParamsChanged = false; 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. diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 4eab1a2447..022c128f3a 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -690,7 +690,7 @@ void GPU_Vulkan::CopyDisplayToOutputInternal() { framebufferManagerVulkan_->CopyDisplayToOutput(); - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } // Maybe should write this in ASM... @@ -918,27 +918,27 @@ void GPU_Vulkan::Execute_Spline(u32 op, u32 diff) { void GPU_Vulkan::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; // Why? } void GPU_Vulkan::Execute_ViewportZType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); } @@ -963,40 +963,40 @@ void GPU_Vulkan::Execute_TexOffsetV(u32 op, u32 diff) { } void GPU_Vulkan::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_Vulkan::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) { + if (diff || (gstate_c.textureImageChanged || gstate_c.textureParamsChanged)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } } void GPU_Vulkan::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; } void GPU_Vulkan::Execute_TexMapMode(u32 op, u32 diff) { @@ -1004,7 +1004,7 @@ void GPU_Vulkan::Execute_TexMapMode(u32 op, u32 diff) { } void GPU_Vulkan::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_TexEnvColor(u32 op, u32 diff) { @@ -1021,18 +1021,16 @@ void GPU_Vulkan::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; textureCacheVulkan_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); - // This could be used to "dirty" textures with clut. } void GPU_Vulkan::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; - // This could be used to "dirty" textures with clut. + gstate_c.textureParamsChanged = true; } void GPU_Vulkan::Execute_Ambient(u32 op, u32 diff) { @@ -1769,7 +1767,7 @@ void GPU_Vulkan::DoState(PointerWrap &p) { textureCacheVulkan_->Clear(true); depalShaderCache_.Clear(); - gstate_c.textureChanged = TEXCHANGE_UPDATED; + gstate_c.textureImageChanged = true; framebufferManagerVulkan_->DestroyAllFBOs(true); shaderManagerVulkan_->ClearShaders(); pipelineManager_->Clear(); diff --git a/GPU/Vulkan/TextureCacheVulkan.h b/GPU/Vulkan/TextureCacheVulkan.h index 213c43e491..4bea30f2e9 100644 --- a/GPU/Vulkan/TextureCacheVulkan.h +++ b/GPU/Vulkan/TextureCacheVulkan.h @@ -121,7 +121,7 @@ public: void ForgetLastTexture() { lastBoundTexture = nullptr; - gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY; + gstate_c.textureParamsChanged = true; } void ApplyTexture(VulkanPushBuffer *uploadBuffer, VkImageView &imageView, VkSampler &sampler); From e4cb44c2439952a2b37b5571431ec752f9b2a6f1 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 09:41:38 +0100 Subject: [PATCH 04/11] Merge the texture flags into the dirty flags --- GPU/Common/ShaderCommon.h | 2 + GPU/Directx9/DrawEngineDX9.cpp | 2 +- GPU/Directx9/FramebufferDX9.cpp | 18 ++-- GPU/Directx9/GPU_DX9.cpp | 124 ++++++++++++++-------------- GPU/Directx9/ShaderManagerDX9.cpp | 4 +- GPU/Directx9/StateMappingDX9.cpp | 15 ++-- GPU/Directx9/TextureCacheDX9.cpp | 4 +- GPU/GLES/DrawEngineGLES.cpp | 2 +- GPU/GLES/FramebufferManagerGLES.cpp | 6 +- GPU/GLES/GPU_GLES.cpp | 105 ++++++++++++----------- GPU/GLES/ShaderManagerGLES.cpp | 4 +- GPU/GLES/StateMappingGLES.cpp | 15 ++-- GPU/GLES/TextureCacheGLES.cpp | 2 +- GPU/GLES/TextureCacheGLES.h | 2 +- GPU/GPUCommon.cpp | 28 +++---- GPU/GPUState.cpp | 8 +- GPU/GPUState.h | 22 ++--- GPU/Null/NullGpu.cpp | 6 +- GPU/Vulkan/DrawEngineVulkan.cpp | 11 ++- GPU/Vulkan/FramebufferVulkan.cpp | 6 +- GPU/Vulkan/GPU_Vulkan.cpp | 96 +++++++++++---------- GPU/Vulkan/ShaderManagerVulkan.cpp | 2 +- GPU/Vulkan/StateMappingVulkan.cpp | 6 +- GPU/Vulkan/TextureCacheVulkan.cpp | 2 +- GPU/Vulkan/TextureCacheVulkan.h | 2 +- 25 files changed, 241 insertions(+), 253 deletions(-) diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index fb513c6455..967d2f01ea 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -89,6 +89,8 @@ enum : uint64_t { // Other dirty elements that aren't uniforms! DIRTY_FRAMEBUF = 1ULL << 40, + DIRTY_TEXTURE_IMAGE = 1ULL << 41, + DIRTY_TEXTURE_PARAMS = 1ULL << 42, // Now we can add further dirty flags that are not uniforms. diff --git a/GPU/Directx9/DrawEngineDX9.cpp b/GPU/Directx9/DrawEngineDX9.cpp index 7e21583849..eeb2f87831 100644 --- a/GPU/Directx9/DrawEngineDX9.cpp +++ b/GPU/Directx9/DrawEngineDX9.cpp @@ -313,7 +313,7 @@ void DrawEngineDX9::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, in if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); Flush(); } } diff --git a/GPU/Directx9/FramebufferDX9.cpp b/GPU/Directx9/FramebufferDX9.cpp index 180dc9c5ff..798a89f327 100644 --- a/GPU/Directx9/FramebufferDX9.cpp +++ b/GPU/Directx9/FramebufferDX9.cpp @@ -390,11 +390,11 @@ namespace DX9 { // ugly... if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } @@ -447,11 +447,11 @@ namespace DX9 { // ugly... if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } @@ -465,11 +465,11 @@ namespace DX9 { // ugly... if (gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } if (gstate_c.curRTRenderWidth != vfb->renderWidth || gstate_c.curRTRenderHeight != vfb->renderHeight) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 7286ce59af..7cd3356b9a 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -644,7 +644,7 @@ void GPU_DX9::CopyDisplayToOutputInternal() { // shaderManager_->EndFrame(); shaderManagerDX9_->DirtyLastShader(); - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } // Maybe should write this in ASM... @@ -708,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)) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } } @@ -720,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)) - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(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) { - gstate_c.DirtyUniform(gstate_c.deferredVertTypeDirty); + gstate_c.Dirty(gstate_c.deferredVertTypeDirty); gstate_c.deferredVertTypeDirty = 0; } } @@ -890,97 +890,97 @@ void GPU_DX9::Execute_Spline(u32 op, u32 diff) { void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); switch (op >> 24) { case GE_CMD_VIEWPORTZSCALE: case GE_CMD_VIEWPORTZCENTER: - gstate_c.DirtyUniform(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE); break; } } void GPU_DX9::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexScaleV(u32 op, u32 diff) { gstate_c.uv.vScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexOffsetU(u32 op, u32 diff) { gstate_c.uv.uOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.uv.vOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_DX9::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || (gstate_c.textureParamsChanged || gstate_c.textureImageChanged)) { + if (diff || gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } } void GPU_DX9::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_DX9::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_DX9::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_TEXENV); + gstate_c.Dirty(DIRTY_TEXENV); } void GPU_DX9::Execute_TexLevel(u32 op, u32 diff) { @@ -993,79 +993,79 @@ void GPU_DX9::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_DX9::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheDX9_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); // This could be used to "dirty" textures with clut. } void GPU_DX9::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); // This could be used to "dirty" textures with clut. } void GPU_DX9::Execute_Ambient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_AMBIENT); + gstate_c.Dirty(DIRTY_AMBIENT); } void GPU_DX9::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATDIFFUSE); + gstate_c.Dirty(DIRTY_MATDIFFUSE); } void GPU_DX9::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATEMISSIVE); + gstate_c.Dirty(DIRTY_MATEMISSIVE); } void GPU_DX9::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA); + gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); } void GPU_DX9::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATSPECULAR); + gstate_c.Dirty(DIRTY_MATSPECULAR); } void GPU_DX9::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT0); + gstate_c.Dirty(DIRTY_LIGHT0); } void GPU_DX9::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT1); + gstate_c.Dirty(DIRTY_LIGHT1); } void GPU_DX9::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT2); + gstate_c.Dirty(DIRTY_LIGHT2); } void GPU_DX9::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT3); + gstate_c.Dirty(DIRTY_LIGHT3); } void GPU_DX9::Execute_FogColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOLOR); + gstate_c.Dirty(DIRTY_FOGCOLOR); } void GPU_DX9::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOEF); + gstate_c.Dirty(DIRTY_FOGCOEF); } void GPU_DX9::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORMASK); } void GPU_DX9::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORREF); + gstate_c.Dirty(DIRTY_ALPHACOLORMASK); } void GPU_DX9::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE); + gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); } void GPU_DX9::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); + gstate_c.Dirty(DIRTY_ALPHACOLORREF); } void GPU_DX9::Execute_Generic(u32 op, u32 diff) { @@ -1116,7 +1116,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_TEXTUREMAPENABLE: if (diff) - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); break; case GE_CMD_LIGHTINGENABLE: @@ -1124,17 +1124,17 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_FOGCOLOR: if (diff) - gstate_c.DirtyUniform(DIRTY_FOGCOLOR); + gstate_c.Dirty(DIRTY_FOGCOLOR); break; case GE_CMD_FOG1: if (diff) - gstate_c.DirtyUniform(DIRTY_FOGCOEF); + gstate_c.Dirty(DIRTY_FOGCOEF); break; case GE_CMD_FOG2: if (diff) - gstate_c.DirtyUniform(DIRTY_FOGCOEF); + gstate_c.Dirty(DIRTY_FOGCOEF); break; case GE_CMD_FOGENABLE: @@ -1254,29 +1254,29 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_AMBIENTCOLOR: case GE_CMD_AMBIENTALPHA: if (diff) - gstate_c.DirtyUniform(DIRTY_AMBIENT); + gstate_c.Dirty(DIRTY_AMBIENT); break; case GE_CMD_MATERIALDIFFUSE: if (diff) - gstate_c.DirtyUniform(DIRTY_MATDIFFUSE); + gstate_c.Dirty(DIRTY_MATDIFFUSE); break; case GE_CMD_MATERIALEMISSIVE: if (diff) - gstate_c.DirtyUniform(DIRTY_MATEMISSIVE); + gstate_c.Dirty(DIRTY_MATEMISSIVE); break; case GE_CMD_MATERIALAMBIENT: case GE_CMD_MATERIALALPHA: if (diff) - gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA); + gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); break; case GE_CMD_MATERIALSPECULAR: case GE_CMD_MATERIALSPECULARCOEF: if (diff) - gstate_c.DirtyUniform(DIRTY_MATSPECULAR); + gstate_c.Dirty(DIRTY_MATSPECULAR); break; case GE_CMD_LIGHTTYPE0: @@ -1293,7 +1293,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_LDC0: case GE_CMD_LSC0: if (diff) - gstate_c.DirtyUniform(DIRTY_LIGHT0); + gstate_c.Dirty(DIRTY_LIGHT0); break; case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1: @@ -1305,7 +1305,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_LDC1: case GE_CMD_LSC1: if (diff) - gstate_c.DirtyUniform(DIRTY_LIGHT1); + gstate_c.Dirty(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: @@ -1316,7 +1316,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_LDC2: case GE_CMD_LSC2: if (diff) - gstate_c.DirtyUniform(DIRTY_LIGHT2); + gstate_c.Dirty(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: @@ -1327,7 +1327,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_LDC3: case GE_CMD_LSC3: if (diff) - gstate_c.DirtyUniform(DIRTY_LIGHT3); + gstate_c.Dirty(DIRTY_LIGHT3); break; case GE_CMD_VIEWPORTXSCALE: @@ -1381,7 +1381,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_COLORTEST: case GE_CMD_COLORTESTMASK: if (diff) - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORMASK); break; case GE_CMD_ALPHATEST: @@ -1390,12 +1390,12 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { // Intentional fallthrough. case GE_CMD_COLORREF: if (diff) - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); + gstate_c.Dirty(DIRTY_ALPHACOLORREF); break; case GE_CMD_TEXENVCOLOR: if (diff) - gstate_c.DirtyUniform(DIRTY_TEXENV); + gstate_c.Dirty(DIRTY_TEXENV); break; case GE_CMD_TEXFUNC: @@ -1599,7 +1599,7 @@ void GPU_DX9::DoState(PointerWrap &p) { textureCacheDX9_->Clear(true); drawEngine_.ClearTrackedVertexArrays(); - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); framebufferManagerDX9_->DestroyAllFBOs(true); shaderManagerDX9_->ClearCache(true); } diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index ce2b50c8d7..954cf35014 100644 --- a/GPU/Directx9/ShaderManagerDX9.cpp +++ b/GPU/Directx9/ShaderManagerDX9.cpp @@ -522,7 +522,7 @@ void ShaderManagerDX9::Clear() { } fsCache_.clear(); vsCache_.clear(); - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); lastFSID_.clear(); lastVSID_.clear(); DirtyShader(); @@ -539,7 +539,7 @@ void ShaderManagerDX9::DirtyShader() { lastVSID_.clear(); lastVShader_ = nullptr; lastPShader_ = nullptr; - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); } void ShaderManagerDX9::DirtyLastShader() { // disables vertex arrays diff --git a/GPU/Directx9/StateMappingDX9.cpp b/GPU/Directx9/StateMappingDX9.cpp index 717a8e749a..cd137a9209 100644 --- a/GPU/Directx9/StateMappingDX9.cpp +++ b/GPU/Directx9/StateMappingDX9.cpp @@ -111,7 +111,7 @@ bool DrawEngineDX9::ApplyShaderBlending() { fboTexNeedBind_ = true; - gstate_c.DirtyUniform(DIRTY_SHADERBLEND); + gstate_c.Dirty(DIRTY_SHADERBLEND); return true; } @@ -125,14 +125,13 @@ inline void DrawEngineDX9::ResetShaderBlending() { void DrawEngineDX9::ApplyDrawState(int prim) { // TODO: All this setup is soon so expensive that we'll need dirty flags, or simply do it in the command writes where we detect dirty by xoring. Silly to do all this work on every drawcall. - if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if (gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); - gstate_c.textureImageChanged = false; - gstate_c.textureParamsChanged = false; + gstate_c.Clean(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS); 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. - gstate_c.DirtyUniform(DIRTY_TEXCLAMP); + gstate_c.Dirty(DIRTY_TEXCLAMP); } } @@ -175,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) { - gstate_c.DirtyUniform(DIRTY_SHADERBLEND); + gstate_c.Dirty(DIRTY_SHADERBLEND); } if (blendState.useBlendColor) { dxstate.blendColor.setDWORD(blendState.blendColor); @@ -298,10 +297,10 @@ void DrawEngineDX9::ApplyDrawState(int prim) { dxstate.viewport.set(vpAndScissor.viewportX, vpAndScissor.viewportY, vpAndScissor.viewportW, vpAndScissor.viewportH, depthMin, depthMax); if (vpAndScissor.dirtyProj) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } if (vpAndScissor.dirtyDepth) { - gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_DEPTHRANGE); } } diff --git a/GPU/Directx9/TextureCacheDX9.cpp b/GPU/Directx9/TextureCacheDX9.cpp index 4be51ae27d..e6ef466af7 100644 --- a/GPU/Directx9/TextureCacheDX9.cpp +++ b/GPU/Directx9/TextureCacheDX9.cpp @@ -127,7 +127,7 @@ void TextureCacheDX9::DeleteTexture(TexCache::iterator it) { void TextureCacheDX9::ForgetLastTexture() { lastBoundTexture = INVALID_TEX; - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } // Removes old textures. @@ -931,7 +931,7 @@ void TextureCacheDX9::SetTexture(bool force) { // Always rehash in this case, if one changed the rest all probably did. rehash = true; entry->status &= ~TexCacheEntry::STATUS_CLUT_RECHECK; - } else if (!gstate_c.textureImageChanged) { + } else if (!gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE)) { // Okay, just some parameter change - the data didn't change, no need to rehash. rehash = false; } diff --git a/GPU/GLES/DrawEngineGLES.cpp b/GPU/GLES/DrawEngineGLES.cpp index 586c301703..e4554810f8 100644 --- a/GPU/GLES/DrawEngineGLES.cpp +++ b/GPU/GLES/DrawEngineGLES.cpp @@ -337,7 +337,7 @@ void DrawEngineGLES::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, i if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); Flush(); } } diff --git a/GPU/GLES/FramebufferManagerGLES.cpp b/GPU/GLES/FramebufferManagerGLES.cpp index 120f403e12..c7565a62ad 100644 --- a/GPU/GLES/FramebufferManagerGLES.cpp +++ b/GPU/GLES/FramebufferManagerGLES.cpp @@ -647,7 +647,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferCreated(VirtualFramebuffer * // ugly... if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } @@ -710,7 +710,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferSwitched(VirtualFramebuffer // ugly... if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } @@ -724,7 +724,7 @@ void FramebufferManagerGLES::NotifyRenderFramebufferUpdated(VirtualFramebuffer * // ugly... if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) { - gstate_c.DirtyUniform(DIRTY_PROJTHROUGHMATRIX); + gstate_c.Dirty(DIRTY_PROJTHROUGHMATRIX); } } diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index fae0215582..2e42ef34b8 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -768,7 +768,7 @@ void GPU_GLES::BeginFrameInternal() { shaderManagerGL_->DirtyShader(); // Not sure if this is really needed. - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); framebufferManagerGL_->BeginFrame(); } @@ -832,7 +832,7 @@ void GPU_GLES::CopyDisplayToOutputInternal() { #endif // Wait, why? - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } // Maybe should write this in ASM... @@ -966,7 +966,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)) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } } @@ -978,11 +978,11 @@ void GPU_GLES::Execute_VertexTypeSkinning(u32 op, u32 diff) { Flush(); gstate.vertType ^= diff; if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(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) { - gstate_c.DirtyUniform(gstate_c.deferredVertTypeDirty); + gstate_c.Dirty(gstate_c.deferredVertTypeDirty); gstate_c.deferredVertTypeDirty = 0; } } @@ -1027,7 +1027,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) { - gstate_c.DirtyUniform(DIRTY_BEZIERCOUNTU); + gstate_c.Dirty(DIRTY_BEZIERCOUNTU); gstate_c.bezier_count_u = bz_ucount; } } @@ -1084,19 +1084,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) { - gstate_c.DirtyUniform(DIRTY_SPLINECOUNTU); + gstate_c.Dirty(DIRTY_SPLINECOUNTU); gstate_c.spline_count_u = sp_ucount; } if (gstate_c.spline_count_v != sp_vcount) { - gstate_c.DirtyUniform(DIRTY_SPLINECOUNTV); + gstate_c.Dirty(DIRTY_SPLINECOUNTV); gstate_c.spline_count_v = sp_vcount; } if (gstate_c.spline_type_u != sp_utype) { - gstate_c.DirtyUniform(DIRTY_SPLINETYPEU); + gstate_c.Dirty(DIRTY_SPLINETYPEU); gstate_c.spline_type_u = sp_utype; } if (gstate_c.spline_type_v != sp_vtype) { - gstate_c.DirtyUniform(DIRTY_SPLINETYPEV); + gstate_c.Dirty(DIRTY_SPLINETYPEV); gstate_c.spline_type_v = sp_vtype; } } @@ -1113,97 +1113,97 @@ void GPU_GLES::Execute_Spline(u32 op, u32 diff) { void GPU_GLES::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; - gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); + gstate_c.Dirty(DIRTY_DEPTHRANGE); } void GPU_GLES::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexScaleV(u32 op, u32 diff) { gstate_c.uv.vScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexOffsetU(u32 op, u32 diff) { gstate_c.uv.uOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.uv.vOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_GLES::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || (gstate_c.textureImageChanged || gstate_c.textureParamsChanged)) { + if (diff || gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } } void GPU_GLES::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_TEXENV); + gstate_c.Dirty(DIRTY_TEXENV); } void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) { @@ -1216,77 +1216,76 @@ void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheGL_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); } void GPU_GLES::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_GLES::Execute_Ambient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_AMBIENT); + gstate_c.Dirty(DIRTY_AMBIENT); } void GPU_GLES::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATDIFFUSE); + gstate_c.Dirty(DIRTY_MATDIFFUSE); } void GPU_GLES::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATEMISSIVE); + gstate_c.Dirty(DIRTY_MATEMISSIVE); } void GPU_GLES::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA); + gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); } void GPU_GLES::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATSPECULAR); + gstate_c.Dirty(DIRTY_MATSPECULAR); } void GPU_GLES::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT0); + gstate_c.Dirty(DIRTY_LIGHT0); } void GPU_GLES::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT1); + gstate_c.Dirty(DIRTY_LIGHT1); } void GPU_GLES::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT2); + gstate_c.Dirty(DIRTY_LIGHT2); } void GPU_GLES::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT3); + gstate_c.Dirty(DIRTY_LIGHT3); } void GPU_GLES::Execute_FogColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOLOR); + gstate_c.Dirty(DIRTY_FOGCOLOR); } void GPU_GLES::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOEF); + gstate_c.Dirty(DIRTY_FOGCOEF); } void GPU_GLES::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORMASK); } void GPU_GLES::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK); } void GPU_GLES::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE); + gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); } void GPU_GLES::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); + gstate_c.Dirty(DIRTY_ALPHACOLORREF); } void GPU_GLES::Execute_Generic(u32 op, u32 diff) { @@ -1884,7 +1883,7 @@ void GPU_GLES::DoState(PointerWrap &p) { depalShaderCache_.Clear(); drawEngine_.ClearTrackedVertexArrays(); - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); framebufferManagerGL_->DestroyAllFBOs(true); shaderManagerGL_->ClearCache(true); } diff --git a/GPU/GLES/ShaderManagerGLES.cpp b/GPU/GLES/ShaderManagerGLES.cpp index 6dfe9e2733..02bac62519 100644 --- a/GPU/GLES/ShaderManagerGLES.cpp +++ b/GPU/GLES/ShaderManagerGLES.cpp @@ -772,7 +772,7 @@ void ShaderManagerGLES::Clear() { linkedShaderCache_.clear(); fsCache_.clear(); vsCache_.clear(); - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); lastFSID_.set_invalid(); lastVSID_.set_invalid(); DirtyShader(); @@ -788,7 +788,7 @@ void ShaderManagerGLES::DirtyShader() { lastFSID_.set_invalid(); lastVSID_.set_invalid(); DirtyLastShader(); - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); shaderSwitchDirty_ = 0; } diff --git a/GPU/GLES/StateMappingGLES.cpp b/GPU/GLES/StateMappingGLES.cpp index b5458e21ec..b7d0461bab 100644 --- a/GPU/GLES/StateMappingGLES.cpp +++ b/GPU/GLES/StateMappingGLES.cpp @@ -144,7 +144,7 @@ bool DrawEngineGLES::ApplyShaderBlending() { fboTexNeedBind_ = true; - gstate_c.DirtyUniform(DIRTY_SHADERBLEND); + gstate_c.Dirty(DIRTY_SHADERBLEND); return true; } @@ -159,14 +159,13 @@ inline void DrawEngineGLES::ResetShaderBlending() { // TODO: All this setup is so expensive that we'll need dirty flags, or simply do it in the command writes where we detect dirty by xoring. Silly to do all this work on every drawcall. void DrawEngineGLES::ApplyDrawState(int prim) { - if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if (gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); - gstate_c.textureImageChanged = false; - gstate_c.textureParamsChanged = false; + gstate_c.Clean(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS); 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. - gstate_c.DirtyUniform(DIRTY_TEXCLAMP); + gstate_c.Dirty(DIRTY_TEXCLAMP); } } @@ -201,7 +200,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) { - gstate_c.DirtyUniform(DIRTY_SHADERBLEND); + gstate_c.Dirty(DIRTY_SHADERBLEND); } if (blendState.useBlendColor) { uint32_t color = blendState.blendColor; @@ -368,10 +367,10 @@ void DrawEngineGLES::ApplyDrawState(int prim) { glstate.depthRange.set(vpAndScissor.depthRangeMin, vpAndScissor.depthRangeMax); if (vpAndScissor.dirtyProj) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } if (vpAndScissor.dirtyDepth) { - gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_DEPTHRANGE); } } diff --git a/GPU/GLES/TextureCacheGLES.cpp b/GPU/GLES/TextureCacheGLES.cpp index 43c165dbe3..8585cec83e 100644 --- a/GPU/GLES/TextureCacheGLES.cpp +++ b/GPU/GLES/TextureCacheGLES.cpp @@ -1034,7 +1034,7 @@ void TextureCacheGLES::SetTexture(bool force) { // Always rehash in this case, if one changed the rest all probably did. rehash = true; entry->status &= ~TexCacheEntry::STATUS_CLUT_RECHECK; - } else if (!gstate_c.textureImageChanged) { + } else if (!gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE)) { // Okay, just some parameter change - the data didn't change, no need to rehash. rehash = false; } diff --git a/GPU/GLES/TextureCacheGLES.h b/GPU/GLES/TextureCacheGLES.h index 3dbe7168b2..7e68ee0d13 100644 --- a/GPU/GLES/TextureCacheGLES.h +++ b/GPU/GLES/TextureCacheGLES.h @@ -75,7 +75,7 @@ public: void ForgetLastTexture() { lastBoundTexture = -1; - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } u32 AllocTextureName(); diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index ff9e5cb324..5acb08e0d7 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -787,8 +787,8 @@ void GPUCommon::ProcessDLQueueInternal() { UpdateTickEstimate(std::max(busyTicks, startingTicks + cyclesExecuted)); // Game might've written new texture data. - gstate_c.textureImageChanged = true; - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); // Seems to be correct behaviour to process the list anyway? if (startingTicks < busyTicks) { @@ -1194,7 +1194,7 @@ void GPUCommon::Execute_BlockTransferStart(u32 op, u32 diff) { DoBlockTransfer(gstate_c.skipDrawReason); // Fixes Gran Turismo's funky text issue, since it overwrites the current texture. - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) { @@ -1209,7 +1209,7 @@ void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) { if (dst[i] != newVal) { Flush(); dst[i] = newVal; - gstate_c.DirtyUniform(DIRTY_WORLDMATRIX); + gstate_c.Dirty(DIRTY_WORLDMATRIX); } if (++i >= end) { break; @@ -1231,7 +1231,7 @@ void GPUCommon::Execute_WorldMtxData(u32 op, u32 diff) { if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) { Flush(); ((u32 *)gstate.worldMatrix)[num] = newVal; - gstate_c.DirtyUniform(DIRTY_WORLDMATRIX); + gstate_c.Dirty(DIRTY_WORLDMATRIX); } num++; gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0xF); @@ -1249,7 +1249,7 @@ void GPUCommon::Execute_ViewMtxNum(u32 op, u32 diff) { if (dst[i] != newVal) { Flush(); dst[i] = newVal; - gstate_c.DirtyUniform(DIRTY_VIEWMATRIX); + gstate_c.Dirty(DIRTY_VIEWMATRIX); } if (++i >= end) { break; @@ -1271,7 +1271,7 @@ void GPUCommon::Execute_ViewMtxData(u32 op, u32 diff) { if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) { Flush(); ((u32 *)gstate.viewMatrix)[num] = newVal; - gstate_c.DirtyUniform(DIRTY_VIEWMATRIX); + gstate_c.Dirty(DIRTY_VIEWMATRIX); } num++; gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0xF); @@ -1289,7 +1289,7 @@ void GPUCommon::Execute_ProjMtxNum(u32 op, u32 diff) { if (dst[i] != newVal) { Flush(); dst[i] = newVal; - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } if (++i >= end) { break; @@ -1311,7 +1311,7 @@ void GPUCommon::Execute_ProjMtxData(u32 op, u32 diff) { if (newVal != ((const u32 *)gstate.projMatrix)[num]) { Flush(); ((u32 *)gstate.projMatrix)[num] = newVal; - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } num++; gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0xF); @@ -1329,7 +1329,7 @@ void GPUCommon::Execute_TgenMtxNum(u32 op, u32 diff) { if (dst[i] != newVal) { Flush(); dst[i] = newVal; - gstate_c.DirtyUniform(DIRTY_TEXMATRIX); + gstate_c.Dirty(DIRTY_TEXMATRIX); } if (++i >= end) { break; @@ -1351,7 +1351,7 @@ void GPUCommon::Execute_TgenMtxData(u32 op, u32 diff) { if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) { Flush(); ((u32 *)gstate.tgenMatrix)[num] = newVal; - gstate_c.DirtyUniform(DIRTY_TEXMATRIX); + gstate_c.Dirty(DIRTY_TEXMATRIX); } num++; gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0xF); @@ -1379,7 +1379,7 @@ void GPUCommon::Execute_BoneMtxNum(u32 op, u32 diff) { const int numPlusCount = (op & 0x7F) + i; for (int num = op & 0x7F; num < numPlusCount; num += 12) { - gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12)); + gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12)); } } else { while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) { @@ -1411,7 +1411,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(); - gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12)); + gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12)); } else { gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12); } @@ -1478,7 +1478,7 @@ void GPUCommon::FastLoadBoneMatrix(u32 target) { if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) { Flush(); - gstate_c.DirtyUniform(uniformsToDirty); + gstate_c.Dirty(uniformsToDirty); } else { gstate_c.deferredVertTypeDirty |= uniformsToDirty; } diff --git a/GPU/GPUState.cpp b/GPU/GPUState.cpp index 1f6d2a9877..4b39884c17 100644 --- a/GPU/GPUState.cpp +++ b/GPU/GPUState.cpp @@ -216,8 +216,7 @@ void GPUStateCache::DoState(PointerWrap &p) { vertexAddr = old.vertexAddr; indexAddr = old.indexAddr; offsetAddr = old.offsetAddr; - textureImageChanged = true; - textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS); textureFullAlpha = old.textureFullAlpha; vertexFullAlpha = old.vertexFullAlpha; skipDrawReason = old.skipDrawReason; @@ -227,10 +226,9 @@ void GPUStateCache::DoState(PointerWrap &p) { p.Do(indexAddr); p.Do(offsetAddr); - int textureChanged = 0; + uint8_t textureChanged = 0; p.Do(textureChanged); // legacy - textureImageChanged = true; - textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS); p.Do(textureFullAlpha); p.Do(vertexFullAlpha); bool framebufChanged = false; // legacy diff --git a/GPU/GPUState.h b/GPU/GPUState.h index 88660beaa3..56536de9f7 100644 --- a/GPU/GPUState.h +++ b/GPU/GPUState.h @@ -483,9 +483,6 @@ 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 Dirty(u64 what) { dirty |= what; } @@ -507,9 +504,6 @@ struct GPUStateCache { uint64_t dirty; - bool textureImageChanged; - bool textureParamsChanged; - bool textureFullAlpha; bool textureSimpleAlpha; bool vertexFullAlpha; @@ -518,14 +512,6 @@ struct GPUStateCache { UVScale uv; - bool bezier; - bool spline; - int bezier_count_u; - int spline_count_u; - int spline_count_v; - int spline_type_u; - int spline_type_v; - bool bgraTexture; bool needShaderTexClamp; bool allowShaderBlend; @@ -559,6 +545,14 @@ struct GPUStateCache { u32 curRTRenderHeight; u32 curRTOffsetX; + bool bezier; + bool spline; + int bezier_count_u; + int spline_count_u; + int spline_count_v; + int spline_type_u; + int spline_type_v; + u32 getRelativeAddress(u32 data) const; void Reset(); void DoState(PointerWrap &p); diff --git a/GPU/Null/NullGpu.cpp b/GPU/Null/NullGpu.cpp index 49e3a0e8c2..02b0a4efff 100644 --- a/GPU/Null/NullGpu.cpp +++ b/GPU/Null/NullGpu.cpp @@ -214,7 +214,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { break; case GE_CMD_TEXADDR0: - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); case GE_CMD_TEXADDR1: case GE_CMD_TEXADDR2: case GE_CMD_TEXADDR3: @@ -226,7 +226,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { break; case GE_CMD_TEXBUFWIDTH0: - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); case GE_CMD_TEXBUFWIDTH1: case GE_CMD_TEXBUFWIDTH2: case GE_CMD_TEXBUFWIDTH3: @@ -342,7 +342,7 @@ void NullGPU::ExecuteOp(u32 op, u32 diff) { } case GE_CMD_TEXSIZE0: - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); gstate_c.curTextureWidth = 1 << (gstate.texsize[0] & 0xf); gstate_c.curTextureHeight = 1 << ((gstate.texsize[0]>>8) & 0xf); //fall thru - ignoring the mipmap sizes for now diff --git a/GPU/Vulkan/DrawEngineVulkan.cpp b/GPU/Vulkan/DrawEngineVulkan.cpp index aeae2146e4..d676649502 100644 --- a/GPU/Vulkan/DrawEngineVulkan.cpp +++ b/GPU/Vulkan/DrawEngineVulkan.cpp @@ -361,7 +361,7 @@ void DrawEngineVulkan::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, if (prim == GE_PRIM_RECTANGLES && (gstate.getTextureAddress(0) & 0x3FFFFFFF) == (gstate.getFrameBufAddress() & 0x3FFFFFFF)) { // Rendertarget == texture? if (!g_Config.bDisableSlowFramebufEffects) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); Flush(cmd_); } } @@ -600,7 +600,7 @@ void DrawEngineVulkan::DirtyAllUBOs() { dirtyUniforms_ = DIRTY_BASE_UNIFORMS | DIRTY_LIGHT_UNIFORMS | DIRTY_BONE_UNIFORMS; imageView = VK_NULL_HANDLE; sampler = VK_NULL_HANDLE; - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } //void DrawEngineVulkan::ApplyDrawStateLate() { @@ -630,15 +630,14 @@ void DrawEngineVulkan::DoFlush(VkCommandBuffer cmd) { FrameData *frame = &frame_[curFrame_ & 1]; bool textureNeedsApply = false; - if ((gstate_c.textureImageChanged || gstate_c.textureParamsChanged) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { + if (gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS) && !gstate.isModeClear() && gstate.isTextureMapEnabled()) { textureCache_->SetTexture(); + gstate_c.Clean(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS); textureNeedsApply = true; - gstate_c.textureImageChanged = false; - gstate_c.textureParamsChanged = false; 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. - gstate_c.DirtyUniform(DIRTY_TEXCLAMP); + gstate_c.Dirty(DIRTY_TEXCLAMP); } } diff --git a/GPU/Vulkan/FramebufferVulkan.cpp b/GPU/Vulkan/FramebufferVulkan.cpp index 217e1a0dc2..a9c89da6d0 100644 --- a/GPU/Vulkan/FramebufferVulkan.cpp +++ b/GPU/Vulkan/FramebufferVulkan.cpp @@ -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_) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } } @@ -695,7 +695,7 @@ void FramebufferManagerVulkan::NotifyRenderFramebufferSwitched(VirtualFramebuffe // ugly... if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } } @@ -709,7 +709,7 @@ void FramebufferManagerVulkan::NotifyRenderFramebufferUpdated(VirtualFramebuffer // ugly... if ((gstate_c.curRTWidth != vfb->width || gstate_c.curRTHeight != vfb->height) && shaderManager_) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(DIRTY_PROJMATRIX); } } diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 022c128f3a..53cd63c5fd 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -507,7 +507,7 @@ void GPU_Vulkan::BeginHostFrame() { framebufferManagerVulkan_->BeginFrameVulkan(); shaderManagerVulkan_->DirtyShader(); - gstate_c.DirtyUniform(DIRTY_ALL); + gstate_c.Dirty(DIRTY_ALL); if (dumpNextFrame_) { NOTICE_LOG(G3D, "DUMPING THIS FRAME"); @@ -690,7 +690,7 @@ void GPU_Vulkan::CopyDisplayToOutputInternal() { framebufferManagerVulkan_->CopyDisplayToOutput(); - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } // Maybe should write this in ASM... @@ -823,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)) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } } @@ -918,97 +918,96 @@ void GPU_Vulkan::Execute_Spline(u32 op, u32 diff) { void GPU_Vulkan::Execute_Region(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_Scissor(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_FramebufType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_ViewportType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; // Why? + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); // Why? } void GPU_Vulkan::Execute_ViewportZType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.textureParamsChanged = true; - gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); + gstate_c.Dirty(DIRTY_DEPTHRANGE); } void GPU_Vulkan::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexScaleV(u32 op, u32 diff) { gstate_c.uv.vScale = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexOffsetU(u32 op, u32 diff) { gstate_c.uv.uOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.uv.vOff = getFloat24(op); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_Vulkan::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. - if (diff || (gstate_c.textureImageChanged || gstate_c.textureParamsChanged)) { + if (diff || gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS)) { gstate_c.curTextureWidth = gstate.getTextureWidth(0); gstate_c.curTextureHeight = gstate.getTextureHeight(0); - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); // We will need to reset the texture now. - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_UVSCALEOFFSET | DIRTY_TEXTURE_PARAMS); } } void GPU_Vulkan::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); } void GPU_Vulkan::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_UVSCALEOFFSET); + gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } void GPU_Vulkan::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_TEXENV); + gstate_c.Dirty(DIRTY_TEXENV); } void GPU_Vulkan::Execute_TexLevel(u32 op, u32 diff) { @@ -1021,77 +1020,76 @@ void GPU_Vulkan::Execute_TexLevel(u32 op, u32 diff) { gstate.texlevel ^= diff; } */ - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_LoadClut(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheVulkan_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); } void GPU_Vulkan::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void GPU_Vulkan::Execute_Ambient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_AMBIENT); + gstate_c.Dirty(DIRTY_AMBIENT); } void GPU_Vulkan::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATDIFFUSE); + gstate_c.Dirty(DIRTY_MATDIFFUSE); } void GPU_Vulkan::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATEMISSIVE); + gstate_c.Dirty(DIRTY_MATEMISSIVE); } void GPU_Vulkan::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATAMBIENTALPHA); + gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); } void GPU_Vulkan::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_MATSPECULAR); + gstate_c.Dirty(DIRTY_MATSPECULAR); } void GPU_Vulkan::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT0); + gstate_c.Dirty(DIRTY_LIGHT0); } void GPU_Vulkan::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT1); + gstate_c.Dirty(DIRTY_LIGHT1); } void GPU_Vulkan::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT2); + gstate_c.Dirty(DIRTY_LIGHT2); } void GPU_Vulkan::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_LIGHT3); + gstate_c.Dirty(DIRTY_LIGHT3); } void GPU_Vulkan::Execute_FogColor(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOLOR); + gstate_c.Dirty(DIRTY_FOGCOLOR); } void GPU_Vulkan::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_FOGCOEF); + gstate_c.Dirty(DIRTY_FOGCOEF); } void GPU_Vulkan::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORMASK); } void GPU_Vulkan::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); - gstate_c.DirtyUniform(DIRTY_ALPHACOLORMASK); + gstate_c.Dirty(DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK); } void GPU_Vulkan::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_STENCILREPLACEVALUE); + gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); } void GPU_Vulkan::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.DirtyUniform(DIRTY_ALPHACOLORREF); + gstate_c.Dirty(DIRTY_ALPHACOLORREF); } void GPU_Vulkan::Execute_BoneMtxNum(u32 op, u32 diff) { @@ -1115,7 +1113,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) { - gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12)); + gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12)); } const int count = i; @@ -1133,7 +1131,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(); - gstate_c.DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12)); + gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12)); ((u32 *)gstate.boneMatrix)[num] = newVal; } num++; @@ -1679,7 +1677,7 @@ void GPU_Vulkan::FastLoadBoneMatrix(u32 target) { uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7); } Flush(); - gstate_c.DirtyUniform(uniformsToDirty); + gstate_c.Dirty(uniformsToDirty); gstate.FastLoadBoneMatrix(target); } @@ -1767,7 +1765,7 @@ void GPU_Vulkan::DoState(PointerWrap &p) { textureCacheVulkan_->Clear(true); depalShaderCache_.Clear(); - gstate_c.textureImageChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); framebufferManagerVulkan_->DestroyAllFBOs(true); shaderManagerVulkan_->ClearShaders(); pipelineManager_->Clear(); diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index e96b66e7cc..a5f15151f7 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -409,7 +409,7 @@ void ShaderManagerVulkan::Clear() { void ShaderManagerVulkan::ClearShaders() { Clear(); DirtyShader(); - gstate_c.DirtyUniform(DIRTY_ALL_UNIFORMS); + gstate_c.Dirty(DIRTY_ALL_UNIFORMS); } void ShaderManagerVulkan::DirtyShader() { diff --git a/GPU/Vulkan/StateMappingVulkan.cpp b/GPU/Vulkan/StateMappingVulkan.cpp index 88ca99ca03..15f28ae6b3 100644 --- a/GPU/Vulkan/StateMappingVulkan.cpp +++ b/GPU/Vulkan/StateMappingVulkan.cpp @@ -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) { - gstate_c.DirtyUniform(DIRTY_SHADERBLEND); + gstate_c.Dirty(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) { - gstate_c.DirtyUniform(DIRTY_PROJMATRIX); + gstate_c.Dirty(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) { - gstate_c.DirtyUniform(DIRTY_DEPTHRANGE); + gstate_c.Dirty(DIRTY_DEPTHRANGE); } } diff --git a/GPU/Vulkan/TextureCacheVulkan.cpp b/GPU/Vulkan/TextureCacheVulkan.cpp index 01766547f8..518605a48b 100644 --- a/GPU/Vulkan/TextureCacheVulkan.cpp +++ b/GPU/Vulkan/TextureCacheVulkan.cpp @@ -968,7 +968,7 @@ void TextureCacheVulkan::SetTexture() { // Always rehash in this case, if one changed the rest all probably did. rehash = true; entry->status &= ~TexCacheEntry::STATUS_CLUT_RECHECK; - } else if ((gstate_c.textureChanged & TEXCHANGE_UPDATED) == 0) { + } else if (!gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE)) { // Okay, just some parameter change - the data didn't change, no need to rehash. rehash = false; } diff --git a/GPU/Vulkan/TextureCacheVulkan.h b/GPU/Vulkan/TextureCacheVulkan.h index 4bea30f2e9..2d80f85f7a 100644 --- a/GPU/Vulkan/TextureCacheVulkan.h +++ b/GPU/Vulkan/TextureCacheVulkan.h @@ -121,7 +121,7 @@ public: void ForgetLastTexture() { lastBoundTexture = nullptr; - gstate_c.textureParamsChanged = true; + gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); } void ApplyTexture(VulkanPushBuffer *uploadBuffer, VkImageView &imageView, VkSampler &sampler); From c70265d7f29bbbc72f062e757528cb1e250466ff Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 10:44:02 +0100 Subject: [PATCH 05/11] Use table-driven dirtying instead of callbacks in GPU_GLES --- GPU/Directx9/GPU_DX9.cpp | 18 +- GPU/GLES/GPU_GLES.cpp | 1001 +++++++------------------------------ GPU/GLES/GPU_GLES.h | 37 +- GPU/GPUCommon.cpp | 89 +++- GPU/GPUCommon.h | 5 + GPU/Vulkan/GPU_Vulkan.cpp | 16 +- GPU/ge_constants.h | 37 +- 7 files changed, 300 insertions(+), 903 deletions(-) diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 7cd3356b9a..c21429f426 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -187,14 +187,14 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Morph weights. TODO: Remove precomputation? - {GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, + {GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, // Control spline/bezier patches. Don't really require flushing as such, but meh. {GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE}, @@ -1430,7 +1430,7 @@ void GPU_DX9::Execute_Generic(u32 op, u32 diff) { case GE_CMD_MORPHWEIGHT5: case GE_CMD_MORPHWEIGHT6: case GE_CMD_MORPHWEIGHT7: - gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data); + Execute_MorphWeight(op, diff); break; case GE_CMD_DITH0: diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index 2e42ef34b8..09ad5ec45a 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -58,7 +58,7 @@ enum { FLAG_EXECUTEONCHANGE = 8, FLAG_READS_PC = 16, FLAG_WRITES_PC = 32, - FLAG_DIRTYONCHANGE = 64, // NOTE: Either this or FLAG_EXECUTE*, not both! + // No flag for dirtying needed - if the dirty flag is non zero, it's "on change". }; struct CommandTableEntry { @@ -72,23 +72,23 @@ struct CommandTableEntry { // TODO: Share this table between the backends. Will have to make another indirection for the function pointers though.. static const CommandTableEntry commandTable[] = { // Changes that dirty the framebuffer - {GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType}, - {GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType}, - {GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType}, + {GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, {GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE}, // Changes that dirty uniforms - {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GPU_GLES::Execute_FogColor}, - {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_GLES::Execute_FogCoef}, - {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_GLES::Execute_FogCoef}, + {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOLOR}, + {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF}, + {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF}, // Should these maybe flush? {GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, {GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, // Changes that dirty texture scaling. - {GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexMapMode}, + {GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_UVSCALEOFFSET}, {GE_CMD_TEXSCALEU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexScaleU}, {GE_CMD_TEXSCALEV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexScaleV}, {GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexOffsetU}, @@ -97,48 +97,48 @@ static const CommandTableEntry commandTable[] = { // 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, 0, &GPU_GLES::Execute_TexSize0}, - {GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN}, - {GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexFormat}, - {GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexLevel}, - {GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddr0}, - {GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN}, - {GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufw0}, - {GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN}, + {GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE}, + {GE_CMD_TEXLEVEL, 0, DIRTY_TEXTURE_PARAMS}, // Flushing on this is EXPENSIVE in Gran Turismo and of little use + {GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE|DIRTY_UVSCALEOFFSET}, + {GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE}, + {GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, // These must flush on change, so that LoadClut doesn't have to always flush. {GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ClutFormat}, + {GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, // 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, 0, &GPU_GLES::Execute_TexParamType}, + {GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, {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, DIRTY_ALPHACOLORMASK, &GPU_GLES::Execute_ColorTestMask}, + {GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORMASK}, // These change the vertex shader so need flushing. {GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE}, @@ -155,13 +155,13 @@ static const CommandTableEntry commandTable[] = { // This changes both shaders so need flushing. {GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexParamType}, - {GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexParamType}, + {GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, + {GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, // Uniform changes - {GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_GLES::Execute_AlphaTest}, - {GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ColorRef}, - {GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_GLES::Execute_TexEnvColor}, + {GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK}, + {GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF}, + {GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXENV}, // Simple render state changes. Handled in StateMapping.cpp. {GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE}, @@ -170,7 +170,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, DIRTY_STENCILREPLACEVALUE, &GPU_GLES::Execute_StencilTest}, + {GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_STENCILREPLACEVALUE}, {GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE}, @@ -187,15 +187,15 @@ static const CommandTableEntry commandTable[] = { // Can probably ignore this one as we don't support AA lines. {GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE}, - // Morph weights. TODO: Remove precomputation? - {GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, + // Morph weights. + {GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, + {GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight}, // Control spline/bezier patches. Don't really require flushing as such, but meh. {GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE}, @@ -204,94 +204,94 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Viewport. - {GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType}, - {GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType}, - {GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType}, - {GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType}, - {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_GLES::Execute_ViewportZType}, - {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_GLES::Execute_ViewportZType}, + {GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE}, + {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE}, {GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Region - {GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Region}, - {GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Region}, + {GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, // Scissor - {GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Scissor}, - {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Scissor}, + {GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, + {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, // 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, DIRTY_AMBIENT, &GPU_GLES::Execute_Ambient}, - {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_GLES::Execute_Ambient}, - {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_GLES::Execute_MaterialDiffuse}, - {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_GLES::Execute_MaterialEmissive}, - {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_GLES::Execute_MaterialAmbient}, - {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_GLES::Execute_MaterialAmbient}, - {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_GLES::Execute_MaterialSpecular}, - {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_GLES::Execute_MaterialSpecular}, + {GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT}, + {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT}, + {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATDIFFUSE}, + {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATEMISSIVE}, + {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA}, + {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA}, + {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR}, + {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR}, // These dirty uniforms, which could be table-ized to avoid execute. - {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param}, - {GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param}, - {GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param}, - {GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, - {GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param}, + {GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, // Ignored commands {GE_CMD_TEXFLUSH, 0}, @@ -311,7 +311,7 @@ static const CommandTableEntry commandTable[] = { // From Common. No flushing but definitely need execute. {GE_CMD_OFFSETADDR, FLAG_EXECUTE, 0, &GPUCommon::Execute_OffsetAddr}, - {GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_Origin}, // Really? + {GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_Origin}, {GE_CMD_PRIM, FLAG_EXECUTE, 0, &GPU_GLES::Execute_Prim}, {GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_Jump}, {GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_Call}, @@ -355,40 +355,40 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::Execute_BoneMtxData}, // Vertex Screen/Texture/Color - {GE_CMD_VSCX, FLAG_EXECUTE}, - {GE_CMD_VSCY, FLAG_EXECUTE}, - {GE_CMD_VSCZ, FLAG_EXECUTE}, - {GE_CMD_VTCS, FLAG_EXECUTE}, - {GE_CMD_VTCT, FLAG_EXECUTE}, - {GE_CMD_VTCQ, FLAG_EXECUTE}, - {GE_CMD_VCV, FLAG_EXECUTE}, - {GE_CMD_VAP, FLAG_EXECUTE}, - {GE_CMD_VFC, FLAG_EXECUTE}, - {GE_CMD_VSCV, FLAG_EXECUTE}, + {GE_CMD_VSCX, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VSCY, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VSCZ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VTCS, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VTCT, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VTCQ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VAP, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VFC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_VSCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, // "Missing" commands (gaps in the sequence) - {GE_CMD_UNKNOWN_03, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_0D, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_11, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_29, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_34, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_35, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_39, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_4E, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_4F, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_52, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_59, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_5A, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_B6, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_B7, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_D1, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_ED, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_EF, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FA, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FB, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FC, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FD, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FE, FLAG_EXECUTE}, + {GE_CMD_UNKNOWN_03, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_0D, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_11, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_29, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_34, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_35, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_39, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_4E, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_4F, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_52, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_59, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_5A, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_B6, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_B7, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_D1, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_ED, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_EF, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FA, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FB, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FD, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FE, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, // Appears to be debugging related or something? Hit a lot in GoW. {GE_CMD_UNKNOWN_FF, 0}, }; @@ -438,10 +438,10 @@ GPU_GLES::GPU_GLES(GraphicsContext *ctx) } else { dupeCheck.insert(cmd); } - cmdInfo_[cmd].flags |= commandTable[i].flags; + cmdInfo_[cmd].flags |= (uint64_t)commandTable[i].flags | (commandTable[i].dirtyUniform << 8); cmdInfo_[cmd].func = commandTable[i].func; - if (!cmdInfo_[cmd].func) { - cmdInfo_[cmd].func = &GPU_GLES::Execute_Generic; + if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { + Crash(); } } // Find commands missing from the table. @@ -856,6 +856,10 @@ void GPU_GLES::FastRunLoop(DisplayList &list) { downcount = dc; (this->*info.func)(op, diff); dc = downcount; + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } list.pc += 4; } @@ -887,6 +891,10 @@ void GPU_GLES::ExecuteOp(u32 op, u32 diff) { const u8 cmdFlags = info.flags; if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) { (this->*info.func)(op, diff); + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } } @@ -1111,32 +1119,6 @@ void GPU_GLES::Execute_Spline(u32 op, u32 diff) { AdvanceVerts(gstate.vertType, count, bytesRead); } -void GPU_GLES::Execute_Region(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_Scissor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); - gstate_c.Dirty(DIRTY_DEPTHRANGE); -} - void GPU_GLES::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); gstate_c.Dirty(DIRTY_UVSCALEOFFSET); @@ -1157,23 +1139,6 @@ void GPU_GLES::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } -void GPU_GLES::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_GLES::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_GLES::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. @@ -1186,639 +1151,11 @@ void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) { } } -void GPU_GLES::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXENV); -} - -void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) { - // I had hoped that this would let us avoid excessively flushing in Gran Turismo, but not so, - // as the game switches rapidly between modes 0 and 1. - /* - if (gstate.getTexLevelMode() == GE_TEXLEVEL_MODE_CONST) { - gstate.texlevel ^= diff; - Flush(); - gstate.texlevel ^= diff; - } - */ - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_GLES::Execute_LoadClut(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheGL_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); } -void GPU_GLES::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_GLES::Execute_Ambient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_AMBIENT); -} - -void GPU_GLES::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATDIFFUSE); -} - -void GPU_GLES::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATEMISSIVE); -} - -void GPU_GLES::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); -} - -void GPU_GLES::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATSPECULAR); -} - -void GPU_GLES::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT0); -} - -void GPU_GLES::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT1); -} - -void GPU_GLES::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT2); -} - -void GPU_GLES::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT3); -} - -void GPU_GLES::Execute_FogColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOLOR); -} - -void GPU_GLES::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOEF); -} - -void GPU_GLES::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORMASK); -} - -void GPU_GLES::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK); -} - -void GPU_GLES::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); -} - -void GPU_GLES::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF); -} - -void GPU_GLES::Execute_Generic(u32 op, u32 diff) { - u32 cmd = op >> 24; - u32 data = op & 0xFFFFFF; - - // Handle control and drawing commands here directly. The others we delegate. - switch (cmd) { - case GE_CMD_BASE: - break; - - case GE_CMD_VADDR: - Execute_Vaddr(op, diff); - break; - - case GE_CMD_IADDR: - Execute_Iaddr(op, diff); - break; - - case GE_CMD_PRIM: - Execute_Prim(op, diff); - break; - - case GE_CMD_BEZIER: - Execute_Bezier(op, diff); - break; - - case GE_CMD_SPLINE: - Execute_Spline(op, diff); - break; - - case GE_CMD_BOUNDINGBOX: - Execute_BoundingBox(op, diff); - break; - - case GE_CMD_VERTEXTYPE: - Execute_VertexType(op, diff); - break; - - case GE_CMD_REGION1: - case GE_CMD_REGION2: - Execute_Region(op, diff); - break; - - case GE_CMD_CLIPENABLE: - //we always clip, this is opengl - break; - - case GE_CMD_CULLFACEENABLE: - case GE_CMD_CULL: - break; - - case GE_CMD_TEXTUREMAPENABLE: - // Don't need to dirty the texture here, already dirtied at list start/etc. - break; - - case GE_CMD_LIGHTINGENABLE: - break; - - case GE_CMD_FOGCOLOR: - Execute_FogColor(op, diff); - break; - - case GE_CMD_FOG1: - case GE_CMD_FOG2: - Execute_FogCoef(op, diff); - break; - - case GE_CMD_FOGENABLE: - break; - - case GE_CMD_DITHERENABLE: - break; - - case GE_CMD_OFFSETX: - break; - - case GE_CMD_OFFSETY: - break; - - case GE_CMD_TEXSCALEU: - Execute_TexScaleU(op, diff); - break; - - case GE_CMD_TEXSCALEV: - Execute_TexScaleV(op, diff); - break; - - case GE_CMD_TEXOFFSETU: - Execute_TexOffsetU(op, diff); - break; - - case GE_CMD_TEXOFFSETV: - Execute_TexOffsetV(op, diff); - break; - - case GE_CMD_SCISSOR1: - case GE_CMD_SCISSOR2: - Execute_Scissor(op, diff); - break; - - /// - case GE_CMD_MINZ: - case GE_CMD_MAXZ: - break; - - case GE_CMD_FRAMEBUFPTR: - case GE_CMD_FRAMEBUFWIDTH: - case GE_CMD_FRAMEBUFPIXFORMAT: - Execute_FramebufType(op, diff); - break; - - case GE_CMD_TEXADDR0: - Execute_TexAddr0(op, diff); - break; - - case GE_CMD_TEXADDR1: - case GE_CMD_TEXADDR2: - case GE_CMD_TEXADDR3: - case GE_CMD_TEXADDR4: - case GE_CMD_TEXADDR5: - case GE_CMD_TEXADDR6: - case GE_CMD_TEXADDR7: - Execute_TexAddrN(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH0: - Execute_TexBufw0(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH1: - case GE_CMD_TEXBUFWIDTH2: - case GE_CMD_TEXBUFWIDTH3: - case GE_CMD_TEXBUFWIDTH4: - case GE_CMD_TEXBUFWIDTH5: - case GE_CMD_TEXBUFWIDTH6: - case GE_CMD_TEXBUFWIDTH7: - Execute_TexBufwN(op, diff); - break; - - case GE_CMD_CLUTFORMAT: - Execute_ClutFormat(op, diff); - break; - - case GE_CMD_CLUTADDR: - case GE_CMD_CLUTADDRUPPER: - // Hm, LOADCLUT actually changes the CLUT so no need to dirty here. - break; - - case GE_CMD_LOADCLUT: - Execute_LoadClut(op, diff); - break; - - case GE_CMD_TEXMAPMODE: - Execute_TexMapMode(op, diff); - break; - - case GE_CMD_TEXSHADELS: - break; - - case GE_CMD_TRANSFERSRC: - case GE_CMD_TRANSFERSRCW: - case GE_CMD_TRANSFERDST: - case GE_CMD_TRANSFERDSTW: - case GE_CMD_TRANSFERSRCPOS: - case GE_CMD_TRANSFERDSTPOS: - break; - - case GE_CMD_TRANSFERSIZE: - break; - - case GE_CMD_TRANSFERSTART: - Execute_BlockTransferStart(op, diff); - break; - - case GE_CMD_TEXSIZE0: - Execute_TexSize0(op, diff); - break; - - case GE_CMD_TEXSIZE1: - case GE_CMD_TEXSIZE2: - case GE_CMD_TEXSIZE3: - case GE_CMD_TEXSIZE4: - case GE_CMD_TEXSIZE5: - case GE_CMD_TEXSIZE6: - case GE_CMD_TEXSIZE7: - Execute_TexSizeN(op, diff); - break; - - case GE_CMD_ZBUFPTR: - case GE_CMD_ZBUFWIDTH: - break; - - case GE_CMD_AMBIENTCOLOR: - case GE_CMD_AMBIENTALPHA: - Execute_Ambient(op, diff); - break; - - case GE_CMD_MATERIALDIFFUSE: - Execute_MaterialDiffuse(op, diff); - break; - - case GE_CMD_MATERIALEMISSIVE: - Execute_MaterialEmissive(op, diff); - break; - - case GE_CMD_MATERIALAMBIENT: - case GE_CMD_MATERIALALPHA: - Execute_MaterialAmbient(op, diff); - break; - - case GE_CMD_MATERIALSPECULAR: - case GE_CMD_MATERIALSPECULARCOEF: - Execute_MaterialSpecular(op, diff); - break; - - case GE_CMD_LIGHTTYPE0: - case GE_CMD_LIGHTTYPE1: - case GE_CMD_LIGHTTYPE2: - case GE_CMD_LIGHTTYPE3: - break; - - case GE_CMD_LX0:case GE_CMD_LY0:case GE_CMD_LZ0: - case GE_CMD_LDX0:case GE_CMD_LDY0:case GE_CMD_LDZ0: - case GE_CMD_LKA0:case GE_CMD_LKB0:case GE_CMD_LKC0: - case GE_CMD_LKS0: // spot coef ("conv") - case GE_CMD_LKO0: // light angle ("cutoff") - case GE_CMD_LAC0: - case GE_CMD_LDC0: - case GE_CMD_LSC0: - Execute_Light0Param(op, diff); - break; - case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1: - case GE_CMD_LDX1:case GE_CMD_LDY1:case GE_CMD_LDZ1: - case GE_CMD_LKA1:case GE_CMD_LKB1:case GE_CMD_LKC1: - case GE_CMD_LKS1: - case GE_CMD_LKO1: - case GE_CMD_LAC1: - case GE_CMD_LDC1: - case GE_CMD_LSC1: - Execute_Light1Param(op, diff); - 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: - case GE_CMD_LKA2:case GE_CMD_LKB2:case GE_CMD_LKC2: - case GE_CMD_LKS2: - case GE_CMD_LKO2: - case GE_CMD_LAC2: - case GE_CMD_LDC2: - case GE_CMD_LSC2: - Execute_Light2Param(op, diff); - 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: - case GE_CMD_LKA3:case GE_CMD_LKB3:case GE_CMD_LKC3: - case GE_CMD_LKS3: - case GE_CMD_LKO3: - case GE_CMD_LAC3: - case GE_CMD_LDC3: - case GE_CMD_LSC3: - Execute_Light3Param(op, diff); - break; - - case GE_CMD_VIEWPORTXSCALE: - case GE_CMD_VIEWPORTYSCALE: - case GE_CMD_VIEWPORTXCENTER: - case GE_CMD_VIEWPORTYCENTER: - case GE_CMD_VIEWPORTZSCALE: - case GE_CMD_VIEWPORTZCENTER: - Execute_ViewportType(op, diff); - break; - - case GE_CMD_LIGHTENABLE0: - case GE_CMD_LIGHTENABLE1: - case GE_CMD_LIGHTENABLE2: - case GE_CMD_LIGHTENABLE3: - break; - - case GE_CMD_SHADEMODE: - break; - - case GE_CMD_PATCHDIVISION: - case GE_CMD_PATCHPRIMITIVE: - case GE_CMD_PATCHFACING: - break; - - - case GE_CMD_MATERIALUPDATE: - break; - - ////////////////////////////////////////////////////////////////// - // CLEARING - ////////////////////////////////////////////////////////////////// - case GE_CMD_CLEARMODE: - break; - - ////////////////////////////////////////////////////////////////// - // ALPHA BLENDING - ////////////////////////////////////////////////////////////////// - case GE_CMD_ALPHABLENDENABLE: - case GE_CMD_BLENDMODE: - break; - - case GE_CMD_BLENDFIXEDA: - case GE_CMD_BLENDFIXEDB: - break; - - case GE_CMD_ALPHATESTENABLE: - case GE_CMD_COLORTESTENABLE: - // They are done in the fragment shader. - break; - - case GE_CMD_COLORTEST: - break; - - case GE_CMD_COLORTESTMASK: - Execute_ColorTestMask(op, diff); - break; - - case GE_CMD_ALPHATEST: - Execute_AlphaTest(op, diff); - break; - - case GE_CMD_COLORREF: - Execute_ColorRef(op, diff); - break; - - case GE_CMD_TEXENVCOLOR: - Execute_TexEnvColor(op, diff); - break; - - case GE_CMD_TEXFUNC: - case GE_CMD_TEXFLUSH: - break; - - case GE_CMD_TEXFORMAT: - Execute_TexFormat(op, diff); - break; - - case GE_CMD_TEXMODE: - case GE_CMD_TEXFILTER: - case GE_CMD_TEXWRAP: - Execute_TexParamType(op, diff); - break; - - ////////////////////////////////////////////////////////////////// - // DEPTH TESTING - ////////////////////////////////////////////////////////////////// - - case GE_CMD_ZTESTENABLE: - case GE_CMD_ZTEST: - case GE_CMD_ZWRITEDISABLE: - break; - - case GE_CMD_MORPHWEIGHT0: - case GE_CMD_MORPHWEIGHT1: - case GE_CMD_MORPHWEIGHT2: - case GE_CMD_MORPHWEIGHT3: - case GE_CMD_MORPHWEIGHT4: - case GE_CMD_MORPHWEIGHT5: - case GE_CMD_MORPHWEIGHT6: - case GE_CMD_MORPHWEIGHT7: - gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data); - break; - - case GE_CMD_DITH0: - case GE_CMD_DITH1: - case GE_CMD_DITH2: - case GE_CMD_DITH3: - break; - - case GE_CMD_WORLDMATRIXNUMBER: - Execute_WorldMtxNum(op, diff); - break; - - case GE_CMD_WORLDMATRIXDATA: - Execute_WorldMtxData(op, diff); - break; - - case GE_CMD_VIEWMATRIXNUMBER: - Execute_ViewMtxNum(op, diff); - break; - - case GE_CMD_VIEWMATRIXDATA: - Execute_ViewMtxData(op, diff); - break; - - case GE_CMD_PROJMATRIXNUMBER: - Execute_ProjMtxNum(op, diff); - break; - - case GE_CMD_PROJMATRIXDATA: - Execute_ProjMtxData(op, diff); - break; - - case GE_CMD_TGENMATRIXNUMBER: - Execute_TgenMtxNum(op, diff); - break; - - case GE_CMD_TGENMATRIXDATA: - Execute_TgenMtxData(op, diff); - break; - - case GE_CMD_BONEMATRIXNUMBER: - Execute_BoneMtxNum(op, diff); - break; - - case GE_CMD_BONEMATRIXDATA: - Execute_BoneMtxData(op, diff); - break; - -#ifndef MOBILE_DEVICE - case GE_CMD_ANTIALIASENABLE: - if (data != 0) - WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data); - break; - - case GE_CMD_TEXLODSLOPE: - if (data != 0) - WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data); - break; -#endif - - case GE_CMD_TEXLEVEL: - Execute_TexLevel(op, diff); - break; - - ////////////////////////////////////////////////////////////////// - // STENCIL TESTING - ////////////////////////////////////////////////////////////////// - - case GE_CMD_STENCILTEST: - Execute_StencilTest(op, diff); - break; - - case GE_CMD_STENCILTESTENABLE: - case GE_CMD_STENCILOP: - break; - - case GE_CMD_MASKRGB: - case GE_CMD_MASKALPHA: - break; - - case GE_CMD_REVERSENORMAL: - break; - - case GE_CMD_VSCX: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data); - break; - - case GE_CMD_VSCY: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data); - break; - - case GE_CMD_VSCZ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data); - break; - - case GE_CMD_VTCS: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data); - break; - - case GE_CMD_VTCT: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data); - break; - - case GE_CMD_VTCQ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data); - break; - - case GE_CMD_VCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data); - break; - - case GE_CMD_VAP: - if (data != 0) - WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data); - break; - - case GE_CMD_VFC: - if (data != 0) - WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data); - break; - - case GE_CMD_VSCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data); - break; - - - case GE_CMD_UNKNOWN_03: - case GE_CMD_UNKNOWN_0D: - case GE_CMD_UNKNOWN_11: - case GE_CMD_UNKNOWN_29: - case GE_CMD_UNKNOWN_34: - case GE_CMD_UNKNOWN_35: - case GE_CMD_UNKNOWN_39: - case GE_CMD_UNKNOWN_4E: - case GE_CMD_UNKNOWN_4F: - case GE_CMD_UNKNOWN_52: - case GE_CMD_UNKNOWN_59: - case GE_CMD_UNKNOWN_5A: - case GE_CMD_UNKNOWN_B6: - case GE_CMD_UNKNOWN_B7: - case GE_CMD_UNKNOWN_D1: - case GE_CMD_UNKNOWN_ED: - case GE_CMD_UNKNOWN_EF: - case GE_CMD_UNKNOWN_FA: - case GE_CMD_UNKNOWN_FB: - case GE_CMD_UNKNOWN_FC: - case GE_CMD_UNKNOWN_FD: - case GE_CMD_UNKNOWN_FE: - if (data != 0) - WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op); - break; - case GE_CMD_UNKNOWN_FF: - // This is hit in quite a few games, supposedly it is a no-op. - // Might be used for debugging or something? - break; - - default: - GPUCommon::ExecuteOp(op, diff); - break; - } -} - void GPU_GLES::GetStats(char *buffer, size_t bufsize) { float vertexAverageCycles = gpuStats.numVertsSubmitted > 0 ? (float)gpuStats.vertexGPUCycles / (float)gpuStats.numVertsSubmitted : 0.0f; snprintf(buffer, bufsize - 1, diff --git a/GPU/GLES/GPU_GLES.h b/GPU/GLES/GPU_GLES.h index b4b5647e05..e6e9d4cd53 100644 --- a/GPU/GLES/GPU_GLES.h +++ b/GPU/GLES/GPU_GLES.h @@ -41,7 +41,6 @@ public: void CheckGPUFeatures(); void PreExecuteOp(u32 op, u32 diff) override; - void Execute_Generic(u32 op, u32 diff); void ExecuteOp(u32 op, u32 diff) override; void ReapplyGfxStateInternal() override; @@ -82,7 +81,7 @@ public: typedef void (GPU_GLES::*CmdFunc)(u32 op, u32 diff); struct CommandInfo { - u8 flags; + uint64_t flags; GPU_GLES::CmdFunc func; }; @@ -91,45 +90,15 @@ public: void Execute_Prim(u32 op, u32 diff); void Execute_Bezier(u32 op, u32 diff); void Execute_Spline(u32 op, u32 diff); + void Execute_LoadClut(u32 op, u32 diff); void Execute_VertexType(u32 op, u32 diff); void Execute_VertexTypeSkinning(u32 op, u32 diff); - void Execute_Region(u32 op, u32 diff); - void Execute_Scissor(u32 op, u32 diff); - void Execute_FramebufType(u32 op, u32 diff); - void Execute_ViewportType(u32 op, u32 diff); - void Execute_ViewportZType(u32 op, u32 diff); + void Execute_TexScaleU(u32 op, u32 diff); void Execute_TexScaleV(u32 op, u32 diff); void Execute_TexOffsetU(u32 op, u32 diff); void Execute_TexOffsetV(u32 op, u32 diff); - void Execute_TexAddr0(u32 op, u32 diff); - void Execute_TexAddrN(u32 op, u32 diff); - void Execute_TexBufw0(u32 op, u32 diff); - void Execute_TexBufwN(u32 op, u32 diff); void Execute_TexSize0(u32 op, u32 diff); - void Execute_TexSizeN(u32 op, u32 diff); - void Execute_TexFormat(u32 op, u32 diff); - void Execute_TexMapMode(u32 op, u32 diff); - void Execute_TexParamType(u32 op, u32 diff); - void Execute_TexEnvColor(u32 op, u32 diff); - void Execute_TexLevel(u32 op, u32 diff); - void Execute_LoadClut(u32 op, u32 diff); - void Execute_ClutFormat(u32 op, u32 diff); - void Execute_Ambient(u32 op, u32 diff); - void Execute_MaterialDiffuse(u32 op, u32 diff); - void Execute_MaterialEmissive(u32 op, u32 diff); - void Execute_MaterialAmbient(u32 op, u32 diff); - void Execute_MaterialSpecular(u32 op, u32 diff); - void Execute_Light0Param(u32 op, u32 diff); - void Execute_Light1Param(u32 op, u32 diff); - void Execute_Light2Param(u32 op, u32 diff); - void Execute_Light3Param(u32 op, u32 diff); - void Execute_FogColor(u32 op, u32 diff); - void Execute_FogCoef(u32 op, u32 diff); - void Execute_ColorTestMask(u32 op, u32 diff); - void Execute_AlphaTest(u32 op, u32 diff); - void Execute_StencilTest(u32 op, u32 diff); - void Execute_ColorRef(u32 op, u32 diff); // Using string because it's generic - makes no assumptions on the size of the shader IDs of this backend. std::vector DebugGetShaderIDs(DebugShaderType shader) override; diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index 5acb08e0d7..f6336c02d4 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -4,6 +4,7 @@ #include "base/mutex.h" #include "base/timeutil.h" #include "Common/ColorConv.h" +#include "Core/Reporting.h" #include "GPU/GeDisasm.h" #include "GPU/GPU.h" #include "GPU/GPUCommon.h" @@ -1421,6 +1422,10 @@ void GPUCommon::Execute_BoneMtxData(u32 op, u32 diff) { gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x7F); } +void GPUCommon::Execute_MorphWeight(u32 op, u32 diff) { + gstate_c.morphWeights[(op >> 24) - GE_CMD_MORPHWEIGHT0] = getFloat24(op); +} + void GPUCommon::ExecuteOp(u32 op, u32 diff) { const u32 cmd = op >> 24; @@ -1463,7 +1468,89 @@ void GPUCommon::ExecuteOp(u32 op, u32 diff) { break; default: - DEBUG_LOG(G3D,"DL Unknown: %08x @ %08x", op, currentList == NULL ? 0 : currentList->pc); + DEBUG_LOG(G3D, "DL Unknown: %08x @ %08x", op, currentList == NULL ? 0 : currentList->pc); + break; + } +} + +void GPUCommon::Execute_Unknown(u32 op, u32 diff) { + switch (op >> 24) { + case GE_CMD_VSCX: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", op); + break; + + case GE_CMD_VSCY: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", op); + break; + + case GE_CMD_VSCZ: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", op); + break; + + case GE_CMD_VTCS: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", op); + break; + + case GE_CMD_VTCT: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", op); + break; + + case GE_CMD_VTCQ: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", op); + break; + + case GE_CMD_VCV: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", op); + break; + + case GE_CMD_VAP: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", op); + break; + + case GE_CMD_VFC: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", op); + break; + + case GE_CMD_VSCV: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", op); + break; + + case GE_CMD_UNKNOWN_03: + case GE_CMD_UNKNOWN_0D: + case GE_CMD_UNKNOWN_11: + case GE_CMD_UNKNOWN_29: + case GE_CMD_UNKNOWN_34: + case GE_CMD_UNKNOWN_35: + case GE_CMD_UNKNOWN_39: + case GE_CMD_UNKNOWN_4E: + case GE_CMD_UNKNOWN_4F: + case GE_CMD_UNKNOWN_52: + case GE_CMD_UNKNOWN_59: + case GE_CMD_UNKNOWN_5A: + case GE_CMD_UNKNOWN_B6: + case GE_CMD_UNKNOWN_B7: + case GE_CMD_UNKNOWN_D1: + case GE_CMD_UNKNOWN_ED: + case GE_CMD_UNKNOWN_EF: + case GE_CMD_UNKNOWN_FA: + case GE_CMD_UNKNOWN_FB: + case GE_CMD_UNKNOWN_FC: + case GE_CMD_UNKNOWN_FD: + case GE_CMD_UNKNOWN_FE: + if ((op & 0xFFFFFF) != 0) + WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op); + break; + default: break; } } diff --git a/GPU/GPUCommon.h b/GPU/GPUCommon.h index 8eb5fe1e66..b9c73b5aaf 100644 --- a/GPU/GPUCommon.h +++ b/GPU/GPUCommon.h @@ -39,6 +39,7 @@ public: void ExecuteOp(u32 op, u32 diff) override; void PreExecuteOp(u32 op, u32 diff) override; + bool InterpretList(DisplayList &list) override; virtual bool ProcessDLQueue(); u32 UpdateStall(int listid, u32 newstall) override; @@ -96,6 +97,10 @@ public: void Execute_BoneMtxNum(u32 op, u32 diff); void Execute_BoneMtxData(u32 op, u32 diff); + void Execute_MorphWeight(u32 op, u32 diff); + + void Execute_Unknown(u32 op, u32 diff); + int EstimatePerVertexCost(); // Note: Not virtual! diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 53cd63c5fd..fb9efb3ab5 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -184,14 +184,14 @@ static const CommandTableEntry commandTable[] = { { GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE }, // Morph weights. TODO: Remove precomputation? - { GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, - { GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE }, + { GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, + { GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight }, // Control spline/bezier patches. Don't really require flushing as such, but meh. { GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE }, diff --git a/GPU/ge_constants.h b/GPU/ge_constants.h index b7c5dfe965..1ea7ab0549 100644 --- a/GPU/ge_constants.h +++ b/GPU/ge_constants.h @@ -17,8 +17,7 @@ #pragma once -enum GECommand -{ +enum GECommand { GE_CMD_NOP = 0, GE_CMD_VADDR = 0x1, GE_CMD_IADDR = 0x2, @@ -42,13 +41,13 @@ enum GECommand GE_CMD_LIGHTINGENABLE = 0x17, GE_CMD_LIGHTENABLE0 = 0x18, GE_CMD_LIGHTENABLE1 = 0x19, - GE_CMD_LIGHTENABLE2 = 0x1a, - GE_CMD_LIGHTENABLE3 = 0x1b, - GE_CMD_CLIPENABLE = 0x1c, - GE_CMD_CULLFACEENABLE, - GE_CMD_TEXTUREMAPENABLE, - GE_CMD_FOGENABLE, - GE_CMD_DITHERENABLE, + GE_CMD_LIGHTENABLE2 = 0x1A, + GE_CMD_LIGHTENABLE3 = 0x1B, + GE_CMD_CLIPENABLE = 0x1C, + GE_CMD_CULLFACEENABLE = 0x1D, + GE_CMD_TEXTUREMAPENABLE = 0x1E, + GE_CMD_FOGENABLE = 0x1F, + GE_CMD_DITHERENABLE = 0x20, GE_CMD_ALPHABLENDENABLE = 0x21, GE_CMD_ALPHATESTENABLE = 0x22, GE_CMD_ZTESTENABLE = 0x23, @@ -71,14 +70,14 @@ enum GECommand GE_CMD_PATCHPRIMITIVE = 0x37, GE_CMD_PATCHFACING = 0x38, GE_CMD_WORLDMATRIXNUMBER = 0x3A, - GE_CMD_WORLDMATRIXDATA, - GE_CMD_VIEWMATRIXNUMBER, - GE_CMD_VIEWMATRIXDATA, - GE_CMD_PROJMATRIXNUMBER, - GE_CMD_PROJMATRIXDATA, + GE_CMD_WORLDMATRIXDATA = 0x3B, + GE_CMD_VIEWMATRIXNUMBER = 0x3C, + GE_CMD_VIEWMATRIXDATA = 0x3D, + GE_CMD_PROJMATRIXNUMBER = 0x3E, + GE_CMD_PROJMATRIXDATA = 0x3F, GE_CMD_TGENMATRIXNUMBER = 0x40, GE_CMD_TGENMATRIXDATA = 0x41, - GE_CMD_VIEWPORTXSCALE, + GE_CMD_VIEWPORTXSCALE = 0x42, GE_CMD_VIEWPORTYSCALE, GE_CMD_VIEWPORTZSCALE, GE_CMD_VIEWPORTXCENTER, @@ -93,14 +92,14 @@ enum GECommand GE_CMD_SHADEMODE = 0x50, // flat or gouraud GE_CMD_REVERSENORMAL = 0x51, GE_CMD_MATERIALUPDATE = 0x53, - GE_CMD_MATERIALEMISSIVE, //not sure about these but this makes sense - GE_CMD_MATERIALAMBIENT, //gotta try enabling lighting and check :) + GE_CMD_MATERIALEMISSIVE = 0x54, //not sure about these but this makes sense + GE_CMD_MATERIALAMBIENT = 0x55, //gotta try enabling lighting and check :) GE_CMD_MATERIALDIFFUSE = 0x56, GE_CMD_MATERIALSPECULAR = 0x57, GE_CMD_MATERIALALPHA = 0x58, GE_CMD_MATERIALSPECULARCOEF = 0x5B, - GE_CMD_AMBIENTCOLOR, - GE_CMD_AMBIENTALPHA, + GE_CMD_AMBIENTCOLOR = 0x5C, + GE_CMD_AMBIENTALPHA = 0x5D, GE_CMD_LIGHTMODE = 0x5E, GE_CMD_LIGHTTYPE0 = 0x5F, GE_CMD_LIGHTTYPE1 = 0x60, From 068f2d3c71f62ff8ba73bffb88653017b281278c Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 10:56:30 +0100 Subject: [PATCH 06/11] Remove Execute_Generic in both D3D9 and Vulkan backends --- GPU/Directx9/GPU_DX9.cpp | 718 +++++++------------------------------- GPU/Directx9/GPU_DX9.h | 1 - GPU/Vulkan/GPU_Vulkan.cpp | 603 ++------------------------------ GPU/Vulkan/GPU_Vulkan.h | 1 - 4 files changed, 157 insertions(+), 1166 deletions(-) diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index c21429f426..d2650ddd4d 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -76,9 +76,9 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE}, // Changes that dirty uniforms - {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, + {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogColor}, + {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogCoef}, + {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogCoef}, // Should these maybe flush? {GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE}, @@ -140,14 +140,14 @@ static const CommandTableEntry commandTable[] = { // 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, 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_LIGHTENABLE0, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTENABLE1, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTENABLE2, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTENABLE3, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTTYPE0, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTTYPE1, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTTYPE2, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_LIGHTTYPE3, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_MATERIALUPDATE, FLAG_FLUSHBEFOREONCHANGE}, // This changes both shaders so need flushing. @@ -212,85 +212,85 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE}, // 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}, + {GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Region}, + {GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Region}, // 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}, + {GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Scissor}, + {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &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}, - {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, - {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE}, + {GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Ambient}, + {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Ambient }, + {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialDiffuse}, + {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialEmissive}, + {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialSpecular}, + {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialSpecular }, // 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, 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_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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}, + {GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, + {GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, + {GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, + {GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, // Ignored commands {GE_CMD_CLIPENABLE, 0}, @@ -310,16 +310,16 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_TRANSFERSIZE, 0}, // From Common. No flushing but definitely need execute. - {GE_CMD_OFFSETADDR, FLAG_EXECUTE}, - {GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC}, // Really? - {GE_CMD_PRIM, FLAG_EXECUTE}, - {GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC}, - {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_OFFSETADDR, FLAG_EXECUTE, 0, &GPU_DX9::Execute_OffsetAddr}, + {GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPU_DX9::Execute_Origin}, // Really? + {GE_CMD_PRIM, FLAG_EXECUTE, 0, &GPU_DX9::Execute_Prim}, + {GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_DX9::Execute_Jump}, + {GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_DX9::Execute_Call}, + {GE_CMD_RET, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_DX9::Execute_Ret}, + {GE_CMD_END, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_DX9::Execute_End}, {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_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_DX9::Execute_BJump}, // EXECUTE {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. @@ -355,40 +355,40 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_BoneMtxData}, // Vertex Screen/Texture/Color - { GE_CMD_VSCX, FLAG_EXECUTE }, - { GE_CMD_VSCY, FLAG_EXECUTE }, - { GE_CMD_VSCZ, FLAG_EXECUTE }, - { GE_CMD_VTCS, FLAG_EXECUTE }, - { GE_CMD_VTCT, FLAG_EXECUTE }, - { GE_CMD_VTCQ, FLAG_EXECUTE }, - { GE_CMD_VCV, FLAG_EXECUTE }, - { GE_CMD_VAP, FLAG_EXECUTE }, - { GE_CMD_VFC, FLAG_EXECUTE }, - { GE_CMD_VSCV, FLAG_EXECUTE }, + { GE_CMD_VSCX, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VSCY, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VSCZ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VTCS, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VTCT, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VTCQ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VAP, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VFC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + { GE_CMD_VSCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, // "Missing" commands (gaps in the sequence) - {GE_CMD_UNKNOWN_03, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_0D, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_11, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_29, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_34, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_35, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_39, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_4E, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_4F, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_52, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_59, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_5A, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_B6, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_B7, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_D1, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_ED, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_EF, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FA, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FB, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FC, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FD, FLAG_EXECUTE}, - {GE_CMD_UNKNOWN_FE, FLAG_EXECUTE}, + {GE_CMD_UNKNOWN_03, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_0D, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_11, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_29, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_34, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_35, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_39, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_4E, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_4F, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_52, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_59, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_5A, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_B6, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_B7, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_D1, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_ED, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_EF, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FA, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FB, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FD, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, + {GE_CMD_UNKNOWN_FE, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown}, // Appears to be debugging related or something? Hit a lot in GoW. { GE_CMD_UNKNOWN_FF, 0 }, }; @@ -436,8 +436,8 @@ GPU_DX9::GPU_DX9(GraphicsContext *gfxCtx) } cmdInfo_[cmd].flags |= commandTable[i].flags; cmdInfo_[cmd].func = commandTable[i].func; - if (!cmdInfo_[cmd].func) { - cmdInfo_[cmd].func = &GPU_DX9::Execute_Generic; + if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { + Crash(); } } // Find commands missing from the table. @@ -1068,482 +1068,6 @@ void GPU_DX9::Execute_ColorRef(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_ALPHACOLORREF); } -void GPU_DX9::Execute_Generic(u32 op, u32 diff) { - u32 cmd = op >> 24; - u32 data = op & 0xFFFFFF; - - // Handle control and drawing commands here directly. The others we delegate. - switch (cmd) { - case GE_CMD_BASE: - break; - - case GE_CMD_VADDR: - Execute_Vaddr(op, diff); - break; - - case GE_CMD_IADDR: - Execute_Iaddr(op, diff); - break; - - case GE_CMD_PRIM: - Execute_Prim(op, diff); - break; - - case GE_CMD_BEZIER: - Execute_Bezier(op, diff); - break; - - case GE_CMD_SPLINE: - Execute_Spline(op, diff); - break; - - case GE_CMD_BOUNDINGBOX: - Execute_BoundingBox(op, diff); - break; - - case GE_CMD_REGION1: - case GE_CMD_REGION2: - Execute_Region(op, diff); - break; - - case GE_CMD_CLIPENABLE: - //we always clip, this is opengl - break; - - case GE_CMD_CULLFACEENABLE: - case GE_CMD_CULL: - break; - - case GE_CMD_TEXTUREMAPENABLE: - if (diff) - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); - break; - - case GE_CMD_LIGHTINGENABLE: - break; - - case GE_CMD_FOGCOLOR: - if (diff) - gstate_c.Dirty(DIRTY_FOGCOLOR); - break; - - case GE_CMD_FOG1: - if (diff) - gstate_c.Dirty(DIRTY_FOGCOEF); - break; - - case GE_CMD_FOG2: - if (diff) - gstate_c.Dirty(DIRTY_FOGCOEF); - break; - - case GE_CMD_FOGENABLE: - break; - - case GE_CMD_DITHERENABLE: - break; - - case GE_CMD_OFFSETX: - break; - - case GE_CMD_OFFSETY: - break; - - case GE_CMD_TEXSCALEU: Execute_TexScaleU(op, diff); break; - case GE_CMD_TEXSCALEV: Execute_TexScaleV(op, diff); break; - case GE_CMD_TEXOFFSETU: Execute_TexOffsetU(op, diff); break; - case GE_CMD_TEXOFFSETV: Execute_TexOffsetV(op, diff); break; - - case GE_CMD_SCISSOR1: - case GE_CMD_SCISSOR2: - Execute_Scissor(op, diff); - break; - - /// - case GE_CMD_MINZ: - case GE_CMD_MAXZ: - break; - - case GE_CMD_FRAMEBUFPTR: - case GE_CMD_FRAMEBUFWIDTH: - case GE_CMD_FRAMEBUFPIXFORMAT: - Execute_FramebufType(op, diff); - break; - - case GE_CMD_TEXADDR0: - Execute_TexAddr0(op, diff); - break; - - case GE_CMD_TEXADDR1: - case GE_CMD_TEXADDR2: - case GE_CMD_TEXADDR3: - case GE_CMD_TEXADDR4: - case GE_CMD_TEXADDR5: - case GE_CMD_TEXADDR6: - case GE_CMD_TEXADDR7: - Execute_TexAddrN(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH0: - Execute_TexAddr0(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH1: - case GE_CMD_TEXBUFWIDTH2: - case GE_CMD_TEXBUFWIDTH3: - case GE_CMD_TEXBUFWIDTH4: - case GE_CMD_TEXBUFWIDTH5: - case GE_CMD_TEXBUFWIDTH6: - case GE_CMD_TEXBUFWIDTH7: - Execute_TexBufwN(op, diff); - break; - - case GE_CMD_CLUTFORMAT: - Execute_ClutFormat(op, diff); - break; - - case GE_CMD_CLUTADDR: - case GE_CMD_CLUTADDRUPPER: - // Hm, LOADCLUT actually changes the CLUT so no need to dirty here. - break; - - case GE_CMD_LOADCLUT: - Execute_LoadClut(op, diff); - break; - - case GE_CMD_TEXMAPMODE: - Execute_TexMapMode(op, diff); - break; - - case GE_CMD_TEXSHADELS: - break; - - case GE_CMD_TRANSFERSRC: - case GE_CMD_TRANSFERSRCW: - case GE_CMD_TRANSFERDST: - case GE_CMD_TRANSFERDSTW: - case GE_CMD_TRANSFERSRCPOS: - case GE_CMD_TRANSFERDSTPOS: - break; - - case GE_CMD_TRANSFERSIZE: - break; - - case GE_CMD_TRANSFERSTART: - Execute_BlockTransferStart(op, diff); - break; - - case GE_CMD_TEXSIZE0: - Execute_TexSize0(op, diff); - break; - - case GE_CMD_TEXSIZE1: - case GE_CMD_TEXSIZE2: - case GE_CMD_TEXSIZE3: - case GE_CMD_TEXSIZE4: - case GE_CMD_TEXSIZE5: - case GE_CMD_TEXSIZE6: - case GE_CMD_TEXSIZE7: - Execute_TexSizeN(op, diff); - break; - - case GE_CMD_ZBUFPTR: - case GE_CMD_ZBUFWIDTH: - break; - - case GE_CMD_AMBIENTCOLOR: - case GE_CMD_AMBIENTALPHA: - if (diff) - gstate_c.Dirty(DIRTY_AMBIENT); - break; - - case GE_CMD_MATERIALDIFFUSE: - if (diff) - gstate_c.Dirty(DIRTY_MATDIFFUSE); - break; - - case GE_CMD_MATERIALEMISSIVE: - if (diff) - gstate_c.Dirty(DIRTY_MATEMISSIVE); - break; - - case GE_CMD_MATERIALAMBIENT: - case GE_CMD_MATERIALALPHA: - if (diff) - gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); - break; - - case GE_CMD_MATERIALSPECULAR: - case GE_CMD_MATERIALSPECULARCOEF: - if (diff) - gstate_c.Dirty(DIRTY_MATSPECULAR); - break; - - case GE_CMD_LIGHTTYPE0: - case GE_CMD_LIGHTTYPE1: - case GE_CMD_LIGHTTYPE2: - case GE_CMD_LIGHTTYPE3: - break; - case GE_CMD_LX0:case GE_CMD_LY0:case GE_CMD_LZ0: - case GE_CMD_LDX0:case GE_CMD_LDY0:case GE_CMD_LDZ0: - case GE_CMD_LKA0:case GE_CMD_LKB0:case GE_CMD_LKC0: - case GE_CMD_LKS0: // spot coef ("conv") - case GE_CMD_LKO0: // light angle ("cutoff") - case GE_CMD_LAC0: - case GE_CMD_LDC0: - case GE_CMD_LSC0: - if (diff) - gstate_c.Dirty(DIRTY_LIGHT0); - break; - - case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1: - case GE_CMD_LDX1:case GE_CMD_LDY1:case GE_CMD_LDZ1: - case GE_CMD_LKA1:case GE_CMD_LKB1:case GE_CMD_LKC1: - case GE_CMD_LKS1: - case GE_CMD_LKO1: - case GE_CMD_LAC1: - case GE_CMD_LDC1: - case GE_CMD_LSC1: - if (diff) - gstate_c.Dirty(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: - case GE_CMD_LKA2:case GE_CMD_LKB2:case GE_CMD_LKC2: - case GE_CMD_LKS2: - case GE_CMD_LKO2: - case GE_CMD_LAC2: - case GE_CMD_LDC2: - case GE_CMD_LSC2: - if (diff) - gstate_c.Dirty(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: - case GE_CMD_LKA3:case GE_CMD_LKB3:case GE_CMD_LKC3: - case GE_CMD_LKS3: - case GE_CMD_LKO3: - case GE_CMD_LAC3: - case GE_CMD_LDC3: - case GE_CMD_LSC3: - if (diff) - gstate_c.Dirty(DIRTY_LIGHT3); - break; - - case GE_CMD_VIEWPORTXSCALE: - case GE_CMD_VIEWPORTYSCALE: - case GE_CMD_VIEWPORTXCENTER: - case GE_CMD_VIEWPORTYCENTER: - case GE_CMD_VIEWPORTZSCALE: - case GE_CMD_VIEWPORTZCENTER: - if (diff) - Execute_ViewportType(op, diff); - break; - - case GE_CMD_LIGHTENABLE0: - case GE_CMD_LIGHTENABLE1: - case GE_CMD_LIGHTENABLE2: - case GE_CMD_LIGHTENABLE3: - break; - - case GE_CMD_SHADEMODE: - break; - - case GE_CMD_PATCHDIVISION: - case GE_CMD_PATCHPRIMITIVE: - case GE_CMD_PATCHFACING: - break; - - - case GE_CMD_MATERIALUPDATE: - break; - - ////////////////////////////////////////////////////////////////// - // CLEARING - ////////////////////////////////////////////////////////////////// - case GE_CMD_CLEARMODE: - break; - - ////////////////////////////////////////////////////////////////// - // ALPHA BLENDING - ////////////////////////////////////////////////////////////////// - case GE_CMD_ALPHABLENDENABLE: - case GE_CMD_BLENDMODE: - case GE_CMD_BLENDFIXEDA: - case GE_CMD_BLENDFIXEDB: - break; - - case GE_CMD_ALPHATESTENABLE: - case GE_CMD_COLORTESTENABLE: - // They are done in the fragment shader. - break; - - case GE_CMD_COLORTEST: - case GE_CMD_COLORTESTMASK: - if (diff) - gstate_c.Dirty(DIRTY_ALPHACOLORMASK); - break; - - case GE_CMD_ALPHATEST: - if (((data >> 16) & 0xFF) != 0xFF && (data & 7) > 1) - WARN_LOG_REPORT_ONCE(alphatestmask, G3D, "Unsupported alphatest mask: %02x", (data >> 16) & 0xFF); - // Intentional fallthrough. - case GE_CMD_COLORREF: - if (diff) - gstate_c.Dirty(DIRTY_ALPHACOLORREF); - break; - - case GE_CMD_TEXENVCOLOR: - if (diff) - gstate_c.Dirty(DIRTY_TEXENV); - break; - - case GE_CMD_TEXFUNC: - case GE_CMD_TEXFLUSH: - break; - - case GE_CMD_TEXFORMAT: - Execute_TexFormat(op, diff); - break; - - case GE_CMD_TEXMODE: - case GE_CMD_TEXFILTER: - case GE_CMD_TEXWRAP: - Execute_TexParamType(op, diff); - break; - - ////////////////////////////////////////////////////////////////// - // Z/STENCIL TESTING - ////////////////////////////////////////////////////////////////// - - case GE_CMD_STENCILTESTENABLE: - case GE_CMD_ZTESTENABLE: - case GE_CMD_ZTEST: - case GE_CMD_ZWRITEDISABLE: - break; - - case GE_CMD_MORPHWEIGHT0: - case GE_CMD_MORPHWEIGHT1: - case GE_CMD_MORPHWEIGHT2: - case GE_CMD_MORPHWEIGHT3: - case GE_CMD_MORPHWEIGHT4: - case GE_CMD_MORPHWEIGHT5: - case GE_CMD_MORPHWEIGHT6: - case GE_CMD_MORPHWEIGHT7: - Execute_MorphWeight(op, diff); - break; - - case GE_CMD_DITH0: - case GE_CMD_DITH1: - case GE_CMD_DITH2: - case GE_CMD_DITH3: - break; - - case GE_CMD_LOGICOPENABLE: - case GE_CMD_LOGICOP: - break; - - case GE_CMD_ANTIALIASENABLE: - if (data != 0) - WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data); - break; - - case GE_CMD_TEXLODSLOPE: - if (data != 0) - WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data); - break; - - case GE_CMD_TEXLEVEL: - Execute_TexLevel(op, diff); - break; - - case GE_CMD_VSCX: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data); - break; - - case GE_CMD_VSCY: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data); - break; - - case GE_CMD_VSCZ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data); - break; - - case GE_CMD_VTCS: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data); - break; - - case GE_CMD_VTCT: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data); - break; - - case GE_CMD_VTCQ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data); - break; - - case GE_CMD_VCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data); - break; - - case GE_CMD_VAP: - if (data != 0) - WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data); - break; - - case GE_CMD_VFC: - if (data != 0) - WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data); - break; - - case GE_CMD_VSCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data); - break; - - - case GE_CMD_UNKNOWN_03: - case GE_CMD_UNKNOWN_0D: - case GE_CMD_UNKNOWN_11: - case GE_CMD_UNKNOWN_29: - case GE_CMD_UNKNOWN_34: - case GE_CMD_UNKNOWN_35: - case GE_CMD_UNKNOWN_39: - case GE_CMD_UNKNOWN_4E: - case GE_CMD_UNKNOWN_4F: - case GE_CMD_UNKNOWN_52: - case GE_CMD_UNKNOWN_59: - case GE_CMD_UNKNOWN_5A: - case GE_CMD_UNKNOWN_B6: - case GE_CMD_UNKNOWN_B7: - case GE_CMD_UNKNOWN_D1: - case GE_CMD_UNKNOWN_ED: - case GE_CMD_UNKNOWN_EF: - case GE_CMD_UNKNOWN_FA: - case GE_CMD_UNKNOWN_FB: - case GE_CMD_UNKNOWN_FC: - case GE_CMD_UNKNOWN_FD: - case GE_CMD_UNKNOWN_FE: - if (data != 0) - WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op); - break; - case GE_CMD_UNKNOWN_FF: - // This is hit in quite a few games, supposedly it is a no-op. - // Might be used for debugging or something? - break; - - default: - GPUCommon::ExecuteOp(op, diff); - break; - } -} - void GPU_DX9::GetStats(char *buffer, size_t bufsize) { float vertexAverageCycles = gpuStats.numVertsSubmitted > 0 ? (float)gpuStats.vertexGPUCycles / (float)gpuStats.numVertsSubmitted : 0.0f; snprintf(buffer, bufsize - 1, diff --git a/GPU/Directx9/GPU_DX9.h b/GPU/Directx9/GPU_DX9.h index 836550ed30..3e351de18d 100644 --- a/GPU/Directx9/GPU_DX9.h +++ b/GPU/Directx9/GPU_DX9.h @@ -80,7 +80,6 @@ public: GPU_DX9::CmdFunc func; }; - void Execute_Generic(u32 op, u32 diff); void Execute_Vaddr(u32 op, u32 diff); void Execute_Iaddr(u32 op, u32 diff); void Execute_Prim(u32 op, u32 diff); diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index fb9efb3ab5..5535527ec2 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -350,41 +350,41 @@ static const CommandTableEntry commandTable[] = { { GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_Vulkan::Execute_BoneMtxNum }, { GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPU_Vulkan::Execute_BoneMtxData }, - // Vertex Screen/Texture/Color - { GE_CMD_VSCX, FLAG_EXECUTE }, - { GE_CMD_VSCY, FLAG_EXECUTE }, - { GE_CMD_VSCZ, FLAG_EXECUTE }, - { GE_CMD_VTCS, FLAG_EXECUTE }, - { GE_CMD_VTCT, FLAG_EXECUTE }, - { GE_CMD_VTCQ, FLAG_EXECUTE }, - { GE_CMD_VCV, FLAG_EXECUTE }, - { GE_CMD_VAP, FLAG_EXECUTE }, - { GE_CMD_VFC, FLAG_EXECUTE }, - { GE_CMD_VSCV, FLAG_EXECUTE }, + // Vertex Screen/Texture/Color + { GE_CMD_VSCX, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VSCY, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VSCZ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VTCS, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VTCT, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VTCQ, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VAP, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VFC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_VSCV, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, - // "Missing" commands (gaps in the sequence) - { GE_CMD_UNKNOWN_03, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_0D, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_11, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_29, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_34, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_35, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_39, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_4E, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_4F, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_52, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_59, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_5A, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_B6, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_B7, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_D1, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_ED, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_EF, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_FA, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_FB, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_FC, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_FD, FLAG_EXECUTE }, - { GE_CMD_UNKNOWN_FE, FLAG_EXECUTE }, + // "Missing" commands (gaps in the sequence) + { GE_CMD_UNKNOWN_03, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_0D, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_11, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_29, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_34, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_35, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_39, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_4E, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_4F, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_52, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_59, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_5A, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_B6, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_B7, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_D1, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_ED, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_EF, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_FA, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_FB, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_FC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_FD, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, + { GE_CMD_UNKNOWN_FE, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown }, // Appears to be debugging related or something? Hit a lot in GoW. { GE_CMD_UNKNOWN_FF, 0 }, }; @@ -434,8 +434,8 @@ GPU_Vulkan::GPU_Vulkan(GraphicsContext *ctx) } cmdInfo_[cmd].flags |= commandTable[i].flags; cmdInfo_[cmd].func = commandTable[i].func; - if (!cmdInfo_[cmd].func) { - cmdInfo_[cmd].func = &GPU_Vulkan::Execute_Generic; + if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { + Crash(); } } // Find commands missing from the table. @@ -1138,537 +1138,6 @@ void GPU_Vulkan::Execute_BoneMtxData(u32 op, u32 diff) { gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x7F); } -void GPU_Vulkan::Execute_Generic(u32 op, u32 diff) { - u32 cmd = op >> 24; - u32 data = op & 0xFFFFFF; - - // Handle control and drawing commands here directly. The others we delegate. - switch (cmd) { - case GE_CMD_BASE: - break; - - case GE_CMD_VADDR: - Execute_Vaddr(op, diff); - break; - - case GE_CMD_IADDR: - Execute_Iaddr(op, diff); - break; - - case GE_CMD_PRIM: - Execute_Prim(op, diff); - break; - - case GE_CMD_BEZIER: - Execute_Bezier(op, diff); - break; - - case GE_CMD_SPLINE: - Execute_Spline(op, diff); - break; - - case GE_CMD_BOUNDINGBOX: - Execute_BoundingBox(op, diff); - break; - - case GE_CMD_VERTEXTYPE: - Execute_VertexType(op, diff); - break; - - case GE_CMD_REGION1: - case GE_CMD_REGION2: - Execute_Region(op, diff); - break; - - case GE_CMD_CLIPENABLE: - //we always clip, this is opengl - break; - - case GE_CMD_CULLFACEENABLE: - case GE_CMD_CULL: - break; - - case GE_CMD_TEXTUREMAPENABLE: - // Don't need to dirty the texture here, already dirtied at list start/etc. - break; - - case GE_CMD_LIGHTINGENABLE: - break; - - case GE_CMD_FOGCOLOR: - Execute_FogColor(op, diff); - break; - - case GE_CMD_FOG1: - case GE_CMD_FOG2: - Execute_FogCoef(op, diff); - break; - - case GE_CMD_FOGENABLE: - break; - - case GE_CMD_DITHERENABLE: - break; - - case GE_CMD_OFFSETX: - break; - - case GE_CMD_OFFSETY: - break; - - case GE_CMD_TEXSCALEU: - Execute_TexScaleU(op, diff); - break; - - case GE_CMD_TEXSCALEV: - Execute_TexScaleV(op, diff); - break; - - case GE_CMD_TEXOFFSETU: - Execute_TexOffsetU(op, diff); - break; - - case GE_CMD_TEXOFFSETV: - Execute_TexOffsetV(op, diff); - break; - - case GE_CMD_SCISSOR1: - case GE_CMD_SCISSOR2: - Execute_Scissor(op, diff); - break; - - /// - case GE_CMD_MINZ: - case GE_CMD_MAXZ: - break; - - case GE_CMD_FRAMEBUFPTR: - case GE_CMD_FRAMEBUFWIDTH: - case GE_CMD_FRAMEBUFPIXFORMAT: - Execute_FramebufType(op, diff); - break; - - case GE_CMD_TEXADDR0: - Execute_TexAddr0(op, diff); - break; - - case GE_CMD_TEXADDR1: - case GE_CMD_TEXADDR2: - case GE_CMD_TEXADDR3: - case GE_CMD_TEXADDR4: - case GE_CMD_TEXADDR5: - case GE_CMD_TEXADDR6: - case GE_CMD_TEXADDR7: - Execute_TexAddrN(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH0: - Execute_TexBufw0(op, diff); - break; - - case GE_CMD_TEXBUFWIDTH1: - case GE_CMD_TEXBUFWIDTH2: - case GE_CMD_TEXBUFWIDTH3: - case GE_CMD_TEXBUFWIDTH4: - case GE_CMD_TEXBUFWIDTH5: - case GE_CMD_TEXBUFWIDTH6: - case GE_CMD_TEXBUFWIDTH7: - Execute_TexBufwN(op, diff); - break; - - case GE_CMD_CLUTFORMAT: - Execute_ClutFormat(op, diff); - break; - - case GE_CMD_CLUTADDR: - case GE_CMD_CLUTADDRUPPER: - // Hm, LOADCLUT actually changes the CLUT so no need to dirty here. - break; - - case GE_CMD_LOADCLUT: - Execute_LoadClut(op, diff); - break; - - case GE_CMD_TEXMAPMODE: - Execute_TexMapMode(op, diff); - break; - - case GE_CMD_TEXSHADELS: - break; - - case GE_CMD_TRANSFERSRC: - case GE_CMD_TRANSFERSRCW: - case GE_CMD_TRANSFERDST: - case GE_CMD_TRANSFERDSTW: - case GE_CMD_TRANSFERSRCPOS: - case GE_CMD_TRANSFERDSTPOS: - break; - - case GE_CMD_TRANSFERSIZE: - break; - - case GE_CMD_TRANSFERSTART: - Execute_BlockTransferStart(op, diff); - break; - - case GE_CMD_TEXSIZE0: - Execute_TexSize0(op, diff); - break; - - case GE_CMD_TEXSIZE1: - case GE_CMD_TEXSIZE2: - case GE_CMD_TEXSIZE3: - case GE_CMD_TEXSIZE4: - case GE_CMD_TEXSIZE5: - case GE_CMD_TEXSIZE6: - case GE_CMD_TEXSIZE7: - Execute_TexSizeN(op, diff); - break; - - case GE_CMD_ZBUFPTR: - case GE_CMD_ZBUFWIDTH: - break; - - case GE_CMD_AMBIENTCOLOR: - case GE_CMD_AMBIENTALPHA: - Execute_Ambient(op, diff); - break; - - case GE_CMD_MATERIALDIFFUSE: - Execute_MaterialDiffuse(op, diff); - break; - - case GE_CMD_MATERIALEMISSIVE: - Execute_MaterialEmissive(op, diff); - break; - - case GE_CMD_MATERIALAMBIENT: - case GE_CMD_MATERIALALPHA: - Execute_MaterialAmbient(op, diff); - break; - - case GE_CMD_MATERIALSPECULAR: - case GE_CMD_MATERIALSPECULARCOEF: - Execute_MaterialSpecular(op, diff); - break; - - case GE_CMD_LIGHTTYPE0: - case GE_CMD_LIGHTTYPE1: - case GE_CMD_LIGHTTYPE2: - case GE_CMD_LIGHTTYPE3: - break; - - case GE_CMD_LX0:case GE_CMD_LY0:case GE_CMD_LZ0: - case GE_CMD_LDX0:case GE_CMD_LDY0:case GE_CMD_LDZ0: - case GE_CMD_LKA0:case GE_CMD_LKB0:case GE_CMD_LKC0: - case GE_CMD_LKS0: // spot coef ("conv") - case GE_CMD_LKO0: // light angle ("cutoff") - case GE_CMD_LAC0: - case GE_CMD_LDC0: - case GE_CMD_LSC0: - Execute_Light0Param(op, diff); - break; - case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1: - case GE_CMD_LDX1:case GE_CMD_LDY1:case GE_CMD_LDZ1: - case GE_CMD_LKA1:case GE_CMD_LKB1:case GE_CMD_LKC1: - case GE_CMD_LKS1: - case GE_CMD_LKO1: - case GE_CMD_LAC1: - case GE_CMD_LDC1: - case GE_CMD_LSC1: - Execute_Light1Param(op, diff); - 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: - case GE_CMD_LKA2:case GE_CMD_LKB2:case GE_CMD_LKC2: - case GE_CMD_LKS2: - case GE_CMD_LKO2: - case GE_CMD_LAC2: - case GE_CMD_LDC2: - case GE_CMD_LSC2: - Execute_Light2Param(op, diff); - 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: - case GE_CMD_LKA3:case GE_CMD_LKB3:case GE_CMD_LKC3: - case GE_CMD_LKS3: - case GE_CMD_LKO3: - case GE_CMD_LAC3: - case GE_CMD_LDC3: - case GE_CMD_LSC3: - Execute_Light3Param(op, diff); - break; - - case GE_CMD_VIEWPORTXSCALE: - case GE_CMD_VIEWPORTYSCALE: - case GE_CMD_VIEWPORTXCENTER: - case GE_CMD_VIEWPORTYCENTER: - case GE_CMD_VIEWPORTZSCALE: - case GE_CMD_VIEWPORTZCENTER: - Execute_ViewportType(op, diff); - break; - - case GE_CMD_LIGHTENABLE0: - case GE_CMD_LIGHTENABLE1: - case GE_CMD_LIGHTENABLE2: - case GE_CMD_LIGHTENABLE3: - break; - - case GE_CMD_SHADEMODE: - break; - - case GE_CMD_PATCHDIVISION: - case GE_CMD_PATCHPRIMITIVE: - case GE_CMD_PATCHFACING: - break; - - - case GE_CMD_MATERIALUPDATE: - break; - - ////////////////////////////////////////////////////////////////// - // CLEARING - ////////////////////////////////////////////////////////////////// - case GE_CMD_CLEARMODE: - break; - - ////////////////////////////////////////////////////////////////// - // ALPHA BLENDING - ////////////////////////////////////////////////////////////////// - case GE_CMD_ALPHABLENDENABLE: - case GE_CMD_BLENDMODE: - break; - - case GE_CMD_BLENDFIXEDA: - case GE_CMD_BLENDFIXEDB: - break; - - case GE_CMD_ALPHATESTENABLE: - case GE_CMD_COLORTESTENABLE: - // They are done in the fragment shader. - break; - - case GE_CMD_COLORTEST: - break; - - case GE_CMD_COLORTESTMASK: - Execute_ColorTestMask(op, diff); - break; - - case GE_CMD_ALPHATEST: - Execute_AlphaTest(op, diff); - break; - - case GE_CMD_COLORREF: - Execute_ColorRef(op, diff); - break; - - case GE_CMD_TEXENVCOLOR: - Execute_TexEnvColor(op, diff); - break; - - case GE_CMD_TEXFUNC: - case GE_CMD_TEXFLUSH: - break; - - case GE_CMD_TEXFORMAT: - Execute_TexFormat(op, diff); - break; - - case GE_CMD_TEXMODE: - case GE_CMD_TEXFILTER: - case GE_CMD_TEXWRAP: - Execute_TexParamType(op, diff); - break; - - ////////////////////////////////////////////////////////////////// - // DEPTH TESTING - ////////////////////////////////////////////////////////////////// - - case GE_CMD_ZTESTENABLE: - case GE_CMD_ZTEST: - case GE_CMD_ZWRITEDISABLE: - break; - - case GE_CMD_MORPHWEIGHT0: - case GE_CMD_MORPHWEIGHT1: - case GE_CMD_MORPHWEIGHT2: - case GE_CMD_MORPHWEIGHT3: - case GE_CMD_MORPHWEIGHT4: - case GE_CMD_MORPHWEIGHT5: - case GE_CMD_MORPHWEIGHT6: - case GE_CMD_MORPHWEIGHT7: - gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data); - break; - - case GE_CMD_DITH0: - case GE_CMD_DITH1: - case GE_CMD_DITH2: - case GE_CMD_DITH3: - break; - - case GE_CMD_WORLDMATRIXNUMBER: - Execute_WorldMtxNum(op, diff); - break; - - case GE_CMD_WORLDMATRIXDATA: - Execute_WorldMtxData(op, diff); - break; - - case GE_CMD_VIEWMATRIXNUMBER: - Execute_ViewMtxNum(op, diff); - break; - - case GE_CMD_VIEWMATRIXDATA: - Execute_ViewMtxData(op, diff); - break; - - case GE_CMD_PROJMATRIXNUMBER: - Execute_ProjMtxNum(op, diff); - break; - - case GE_CMD_PROJMATRIXDATA: - Execute_ProjMtxData(op, diff); - break; - - case GE_CMD_TGENMATRIXNUMBER: - Execute_TgenMtxNum(op, diff); - break; - - case GE_CMD_TGENMATRIXDATA: - Execute_TgenMtxData(op, diff); - break; - - case GE_CMD_BONEMATRIXNUMBER: - Execute_BoneMtxNum(op, diff); - break; - - case GE_CMD_BONEMATRIXDATA: - Execute_BoneMtxData(op, diff); - break; - -#ifndef MOBILE_DEVICE - case GE_CMD_ANTIALIASENABLE: - if (data != 0) - WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data); - break; - - case GE_CMD_TEXLODSLOPE: - if (data != 0) - WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data); - break; -#endif - - case GE_CMD_TEXLEVEL: - Execute_TexLevel(op, diff); - break; - - ////////////////////////////////////////////////////////////////// - // STENCIL TESTING - ////////////////////////////////////////////////////////////////// - - case GE_CMD_STENCILTEST: - Execute_StencilTest(op, diff); - break; - - case GE_CMD_STENCILTESTENABLE: - case GE_CMD_STENCILOP: - break; - - case GE_CMD_MASKRGB: - case GE_CMD_MASKALPHA: - break; - - case GE_CMD_REVERSENORMAL: - break; - - case GE_CMD_VSCX: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data); - break; - - case GE_CMD_VSCY: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data); - break; - - case GE_CMD_VSCZ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data); - break; - - case GE_CMD_VTCS: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data); - break; - - case GE_CMD_VTCT: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data); - break; - - case GE_CMD_VTCQ: - if (data != 0) - WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data); - break; - - case GE_CMD_VCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data); - break; - - case GE_CMD_VAP: - if (data != 0) - WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data); - break; - - case GE_CMD_VFC: - if (data != 0) - WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data); - break; - - case GE_CMD_VSCV: - if (data != 0) - WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data); - break; - - - case GE_CMD_UNKNOWN_03: - case GE_CMD_UNKNOWN_0D: - case GE_CMD_UNKNOWN_11: - case GE_CMD_UNKNOWN_29: - case GE_CMD_UNKNOWN_34: - case GE_CMD_UNKNOWN_35: - case GE_CMD_UNKNOWN_39: - case GE_CMD_UNKNOWN_4E: - case GE_CMD_UNKNOWN_4F: - case GE_CMD_UNKNOWN_52: - case GE_CMD_UNKNOWN_59: - case GE_CMD_UNKNOWN_5A: - case GE_CMD_UNKNOWN_B6: - case GE_CMD_UNKNOWN_B7: - case GE_CMD_UNKNOWN_D1: - case GE_CMD_UNKNOWN_ED: - case GE_CMD_UNKNOWN_EF: - case GE_CMD_UNKNOWN_FA: - case GE_CMD_UNKNOWN_FB: - case GE_CMD_UNKNOWN_FC: - case GE_CMD_UNKNOWN_FD: - case GE_CMD_UNKNOWN_FE: - if (data != 0) - WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op); - break; - case GE_CMD_UNKNOWN_FF: - // This is hit in quite a few games, supposedly it is a no-op. - // Might be used for debugging or something? - break; - - default: - GPUCommon::ExecuteOp(op, diff); - break; - } -} - void GPU_Vulkan::FastLoadBoneMatrix(u32 target) { const int num = gstate.boneMatrixNumber & 0x7F; const int mtxNum = num / 12; diff --git a/GPU/Vulkan/GPU_Vulkan.h b/GPU/Vulkan/GPU_Vulkan.h index 4bd62f98e1..dd9358b6c3 100644 --- a/GPU/Vulkan/GPU_Vulkan.h +++ b/GPU/Vulkan/GPU_Vulkan.h @@ -43,7 +43,6 @@ public: void EndHostFrame() override; void PreExecuteOp(u32 op, u32 diff) override; - void Execute_Generic(u32 op, u32 diff); void ExecuteOp(u32 op, u32 diff) override; void SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) override; From 443d735a285435f6e29daa674af0d2a05d81bd80 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 12:45:50 +0100 Subject: [PATCH 07/11] Activate table-driven dirty-flags in DX9 and Vulkan backends --- GPU/Directx9/GPU_DX9.cpp | 36 ++++++++++++++++++++++-------------- GPU/Vulkan/GPU_Vulkan.cpp | 8 ++++++++ 2 files changed, 30 insertions(+), 14 deletions(-) diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index d2650ddd4d..c64cd88629 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -203,12 +203,12 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Viewport. - {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_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, + {GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, + {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_DX9::Execute_ViewportType}, + {GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, + {GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, + {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_DX9::Execute_ViewportType}, {GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Region @@ -220,14 +220,14 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &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, 0, &GPU_DX9::Execute_Ambient}, - {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_Ambient }, - {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialDiffuse}, - {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialEmissive}, - {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialAmbient}, - {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialAmbient}, - {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialSpecular}, - {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_MaterialSpecular }, + {GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_DX9::Execute_Ambient}, + {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_DX9::Execute_Ambient }, + {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_DX9::Execute_MaterialDiffuse}, + {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_DX9::Execute_MaterialEmissive}, + {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENT, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENT, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular}, + {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular }, // 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, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, @@ -665,6 +665,10 @@ void GPU_DX9::FastRunLoop(DisplayList &list) { gstate.cmdmem[cmd] = op; // TODO: no need to write if diff==0... if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) { (this->*info.func)(op, diff); + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } list.pc += 4; } @@ -695,6 +699,10 @@ void GPU_DX9::ExecuteOp(u32 op, u32 diff) { const u8 cmdFlags = info.flags; if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) { (this->*info.func)(op, diff); + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } } diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 5535527ec2..a350f19913 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -714,6 +714,10 @@ void GPU_Vulkan::FastRunLoop(DisplayList &list) { downcount = dc; (this->*info.func)(op, diff); dc = downcount; + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } list.pc += 4; } @@ -743,6 +747,10 @@ void GPU_Vulkan::ExecuteOp(u32 op, u32 diff) { const u8 cmdFlags = info.flags; if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) { (this->*info.func)(op, diff); + } else if (diff) { + uint64_t dirty = info.flags >> 8; + if (dirty) + gstate_c.Dirty(dirty); } } From 1fe32d380bcec2355ea92fdd98c2349d8b5b391d Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 12:53:42 +0100 Subject: [PATCH 08/11] Update lots of dirty-flag table entries --- GPU/Directx9/GPU_DX9.cpp | 103 +++++++++++++++++++------------------- GPU/Directx9/GPU_DX9.h | 2 +- GPU/GLES/GPU_GLES.cpp | 8 +-- GPU/Vulkan/GPU_Vulkan.cpp | 92 +++++++++++++++++----------------- GPU/Vulkan/GPU_Vulkan.h | 2 +- 5 files changed, 104 insertions(+), 103 deletions(-) diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index c64cd88629..8e68417013 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -63,79 +63,79 @@ enum { struct CommandTableEntry { uint8_t cmd; uint8_t flags; - uint64_t dirtyUniform; + uint64_t dirty; GPU_DX9::CmdFunc func; }; static const CommandTableEntry commandTable[] = { // Changes that dirty the framebuffer - {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_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, + {GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, + {GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, {GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE}, // Changes that dirty uniforms - {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogColor}, - {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogCoef}, - {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_FogCoef}, + {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GPU_DX9::Execute_FogColor}, + {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_DX9::Execute_FogCoef}, + {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_DX9::Execute_FogCoef}, // Should these maybe flush? - {GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, + {GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, // Changes that dirty texture scaling. - { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexMapMode }, + { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexMapMode }, - { 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 }, + { GE_CMD_TEXSCALEU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexScaleU }, + { GE_CMD_TEXSCALEV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexScaleV }, + { GE_CMD_TEXOFFSETU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexOffsetU }, + { GE_CMD_TEXOFFSETV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &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, 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_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, + {GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &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_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE | DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexAddr0}, + {GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, + {GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_DX9::Execute_TexBufw0}, + {GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, + {GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, {GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_ClutFormat}, + {GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &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, 0, &GPU_DX9::Execute_TexParamType}, + {GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &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, 0, &GPU_DX9::Execute_ColorTestMask}, + {GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORMASK, &GPU_DX9::Execute_ColorTestMask}, // These change the vertex shader so need flushing. {GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE}, @@ -152,13 +152,13 @@ static const CommandTableEntry commandTable[] = { // This changes both shaders so need flushing. {GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexParamType}, - {GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_DX9::Execute_TexParamType}, + {GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexParamType}, + {GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexParamType}, // Uniform changes - {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}, + {GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_DX9::Execute_AlphaTest}, + {GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF, &GPU_DX9::Execute_ColorRef}, + {GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_DX9::Execute_TexEnvColor}, // Simple render state changes. Handled in StateMapping.cpp. {GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE}, @@ -167,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, 0, &GPU_DX9::Execute_StencilTest}, + {GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_STENCILREPLACEVALUE, &GPU_DX9::Execute_StencilTest}, {GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE}, @@ -224,12 +224,12 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_DX9::Execute_Ambient }, {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_DX9::Execute_MaterialDiffuse}, {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_DX9::Execute_MaterialEmissive}, - {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENT, &GPU_DX9::Execute_MaterialAmbient}, - {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENT, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_DX9::Execute_MaterialAmbient}, + {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_DX9::Execute_MaterialAmbient}, {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular}, {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular }, - // These precompute a value. not sure if worth it. Also dirty uniforms, which could be table-ized to avoid execute. + // Lighting base colors {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, @@ -243,6 +243,7 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + // Light parameters {GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, @@ -434,7 +435,7 @@ GPU_DX9::GPU_DX9(GraphicsContext *gfxCtx) } else { dupeCheck.insert(cmd); } - cmdInfo_[cmd].flags |= commandTable[i].flags; + cmdInfo_[cmd].flags |= (uint64_t)commandTable[i].flags | (commandTable[i].dirty << 8); cmdInfo_[cmd].func = commandTable[i].func; if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { Crash(); diff --git a/GPU/Directx9/GPU_DX9.h b/GPU/Directx9/GPU_DX9.h index 3e351de18d..9e998a9829 100644 --- a/GPU/Directx9/GPU_DX9.h +++ b/GPU/Directx9/GPU_DX9.h @@ -76,7 +76,7 @@ public: typedef void (GPU_DX9::*CmdFunc)(u32 op, u32 diff); struct CommandInfo { - u8 flags; + uint64_t flags; GPU_DX9::CmdFunc func; }; diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index 09ad5ec45a..c266f1c59d 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -64,7 +64,7 @@ enum { struct CommandTableEntry { uint8_t cmd; uint8_t flags; - uint64_t dirtyUniform; + uint64_t dirty; GPU_GLES::CmdFunc func; }; @@ -220,7 +220,7 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, - // These dirty various vertex shader uniforms. Could embed information about that in this table and call dirtyuniform directly, hm... + // Lighting base colors {GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT}, {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT}, {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATDIFFUSE}, @@ -230,7 +230,7 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR}, {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR}, - // These dirty uniforms, which could be table-ized to avoid execute. + // Light parameters {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, @@ -438,7 +438,7 @@ GPU_GLES::GPU_GLES(GraphicsContext *ctx) } else { dupeCheck.insert(cmd); } - cmdInfo_[cmd].flags |= (uint64_t)commandTable[i].flags | (commandTable[i].dirtyUniform << 8); + cmdInfo_[cmd].flags |= (uint64_t)commandTable[i].flags | (commandTable[i].dirty << 8); cmdInfo_[cmd].func = commandTable[i].func; if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { Crash(); diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index a350f19913..2919a6baca 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -58,7 +58,7 @@ enum { struct CommandTableEntry { uint8_t cmd; uint8_t flags; - uint64_t dirtyFlags; + uint64_t dirty; GPU_Vulkan::CmdFunc func; }; @@ -68,9 +68,9 @@ GPU_Vulkan::CommandInfo GPU_Vulkan::cmdInfo_[256]; // TODO: Share this table between the backends. Will have to make another indirection for the function pointers though.. static const CommandTableEntry commandTable[] = { // Changes that dirty the framebuffer - { GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_FramebufType }, - { GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_FramebufType }, - { GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_FramebufType }, + { GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, + { GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, + { GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, { GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE }, @@ -93,41 +93,41 @@ static const CommandTableEntry commandTable[] = { // 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, 0, &GPU_Vulkan::Execute_TexSize0 }, - { GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexFormat }, + { GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, + { GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexFormat }, { GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexLevel }, - { GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddr0 }, - { GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufw0 }, - { GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexAddr0 }, + { GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, + { GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexBufw0 }, + { GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, // These must flush on change, so that LoadClut doesn't have to always flush. { GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE }, - { GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ClutFormat }, + { GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::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, 0, &GPU_Vulkan::Execute_TexParamType }, + { GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, { GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_SHADEMODE, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_TEXFUNC, FLAG_FLUSHBEFOREONCHANGE }, @@ -151,12 +151,12 @@ static const CommandTableEntry commandTable[] = { // This changes both shaders so need flushing. { GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE }, - { GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexParamType }, - { GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexParamType }, + { GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, + { GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, // Uniform changes { GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_Vulkan::Execute_AlphaTest }, - { GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ColorRef }, + { GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF, &GPU_Vulkan::Execute_ColorRef }, { GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_Vulkan::Execute_TexEnvColor }, // Simple render state changes. Handled in StateMapping.cpp. @@ -200,22 +200,22 @@ static const CommandTableEntry commandTable[] = { { GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE }, // Viewport. - { GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, - { GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, + { GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, + { GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, + { GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, + { GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, + { GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, + { GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, // Region - { GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_Region }, - { GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_Region }, + { GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Region }, + { GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Region }, // Scissor - { GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_Scissor }, - { GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_Scissor }, + { GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Scissor }, + { GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Scissor }, - // These dirty various vertex shader uniforms. Could embed information about that in this table and call dirtyuniform directly, hm... + // Lighting base colors { GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_Vulkan::Execute_Ambient }, { GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_Vulkan::Execute_Ambient }, { GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_Vulkan::Execute_MaterialDiffuse }, @@ -225,7 +225,7 @@ static const CommandTableEntry commandTable[] = { { GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_Vulkan::Execute_MaterialSpecular }, { GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_Vulkan::Execute_MaterialSpecular }, - // These dirty uniforms, which could be table-ized to avoid execute. + // Light parameters { GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, { GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, { GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, @@ -432,7 +432,7 @@ GPU_Vulkan::GPU_Vulkan(GraphicsContext *ctx) } else { dupeCheck.insert(cmd); } - cmdInfo_[cmd].flags |= commandTable[i].flags; + cmdInfo_[cmd].flags |= (uint64_t)commandTable[i].flags | (commandTable[i].dirty << 8); cmdInfo_[cmd].func = commandTable[i].func; if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) { Crash(); diff --git a/GPU/Vulkan/GPU_Vulkan.h b/GPU/Vulkan/GPU_Vulkan.h index dd9358b6c3..c1d1fd853a 100644 --- a/GPU/Vulkan/GPU_Vulkan.h +++ b/GPU/Vulkan/GPU_Vulkan.h @@ -69,7 +69,7 @@ public: typedef void (GPU_Vulkan::*CmdFunc)(u32 op, u32 diff); struct CommandInfo { - u8 flags; + uint64_t flags; GPU_Vulkan::CmdFunc func; }; From d85888dc2b9aa7b543dc057f307ce9104cbbac2c Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 13:13:09 +0100 Subject: [PATCH 09/11] Table-driven dirty-flags for Vulkan and D3D9. Minor Vulkan optimization. --- GPU/Directx9/GPU_DX9.cpp | 389 +++++++++-------------------- GPU/Directx9/GPU_DX9.h | 30 --- GPU/GLES/GPU_GLES.cpp | 9 +- GPU/Vulkan/GPU_Vulkan.cpp | 373 +++++++++------------------ GPU/Vulkan/GPU_Vulkan.h | 31 --- GPU/Vulkan/ShaderManagerVulkan.cpp | 9 +- 6 files changed, 248 insertions(+), 593 deletions(-) diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 8e68417013..b1b36b7dfe 100644 --- a/GPU/Directx9/GPU_DX9.cpp +++ b/GPU/Directx9/GPU_DX9.cpp @@ -69,73 +69,72 @@ struct CommandTableEntry { static const CommandTableEntry commandTable[] = { // Changes that dirty the framebuffer - {GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, - {GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, - {GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_DX9::Execute_FramebufType}, + { GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, {GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE}, // Changes that dirty uniforms - {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GPU_DX9::Execute_FogColor}, - {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_DX9::Execute_FogCoef}, - {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_DX9::Execute_FogCoef}, + {GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOLOR}, + {GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF}, + {GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF}, // Should these maybe flush? {GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, {GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE}, // Changes that dirty texture scaling. - { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexMapMode }, - + { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_UVSCALEOFFSET }, { GE_CMD_TEXSCALEU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexScaleU }, { GE_CMD_TEXSCALEV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexScaleV }, { GE_CMD_TEXOFFSETU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexOffsetU }, { GE_CMD_TEXOFFSETV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &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, 0, &GPU_DX9::Execute_TexSize0}, - {GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexSizeN}, - {GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_DX9::Execute_TexFormat}, - {GE_CMD_TEXLEVEL, FLAG_EXECUTE, 0, &GPU_DX9::Execute_TexLevel}, - {GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE | DIRTY_UVSCALEOFFSET, &GPU_DX9::Execute_TexAddr0}, - {GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexAddrN}, - {GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_DX9::Execute_TexBufw0}, - {GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexBufwN}, - {GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ClutFormat}, + // Changes that dirty the current texture. + { GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_DX9::Execute_TexSize0 }, + { GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE }, + { GE_CMD_TEXLEVEL, 0, DIRTY_TEXTURE_PARAMS }, // Flushing on this is EXPENSIVE in Gran Turismo and of little use + { GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE | DIRTY_UVSCALEOFFSET }, + { GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE }, + { GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + // These must flush on change, so that LoadClut doesn't have to always flush. + { GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE }, + { GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE }, + { GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, // 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, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexParamType}, + {GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, {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, DIRTY_ALPHACOLORMASK, &GPU_DX9::Execute_ColorTestMask}, + {GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORMASK}, // These change the vertex shader so need flushing. {GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE}, @@ -151,14 +150,14 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_MATERIALUPDATE, FLAG_FLUSHBEFOREONCHANGE}, // This changes both shaders so need flushing. - {GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE}, - {GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexParamType}, - {GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_TexParamType}, + { GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE }, + { GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, // Uniform changes - {GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_DX9::Execute_AlphaTest}, - {GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF, &GPU_DX9::Execute_ColorRef}, - {GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_DX9::Execute_TexEnvColor}, + { GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK }, + { GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF }, + { GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXENV }, // Simple render state changes. Handled in StateMapping.cpp. {GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE}, @@ -167,7 +166,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, DIRTY_STENCILREPLACEVALUE, &GPU_DX9::Execute_StencilTest}, + {GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_STENCILREPLACEVALUE}, {GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE}, {GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE}, @@ -203,95 +202,93 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE}, // Viewport. - {GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_DX9::Execute_ViewportType}, - {GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE}, + { GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX }, + { GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX }, // Region - {GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Region}, - {GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Region}, + { GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, // Scissor - {GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_DX9::Execute_Scissor}, - {GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &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, DIRTY_AMBIENT, &GPU_DX9::Execute_Ambient}, - {GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_DX9::Execute_Ambient }, - {GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_DX9::Execute_MaterialDiffuse}, - {GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_DX9::Execute_MaterialEmissive}, - {GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_DX9::Execute_MaterialAmbient}, - {GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_DX9::Execute_MaterialAmbient}, - {GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular}, - {GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_DX9::Execute_MaterialSpecular }, + { GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, // Lighting base colors - {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + { GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT }, + { GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT }, + { GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATDIFFUSE }, + { GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATEMISSIVE }, + { GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA }, + { GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA }, + { GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR }, + { GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR }, // Light parameters - {GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, - {GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_DX9::Execute_Light0Param}, - {GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_DX9::Execute_Light1Param}, - {GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_DX9::Execute_Light2Param}, - {GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, - {GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_DX9::Execute_Light3Param}, + {GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + + {GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0}, + {GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1}, + {GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2}, + {GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, + {GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3}, // Ignored commands {GE_CMD_CLIPENABLE, 0}, @@ -897,32 +894,6 @@ void GPU_DX9::Execute_Spline(u32 op, u32 diff) { AdvanceVerts(gstate.vertType, count, bytesRead); } -void GPU_DX9::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); - switch (op >> 24) { - case GE_CMD_VIEWPORTZSCALE: - case GE_CMD_VIEWPORTZCENTER: - gstate_c.Dirty(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE); - break; - } -} - -void GPU_DX9::Execute_Region(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_DX9::Execute_Scissor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_DX9::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_DX9::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); gstate_c.Dirty(DIRTY_UVSCALEOFFSET); @@ -943,23 +914,6 @@ void GPU_DX9::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } -void GPU_DX9::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_DX9::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_DX9::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_DX9::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_DX9::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. @@ -972,111 +926,12 @@ void GPU_DX9::Execute_TexSize0(u32 op, u32 diff) { } } -void GPU_DX9::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_DX9::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_DX9::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_DX9::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_DX9::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXENV); -} - -void GPU_DX9::Execute_TexLevel(u32 op, u32 diff) { - // I had hoped that this would let us avoid excessively flushing in Gran Turismo, but not so, - // as the game switches rapidly between modes 0 and 1. - /* - if (gstate.getTexLevelMode() == GE_TEXLEVEL_MODE_CONST) { - gstate.texlevel ^= diff; - Flush(); - gstate.texlevel ^= diff; - } - */ - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_DX9::Execute_LoadClut(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheDX9_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); // This could be used to "dirty" textures with clut. } -void GPU_DX9::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); - // This could be used to "dirty" textures with clut. -} - -void GPU_DX9::Execute_Ambient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_AMBIENT); -} - -void GPU_DX9::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATDIFFUSE); -} - -void GPU_DX9::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATEMISSIVE); -} - -void GPU_DX9::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); -} - -void GPU_DX9::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATSPECULAR); -} - -void GPU_DX9::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT0); -} - -void GPU_DX9::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT1); -} - -void GPU_DX9::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT2); -} - -void GPU_DX9::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT3); -} - -void GPU_DX9::Execute_FogColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOLOR); -} - -void GPU_DX9::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOEF); -} - -void GPU_DX9::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORMASK); -} - -void GPU_DX9::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF); - gstate_c.Dirty(DIRTY_ALPHACOLORMASK); -} - -void GPU_DX9::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); -} - -void GPU_DX9::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF); -} - void GPU_DX9::GetStats(char *buffer, size_t bufsize) { float vertexAverageCycles = gpuStats.numVertsSubmitted > 0 ? (float)gpuStats.vertexGPUCycles / (float)gpuStats.numVertsSubmitted : 0.0f; snprintf(buffer, bufsize - 1, diff --git a/GPU/Directx9/GPU_DX9.h b/GPU/Directx9/GPU_DX9.h index 9e998a9829..626d9384d3 100644 --- a/GPU/Directx9/GPU_DX9.h +++ b/GPU/Directx9/GPU_DX9.h @@ -87,42 +87,12 @@ public: void Execute_Spline(u32 op, u32 diff); void Execute_VertexType(u32 op, u32 diff); void Execute_VertexTypeSkinning(u32 op, u32 diff); - void Execute_Region(u32 op, u32 diff); - void Execute_Scissor(u32 op, u32 diff); - void Execute_FramebufType(u32 op, u32 diff); - void Execute_ViewportType(u32 op, u32 diff); void Execute_TexScaleU(u32 op, u32 diff); void Execute_TexScaleV(u32 op, u32 diff); void Execute_TexOffsetU(u32 op, u32 diff); void Execute_TexOffsetV(u32 op, u32 diff); - void Execute_TexAddr0(u32 op, u32 diff); - void Execute_TexAddrN(u32 op, u32 diff); - void Execute_TexBufw0(u32 op, u32 diff); - void Execute_TexBufwN(u32 op, u32 diff); void Execute_TexSize0(u32 op, u32 diff); - void Execute_TexSizeN(u32 op, u32 diff); - void Execute_TexFormat(u32 op, u32 diff); - void Execute_TexMapMode(u32 op, u32 diff); - void Execute_TexParamType(u32 op, u32 diff); - void Execute_TexEnvColor(u32 op, u32 diff); - void Execute_TexLevel(u32 op, u32 diff); void Execute_LoadClut(u32 op, u32 diff); - void Execute_ClutFormat(u32 op, u32 diff); - void Execute_Ambient(u32 op, u32 diff); - void Execute_MaterialDiffuse(u32 op, u32 diff); - void Execute_MaterialEmissive(u32 op, u32 diff); - void Execute_MaterialAmbient(u32 op, u32 diff); - void Execute_MaterialSpecular(u32 op, u32 diff); - void Execute_Light0Param(u32 op, u32 diff); - void Execute_Light1Param(u32 op, u32 diff); - void Execute_Light2Param(u32 op, u32 diff); - void Execute_Light3Param(u32 op, u32 diff); - void Execute_FogColor(u32 op, u32 diff); - void Execute_FogCoef(u32 op, u32 diff); - void Execute_ColorTestMask(u32 op, u32 diff); - void Execute_AlphaTest(u32 op, u32 diff); - void Execute_StencilTest(u32 op, u32 diff); - void Execute_ColorRef(u32 op, u32 diff); // Using string because it's generic - makes no assumptions on the size of the shader IDs of this backend. std::vector DebugGetShaderIDs(DebugShaderType shader) override; diff --git a/GPU/GLES/GPU_GLES.cpp b/GPU/GLES/GPU_GLES.cpp index c266f1c59d..6b6b04bb49 100644 --- a/GPU/GLES/GPU_GLES.cpp +++ b/GPU/GLES/GPU_GLES.cpp @@ -94,8 +94,7 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexOffsetU}, {GE_CMD_TEXOFFSETV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexOffsetV}, - // Changes that dirty the current texture. Really should be possible to avoid executing these if we compile - // by adding some more flags. + // Changes that dirty the current texture. {GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_GLES::Execute_TexSize0}, {GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, {GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS}, @@ -208,9 +207,8 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, {GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, {GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, - {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE}, - {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE}, - {GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE}, + {GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX}, + {GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX}, // Region {GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS}, @@ -297,6 +295,7 @@ static const CommandTableEntry commandTable[] = { {GE_CMD_TEXFLUSH, 0}, {GE_CMD_TEXLODSLOPE, 0}, {GE_CMD_TEXSYNC, 0}, + {GE_CMD_CLIPENABLE, 0}, // These are just nop or part of other later commands. {GE_CMD_NOP, 0}, diff --git a/GPU/Vulkan/GPU_Vulkan.cpp b/GPU/Vulkan/GPU_Vulkan.cpp index 2919a6baca..3e065f0d1f 100644 --- a/GPU/Vulkan/GPU_Vulkan.cpp +++ b/GPU/Vulkan/GPU_Vulkan.cpp @@ -68,73 +68,72 @@ GPU_Vulkan::CommandInfo GPU_Vulkan::cmdInfo_[256]; // TODO: Share this table between the backends. Will have to make another indirection for the function pointers though.. static const CommandTableEntry commandTable[] = { // Changes that dirty the framebuffer - { GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, - { GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, - { GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF, &GPU_Vulkan::Execute_FramebufType }, + { GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, { GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE }, // Changes that dirty uniforms - { GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GPU_Vulkan::Execute_FogColor }, - { GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_Vulkan::Execute_FogCoef }, - { GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_Vulkan::Execute_FogCoef }, + { GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOLOR }, + { GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF }, + { GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF }, // Should these maybe flush? { GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE }, { GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE }, // Changes that dirty texture scaling. - { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_Vulkan::Execute_TexMapMode }, + { GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_UVSCALEOFFSET }, { GE_CMD_TEXSCALEU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_Vulkan::Execute_TexScaleU }, { GE_CMD_TEXSCALEV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_Vulkan::Execute_TexScaleV }, { GE_CMD_TEXOFFSETU, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_Vulkan::Execute_TexOffsetU }, { GE_CMD_TEXOFFSETV, FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_Vulkan::Execute_TexOffsetV }, - // Changes that dirty the current texture. Really should be possible to avoid executing these if we compile - // by adding some more flags. + // Changes that dirty the current texture. { GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_Vulkan::Execute_TexSize0 }, - { GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexSizeN }, - { GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexFormat }, - { GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, 0, &GPU_Vulkan::Execute_TexLevel }, - { GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexAddr0 }, - { GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexAddrN }, - { GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_IMAGE, &GPU_Vulkan::Execute_TexBufw0 }, - { GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, - { GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexBufwN }, + { GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE }, + { GE_CMD_TEXLEVEL, 0, DIRTY_TEXTURE_PARAMS }, // Flushing on this is EXPENSIVE in Gran Turismo and of little use + { GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE | DIRTY_UVSCALEOFFSET }, + { GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE }, + { GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, // These must flush on change, so that LoadClut doesn't have to always flush. { GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE }, - { GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ClutFormat }, + { GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, // 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, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, + { GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, { 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, DIRTY_ALPHACOLORMASK, &GPU_Vulkan::Execute_ColorTestMask }, + { GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORMASK }, // These change the vertex shader so need flushing. { GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE }, @@ -151,13 +150,13 @@ static const CommandTableEntry commandTable[] = { // This changes both shaders so need flushing. { GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE }, - { GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, - { GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_TexParamType }, + { GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, + { GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS }, // Uniform changes - { GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_Vulkan::Execute_AlphaTest }, - { GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF, &GPU_Vulkan::Execute_ColorRef }, - { GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_Vulkan::Execute_TexEnvColor }, + { GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK }, + { GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF }, + { GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXENV }, // Simple render state changes. Handled in StateMapping.cpp. { GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE }, @@ -166,7 +165,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, DIRTY_STENCILREPLACEVALUE, &GPU_Vulkan::Execute_StencilTest }, + { GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_STENCILREPLACEVALUE }, { GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE }, @@ -200,93 +199,93 @@ static const CommandTableEntry commandTable[] = { { GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE }, // Viewport. - { GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_ViewportType }, - { GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, - { GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE, &GPU_Vulkan::Execute_ViewportZType }, + { GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX }, + { GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX }, // Region - { GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Region }, - { GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Region }, + { GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, // Scissor - { GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Scissor }, - { GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FRAMEBUF|DIRTY_TEXTURE_PARAMS, &GPU_Vulkan::Execute_Scissor }, + { GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, + { GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS }, // Lighting base colors - { GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_Vulkan::Execute_Ambient }, - { GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_Vulkan::Execute_Ambient }, - { GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_Vulkan::Execute_MaterialDiffuse }, - { GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_Vulkan::Execute_MaterialEmissive }, - { GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_Vulkan::Execute_MaterialAmbient }, - { GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_Vulkan::Execute_MaterialAmbient }, - { GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_Vulkan::Execute_MaterialSpecular }, - { GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_Vulkan::Execute_MaterialSpecular }, + { GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT }, + { GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT }, + { GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATDIFFUSE }, + { GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATEMISSIVE }, + { GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA }, + { GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA }, + { GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR }, + { GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR }, // Light parameters - { GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, - { GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, - { GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, - { GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, - { GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, - { GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_Vulkan::Execute_Light0Param }, - { GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_Vulkan::Execute_Light1Param }, - { GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_Vulkan::Execute_Light2Param }, - { GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, - { GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_Vulkan::Execute_Light3Param }, + { GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 }, + { GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 }, + { GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 }, + { GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, + { GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 }, // Ignored commands { GE_CMD_CLIPENABLE, 0 }, @@ -924,32 +923,6 @@ void GPU_Vulkan::Execute_Spline(u32 op, u32 diff) { AdvanceVerts(gstate.vertType, count, bytesRead); } -void GPU_Vulkan::Execute_Region(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_Scissor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_FramebufType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_ViewportType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); // Why? -} - -void GPU_Vulkan::Execute_ViewportZType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FRAMEBUF); - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); - gstate_c.Dirty(DIRTY_DEPTHRANGE); -} - void GPU_Vulkan::Execute_TexScaleU(u32 op, u32 diff) { gstate_c.uv.uScale = getFloat24(op); gstate_c.Dirty(DIRTY_UVSCALEOFFSET); @@ -970,23 +943,6 @@ void GPU_Vulkan::Execute_TexOffsetV(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_UVSCALEOFFSET); } -void GPU_Vulkan::Execute_TexAddr0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_Vulkan::Execute_TexAddrN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_TexBufw0(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_Vulkan::Execute_TexBufwN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_Vulkan::Execute_TexSize0(u32 op, u32 diff) { // Render to texture may have overridden the width/height. // Don't reset it unless the size is different / the texture has changed. @@ -998,108 +954,11 @@ void GPU_Vulkan::Execute_TexSize0(u32 op, u32 diff) { } } -void GPU_Vulkan::Execute_TexSizeN(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_TexFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); -} - -void GPU_Vulkan::Execute_TexMapMode(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_UVSCALEOFFSET); -} - -void GPU_Vulkan::Execute_TexParamType(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_TexEnvColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXENV); -} - -void GPU_Vulkan::Execute_TexLevel(u32 op, u32 diff) { - // I had hoped that this would let us avoid excessively flushing in Gran Turismo, but not so, - // as the game switches rapidly between modes 0 and 1. - /* - if (gstate.getTexLevelMode() == GE_TEXLEVEL_MODE_CONST) { - gstate.texlevel ^= diff; - Flush(); - gstate.texlevel ^= diff; - } - */ - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - void GPU_Vulkan::Execute_LoadClut(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); textureCacheVulkan_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes()); } -void GPU_Vulkan::Execute_ClutFormat(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_TEXTURE_PARAMS); -} - -void GPU_Vulkan::Execute_Ambient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_AMBIENT); -} - -void GPU_Vulkan::Execute_MaterialDiffuse(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATDIFFUSE); -} - -void GPU_Vulkan::Execute_MaterialEmissive(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATEMISSIVE); -} - -void GPU_Vulkan::Execute_MaterialAmbient(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATAMBIENTALPHA); -} - -void GPU_Vulkan::Execute_MaterialSpecular(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_MATSPECULAR); -} - -void GPU_Vulkan::Execute_Light0Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT0); -} - -void GPU_Vulkan::Execute_Light1Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT1); -} - -void GPU_Vulkan::Execute_Light2Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT2); -} - -void GPU_Vulkan::Execute_Light3Param(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_LIGHT3); -} - -void GPU_Vulkan::Execute_FogColor(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOLOR); -} - -void GPU_Vulkan::Execute_FogCoef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_FOGCOEF); -} - -void GPU_Vulkan::Execute_ColorTestMask(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORMASK); -} - -void GPU_Vulkan::Execute_AlphaTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK); -} - -void GPU_Vulkan::Execute_StencilTest(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE); -} - -void GPU_Vulkan::Execute_ColorRef(u32 op, u32 diff) { - gstate_c.Dirty(DIRTY_ALPHACOLORREF); -} - void GPU_Vulkan::Execute_BoneMtxNum(u32 op, u32 diff) { // This is almost always followed by GE_CMD_BONEMATRIXDATA. const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4); diff --git a/GPU/Vulkan/GPU_Vulkan.h b/GPU/Vulkan/GPU_Vulkan.h index c1d1fd853a..4bf10b2970 100644 --- a/GPU/Vulkan/GPU_Vulkan.h +++ b/GPU/Vulkan/GPU_Vulkan.h @@ -79,43 +79,12 @@ public: void Execute_Bezier(u32 op, u32 diff); void Execute_Spline(u32 op, u32 diff); void Execute_VertexType(u32 op, u32 diff); - void Execute_Region(u32 op, u32 diff); - void Execute_Scissor(u32 op, u32 diff); - void Execute_FramebufType(u32 op, u32 diff); - void Execute_ViewportType(u32 op, u32 diff); - void Execute_ViewportZType(u32 op, u32 diff); void Execute_TexScaleU(u32 op, u32 diff); void Execute_TexScaleV(u32 op, u32 diff); void Execute_TexOffsetU(u32 op, u32 diff); void Execute_TexOffsetV(u32 op, u32 diff); - void Execute_TexAddr0(u32 op, u32 diff); - void Execute_TexAddrN(u32 op, u32 diff); - void Execute_TexBufw0(u32 op, u32 diff); - void Execute_TexBufwN(u32 op, u32 diff); void Execute_TexSize0(u32 op, u32 diff); - void Execute_TexSizeN(u32 op, u32 diff); - void Execute_TexFormat(u32 op, u32 diff); - void Execute_TexMapMode(u32 op, u32 diff); - void Execute_TexParamType(u32 op, u32 diff); - void Execute_TexEnvColor(u32 op, u32 diff); - void Execute_TexLevel(u32 op, u32 diff); void Execute_LoadClut(u32 op, u32 diff); - void Execute_ClutFormat(u32 op, u32 diff); - void Execute_Ambient(u32 op, u32 diff); - void Execute_MaterialDiffuse(u32 op, u32 diff); - void Execute_MaterialEmissive(u32 op, u32 diff); - void Execute_MaterialAmbient(u32 op, u32 diff); - void Execute_MaterialSpecular(u32 op, u32 diff); - void Execute_Light0Param(u32 op, u32 diff); - void Execute_Light1Param(u32 op, u32 diff); - void Execute_Light2Param(u32 op, u32 diff); - void Execute_Light3Param(u32 op, u32 diff); - void Execute_FogColor(u32 op, u32 diff); - void Execute_FogCoef(u32 op, u32 diff); - void Execute_ColorTestMask(u32 op, u32 diff); - void Execute_AlphaTest(u32 op, u32 diff); - void Execute_StencilTest(u32 op, u32 diff); - void Execute_ColorRef(u32 op, u32 diff); void Execute_BoneMtxNum(u32 op, u32 diff); void Execute_BoneMtxData(u32 op, u32 diff); diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index a5f15151f7..a61ec30fce 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -428,9 +428,12 @@ void ShaderManagerVulkan::DirtyLastShader() { // disables vertex arrays uint32_t ShaderManagerVulkan::UpdateUniforms() { uint32_t dirty = gstate_c.GetDirtyUniforms(); if (dirty != 0) { - BaseUpdateUniforms(dirty); - LightUpdateUniforms(dirty); - BoneUpdateUniforms(dirty); + if (dirty & DIRTY_BASE_UNIFORMS) + BaseUpdateUniforms(dirty); + if (dirty & DIRTY_LIGHT_UNIFORMS) + LightUpdateUniforms(dirty); + if (dirty & DIRTY_BONE_UNIFORMS) + BoneUpdateUniforms(dirty); } gstate_c.CleanUniforms(); return dirty; From 62a171c616eba0a8f8a5b885a77fe6c47b932c40 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 14:16:51 +0100 Subject: [PATCH 10/11] Minor DX9 optimization --- GPU/Directx9/ShaderManagerDX9.cpp | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index 954cf35014..b00d7363a1 100644 --- a/GPU/Directx9/ShaderManagerDX9.cpp +++ b/GPU/Directx9/ShaderManagerDX9.cpp @@ -272,6 +272,8 @@ static void ConvertProjMatrixToD3DThrough(Matrix4x4 &in) { in.translateAndScale(Vec3(xoff, yoff, 0.5f), Vec3(1.0f, 1.0f, 0.5f)); } +const uint64_t psUniforms = DIRTY_TEXENV | DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK | DIRTY_FOGCOLOR | DIRTY_STENCILREPLACEVALUE | DIRTY_SHADERBLEND | DIRTY_TEXCLAMP; + void ShaderManagerDX9::PSUpdateUniforms(u64 dirtyUniforms) { if (dirtyUniforms & DIRTY_TEXENV) { PSSetColorUniform3(CONST_PS_TEXENV, gstate.texenvcolor); @@ -324,6 +326,10 @@ void ShaderManagerDX9::PSUpdateUniforms(u64 dirtyUniforms) { } } +const uint64_t vsUniforms = DIRTY_PROJMATRIX | DIRTY_PROJTHROUGHMATRIX | DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_TEXMATRIX | +DIRTY_FOGCOEF | DIRTY_BONE_UNIFORMS | DIRTY_UVSCALEOFFSET | DIRTY_DEPTHRANGE | +DIRTY_AMBIENT | DIRTY_MATAMBIENTALPHA | DIRTY_MATSPECULAR | DIRTY_MATDIFFUSE | DIRTY_MATEMISSIVE | DIRTY_LIGHT0 | DIRTY_LIGHT1 | DIRTY_LIGHT2 | DIRTY_LIGHT3; + void ShaderManagerDX9::VSUpdateUniforms(u64 dirtyUniforms) { // Update any dirty uniforms before we draw if (dirtyUniforms & DIRTY_PROJMATRIX) { @@ -559,8 +565,10 @@ VSShader *ShaderManagerDX9::ApplyShader(int prim, u32 vertType) { if (lastVShader_ != nullptr && lastPShader_ != nullptr && VSID == lastVSID_ && FSID == lastFSID_) { uint64_t dirtyUniforms = gstate_c.GetDirtyUniforms(); if (dirtyUniforms) { - PSUpdateUniforms(dirtyUniforms); - VSUpdateUniforms(dirtyUniforms); + if (dirtyUniforms & psUniforms) + PSUpdateUniforms(dirtyUniforms); + if (dirtyUniforms & vsUniforms) + VSUpdateUniforms(dirtyUniforms); gstate_c.CleanUniforms(); } return lastVShader_; // Already all set. @@ -611,8 +619,10 @@ VSShader *ShaderManagerDX9::ApplyShader(int prim, u32 vertType) { uint64_t dirtyUniforms = gstate_c.GetDirtyUniforms(); if (dirtyUniforms) { - PSUpdateUniforms(dirtyUniforms); - VSUpdateUniforms(dirtyUniforms); + if (dirtyUniforms & psUniforms) + PSUpdateUniforms(dirtyUniforms); + if (dirtyUniforms & vsUniforms) + VSUpdateUniforms(dirtyUniforms); gstate_c.CleanUniforms(); } From e17d3e1e7a0c1e4fb85dcde7e44aed5874c2526c Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Tue, 24 Jan 2017 20:00:03 +0100 Subject: [PATCH 11/11] Vulkan: Forgot to extend a few more dirtyflag variables to 64-bit. Avoid a warning. --- GPU/Common/DrawEngineCommon.h | 1 + GPU/Vulkan/DrawEngineVulkan.h | 2 +- GPU/Vulkan/ShaderManagerVulkan.cpp | 10 +++++----- GPU/Vulkan/ShaderManagerVulkan.h | 8 ++++---- 4 files changed, 11 insertions(+), 10 deletions(-) diff --git a/GPU/Common/DrawEngineCommon.h b/GPU/Common/DrawEngineCommon.h index e0cc74f3e8..047cbcd98d 100644 --- a/GPU/Common/DrawEngineCommon.h +++ b/GPU/Common/DrawEngineCommon.h @@ -98,6 +98,7 @@ protected: int prevSizeTex; int prevSizeCol; public: + virtual ~TessellationDataTransfer() {} // Send spline/bezier's control points to vertex shader through floating point texture. virtual void SendDataToShader(const float *pos, const float *tex, const float *col, int size, bool hasColor, bool hasTexCoords) = 0; }; diff --git a/GPU/Vulkan/DrawEngineVulkan.h b/GPU/Vulkan/DrawEngineVulkan.h index b047d92ae3..959c4694d4 100644 --- a/GPU/Vulkan/DrawEngineVulkan.h +++ b/GPU/Vulkan/DrawEngineVulkan.h @@ -220,7 +220,7 @@ private: enum { MAX_DEFERRED_DRAW_CALLS = 128 }; // State cache - uint32_t dirtyUniforms_; + uint64_t dirtyUniforms_; uint32_t baseUBOOffset; uint32_t lightUBOOffset; uint32_t boneUBOOffset; diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index a61ec30fce..18f7bf9192 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -187,7 +187,7 @@ uint32_t ShaderManagerVulkan::PushBoneBuffer(VulkanPushBuffer *dest, VkBuffer *b return dest->PushAligned(&ub_bones, sizeof(ub_bones), uboAlignment_, buf); } -void ShaderManagerVulkan::BaseUpdateUniforms(int dirtyUniforms) { +void ShaderManagerVulkan::BaseUpdateUniforms(uint64_t dirtyUniforms) { if (dirtyUniforms & DIRTY_TEXENV) { Uint8x3ToFloat4(ub_base.texEnvColor, gstate.texenvcolor); } @@ -337,7 +337,7 @@ void ShaderManagerVulkan::BaseUpdateUniforms(int dirtyUniforms) { } } -void ShaderManagerVulkan::LightUpdateUniforms(int dirtyUniforms) { +void ShaderManagerVulkan::LightUpdateUniforms(uint64_t dirtyUniforms) { // Lighting if (dirtyUniforms & DIRTY_AMBIENT) { Uint8x3ToFloat4_AlphaUint8(ub_lights.ambientColor, gstate.ambientcolor, gstate.getAmbientA()); @@ -380,7 +380,7 @@ void ShaderManagerVulkan::LightUpdateUniforms(int dirtyUniforms) { } } -void ShaderManagerVulkan::BoneUpdateUniforms(int dirtyUniforms) { +void ShaderManagerVulkan::BoneUpdateUniforms(uint64_t dirtyUniforms) { for (int i = 0; i < 8; i++) { if (dirtyUniforms & (DIRTY_BONEMATRIX0 << i)) { ConvertMatrix4x3To4x4(ub_bones.bones[i], gstate.boneMatrix + 12 * i); @@ -425,8 +425,8 @@ void ShaderManagerVulkan::DirtyLastShader() { // disables vertex arrays lastFShader_ = nullptr; } -uint32_t ShaderManagerVulkan::UpdateUniforms() { - uint32_t dirty = gstate_c.GetDirtyUniforms(); +uint64_t ShaderManagerVulkan::UpdateUniforms() { + uint64_t dirty = gstate_c.GetDirtyUniforms(); if (dirty != 0) { if (dirty & DIRTY_BASE_UNIFORMS) BaseUpdateUniforms(dirty); diff --git a/GPU/Vulkan/ShaderManagerVulkan.h b/GPU/Vulkan/ShaderManagerVulkan.h index ed5bae7191..aa185a0479 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.h +++ b/GPU/Vulkan/ShaderManagerVulkan.h @@ -202,7 +202,7 @@ public: std::vector DebugGetShaderIDs(DebugShaderType type); std::string DebugGetShaderString(std::string id, DebugShaderType type, DebugShaderStringType stringType); - uint32_t UpdateUniforms(); + uint64_t UpdateUniforms(); // TODO: Avoid copying these buffers if same as last draw, can still point to it assuming we're still in the same pushbuffer. // Applies dirty changes and copies the buffer. @@ -215,9 +215,9 @@ public: uint32_t PushBoneBuffer(VulkanPushBuffer *dest, VkBuffer *buf); private: - void BaseUpdateUniforms(int dirtyUniforms); - void LightUpdateUniforms(int dirtyUniforms); - void BoneUpdateUniforms(int dirtyUniforms); + void BaseUpdateUniforms(uint64_t dirtyUniforms); + void LightUpdateUniforms(uint64_t dirtyUniforms); + void BoneUpdateUniforms(uint64_t dirtyUniforms); void Clear();