diff --git a/GPU/Directx9/GPU_DX9.cpp b/GPU/Directx9/GPU_DX9.cpp index 7cd3356b9..c21429f42 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 2e42ef34b..09ad5ec45 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 b4b5647e0..e6e9d4cd5 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 5acb08e0d..f6336c02d 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 8eb5fe1e6..b9c73b5aa 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 53cd63c5f..fb9efb3ab 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 b7c5dfe96..1ea7ab054 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,