Emulator-Archive/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2024-11-23 21:39:52 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
f6649794df
ppsspp/GPU/GLES/GLES_GPU.cpp

2174 lines
73 KiB
C++
Raw Normal View History

Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
Missed these somehow
2012-11-04 22:58:25 +00:00
// the Free Software Foundation, version 2.0 or later versions.
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
Another frameskipping attempt. Now: 0=no frameskip, 1=auto frameskipt, 2-9=fixed frameskip. There is still some flicker remaining in non-buffered rendering that I can't seem to get rid off.
2013-08-15 23:00:26 +00:00
#include "base/logging.h"
Update native + some very minor changes
2013-07-26 22:44:16 +00:00
#include "gfx_es2/gl_state.h"
Start untangling our include mess a little.
2013-12-29 22:28:31 +00:00
#include "Common/ChunkFile.h"
Add memchecks for common HLE copy operations. Better to catch some than miss everything.
2013-12-14 22:54:05 +00:00
#include "Core/Debugger/Breakpoints.h"
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
#include "Core/MemMap.h"
#include "Core/Host.h"
#include "Core/Config.h"
Add reporting for alphatest mask. Actually, maybe it being 0x00 could be advantageous...
2013-05-11 05:51:23 +00:00
#include "Core/Reporting.h"
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
#include "Core/System.h"
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Been meaning to rename DisplayListInterpreter->GLES_GPU forever
2013-08-20 20:34:47 +00:00
#include "GPU/GPUState.h"
#include "GPU/ge_constants.h"
#include "GPU/GeDisasm.h"
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Been meaning to rename DisplayListInterpreter->GLES_GPU forever
2013-08-20 20:34:47 +00:00
#include "GPU/GLES/ShaderManager.h"
#include "GPU/GLES/GLES_GPU.h"
#include "GPU/GLES/Framebuffer.h"
#include "GPU/GLES/TransformPipeline.h"
#include "GPU/GLES/TextureCache.h"
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Shrink the very common sceKernelThread.h include.
2014-03-15 18:44:02 +00:00
#include "Core/MIPS/MIPS.h"
Been meaning to rename DisplayListInterpreter->GLES_GPU forever
2013-08-20 20:34:47 +00:00
#include "Core/HLE/sceKernelThread.h"
#include "Core/HLE/sceKernelInterrupt.h"
#include "Core/HLE/sceGe.h"
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
enum {
FLAG_FLUSHBEFORE = 1,
FLAG_FLUSHBEFOREONCHANGE = 2,
FLAG_EXECUTE = 4, // needs to actually be executed. unused for now.
Use the FLAG_EXECUTEONCHANGE flag. Improves fps by 1-3% in some games, seems to be a win after all.
2014-04-13 17:23:21 +00:00
FLAG_EXECUTEONCHANGE = 8,
Don't reconvert light colors if they don't change. Also prepare for a possible further optimization in GLES_GPU::FastRunLoop
2013-11-10 10:18:58 +00:00
FLAG_ANY_EXECUTE = 4 | 8,
Update some flags in GLES_GPU. It's useful to know if we need to have a correct PC value or downcount.
2014-03-29 21:10:35 +00:00
FLAG_READS_PC = 16,
FLAG_WRITES_PC = 32,
Flush the draw buffer less. Default aniso to 0 on mobile, 8 on PC/the rest.
2013-02-11 18:03:11 +00:00
};
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
struct CommandTableEntry {
u8 cmd;
u8 flags;
Allow individual cmd funcs to be called. Rather than a single one, ExecuteOpInternal(). This allows less "huge switch" code organization, and will (once separated) also improve speed.
2014-04-16 14:54:19 +00:00
GLES_GPU::CmdFunc func;
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
};
static const CommandTableEntry commandTable[] = {
// Changes that dirty the framebuffer
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FramebufType},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE},
// Changes that dirty uniforms
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
{GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FogColor},
{GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FogCoef},
{GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_FogCoef},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Remove some unused gstate_c values.
2013-09-14 21:33:55 +00:00
// Should these maybe flush?
{GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Changes that dirty texture scaling.
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
{GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexMapMode},
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
{GE_CMD_TEXSCALEU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexScaleU},
{GE_CMD_TEXSCALEV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexScaleV},
{GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexOffsetU},
{GE_CMD_TEXOFFSETV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexOffsetV},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Changes that dirty the current texture. Really should be possible to avoid executing these if we compile
// by adding some more flags.
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &GLES_GPU::Execute_TexSize0},
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexSizeN},
Move out texformat as well.
2014-04-17 15:29:44 +00:00
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexFormat},
Split out texture level
2014-04-18 14:00:53 +00:00
{GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexLevel},
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddr0},
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexBufwN},
Update some flags in GLES_GPU. It's useful to know if we need to have a correct PC value or downcount.
2014-03-29 21:10:35 +00:00
// These must flush on change, so that LoadClut doesn't have to always flush.
{GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE},
Split out the clutformat cmd as well.
2014-04-18 05:57:02 +00:00
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ClutFormat},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// These affect the fragment shader so need flushing.
{GE_CMD_CLEARMODE, FLAG_FLUSHBEFOREONCHANGE},
Don't dirty the texture on texmapenable. Tales of Phantasia X flips on and off texturing during battle transitions. This causes tons of needless rehashes.
2014-04-13 20:01:18 +00:00
{GE_CMD_TEXTUREMAPENABLE, FLAG_FLUSHBEFOREONCHANGE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE},
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexParamType},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_SHADEMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXFUNC, FLAG_FLUSHBEFOREONCHANGE},
Fix uniform dirtying on colortest mask.
2014-04-22 05:53:19 +00:00
{GE_CMD_COLORTEST, FLAG_FLUSHBEFOREONCHANGE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_ALPHATESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
Fix uniform dirtying on colortest mask.
2014-04-22 05:53:19 +00:00
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ColorTestMask},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// These change the vertex shader so need flushing.
{GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE}, // TODO: This one is actually processed during vertex decoding which is wrong.
{GE_CMD_LIGHTINGENABLE, FLAG_FLUSHBEFOREONCHANGE},
{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.
{GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE},
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexParamType},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Uniform changes
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_TexEnvColor},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Simple render state changes. Handled in StateMapping.cpp.
Set GE_CMD_SCISSOR1/2 with FLAG_EXECUTE
2013-09-20 06:16:17 +00:00
{GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_OFFSETY, FLAG_FLUSHBEFOREONCHANGE},
Remove some unused gstate_c values.
2013-09-14 21:33:55 +00:00
{GE_CMD_CULL, FLAG_FLUSHBEFOREONCHANGE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_CULLFACEENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_DITHERENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_STENCILOP, FLAG_FLUSHBEFOREONCHANGE},
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_StencilTest},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE},
Implement in-shader blending on gles2 / gl2. I'm sure it'll be slow, though...
2014-06-14 05:49:28 +00:00
{GE_CMD_BLENDFIXEDA, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDFIXEDB, FLAG_FLUSHBEFOREONCHANGE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
{GE_CMD_MASKRGB, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MASKALPHA, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZTEST, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZWRITEDISABLE, FLAG_FLUSHBEFOREONCHANGE},
#ifndef USING_GLES2
{GE_CMD_LOGICOP, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LOGICOPENABLE, FLAG_FLUSHBEFOREONCHANGE},
#else
{GE_CMD_LOGICOP, 0},
{GE_CMD_LOGICOPENABLE, 0},
#endif
// Can probably ignore this one as we don't support AA lines.
{GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Morph weights. TODO: Remove precomputation?
Don't reconvert light colors if they don't change. Also prepare for a possible further optimization in GLES_GPU::FastRunLoop
2013-11-10 10:18:58 +00:00
{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},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Control spline/bezier patches. Don't really require flushing as such, but meh.
{GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHPRIMITIVE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHFACING, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Viewport.
Split out viewport type commands.
2014-04-18 05:49:09 +00:00
{GE_CMD_VIEWPORTX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_ViewportType},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
// Region
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Region},
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
// Scissor
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Scissor},
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// These dirty various vertex shader uniforms. Could embed information about that in this table and call dirtyuniform directly, hm...
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
{GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Ambient},
{GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Ambient},
{GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialDiffuse},
{GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialEmissive},
{GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialAmbient},
{GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialAmbient},
{GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialSpecular},
{GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_MaterialSpecular},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
// These dirty uniforms, which could be table-ized to avoid execute.
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_Light3Param},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Ignored commands
{GE_CMD_CLIPENABLE, 0},
{GE_CMD_TEXFLUSH, 0},
{GE_CMD_TEXLODSLOPE, 0},
{GE_CMD_TEXSYNC, 0},
// These are just nop or part of other later commands.
{GE_CMD_NOP, 0},
{GE_CMD_BASE, 0},
{GE_CMD_TRANSFERSRC, 0},
{GE_CMD_TRANSFERSRCW, 0},
{GE_CMD_TRANSFERDST, 0},
{GE_CMD_TRANSFERDSTW, 0},
{GE_CMD_TRANSFERSRCPOS, 0},
{GE_CMD_TRANSFERDSTPOS, 0},
{GE_CMD_TRANSFERSIZE, 0},
Use the EXECUTE flag to avoid calling ExecuteOp when possible. Minor speedup.
2013-08-23 12:22:26 +00:00
// From Common. No flushing but definitely need execute.
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{GE_CMD_OFFSETADDR, FLAG_EXECUTE, &GPUCommon::Execute_OffsetAddr},
{GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, &GPUCommon::Execute_Origin}, // Really?
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
{GE_CMD_PRIM, FLAG_EXECUTE, &GLES_GPU::Execute_Prim},
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_Jump},
{GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_Call},
{GE_CMD_RET, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_Ret},
{GE_CMD_END, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_End}, // Flush?
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
{GE_CMD_VADDR, FLAG_EXECUTE, &GLES_GPU::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, &GLES_GPU::Execute_Iaddr},
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{GE_CMD_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GPUCommon::Execute_BJump}, // EXECUTE
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, &GLES_GPU::Execute_BoundingBox}, // + FLUSHBEFORE when we implement... or not, do we need to?
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Changing the vertex type requires us to flush.
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &GLES_GPU::Execute_VertexType},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &GLES_GPU::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &GLES_GPU::Execute_Spline},
Use the EXECUTE flag to avoid calling ExecuteOp when possible. Minor speedup.
2013-08-23 12:22:26 +00:00
// These two are actually processed in CMD_END.
Need to flush on FINISH/SIGNAL apparently..
2013-08-23 14:31:03 +00:00
{GE_CMD_SIGNAL, FLAG_FLUSHBEFORE},
{GE_CMD_FINISH, FLAG_FLUSHBEFORE},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Changes that trigger data copies. Only flushing on change for LOADCLUT must be a bit of a hack...
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &GLES_GPU::Execute_LoadClut},
Move out block transfer too, common in GoW.
2014-04-17 15:05:16 +00:00
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC, &GLES_GPU::Execute_BlockTransferStart},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// We don't use the dither table.
{GE_CMD_DITH0},
{GE_CMD_DITH1},
{GE_CMD_DITH2},
{GE_CMD_DITH3},
GPU "dirty" optimization, wip vertexcache
2013-01-20 12:15:46 +00:00
// These handle their own flushing.
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GLES_GPU::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, &GLES_GPU::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GLES_GPU::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, &GLES_GPU::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GLES_GPU::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, &GLES_GPU::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GLES_GPU::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, &GLES_GPU::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &GLES_GPU::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, &GLES_GPU::Execute_BoneMtxData},
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
// 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},
Replace them with GE_CMD_UNKNOWN_XX
2013-09-20 13:10:32 +00:00
// "Missing" commands (gaps in the sequence)
More carefully log unknown GE commands. Need FLAG_EXECUTE or they won't log, we were only getting the ReapplyGfxState() ones before. Let's skip 0 to not log those as well.
2013-09-23 04:00:56 +00:00
{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},
Add some additional unknown cmds to reporting.
2013-10-08 07:34:17 +00:00
{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},
Don't even execute FF, it does nothing. And it happens quite a lot in GoW, interestingly...
2014-04-17 15:05:32 +00:00
// Appears to be debugging related or something? Hit a lot in GoW.
{GE_CMD_UNKNOWN_FF, 0},
More work and optimization. Still not quite there.
2012-12-21 20:49:09 +00:00
};
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
GLES_GPU::CommandInfo GLES_GPU::cmdInfo_[256];
Allow individual cmd funcs to be called. Rather than a single one, ExecuteOpInternal(). This allows less "huge switch" code organization, and will (once separated) also improve speed.
2014-04-16 14:54:19 +00:00
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Align some vertex arrays to page size. It's said to possibly be beneficial.
2013-01-28 23:48:13 +00:00
GLES_GPU::GLES_GPU()
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
: resized_(false) {
VSync codepath only works on _WIN32 so only show it and check it there.
2013-10-27 13:09:46 +00:00
#ifdef _WIN32
May fix Vsync broken previously
2013-08-06 15:08:57 +00:00
lastVsync_ = g_Config.bVSync ? 1 : 0;
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
// Disabled EXT_swap_control_tear for now, it never seems to settle at the correct timing
// so it just keeps tearing. Not what I hoped for...
//if (false && gl_extensions.EXT_swap_control_tear) {
Use EXT_swap_control_tear when available to ensure that VSync never slows things down (tears instead if it can't keep up, better than stuttering)
2013-07-07 08:58:21 +00:00
// See http://developer.download.nvidia.com/opengl/specs/WGL_EXT_swap_control_tear.txt
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
// glstate.SetVSyncInterval(g_Config.bVSync ? -1 :0);
//} else {
Merge items to new UI
2013-07-20 14:03:52 +00:00
glstate.SetVSyncInterval(g_Config.bVSync ? 1 : 0);
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
//}
VSync codepath only works on _WIN32 so only show it and check it there.
2013-10-27 13:09:46 +00:00
#endif
If bPrescaleUV is enabled, no need to flush on change of these params. Also disable the QCOM hint, not sure it does any good at all.
2013-10-09 08:44:12 +00:00
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
shaderManager_ = new ShaderManager();
transformDraw_.SetShaderManager(shaderManager_);
Make GLES_GPU own texturecache
2013-01-30 19:40:26 +00:00
transformDraw_.SetTextureCache(&textureCache_);
Initial support for texturing from framebuffers.
2013-01-31 23:18:23 +00:00
transformDraw_.SetFramebufferManager(&framebufferManager_);
framebufferManager_.SetTextureCache(&textureCache_);
Respect the size of the current FBO when drawing. Some cleanup.
2013-03-15 23:40:37 +00:00
framebufferManager_.SetShaderManager(shaderManager_);
Flush draws before doing any block transfers. Otherwise, we might flush on top, or we might download the wrong thing.
2014-06-11 07:28:28 +00:00
framebufferManager_.SetTransformDrawEngine(&transformDraw_);
Duplicate framebuffers textured onto themselves. This fixes #2917. I verified that, at least for my card, blitting is much faster than glReadPixels (by quite a margin.)
2014-01-20 01:28:11 +00:00
textureCache_.SetFramebufferManager(&framebufferManager_);
Initial work on depalettization.
2014-03-29 20:58:38 +00:00
textureCache_.SetDepalShaderCache(&depalShaderCache_);
Disable vertex arrays before depal as well.
2014-06-01 01:55:00 +00:00
textureCache_.SetShaderManager(shaderManager_);
Make GLES_GPU own texturecache
2013-01-30 19:40:26 +00:00
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
// Sanity check gstate
if ((int *)&gstate.transferstart - (int *)&gstate != 0xEA) {
ERROR_LOG(G3D, "gstate has drifted out of sync!");
}
More work and optimization. Still not quite there.
2012-12-21 20:49:09 +00:00
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
// Sanity check cmdInfo_ table - no dupes please
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
std::set<u8> dupeCheck;
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
memset(cmdInfo_, 0, sizeof(cmdInfo_));
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
for (size_t i = 0; i < ARRAY_SIZE(commandTable); i++) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
const u8 cmd = commandTable[i].cmd;
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
if (dupeCheck.find(cmd) != dupeCheck.end()) {
ERROR_LOG(G3D, "Command table Dupe: %02x (%i)", (int)cmd, (int)cmd);
} else {
dupeCheck.insert(cmd);
}
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
cmdInfo_[cmd].flags |= commandTable[i].flags;
cmdInfo_[cmd].func = commandTable[i].func;
if (!cmdInfo_[cmd].func) {
cmdInfo_[cmd].func = &GLES_GPU::ExecuteOpInternal;
Allow individual cmd funcs to be called. Rather than a single one, ExecuteOpInternal(). This allows less "huge switch" code organization, and will (once separated) also improve speed.
2014-04-16 14:54:19 +00:00
}
Don't log display lists, instead dump them on demand. Makes it fairly convenient to dump and look at display lists at run time on non windows platforms. Adding a menu item on Windows should be trivial.
2012-12-26 23:18:45 +00:00
}
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
// Find commands missing from the table.
for (int i = 0; i < 0xEF; i++) {
if (dupeCheck.find((u8)i) == dupeCheck.end()) {
ERROR_LOG(G3D, "Command missing from table: %02x (%i)", i, i);
}
More work and optimization. Still not quite there.
2012-12-21 20:49:09 +00:00
}
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
If bPrescaleUV is enabled, no need to flush on change of these params. Also disable the QCOM hint, not sure it does any good at all.
2013-10-09 08:44:12 +00:00
// No need to flush before the tex scale/offset commands if we are baking
// the tex scale/offset into the vertices anyway.
Prescale UV bugfixes
2013-10-09 21:09:16 +00:00
If bPrescaleUV is enabled, no need to flush on change of these params. Also disable the QCOM hint, not sure it does any good at all.
2013-10-09 08:44:12 +00:00
if (g_Config.bPrescaleUV) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
cmdInfo_[GE_CMD_TEXSCALEU].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXSCALEV].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETU].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETV].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
If bPrescaleUV is enabled, no need to flush on change of these params. Also disable the QCOM hint, not sure it does any good at all.
2013-10-09 08:44:12 +00:00
}
Simple unoptimized software skinning. Does not take advantage of the possible reduction in state changes yet.
2013-11-10 12:18:52 +00:00
if (g_Config.bSoftwareSkinning) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
cmdInfo_[GE_CMD_VERTEXTYPE].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
Simple unoptimized software skinning. Does not take advantage of the possible reduction in state changes yet.
2013-11-10 12:18:52 +00:00
}
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
BuildReportingInfo();
Fix issues with games that don't call sceDisplaySet mode. Add option to run without FBOs, may be useful on slow devices.
2012-11-20 09:59:23 +00:00
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
GLES_GPU::~GLES_GPU() {
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
framebufferManager_.DestroyAllFBOs();
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
shaderManager_->ClearCache(true);
Depalettize works at other resolutions than 1x. For some strange reason though if you change resolution in game it breaks.
2014-03-30 13:37:51 +00:00
depalShaderCache_.Clear();
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
delete shaderManager_;
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
}
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
// Let's avoid passing nulls into snprintf().
static const char *GetGLStringAlways(GLenum name) {
const GLubyte *value = glGetString(name);
if (!value)
return "?";
return (const char *)value;
}
// Needs to be called on GPU thread, not reporting thread.
void GLES_GPU::BuildReportingInfo() {
const char *glVendor = GetGLStringAlways(GL_VENDOR);
const char *glRenderer = GetGLStringAlways(GL_RENDERER);
const char *glVersion = GetGLStringAlways(GL_VERSION);
const char *glSlVersion = GetGLStringAlways(GL_SHADING_LANGUAGE_VERSION);
const char *glExtensions = GetGLStringAlways(GL_EXTENSIONS);
Allow the full features string to be logged.
2013-05-12 08:38:42 +00:00
char temp[16384];
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
snprintf(temp, sizeof(temp), "%s (%s %s), %s (extensions: %s)", glVersion, glVendor, glRenderer, glSlVersion, glExtensions);
Split out the GPU vendor and the full detail. This way we can sort things more easily.
2013-04-29 07:30:54 +00:00
reportingPrimaryInfo_ = glVendor;
reportingFullInfo_ = temp;
Update reporting as soon as the game boots. This way if it starts with "read framebuffers" but it's switched off, it will notice properly.
2014-02-15 23:18:01 +00:00
Reporting::UpdateConfig();
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
}
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
void GLES_GPU::DeviceLost() {
Update native with gl shutdown fix (helps orientation change). This also adds some logging that helped me figure things out.
2013-10-09 14:08:36 +00:00
ILOG("GLES_GPU: DeviceLost");
Add mutex locks around list management. This way we can safely execute lists on a separate thread.
2013-08-08 06:27:29 +00:00
// Should only be executed on the GL thread.
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
// Simply drop all caches and textures.
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
// FBOs appear to survive? Or no?
Update native with gl shutdown fix (helps orientation change). This also adds some logging that helped me figure things out.
2013-10-09 14:08:36 +00:00
// TransformDraw has registered as a GfxResourceHolder.
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
shaderManager_->ClearCache(false);
Make GLES_GPU own texturecache
2013-01-30 19:40:26 +00:00
textureCache_.Clear(false);
Depalettize works at other resolutions than 1x. For some strange reason though if you change resolution in game it breaks.
2014-03-30 13:37:51 +00:00
depalShaderCache_.Clear();
Wipe all FBOs on device lost. May help app switching issues on Android.
2013-06-11 09:28:41 +00:00
framebufferManager_.DeviceLost();
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
void GLES_GPU::InitClear() {
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
ScheduleEvent(GPU_EVENT_INIT_CLEAR);
}
void GLES_GPU::InitClearInternal() {
Minor fix to bool useNonBufferedRendering
2013-08-27 14:31:50 +00:00
bool useNonBufferedRendering = g_Config.iRenderingMode == FB_NON_BUFFERED_MODE;
if (useNonBufferedRendering) {
Enable color and depth buffer write before clearing.
2013-02-22 21:14:17 +00:00
glstate.depthWrite.set(GL_TRUE);
glstate.colorMask.set(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
Fix issues with games that don't call sceDisplaySet mode. Add option to run without FBOs, may be useful on slow devices.
2012-11-20 09:59:23 +00:00
glClearColor(0,0,0,1);
Always specify all buffers for clearing. Missing one hurst, one extra doesn't.
2013-01-14 18:26:10 +00:00
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
Fix issues with games that don't call sceDisplaySet mode. Add option to run without FBOs, may be useful on slow devices.
2012-11-20 09:59:23 +00:00
}
Add glViewport to cached gl state. Add a couple of missing VFPU ops.
2013-01-06 22:23:36 +00:00
glstate.viewport.set(0, 0, PSP_CoreParameter().pixelWidth, PSP_CoreParameter().pixelHeight);
Some reorg in preparation for FBO work
2012-11-19 20:23:29 +00:00
}
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Don't log display lists, instead dump them on demand. Makes it fairly convenient to dump and look at display lists at run time on non windows platforms. Adding a menu item on Windows should be trivial.
2012-12-26 23:18:45 +00:00
void GLES_GPU::DumpNextFrame() {
dumpNextFrame_ = true;
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
void GLES_GPU::BeginFrame() {
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
ScheduleEvent(GPU_EVENT_BEGIN_FRAME);
}
void GLES_GPU::BeginFrameInternal() {
VSync codepath only works on _WIN32 so only show it and check it there.
2013-10-27 13:09:46 +00:00
#ifdef _WIN32
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
// Turn off vsync when unthrottled
May fix Vsync broken previously
2013-08-06 15:08:57 +00:00
int desiredVSyncInterval = g_Config.bVSync ? 1 : 0;
Remove dead code.
2013-07-11 19:51:45 +00:00
if ((PSP_CoreParameter().unthrottle) || (PSP_CoreParameter().fpsLimit == 1))
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
desiredVSyncInterval = 0;
if (desiredVSyncInterval != lastVsync_) {
swap_control_tear doesn't seem to work out for our timing or something. Let's do regular vsync.
2013-08-24 09:53:54 +00:00
// Disabled EXT_swap_control_tear for now, it never seems to settle at the correct timing
// so it just keeps tearing. Not what I hoped for...
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
//if (false && gl_extensions.EXT_swap_control_tear) {
Use EXT_swap_control_tear when available to ensure that VSync never slows things down (tears instead if it can't keep up, better than stuttering)
2013-07-07 08:58:21 +00:00
// See http://developer.download.nvidia.com/opengl/specs/WGL_EXT_swap_control_tear.txt
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
// glstate.SetVSyncInterval(-desiredVSyncInterval);
//} else {
Use EXT_swap_control_tear when available to ensure that VSync never slows things down (tears instead if it can't keep up, better than stuttering)
2013-07-07 08:58:21 +00:00
glstate.SetVSyncInterval(desiredVSyncInterval);
Disable the adaptive vsync checks by commenting them out. No need to have a disabled check run every frame.
2014-03-25 00:15:41 +00:00
//}
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
lastVsync_ = desiredVSyncInterval;
}
VSync codepath only works on _WIN32 so only show it and check it there.
2013-10-27 13:09:46 +00:00
#endif
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
Make GLES_GPU own texturecache
2013-01-30 19:40:26 +00:00
textureCache_.StartFrame();
Defer vertex decoding until flush. Track draw calls so that they can be cached later.
2013-01-19 16:05:08 +00:00
transformDraw_.DecimateTrackedVertexArrays();
Add basic decimation to the depal clut cache.
2014-05-31 20:08:17 +00:00
depalShaderCache_.Decimate();
Delete old textures, to prevent memory usage from growing indefinitely.
2012-11-22 22:07:15 +00:00
Don't log display lists, instead dump them on demand. Makes it fairly convenient to dump and look at display lists at run time on non windows platforms. Adding a menu item on Windows should be trivial.
2012-12-26 23:18:45 +00:00
if (dumpNextFrame_) {
NOTICE_LOG(G3D, "DUMPING THIS FRAME");
dumpThisFrame_ = true;
dumpNextFrame_ = false;
} else if (dumpThisFrame_) {
dumpThisFrame_ = false;
}
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
shaderManager_->DirtyShader();
// Not sure if this is really needed.
shaderManager_->DirtyUniform(DIRTY_ALL);
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
framebufferManager_.BeginFrame();
Some reorg in preparation for FBO work
2012-11-19 20:23:29 +00:00
}
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Consistently use a proper type for GE fb format.
2013-07-30 06:05:59 +00:00
void GLES_GPU::SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) {
Add GPU debugging hooks to Host, not yet in use.
2013-09-22 07:18:46 +00:00
host->GPUNotifyDisplay(framebuf, stride, format);
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
framebufferManager_.SetDisplayFramebuffer(framebuf, stride, format);
Some reorg in preparation for FBO work
2012-11-19 20:23:29 +00:00
}
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Make un-buffered rendering much smarter, removing flicker. This turns it into a very viable option for many games. You do lose some FX but it can as a result even be used as a workaround for the massive glow in Wipeout...
2013-03-03 12:00:21 +00:00
bool GLES_GPU::FramebufferDirty() {
Temporary fix issue #3167 in non-multithread mode #1
2013-08-14 19:43:40 +00:00
if (g_Config.bSeparateCPUThread) {
// Allow it to process fully before deciding if it's dirty.
SyncThread();
}
SyncThread before deciding if the fbo is dirty. Fixes fps drops in yet other games with multithreading enabled.
2013-08-11 01:45:07 +00:00
Track copies of framebuffers in ram created through sceDmacMemcpy, so that we can display them. Fixes MotoGP while also, in effect, committing #3859. Removes the horrifying ramDisplayFramebufferPtr hack.
2013-09-21 16:52:30 +00:00
VirtualFramebuffer *vfb = framebufferManager_.GetDisplayVFB();
Another frameskipping attempt. Now: 0=no frameskip, 1=auto frameskipt, 2-9=fixed frameskip. There is still some flicker remaining in non-buffered rendering that I can't seem to get rid off.
2013-08-15 23:00:26 +00:00
if (vfb) {
bool dirty = vfb->dirtyAfterDisplay;
vfb->dirtyAfterDisplay = false;
return dirty;
}
return true;
}
bool GLES_GPU::FramebufferReallyDirty() {
if (g_Config.bSeparateCPUThread) {
// Allow it to process fully before deciding if it's dirty.
SyncThread();
}
Track copies of framebuffers in ram created through sceDmacMemcpy, so that we can display them. Fixes MotoGP while also, in effect, committing #3859. Removes the horrifying ramDisplayFramebufferPtr hack.
2013-09-21 16:52:30 +00:00
VirtualFramebuffer *vfb = framebufferManager_.GetDisplayVFB();
Another frameskipping attempt. Now: 0=no frameskip, 1=auto frameskipt, 2-9=fixed frameskip. There is still some flicker remaining in non-buffered rendering that I can't seem to get rid off.
2013-08-15 23:00:26 +00:00
if (vfb) {
bool dirty = vfb->reallyDirtyAfterDisplay;
vfb->reallyDirtyAfterDisplay = false;
return dirty;
}
Make un-buffered rendering much smarter, removing flicker. This turns it into a very viable option for many games. You do lose some FX but it can as a result even be used as a workaround for the massive glow in Wipeout...
2013-03-03 12:00:21 +00:00
return true;
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
void GLES_GPU::CopyDisplayToOutput() {
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
ScheduleEvent(GPU_EVENT_COPY_DISPLAY_TO_OUTPUT);
}
void GLES_GPU::CopyDisplayToOutputInternal() {
Flush draws before doing any block transfers. Otherwise, we might flush on top, or we might download the wrong thing.
2014-06-11 07:28:28 +00:00
// Flush anything left over.
Fix graphical artifact in Jeanne d'Arc world map. We need to use the last set render framebuffer, not the current one at copy to output.
2014-06-11 07:54:54 +00:00
framebufferManager_.RebindFramebuffer();
Flush draws before doing any block transfers. Otherwise, we might flush on top, or we might download the wrong thing.
2014-06-11 07:28:28 +00:00
transformDraw_.Flush();
Fix in-game flickering in Dissidia Final Fantasy
2013-04-02 22:28:09 +00:00
glstate.depthWrite.set(GL_TRUE);
glstate.colorMask.set(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
framebufferManager_.CopyDisplayToOutput();
Make un-buffered rendering much smarter, removing flicker. This turns it into a very viable option for many games. You do lose some FX but it can as a result even be used as a workaround for the massive glow in Wipeout...
2013-03-03 12:00:21 +00:00
framebufferManager_.EndFrame();
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
Must reset lastShader after swtiching shaders outside the "framework".
2013-10-10 18:11:20 +00:00
shaderManager_->DirtyLastShader();
Don't "DirtyShader" at the end of frame, instead just "stop". Fixes issues caused by vertex arrays left enabled still hanging around.
2013-04-07 21:31:04 +00:00
Update native + some very minor changes
2013-07-26 22:44:16 +00:00
// If buffered, discard the depth buffer of the backbuffer. Don't even know if we need one.
#if 0
#ifdef USING_GLES2
if (gl_extensions.EXT_discard_framebuffer && g_Config.iRenderingMode != 0) {
GLenum attachments[] = {GL_DEPTH_EXT, GL_STENCIL_EXT};
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 2, attachments);
}
#endif
#endif
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
}
Use the EXECUTE flag to avoid calling ExecuteOp when possible. Minor speedup.
2013-08-23 12:22:26 +00:00
// Maybe should write this in ASM...
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
void GLES_GPU::FastRunLoop(DisplayList &list) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
const CommandInfo *cmdInfo = cmdInfo_;
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
for (; downcount > 0; --downcount) {
Tiny optimization (32-bit) in GLES_GPU::FastRunLoop
2013-11-07 00:34:43 +00:00
// We know that display list PCs have the upper nibble == 0 - no need to mask the pointer
const u32 op = *(const u32 *)(Memory::base + list.pc);
Avoid some dereferencing in gpu FastRunLoop.
2013-11-06 15:50:16 +00:00
const u32 cmd = op >> 24;
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
const CommandInfo info = cmdInfo[cmd];
const u8 cmdFlags = info.flags; // If we stashed the cmdFlags in the top bits of the cmdmem, we could get away with one table lookup instead of two
Avoid some dereferencing in gpu FastRunLoop.
2013-11-06 15:50:16 +00:00
const u32 diff = op ^ gstate.cmdmem[cmd];
Another frameskipping attempt. Now: 0=no frameskip, 1=auto frameskipt, 2-9=fixed frameskip. There is still some flicker remaining in non-buffered rendering that I can't seem to get rid off.
2013-08-15 23:00:26 +00:00
// Inlined CheckFlushOp here to get rid of the dumpThisFrame_ check.
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
if ((cmdFlags & FLAG_FLUSHBEFORE) || (diff && (cmdFlags & FLAG_FLUSHBEFOREONCHANGE))) {
Another frameskipping attempt. Now: 0=no frameskip, 1=auto frameskipt, 2-9=fixed frameskip. There is still some flicker remaining in non-buffered rendering that I can't seem to get rid off.
2013-08-15 23:00:26 +00:00
transformDraw_.Flush();
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
}
Don't reconvert light colors if they don't change. Also prepare for a possible further optimization in GLES_GPU::FastRunLoop
2013-11-10 10:18:58 +00:00
gstate.cmdmem[cmd] = op; // TODO: no need to write if diff==0...
Use the FLAG_EXECUTEONCHANGE flag. Improves fps by 1-3% in some games, seems to be a win after all.
2014-04-13 17:23:21 +00:00
if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
(this->*info.func)(op, diff);
Tiny optimization (32-bit) in GLES_GPU::FastRunLoop
2013-11-07 00:34:43 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
list.pc += 4;
}
}
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
void GLES_GPU::ProcessEvent(GPUEvent ev) {
switch (ev.type) {
case GPU_EVENT_INIT_CLEAR:
InitClearInternal();
break;
case GPU_EVENT_BEGIN_FRAME:
BeginFrameInternal();
break;
case GPU_EVENT_COPY_DISPLAY_TO_OUTPUT:
CopyDisplayToOutputInternal();
break;
case GPU_EVENT_INVALIDATE_CACHE:
InvalidateCacheInternal(ev.invalidate_cache.addr, ev.invalidate_cache.size, ev.invalidate_cache.type);
break;
Schedule the FBO blit during multithreading. This was it's properly ordered with draws, and it runs on the right GL context.
2014-05-26 05:08:15 +00:00
case GPU_EVENT_FB_MEMCPY:
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
PerformMemoryCopyInternal(ev.fb_memcpy.dst, ev.fb_memcpy.src, ev.fb_memcpy.size);
break;
case GPU_EVENT_FB_MEMSET:
PerformMemorySetInternal(ev.fb_memset.dst, ev.fb_memset.v, ev.fb_memset.size);
Schedule the FBO blit during multithreading. This was it's properly ordered with draws, and it runs on the right GL context.
2014-05-26 05:08:15 +00:00
break;
Implement a very basic stencil upload. This is not fast or efficient, but works.
2014-06-01 01:24:35 +00:00
case GPU_EVENT_FB_STENCIL_UPLOAD:
PerformStencilUploadInternal(ev.fb_stencil_upload.dst, ev.fb_stencil_upload.size);
break;
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
default:
Factor out event queue logic to a template mixin.
2013-08-10 10:33:09 +00:00
GPUCommon::ProcessEvent(ev);
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
}
}
GPU: tiny optimization and log fix
2013-08-06 17:08:38 +00:00
inline void GLES_GPU::CheckFlushOp(int cmd, u32 diff) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
const u8 cmdFlags = cmdInfo_[cmd].flags;
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
if ((cmdFlags & FLAG_FLUSHBEFORE) || (diff && (cmdFlags & FLAG_FLUSHBEFOREONCHANGE))) {
GPU "dirty" optimization, wip vertexcache
2013-01-20 12:15:46 +00:00
if (dumpThisFrame_) {
More log categories, use them (and existing ones). Improve log config.
2013-09-07 20:02:55 +00:00
NOTICE_LOG(G3D, "================ FLUSH ================");
GPU "dirty" optimization, wip vertexcache
2013-01-20 12:15:46 +00:00
}
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
transformDraw_.Flush();
GPU "dirty" optimization, wip vertexcache
2013-01-20 12:15:46 +00:00
}
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
void GLES_GPU::PreExecuteOp(u32 op, u32 diff) {
GPU: tiny optimization and log fix
2013-08-06 17:08:38 +00:00
CheckFlushOp(op >> 24, diff);
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
void GLES_GPU::ExecuteOp(u32 op, u32 diff) {
Use the FLAG_EXECUTEONCHANGE flag. Improves fps by 1-3% in some games, seems to be a win after all.
2014-04-13 17:23:21 +00:00
const u8 cmd = op >> 24;
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
const CommandInfo info = cmdInfo_[cmd];
const u8 cmdFlags = info.flags;
Use the FLAG_EXECUTEONCHANGE flag. Improves fps by 1-3% in some games, seems to be a win after all.
2014-04-13 17:23:21 +00:00
if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) {
Keep flags and func together. Seems not to make a big difference, though.
2014-04-17 08:36:24 +00:00
(this->*info.func)(op, diff);
Use the FLAG_EXECUTEONCHANGE flag. Improves fps by 1-3% in some games, seems to be a win after all.
2014-04-13 17:23:21 +00:00
}
Avoid some dereferencing in gpu FastRunLoop.
2013-11-06 15:50:16 +00:00
}
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
void GLES_GPU::Execute_Vaddr(u32 op, u32 diff) {
gstate_c.vertexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
void GLES_GPU::Execute_Iaddr(u32 op, u32 diff) {
gstate_c.indexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
void GLES_GPU::Execute_Prim(u32 op, u32 diff) {
// This drives all drawing. All other state we just buffer up, then we apply it only
// when it's time to draw. As most PSP games set state redundantly ALL THE TIME, this is a huge optimization.
u32 data = op & 0xFFFFFF;
u32 count = data & 0xFFFF;
GEPrimitiveType prim = static_cast<GEPrimitiveType>(data >> 16);
if (count == 0)
return;
// Discard AA lines as we can't do anything that makes sense with these anyway. The SW plugin might, though.
if (gstate.isAntiAliasEnabled()) {
// Discard AA lines in DOA
if (prim == GE_PRIM_LINE_STRIP)
return;
// Discard AA lines in Summon Night 5
if ((prim == GE_PRIM_LINES) && gstate.isSkinningEnabled())
return;
}
// This also make skipping drawing very effective.
framebufferManager_.SetRenderFrameBuffer();
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
transformDraw_.SetupVertexDecoder(gstate.vertType);
// Rough estimate, not sure what's correct.
int vertexCost = transformDraw_.EstimatePerVertexCost();
cyclesExecuted += vertexCost * count;
return;
}
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
// TODO: Split this so that we can collect sequences of primitives, can greatly speed things up
// on platforms where draw calls are expensive like mobile and D3D
void *verts = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
void *inds = 0;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
if (!Memory::IsValidAddress(gstate_c.indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);
return;
}
inds = Memory::GetPointerUnchecked(gstate_c.indexAddr);
}
#ifndef MOBILE_DEVICE
if (prim > GE_PRIM_RECTANGLES) {
ERROR_LOG_REPORT_ONCE(reportPrim, G3D, "Unexpected prim type: %d", prim);
}
#endif
Note that VADDR/IADDR are not updated on PRIM. Even though they do increase the addresses, they don't affect the CMD registers. Also, make sure not to use a crazy bytesRead for a zero-sized prim.
2014-05-05 01:24:49 +00:00
int bytesRead = 0;
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
transformDraw_.SubmitPrim(verts, inds, prim, count, gstate.vertType, &bytesRead);
int vertexCost = transformDraw_.EstimatePerVertexCost();
gpuStats.vertexGPUCycles += vertexCost * count;
cyclesExecuted += vertexCost * count;
// After drawing, we advance the vertexAddr (when non indexed) or indexAddr (when indexed).
// Some games rely on this, they don't bother reloading VADDR and IADDR.
Note that VADDR/IADDR are not updated on PRIM. Even though they do increase the addresses, they don't affect the CMD registers. Also, make sure not to use a crazy bytesRead for a zero-sized prim.
2014-05-05 01:24:49 +00:00
// The VADDR/IADDR registers are NOT updated.
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
if (inds) {
int indexSize = 1;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT)
indexSize = 2;
gstate_c.indexAddr += count * indexSize;
} else {
gstate_c.vertexAddr += bytesRead;
}
}
void GLES_GPU::Execute_VertexType(u32 op, u32 diff) {
if (!g_Config.bSoftwareSkinning) {
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
} else {
// Don't flush when weight count changes, unless morph is enabled.
if ((diff & ~GE_VTYPE_WEIGHTCOUNT_MASK) || (op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
// Restore and flush
gstate.vertType ^= diff;
Flush();
gstate.vertType ^= diff;
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
}
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
void GLES_GPU::Execute_Bezier(u32 op, u32 diff) {
// This also make skipping drawing very effective.
framebufferManager_.SetRenderFrameBuffer();
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// TODO: Should this eat some cycles? Probably yes. Not sure if important.
return;
}
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
void *indices = NULL;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
if (!Memory::IsValidAddress(gstate_c.indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);
return;
}
indices = Memory::GetPointerUnchecked(gstate_c.indexAddr);
}
if (gstate.getPatchPrimitiveType() != GE_PATCHPRIM_TRIANGLES) {
ERROR_LOG_REPORT(G3D, "Unsupported patch primitive %x", gstate.getPatchPrimitiveType());
return;
}
if (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) {
DEBUG_LOG_REPORT(G3D, "Bezier + morph: %i", (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT);
}
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Bezier + skinning: %i", vertTypeGetNumBoneWeights(gstate.vertType));
}
GEPatchPrimType patchPrim = gstate.getPatchPrimitiveType();
int bz_ucount = op & 0xFF;
int bz_vcount = (op >> 8) & 0xFF;
transformDraw_.SubmitBezier(control_points, indices, bz_ucount, bz_vcount, patchPrim, gstate.vertType);
}
void GLES_GPU::Execute_Spline(u32 op, u32 diff) {
// This also make skipping drawing very effective.
framebufferManager_.SetRenderFrameBuffer();
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// TODO: Should this eat some cycles? Probably yes. Not sure if important.
return;
}
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
void *indices = NULL;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
if (!Memory::IsValidAddress(gstate_c.indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);
return;
}
indices = Memory::GetPointerUnchecked(gstate_c.indexAddr);
}
if (gstate.getPatchPrimitiveType() != GE_PATCHPRIM_TRIANGLES) {
ERROR_LOG_REPORT(G3D, "Unsupported patch primitive %x", gstate.getPatchPrimitiveType());
return;
}
if (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) {
DEBUG_LOG_REPORT(G3D, "Spline + morph: %i", (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT);
}
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Spline + skinning: %i", vertTypeGetNumBoneWeights(gstate.vertType));
}
int sp_ucount = op & 0xFF;
int sp_vcount = (op >> 8) & 0xFF;
int sp_utype = (op >> 16) & 0x3;
int sp_vtype = (op >> 18) & 0x3;
GEPatchPrimType patchPrim = gstate.getPatchPrimitiveType();
transformDraw_.SubmitSpline(control_points, indices, sp_ucount, sp_vcount, sp_utype, sp_vtype, patchPrim, gstate.vertType);
}
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
void GLES_GPU::Execute_BoundingBox(u32 op, u32 diff) {
// Just resetting, nothing to bound.
const u32 data = op & 0x00FFFFFF;
if (data == 0) {
// TODO: Should this set the bboxResult? Let's set it true for now.
currentList->bboxResult = true;
return;
}
if (((data & 7) == 0) && data <= 64) { // Sanity check
void *control_points = Memory::GetPointer(gstate_c.vertexAddr);
if (gstate.vertType & GE_VTYPE_IDX_MASK) {
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Indexed bounding box data not supported.");
// Data seems invalid. Let's assume the box test passed.
currentList->bboxResult = true;
return;
}
// Test if the bounding box is within the drawing region.
currentList->bboxResult = transformDraw_.TestBoundingBox(control_points, data, gstate.vertType);
} else {
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Bad bounding box data: %06x", data);
// Data seems invalid. Let's assume the box test passed.
currentList->bboxResult = true;
}
}
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
void GLES_GPU::Execute_Region(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
void GLES_GPU::Execute_Scissor(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Move out texformat as well.
2014-04-17 15:29:44 +00:00
void GLES_GPU::Execute_FramebufType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Split out viewport type commands.
2014-04-18 05:49:09 +00:00
void GLES_GPU::Execute_ViewportType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
void GLES_GPU::Execute_TexScaleU(u32 op, u32 diff) {
gstate_c.uv.uScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GLES_GPU::Execute_TexScaleV(u32 op, u32 diff) {
gstate_c.uv.vScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GLES_GPU::Execute_TexOffsetU(u32 op, u32 diff) {
gstate_c.uv.uOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GLES_GPU::Execute_TexOffsetV(u32 op, u32 diff) {
gstate_c.uv.vOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
void GLES_GPU::Execute_TexAddr0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
void GLES_GPU::Execute_TexAddrN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void GLES_GPU::Execute_TexBufw0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
void GLES_GPU::Execute_TexBufwN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
void GLES_GPU::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) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
}
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
void GLES_GPU::Execute_TexSizeN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Move out texformat as well.
2014-04-17 15:29:44 +00:00
void GLES_GPU::Execute_TexFormat(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
void GLES_GPU::Execute_TexMapMode(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void GLES_GPU::Execute_TexParamType(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Move out texformat as well.
2014-04-17 15:29:44 +00:00
void GLES_GPU::Execute_TexEnvColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_TEXENV);
}
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
void GLES_GPU::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.textureChanged |= TEXCHANGE_PARAMSONLY;
}
Move out texformat as well.
2014-04-17 15:29:44 +00:00
void GLES_GPU::Execute_LoadClut(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
textureCache_.LoadClut();
// This could be used to "dirty" textures with clut.
}
Split out the clutformat cmd as well.
2014-04-18 05:57:02 +00:00
void GLES_GPU::Execute_ClutFormat(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
// This could be used to "dirty" textures with clut.
}
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
void GLES_GPU::Execute_Ambient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
}
void GLES_GPU::Execute_MaterialDiffuse(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
}
void GLES_GPU::Execute_MaterialEmissive(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
}
void GLES_GPU::Execute_MaterialAmbient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
}
void GLES_GPU::Execute_MaterialSpecular(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
}
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
void GLES_GPU::Execute_Light0Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
}
void GLES_GPU::Execute_Light1Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
}
void GLES_GPU::Execute_Light2Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
}
void GLES_GPU::Execute_Light3Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
}
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
void GLES_GPU::Execute_FogColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
}
void GLES_GPU::Execute_FogCoef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
}
Fix uniform dirtying on colortest mask.
2014-04-22 05:53:19 +00:00
void GLES_GPU::Execute_ColorTestMask(u32 op, u32 diff) {
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
shaderManager_->DirtyUniform(DIRTY_COLORMASK);
}
void GLES_GPU::Execute_AlphaTest(u32 op, u32 diff) {
#ifndef MOBILE_DEVICE
if (((op >> 16) & 0xFF) != 0xFF && (op & 7) > 1)
WARN_LOG_REPORT_ONCE(alphatestmask, G3D, "Unsupported alphatest mask: %02x", (op >> 16) & 0xFF);
#endif
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
}
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
void GLES_GPU::Execute_StencilTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);
}
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
void GLES_GPU::Execute_ColorRef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
}
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
void GLES_GPU::Execute_WorldMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_WORLDMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointer(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.worldMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_WORLDMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GLES_GPU::Execute_WorldMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.worldmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) {
Flush();
((u32 *)gstate.worldMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
}
num++;
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0xF);
}
void GLES_GPU::Execute_ViewMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_VIEWMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointer(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.viewMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_VIEWMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GLES_GPU::Execute_ViewMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.viewmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) {
Flush();
((u32 *)gstate.viewMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
}
num++;
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0xF);
}
void GLES_GPU::Execute_ProjMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_PROJMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointer(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.projMatrix + (op & 0xF));
const int end = 16 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_PROJMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GLES_GPU::Execute_ProjMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.projmtxnum & 0xF;
u32 newVal = op << 8;
if (newVal != ((const u32 *)gstate.projMatrix)[num]) {
Flush();
((u32 *)gstate.projMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
}
num++;
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0xF);
}
void GLES_GPU::Execute_TgenMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_TGENMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointer(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.tgenMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_TGENMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GLES_GPU::Execute_TgenMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.texmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) {
Flush();
((u32 *)gstate.tgenMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
}
num++;
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0xF);
}
void GLES_GPU::Execute_BoneMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_BONEMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointer(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.boneMatrix + (op & 0x7F));
const int end = 12 * 8 - (op & 0x7F);
int i = 0;
// If we can't use software skinning, we have to flush and dirty.
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
}
if (++i >= end) {
break;
}
}
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
}
} else {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
dst[i] = src[i] << 8;
if (++i >= end) {
break;
}
}
}
const int count = i;
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | ((op + count) & 0x7F);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GLES_GPU::Execute_BoneMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.boneMatrixNumber & 0x7F;
u32 newVal = op << 8;
if (num < 96 && newVal != ((const u32 *)gstate.boneMatrix)[num]) {
// 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));
}
((u32 *)gstate.boneMatrix)[num] = newVal;
}
num++;
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x7F);
}
Move out block transfer too, common in GoW.
2014-04-17 15:05:16 +00:00
void GLES_GPU::Execute_BlockTransferStart(u32 op, u32 diff) {
// TODO: Here we should check if the transfer overlaps a framebuffer or any textures,
// and take appropriate action. This is a block transfer between RAM and VRAM, or vice versa.
// Can we skip this on SkipDraw?
DoBlockTransfer();
// Fixes Gran Turismo's funky text issue, since it overwrites the current texture.
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
Avoid some dereferencing in gpu FastRunLoop.
2013-11-06 15:50:16 +00:00
void GLES_GPU::ExecuteOpInternal(u32 op, u32 diff) {
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
u32 cmd = op >> 24;
u32 data = op & 0xFFFFFF;
// Handle control and drawing commands here directly. The others we delegate.
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
switch (cmd) {
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_BASE:
break;
Seems vertex/index addresses should be computed through the same mechanism as jumps. Gets rid of bad vertex address messages in Sol Trigger.
2013-02-02 22:47:35 +00:00
case GE_CMD_VADDR:
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Execute_Vaddr(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_IADDR:
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Execute_Iaddr(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_PRIM:
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Execute_Prim(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
// The arrow and other rotary items in Puzbob are bezier patches, strangely enough.
case GE_CMD_BEZIER:
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
Execute_Bezier(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_SPLINE:
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
Execute_Spline(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_BOUNDINGBOX:
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
Execute_BoundingBox(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_VERTEXTYPE:
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Execute_VertexType(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_REGION1:
case GE_CMD_REGION2:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_Region(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_CLIPENABLE:
//we always clip, this is opengl
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_CULLFACEENABLE:
Add !(gstate.zmsk & 1); to depthMask and remove duplicate GE_CMD_MATERIALUPDATE (exists in line69)
2013-02-24 05:48:09 +00:00
case GE_CMD_CULL:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_TEXTUREMAPENABLE:
Don't dirty the texture on texmapenable. Tales of Phantasia X flips on and off texturing during battle transitions. This causes tons of needless rehashes.
2014-04-13 20:01:18 +00:00
// Don't need to dirty the texture here, already dirtied at list start/etc.
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_LIGHTINGENABLE:
break;
Fix fog and stencil buffer clearing. The latter fixes the sky in MotoGP.
2013-01-14 19:43:18 +00:00
case GE_CMD_FOGCOLOR:
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
Execute_FogColor(op, diff);
Fix fog and stencil buffer clearing. The latter fixes the sky in MotoGP.
2013-01-14 19:43:18 +00:00
break;
case GE_CMD_FOG1:
case GE_CMD_FOG2:
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
Execute_FogCoef(op, diff);
Fix fog and stencil buffer clearing. The latter fixes the sky in MotoGP.
2013-01-14 19:43:18 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_FOGENABLE:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_DITHERENABLE:
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_OFFSETX:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_OFFSETY:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
case GE_CMD_TEXSCALEU:
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
Execute_TexScaleU(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
case GE_CMD_TEXSCALEV:
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
Execute_TexScaleV(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
case GE_CMD_TEXOFFSETU:
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
Execute_TexOffsetU(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
case GE_CMD_TEXOFFSETV:
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
Execute_TexOffsetV(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_SCISSOR1:
case GE_CMD_SCISSOR2:
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
Execute_Scissor(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Remove some unused gstate_c values.
2013-09-14 21:33:55 +00:00
///
Handle depth range (zmin, zmax) in a hackish way
2012-11-24 23:15:21 +00:00
case GE_CMD_MINZ:
case GE_CMD_MAXZ:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_FRAMEBUFPTR:
case GE_CMD_FRAMEBUFWIDTH:
case GE_CMD_FRAMEBUFPIXFORMAT:
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Execute_FramebufType(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_TEXADDR0:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_TexAddr0(op, diff);
Don't check diff in ExecuteOpInternal(). Since it's not called if !diff, there's no need. Small performance improvement.
2014-04-13 17:25:14 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
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:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_TexAddrN(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_TEXBUFWIDTH0:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_TexBufw0(op, diff);
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
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:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_TexBufwN(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Group GE_CMD_CLUTFORMAT
2013-02-23 18:05:06 +00:00
case GE_CMD_CLUTFORMAT:
Split out the clutformat cmd as well.
2014-04-18 05:57:02 +00:00
Execute_ClutFormat(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Small optimizations
2013-11-11 23:18:49 +00:00
case GE_CMD_CLUTADDR:
case GE_CMD_CLUTADDRUPPER:
// Hm, LOADCLUT actually changes the CLUT so no need to dirty here.
break;
Load the clut only using LOADCLUT, not every tex. This is a small optimization, and should match PSP behavior better. It also allows us to hash the clut and convert colors less often.
2013-05-11 22:45:17 +00:00
case GE_CMD_LOADCLUT:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_LoadClut(op, diff);
Load the clut only using LOADCLUT, not every tex. This is a small optimization, and should match PSP behavior better. It also allows us to hash the clut and convert colors less often.
2013-05-11 22:45:17 +00:00
break;
Add experimental wireframe mode for debugging. Fix texenv color. Code cleanup.
2012-12-19 14:14:41 +00:00
case GE_CMD_TEXMAPMODE:
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
Execute_TexMapMode(op, diff);
Cheap HW transform solution for raven02's texture scaling fix.
2013-07-09 23:22:15 +00:00
break;
Add experimental wireframe mode for debugging. Fix texenv color. Code cleanup.
2012-12-19 14:14:41 +00:00
case GE_CMD_TEXSHADELS:
break;
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
case GE_CMD_TRANSFERSRC:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_TRANSFERSRCW:
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
case GE_CMD_TRANSFERDST:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_TRANSFERDSTW:
case GE_CMD_TRANSFERSRCPOS:
case GE_CMD_TRANSFERDSTPOS:
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_TRANSFERSIZE:
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Bug fixing mtv/mfv, add comment
2012-11-22 19:14:24 +00:00
case GE_CMD_TRANSFERSTART: // Orphis calls this TRXKICK
Move out block transfer too, common in GoW.
2014-04-17 15:05:16 +00:00
Execute_BlockTransferStart(op, diff);
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_TEXSIZE0:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_TexSize0(op, diff);
Don't check diff in ExecuteOpInternal(). Since it's not called if !diff, there's no need. Small performance improvement.
2014-04-13 17:25:14 +00:00
break;
Don't reconvert light colors if they don't change. Also prepare for a possible further optimization in GLES_GPU::FastRunLoop
2013-11-10 10:18:58 +00:00
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
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:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_TexSizeN(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_ZBUFPTR:
case GE_CMD_ZBUFWIDTH:
break;
case GE_CMD_AMBIENTCOLOR:
case GE_CMD_AMBIENTALPHA:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_Ambient(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_MATERIALDIFFUSE:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_MaterialDiffuse(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_MATERIALEMISSIVE:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_MaterialEmissive(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Consolidate DIRTY_MATAMBIENTALPHA/DIRTY_MATSPECULAR
2013-04-20 14:46:25 +00:00
case GE_CMD_MATERIALAMBIENT:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_MATERIALALPHA:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_MaterialAmbient(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Consolidate DIRTY_MATAMBIENTALPHA/DIRTY_MATSPECULAR
2013-04-20 14:46:25 +00:00
case GE_CMD_MATERIALSPECULAR:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_MATERIALSPECULARCOEF:
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
Execute_MaterialSpecular(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
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:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
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:
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
Execute_Light0Param(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
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:
Add support for spotlights
2013-04-09 16:25:22 +00:00
case GE_CMD_LKS1:
case GE_CMD_LKO1:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LAC1:
case GE_CMD_LDC1:
case GE_CMD_LSC1:
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
Execute_Light1Param(op, diff);
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
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:
Add support for spotlights
2013-04-09 16:25:22 +00:00
case GE_CMD_LKO2:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LAC2:
case GE_CMD_LDC2:
case GE_CMD_LSC2:
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
Execute_Light2Param(op, diff);
Add support for spotlights
2013-04-09 16:25:22 +00:00
break;
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
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:
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
Execute_Light3Param(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_VIEWPORTX1:
case GE_CMD_VIEWPORTY1:
case GE_CMD_VIEWPORTX2:
case GE_CMD_VIEWPORTY2:
Handle depth range (zmin, zmax) in a hackish way
2012-11-24 23:15:21 +00:00
case GE_CMD_VIEWPORTZ1:
case GE_CMD_VIEWPORTZ2:
Split out viewport type commands.
2014-04-18 05:49:09 +00:00
Execute_ViewportType(op, diff);
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_LIGHTENABLE0:
case GE_CMD_LIGHTENABLE1:
case GE_CMD_LIGHTENABLE2:
case GE_CMD_LIGHTENABLE3:
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
Some misc GE constant renames / disasm
2013-02-02 12:40:26 +00:00
case GE_CMD_SHADEMODE:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_PATCHDIVISION:
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_PATCHPRIMITIVE:
case GE_CMD_PATCHFACING:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_MATERIALUPDATE:
break;
//////////////////////////////////////////////////////////////////
// CLEARING
//////////////////////////////////////////////////////////////////
case GE_CMD_CLEARMODE:
break;
//////////////////////////////////////////////////////////////////
// ALPHA BLENDING
//////////////////////////////////////////////////////////////////
case GE_CMD_ALPHABLENDENABLE:
case GE_CMD_BLENDMODE:
Apply unsupported blending modes in the shader. This handles unsupported fixed color combinations, alpha doubling, etc. Where possible, tries to avoid it - it means using a blit (without the framebuffer fetch extension), which can slow things down a lot with tons of drawcalls.
2014-05-11 16:51:35 +00:00
break;
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_BLENDFIXEDA:
case GE_CMD_BLENDFIXEDB:
break;
case GE_CMD_ALPHATESTENABLE:
Fix fog and stencil buffer clearing. The latter fixes the sky in MotoGP.
2013-01-14 19:43:18 +00:00
case GE_CMD_COLORTESTENABLE:
Add DirtyUniform(DIRTY_COLORMASK)
2013-02-24 21:59:53 +00:00
// They are done in the fragment shader.
break;
Add !(gstate.zmsk & 1); to depthMask and remove duplicate GE_CMD_MATERIALUPDATE (exists in line69)
2013-02-24 05:48:09 +00:00
case GE_CMD_COLORTEST:
Fix uniform dirtying on colortest mask.
2014-04-22 05:53:19 +00:00
break;
Add !(gstate.zmsk & 1); to depthMask and remove duplicate GE_CMD_MATERIALUPDATE (exists in line69)
2013-02-24 05:48:09 +00:00
case GE_CMD_COLORTESTMASK:
Fix uniform dirtying on colortest mask.
2014-04-22 05:53:19 +00:00
Execute_ColorTestMask(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
case GE_CMD_ALPHATEST:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_AlphaTest(op, diff);
Don't check diff in ExecuteOpInternal(). Since it's not called if !diff, there's no need. Small performance improvement.
2014-04-13 17:25:14 +00:00
break;
Combine and sort the GPU command tables by purpose, make it flags for future flexibility. Fix a couple of bugs while at it (logic ops were not flushing, if viewport was partially changed, it might not take).
2013-08-23 11:35:23 +00:00
Add reporting for alphatest mask. Actually, maybe it being 0x00 could be advantageous...
2013-05-11 05:51:23 +00:00
case GE_CMD_COLORREF:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_ColorRef(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
case GE_CMD_TEXENVCOLOR:
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
Execute_TexEnvColor(op, diff);
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_TEXFUNC:
Assorted GPU fixes: Advance vertex pointer, fixes missing triangles in SPT. More logging. Separate proj matrices for through and normal mode (through matrix don't need to get updated as often). Some cleanup.
2012-11-28 12:45:22 +00:00
case GE_CMD_TEXFLUSH:
Set gstate_c.textureChanged = true; and | FLAG_EXECUTE for GE_CMD_TEXWRAP
2013-09-23 12:49:24 +00:00
break;
Flag the texture on format/swizzle change.
2013-09-23 15:08:06 +00:00
case GE_CMD_TEXFORMAT:
Move out texformat as well.
2014-04-17 15:29:44 +00:00
Execute_TexFormat(op, diff);
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
break;
case GE_CMD_TEXMODE:
Set gstate_c.textureChanged = true; and | FLAG_EXECUTE for GE_CMD_TEXWRAP
2013-09-23 12:49:24 +00:00
case GE_CMD_TEXFILTER:
Assorted GPU fixes: Advance vertex pointer, fixes missing triangles in SPT. More logging. Separate proj matrices for through and normal mode (through matrix don't need to get updated as often). Some cleanup.
2012-11-28 12:45:22 +00:00
case GE_CMD_TEXWRAP:
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
Execute_TexParamType(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
//////////////////////////////////////////////////////////////////
Regroup Stencil Testing
2013-12-26 03:18:16 +00:00
// DEPTH TESTING
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
//////////////////////////////////////////////////////////////////
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
case GE_CMD_ZTESTENABLE:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_ZTEST:
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
case GE_CMD_ZWRITEDISABLE:
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
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:
Don't check diff in ExecuteOpInternal(). Since it's not called if !diff, there's no need. Small performance improvement.
2014-04-13 17:25:14 +00:00
gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
SDL port: Add DEBUG option to set _DEBUG, add ability to log gfx stuff
2012-12-01 22:38:18 +00:00
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
case GE_CMD_DITH0:
case GE_CMD_DITH1:
case GE_CMD_DITH2:
case GE_CMD_DITH3:
break;
case GE_CMD_WORLDMATRIXNUMBER:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_WorldMtxNum(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_WORLDMATRIXDATA:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_WorldMtxData(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_VIEWMATRIXNUMBER:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_ViewMtxNum(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_VIEWMATRIXDATA:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_ViewMtxData(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_PROJMATRIXNUMBER:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_ProjMtxNum(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_PROJMATRIXDATA:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_ProjMtxData(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_TGENMATRIXNUMBER:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_TgenMtxNum(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_TGENMATRIXDATA:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_TgenMtxData(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_BONEMATRIXNUMBER:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_BoneMtxNum(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
case GE_CMD_BONEMATRIXDATA:
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
Execute_BoneMtxData(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
Switch from USING_GLES2 to MOBILE_DEVICE. Still using USING_GLES2 for, well, GLES2. But for things that are really about mobile, we need a new define. Devices are coming that don't use GLES2.
2014-02-08 18:29:22 +00:00
#ifndef MOBILE_DEVICE
Add reporting for unsupported GE commands. And clean up some disasm for a couple others.
2013-05-12 17:15:13 +00:00
case GE_CMD_ANTIALIASENABLE:
if (data != 0)
Only report these once to avoid spam.
2013-05-12 19:00:21 +00:00
WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data);
Add reporting for unsupported GE commands. And clean up some disasm for a couple others.
2013-05-12 17:15:13 +00:00
break;
case GE_CMD_TEXLODSLOPE:
if (data != 0)
Only report these once to avoid spam.
2013-05-12 19:00:21 +00:00
WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data);
Add reporting for unsupported GE commands. And clean up some disasm for a couple others.
2013-05-12 17:15:13 +00:00
break;
Switch from USING_GLES2 to MOBILE_DEVICE. Still using USING_GLES2 for, well, GLES2. But for things that are really about mobile, we need a new define. Devices are coming that don't use GLES2.
2014-02-08 18:29:22 +00:00
#endif
Add reporting for unsupported GE commands. And clean up some disasm for a couple others.
2013-05-12 17:15:13 +00:00
case GE_CMD_TEXLEVEL:
Split out texture level
2014-04-18 14:00:53 +00:00
Execute_TexLevel(op, diff);
Add reporting for unsupported GE commands. And clean up some disasm for a couple others.
2013-05-12 17:15:13 +00:00
break;
Regroup Stencil Testing
2013-12-26 03:18:16 +00:00
//////////////////////////////////////////////////////////////////
// STENCIL TESTING
//////////////////////////////////////////////////////////////////
Omit a few commands from "DL Unknown" in debug.
2013-11-18 15:51:10 +00:00
case GE_CMD_STENCILTEST:
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
Execute_StencilTest(op, diff);
Copy the stencil value in REPLACE mode to fragment alpha (but only when it's safe) This is cheap but incomplete. To do it more "right", we need multipass when blending or alpha test is enabled, ugh. That's for later. Anyway, this improves the glow situation in Wipeout somewhat. Still lots of stuff that glows that shouldn't, but a little less overwhelmingly bright.
2013-12-02 23:09:48 +00:00
break;
Regroup Stencil Testing
2013-12-26 03:18:16 +00:00
case GE_CMD_STENCILTESTENABLE:
Omit a few commands from "DL Unknown" in debug.
2013-11-18 15:51:10 +00:00
case GE_CMD_STENCILOP:
break;
case GE_CMD_MASKRGB:
case GE_CMD_MASKALPHA:
break;
Eat some cycles when changing thread priority. Some games call this a lot.
2013-11-28 09:01:22 +00:00
case GE_CMD_REVERSENORMAL:
break;
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
case GE_CMD_VSCX:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VSCY:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VSCZ:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VTCS:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VTCT:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VTCQ:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VCV:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VAP:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VFC:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
case GE_CMD_VSCV:
if (data != 0)
Warn fix
2014-05-06 07:26:52 +00:00
WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data);
Add Vertex texture/color GE commands
2014-04-26 14:58:51 +00:00
break;
Add WARN_LOG_REPORT_ONCE for unknown GE commands
2013-09-20 06:30:33 +00:00
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:
Add some additional unknown cmds to reporting.
2013-10-08 07:34:17 +00:00
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:
More carefully log unknown GE commands. Need FLAG_EXECUTE or they won't log, we were only getting the ReapplyGfxState() ones before. Let's skip 0 to not log those as well.
2013-09-23 04:00:56 +00:00
if (data != 0)
WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op);
Add WARN_LOG_REPORT_ONCE for unknown GE commands
2013-09-20 06:30:33 +00:00
break;
Exclude 0xFF from logging, happens a lot.
2013-10-25 05:03:10 +00:00
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;
Add WARN_LOG_REPORT_ONCE for unknown GE commands
2013-09-20 06:30:33 +00:00
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
default:
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
GPUCommon::ExecuteOp(op, diff);
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
break;
}
}
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
void GLES_GPU::FastLoadBoneMatrix(u32 target) {
Always flush bone matrices when morph is enabled. Fixes graphical glitches in Shadow of Destiny and LittleBigPlanet with software skinning enabled. Maybe the other games in #5304.
2014-03-03 02:19:55 +00:00
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
Flush();
const int num = gstate.boneMatrixNumber & 0x7F;
Fix bug in FastLoadBoneMatrix where the wrong uniform could be dirtied
2014-03-22 08:27:21 +00:00
int mtxNum = num / 12;
uint32_t uniformsToDirty = DIRTY_BONEMATRIX0 << mtxNum;
if ((num - 12 * mtxNum) != 0) {
uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
}
Fix bug in FastLoadBoneMatrix where the wrong uniform could be dirtied
2014-03-22 08:27:21 +00:00
shaderManager_->DirtyUniform(uniformsToDirty);
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
}
gstate.FastLoadBoneMatrix(target);
}
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
void GLES_GPU::UpdateStats() {
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
gpuStats.numVertexShaders = shaderManager_->NumVertexShaders();
gpuStats.numFragmentShaders = shaderManager_->NumFragmentShaders();
gpuStats.numShaders = shaderManager_->NumPrograms();
Fix some x64 type warnings.
2013-02-24 18:38:30 +00:00
gpuStats.numTextures = (int)textureCache_.NumLoadedTextures();
gpuStats.numFBOs = (int)framebufferManager_.NumVFBs();
Reasonably correct viewport handling. Optional debug stats overlay (not always 100% working).
2012-11-26 16:35:08 +00:00
}
Just some cleanup of GPU code
2012-12-28 18:33:26 +00:00
void GLES_GPU::DoBlockTransfer() {
Cleanup and reorganize gpu code a little
2012-12-21 15:49:42 +00:00
// TODO: This is used a lot to copy data around between render targets and textures,
// and also to quickly load textures from RAM to VRAM. So we should do checks like the following:
Use sceKernelDcache*() to invalidate the texcache. Also in the block transfer code.
2012-12-21 22:10:57 +00:00
// * Does dstBasePtr point to an existing texture? If so maybe reload it immediately.
Cleanup and reorganize gpu code a little
2012-12-21 15:49:42 +00:00
//
// * Does srcBasePtr point to a render target, and dstBasePtr to a texture? If so
// either copy between rt and texture or reassign the texture to point to the render target
//
// etc....
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
u32 srcBasePtr = gstate.getTransferSrcAddress();
u32 srcStride = gstate.getTransferSrcStride();
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
u32 dstBasePtr = gstate.getTransferDstAddress();
u32 dstStride = gstate.getTransferDstStride();
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
int srcX = gstate.getTransferSrcX();
int srcY = gstate.getTransferSrcY();
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
int dstX = gstate.getTransferDstX();
int dstY = gstate.getTransferDstY();
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
int width = gstate.getTransferWidth();
int height = gstate.getTransferHeight();
Don't log display lists, instead dump them on demand. Makes it fairly convenient to dump and look at display lists at run time on non windows platforms. Adding a menu item on Windows should be trivial.
2012-12-26 23:18:45 +00:00
Use accessors better for block transfers.
2013-08-24 17:41:45 +00:00
int bpp = gstate.getTransferBpp();
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Fix Gran Turismo's warped text.
2013-08-18 23:07:42 +00:00
DEBUG_LOG(G3D, "Block transfer: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY);
Tiny optimization in block copies
2013-12-04 10:34:54 +00:00
Add memory check for srcBasePtr & dstBasePtr
2013-09-04 08:38:39 +00:00
if (!Memory::IsValidAddress(srcBasePtr)) {
Add BlockTransfer: to ERROR_LOG_REPORT
2013-09-04 08:58:52 +00:00
ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad source transfer address %08x!", srcBasePtr);
Add memory check for srcBasePtr & dstBasePtr
2013-09-04 08:38:39 +00:00
return;
}
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
Add memory check for srcBasePtr & dstBasePtr
2013-09-04 08:38:39 +00:00
if (!Memory::IsValidAddress(dstBasePtr)) {
Add BlockTransfer: to ERROR_LOG_REPORT
2013-09-04 08:58:52 +00:00
ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad destination transfer address %08x!", dstBasePtr);
Add memory check for srcBasePtr & dstBasePtr
2013-09-04 08:38:39 +00:00
return;
}
Try a different approach to the problem in #5117
2014-01-16 21:52:14 +00:00
// Check that the last address of both source and dest are valid addresses
u32 srcLastAddr = srcBasePtr + ((height - 1 + srcY) * srcStride + (srcX + width - 1)) * bpp;
u32 dstLastAddr = dstBasePtr + ((height - 1 + dstY) * dstStride + (dstX + width - 1)) * bpp;
if (!Memory::IsValidAddress(srcLastAddr)) {
ERROR_LOG_REPORT(G3D, "Bottom-right corner of source of block transfer is at an invalid address: %08x", srcLastAddr);
return;
}
if (!Memory::IsValidAddress(dstLastAddr)) {
ERROR_LOG_REPORT(G3D, "Bottom-right corner of destination of block transfer is at an invalid address: %08x", srcLastAddr);
return;
}
Download before, upload after. Fix save pictures. Otherwise, it only works if it does it every frame, and then it's a frame behind. Also fixes Tales of Phantasia X's fades and etc.
2014-05-25 23:00:39 +00:00
// Tell the framebuffer manager to take action if possible. If it does the entire thing, let's just return.
if (!framebufferManager_.NotifyBlockTransferBefore(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp)) {
// Do the copy! (Hm, if we detect a drawn video frame (see below) then we could maybe skip this?)
// Can use GetPointerUnchecked because we checked the addresses above. We could also avoid them
// entirely by walking a couple of pointers...
Fix a few warnings, mostly type comparisons.
2014-06-01 04:38:37 +00:00
if (srcStride == dstStride && (u32)width == srcStride) {
Download before, upload after. Fix save pictures. Otherwise, it only works if it does it every frame, and then it's a frame behind. Also fixes Tales of Phantasia X's fades and etc.
2014-05-25 23:00:39 +00:00
// Common case in God of War, let's do it all in one chunk.
u32 srcLineStartAddr = srcBasePtr + (srcY * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + (dstY * dstStride + dstX) * bpp;
Optimize the case of a direct byte copy. Small improvement (like 3.5%) in God of War.
2014-04-14 04:29:55 +00:00
const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);
u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);
Download before, upload after. Fix save pictures. Otherwise, it only works if it does it every frame, and then it's a frame behind. Also fixes Tales of Phantasia X's fades and etc.
2014-05-25 23:00:39 +00:00
memcpy(dst, src, width * height * bpp);
} else {
for (int y = 0; y < height; y++) {
u32 srcLineStartAddr = srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp;
const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);
u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);
memcpy(dst, src, width * bpp);
}
Optimize the case of a direct byte copy. Small improvement (like 3.5%) in God of War.
2014-04-14 04:29:55 +00:00
}
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
BlockTransfer: Move framebuffer handling into Framebuffer.cpp
2014-05-08 12:54:45 +00:00
textureCache_.Invalidate(dstBasePtr + (dstY * dstStride + dstX) * bpp, height * dstStride * bpp, GPU_INVALIDATE_HINT);
Download before, upload after. Fix save pictures. Otherwise, it only works if it does it every frame, and then it's a frame behind. Also fixes Tales of Phantasia X's fades and etc.
2014-05-25 23:00:39 +00:00
framebufferManager_.NotifyBlockTransferAfter(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp);
Some preparations towards framebuffer management improvements
2014-05-08 12:26:17 +00:00
}
Use sceKernelDcache*() to invalidate the texcache. Also in the block transfer code.
2012-12-21 22:10:57 +00:00
Switch from USING_GLES2 to MOBILE_DEVICE. Still using USING_GLES2 for, well, GLES2. But for things that are really about mobile, we need a new define. Devices are coming that don't use GLES2.
2014-02-08 18:29:22 +00:00
#ifndef MOBILE_DEVICE
Add memchecks for common HLE copy operations. Better to catch some than miss everything.
2013-12-14 22:54:05 +00:00
CBreakPoints::ExecMemCheck(srcBasePtr + (srcY * srcStride + srcX) * bpp, false, height * srcStride * bpp, currentMIPS->pc);
CBreakPoints::ExecMemCheck(dstBasePtr + (srcY * dstStride + srcX) * bpp, true, height * dstStride * bpp, currentMIPS->pc);
#endif
Use sceKernelDcache*() to invalidate the texcache. Also in the block transfer code.
2012-12-21 22:10:57 +00:00
}
Improve GPU invalidation interface, check fonts. When a font is rendered, tell the GPU about it, but don't rehash. This not only improves perf (less hashing) but makes font changes more immediate (no deferred hashing.) But only if they use sceFont.
2013-05-06 05:52:01 +00:00
void GLES_GPU::InvalidateCache(u32 addr, int size, GPUInvalidationType type) {
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
GPUEvent ev(GPU_EVENT_INVALIDATE_CACHE);
ev.invalidate_cache.addr = addr;
ev.invalidate_cache.size = size;
ev.invalidate_cache.type = type;
ScheduleEvent(ev);
}
void GLES_GPU::InvalidateCacheInternal(u32 addr, int size, GPUInvalidationType type) {
Use sceKernelDcache*() to invalidate the texcache. Also in the block transfer code.
2012-12-21 22:10:57 +00:00
if (size > 0)
Improve GPU invalidation interface, check fonts. When a font is rendered, tell the GPU about it, but don't rehash. This not only improves perf (less hashing) but makes font changes more immediate (no deferred hashing.) But only if they use sceFont.
2013-05-06 05:52:01 +00:00
textureCache_.Invalidate(addr, size, type);
Use sceKernelDcache*() to invalidate the texcache. Also in the block transfer code.
2012-12-21 22:10:57 +00:00
else
Improve GPU invalidation interface, check fonts. When a font is rendered, tell the GPU about it, but don't rehash. This not only improves perf (less hashing) but makes font changes more immediate (no deferred hashing.) But only if they use sceFont.
2013-05-06 05:52:01 +00:00
textureCache_.InvalidateAll(type);
Invalidate FBOs when it's obvious they should be. This fixes videos not being visible in for example Star Ocean. Most likely any games doing a copy directly from the mpeg decode.
2013-06-08 11:37:40 +00:00
Skip some code if things are outside framebuffers. Small optimization.
2014-05-26 00:01:28 +00:00
if (type != GPU_INVALIDATE_ALL && framebufferManager_.MayIntersectFramebuffer(addr)) {
Support memcpy uploads to fbos. Makes Vempire look right (has never worked before in any rendering mode.)
2014-05-26 05:00:51 +00:00
// If we're doing block transfers, we shouldn't need this, and it'll only confuse us.
// Vempire invalidates (with writeback) after drawing, but before blitting.
if (!g_Config.bBlockTransferGPU || type == GPU_INVALIDATE_SAFE) {
framebufferManager_.UpdateFromMemory(addr, size, type == GPU_INVALIDATE_SAFE);
}
Skip some code if things are outside framebuffers. Small optimization.
2014-05-26 00:01:28 +00:00
}
Do GPU ram<->vram block transfers. Could be smart enough to clear textures from cache but isn't yet.
2012-11-22 19:57:41 +00:00
}
Split code from GLES_GPU to TransformDrawEngine, cleanup
2012-12-25 12:47:59 +00:00
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
void GLES_GPU::PerformMemoryCopyInternal(u32 dest, u32 src, int size) {
Schedule the FBO blit during multithreading. This was it's properly ordered with draws, and it runs on the right GL context.
2014-05-26 05:08:15 +00:00
if (!framebufferManager_.NotifyFramebufferCopy(src, dest, size)) {
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
// We use a little hack for Download/Upload using a VRAM mirror.
// Since they're identical we don't need to copy.
if (!Memory::IsVRAMAddress(dest) || (dest ^ 0x00400000) != src) {
Memory::Memcpy(dest, Memory::GetPointer(src), size);
}
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
}
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
}
void GLES_GPU::PerformMemorySetInternal(u32 dest, u8 v, int size) {
if (!framebufferManager_.NotifyFramebufferCopy(dest, dest, size, true)) {
Schedule the FBO blit during multithreading. This was it's properly ordered with draws, and it runs on the right GL context.
2014-05-26 05:08:15 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
}
}
Implement a very basic stencil upload. This is not fast or efficient, but works.
2014-06-01 01:24:35 +00:00
void GLES_GPU::PerformStencilUploadInternal(u32 dest, int size) {
framebufferManager_.NotifyStencilUpload(dest, size);
}
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
bool GLES_GPU::PerformMemoryCopy(u32 dest, u32 src, int size) {
Track copies of framebuffers in ram created through sceDmacMemcpy, so that we can display them. Fixes MotoGP while also, in effect, committing #3859. Removes the horrifying ramDisplayFramebufferPtr hack.
2013-09-21 16:52:30 +00:00
// Track stray copies of a framebuffer in RAM. MotoGP does this.
Track more kinds of memcpy operations on fbos.
2014-05-26 00:03:32 +00:00
if (framebufferManager_.MayIntersectFramebuffer(src) || framebufferManager_.MayIntersectFramebuffer(dest)) {
Schedule the FBO blit during multithreading. This was it's properly ordered with draws, and it runs on the right GL context.
2014-05-26 05:08:15 +00:00
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_MEMCPY);
ev.fb_memcpy.dst = dest;
ev.fb_memcpy.src = src;
ev.fb_memcpy.size = size;
ScheduleEvent(ev);
// This is a memcpy, so we need to wait for it to complete.
SyncThread();
Allow memcpy gpu downloads. Fixes FF4 battle transition effect, Trails in the Sky menu, etc.
2014-05-26 03:35:27 +00:00
} else {
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
PerformMemoryCopyInternal(dest, src, size);
}
return true;
}
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
return false;
}
bool GLES_GPU::PerformMemorySet(u32 dest, u8 v, int size) {
// This may indicate a memset, usually to 0, of a framebuffer.
if (framebufferManager_.MayIntersectFramebuffer(dest)) {
Memory::Memset(dest, v, size);
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_MEMSET);
ev.fb_memset.dst = dest;
ev.fb_memset.v = v;
ev.fb_memset.size = size;
ScheduleEvent(ev);
// We don't need to wait for the framebuffer to be updated.
} else {
PerformMemorySetInternal(dest, v, size);
Allow memcpy gpu downloads. Fixes FF4 battle transition effect, Trails in the Sky menu, etc.
2014-05-26 03:35:27 +00:00
}
UpdateMemory() now returns whether to skip the cpy. This way it can do it itself as necessary in the right order.
2014-05-26 03:05:28 +00:00
return true;
Track copies of framebuffers in ram created through sceDmacMemcpy, so that we can display them. Fixes MotoGP while also, in effect, committing #3859. Removes the horrifying ramDisplayFramebufferPtr hack.
2013-09-21 16:52:30 +00:00
}
UpdateMemory() now returns whether to skip the cpy. This way it can do it itself as necessary in the right order.
2014-05-26 03:05:28 +00:00
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
// Or perhaps a texture, let's invalidate.
UpdateMemory() now returns whether to skip the cpy. This way it can do it itself as necessary in the right order.
2014-05-26 03:05:28 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
return false;
Add a better signal for VRAM copies in the GPU.
2013-06-09 08:21:50 +00:00
}
Clean up the framebuffer force downloads.
2014-05-31 06:33:50 +00:00
bool GLES_GPU::PerformMemoryDownload(u32 dest, int size) {
// Cheat a bit to force a download of the framebuffer.
// VRAM + 0x00400000 is simply a VRAM mirror.
return gpu->PerformMemoryCopy(dest ^ 0x00400000, dest, size);
}
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
bool GLES_GPU::PerformMemoryUpload(u32 dest, int size) {
Correct Gods Eater Burst tex download size. Probably takes care of #6289, although it doesn't crash for me.
2014-06-11 05:56:45 +00:00
// Cheat a bit to force an upload of the framebuffer.
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
// VRAM + 0x00400000 is simply a VRAM mirror.
return gpu->PerformMemoryCopy(dest, dest ^ 0x00400000, size);
}
Implement a very basic stencil upload. This is not fast or efficient, but works.
2014-06-01 01:24:35 +00:00
bool GLES_GPU::PerformStencilUpload(u32 dest, int size) {
if (framebufferManager_.MayIntersectFramebuffer(dest)) {
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_STENCIL_UPLOAD);
ev.fb_stencil_upload.dst = dest;
ev.fb_stencil_upload.size = size;
ScheduleEvent(ev);
} else {
PerformStencilUploadInternal(dest, size);
}
return true;
}
return false;
}
Fixed threading issue pointed out by unknownbrackets and made texture scaling changes apply immediately
2013-04-30 15:20:28 +00:00
void GLES_GPU::ClearCacheNextFrame() {
textureCache_.ClearNextFrame();
}
Better window resize handling
2013-01-26 23:15:39 +00:00
void GLES_GPU::Resized() {
Fix viewport resize
2013-01-31 11:14:57 +00:00
framebufferManager_.Resized();
Only clear the shader cache when toggling "Disable alpha test"
2013-10-22 12:34:16 +00:00
}
void GLES_GPU::ClearShaderCache() {
Add ugly hack setting for PowerVR to disable alpha test Causes glitches but the speedup is truly massive in some games so I relent :/ Please do not report graphics bugs when this is enabled... Future: Maybe remove this setting except on PowerVR?
2013-10-22 11:00:19 +00:00
shaderManager_->ClearCache(true);
Better window resize handling
2013-01-26 23:15:39 +00:00
}
Only clear the shader cache when toggling "Disable alpha test"
2013-10-22 12:34:16 +00:00
std::vector<FramebufferInfo> GLES_GPU::GetFramebufferList() {
Add displayList debug dialog
2013-02-17 00:06:06 +00:00
return framebufferManager_.GetFramebufferList();
}
Better window resize handling
2013-01-26 23:15:39 +00:00
void GLES_GPU::DoState(PointerWrap &p) {
GPUCommon::DoState(p);
Don't clear the GPU caches on savestate, just load. And maybe it's not even fully necessary on load...
2013-09-29 20:19:32 +00:00
// TODO: Some of these things may not be necessary.
// None of these are necessary when saving.
In Freeze-Frame mode, don't wipe GPU resources when loading save states.
2013-11-15 15:30:55 +00:00
// In Freeze-Frame mode, we don't want to do any of this.
if (p.mode == p.MODE_READ && !PSP_CoreParameter().frozen) {
Don't clear the GPU caches on savestate, just load. And maybe it's not even fully necessary on load...
2013-09-29 20:19:32 +00:00
textureCache_.Clear(true);
Depalettize works at other resolutions than 1x. For some strange reason though if you change resolution in game it breaks.
2014-03-30 13:37:51 +00:00
depalShaderCache_.Clear();
Don't clear the GPU caches on savestate, just load. And maybe it's not even fully necessary on load...
2013-09-29 20:19:32 +00:00
transformDraw_.ClearTrackedVertexArrays();
Better window resize handling
2013-01-26 23:15:39 +00:00
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
Don't clear the GPU caches on savestate, just load. And maybe it's not even fully necessary on load...
2013-09-29 20:19:32 +00:00
framebufferManager_.DestroyAllFBOs();
}
Move GPU state to sceDisplay, reset GPU on load.
2012-12-29 20:21:56 +00:00
}
Add an interface to return the current framebuffer.
2013-09-23 02:03:31 +00:00
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
bool GLES_GPU::GetCurrentFramebuffer(GPUDebugBuffer &buffer) {
Add an interface to return the current framebuffer.
2013-09-23 02:03:31 +00:00
return framebufferManager_.GetCurrentFramebuffer(buffer);
}
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
Add an interface to grab the depth/stencil buffers. Not sure yet how to show in UI, not well tested...
2013-09-28 09:14:27 +00:00
bool GLES_GPU::GetCurrentDepthbuffer(GPUDebugBuffer &buffer) {
return framebufferManager_.GetCurrentDepthbuffer(buffer);
}
bool GLES_GPU::GetCurrentStencilbuffer(GPUDebugBuffer &buffer) {
return framebufferManager_.GetCurrentStencilbuffer(buffer);
}
Add debug interface for non-L0 texture preview.
2014-06-15 16:30:37 +00:00
bool GLES_GPU::GetCurrentTexture(GPUDebugBuffer &buffer, int level) {
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
if (!gstate.isTextureMapEnabled()) {
return false;
}
#ifndef USING_GLES2
Add debug interface for non-L0 texture preview.
2014-06-15 16:30:37 +00:00
GPUgstate saved;
if (level != 0) {
saved = gstate;
// The way we set textures is a bit complex. Let's just override level 0.
gstate.texsize[0] = gstate.texsize[level];
gstate.texaddr[0] = gstate.texaddr[level];
gstate.texbufwidth[0] = gstate.texbufwidth[level];
}
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
textureCache_.SetTexture(true);
Add debug interface for non-L0 texture preview.
2014-06-15 16:30:37 +00:00
int w = gstate.getTextureWidth(level);
int h = gstate.getTextureHeight(level);
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
Add debug interface for non-L0 texture preview.
2014-06-15 16:30:37 +00:00
if (level != 0) {
gstate = saved;
}
Flip the texture preview when it's a framebuffer.
2013-10-07 07:38:46 +00:00
buffer.Allocate(w, h, GE_FORMAT_8888, gstate_c.flipTexture);
Add a way to get to the current texture as well.
2013-09-28 04:53:42 +00:00
glPixelStorei(GL_PACK_ALIGNMENT, 4);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer.GetData());
return true;
#else
return false;
#endif
Remove duplicate comment
2013-10-01 06:04:48 +00:00
}
Implement some basic vertex previews on prim. 3D doesn't work correctly (sometimes it does...) 2D should be working.
2013-10-14 03:47:52 +00:00
bool GLES_GPU::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
return transformDraw_.GetCurrentSimpleVertices(count, vertices, indices);
}
Also report the vertex decoder jit to verysleepy. Can use the same methods to support other platforms.
2013-12-01 02:39:16 +00:00
bool GLES_GPU::DescribeCodePtr(const u8 *ptr, std::string &name) {
if (transformDraw_.IsCodePtrVertexDecoder(ptr)) {
name = "VertexDecoderJit";
return true;
}
return false;
}
Reference in New Issue Copy Permalink