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
b71061b1ef
ppsspp/GPU/GLES/GLES_GPU.cpp

2424 lines
82 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"
Hook up the frame profiler to a few measurements
2015-05-13 20:28:02 +00:00
#include "profiler/profiler.h"
Update native + some very minor changes
2013-07-26 22:44:16 +00:00
Start untangling our include mess a little.
2013-12-29 22:28:31 +00:00
#include "Common/ChunkFile.h"
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
#include "Core/Config.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"
Make Memory::Memcpy() execute memchecks directly. This makes it easier to handle breakpoints in HLE.
2015-04-06 01:03:50 +00:00
#include "Core/MemMapHelpers.h"
Move all the framebuffer management out into its own file.
2013-01-30 20:09:53 +00:00
#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"
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
#include "GPU/Common/FramebufferCommon.h"
Add snapshot of the whole source code.
2012-11-01 15:19:01 +00:00
Move native/gfx_es2/gl_state.cpp/h into GPU/GLES/GLStateCache.cpp/h
2015-09-06 11:45:17 +00:00
#include "GPU/GLES/GLStateCache.h"
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
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
#ifdef _WIN32
Move Windows GPU init code into Windows/GPU
2015-11-03 22:22:09 +00:00
#include "Windows/GPU/WindowsGLContext.h"
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
#endif
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,
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
FLAG_DIRTYONCHANGE = 64,
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;
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
u32 dirtyUniform;
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
};
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
// This table gets crunched into a faster form by init.
// TODO: Share this table between the backends. Will have to make another indirection for the function pointers though..
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
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GLES_GPU::Execute_FogColor},
{GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GLES_GPU::Execute_FogCoef},
{GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &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?
Round Z in the vertex shader to match a 16-bit Z buffer. However this inexplicably does still not solve the Phantasy Star issue!
2015-08-26 11:26:08 +00:00
{GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE},
{GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE},
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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GLES_GPU::Execute_TexMapMode},
{GE_CMD_TEXSCALEU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GLES_GPU::Execute_TexScaleU},
{GE_CMD_TEXSCALEV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GLES_GPU::Execute_TexScaleV},
{GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GLES_GPU::Execute_TexOffsetU},
{GE_CMD_TEXOFFSETV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GLES_GPU::Execute_TexSize0},
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexSizeN},
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexFormat},
{GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexLevel},
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddr0},
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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},
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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},
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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},
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORMASK, &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.
Cleanup some minor vertex cache stuff.
2014-09-15 14:08:55 +00:00
{GE_CMD_REVERSENORMAL, 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_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},
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GLES_GPU::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &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},
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_STENCILREPLACEVALUE, &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},
{GE_CMD_LOGICOP, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LOGICOPENABLE, FLAG_FLUSHBEFOREONCHANGE},
// 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.
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
{GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GLES_GPU::Execute_ViewportZType},
{GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GLES_GPU::Execute_ViewportZType},
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
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_Region},
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
// Scissor
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GLES_GPU::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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...
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GLES_GPU::Execute_Ambient},
{GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GLES_GPU::Execute_Ambient},
{GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GLES_GPU::Execute_MaterialDiffuse},
{GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GLES_GPU::Execute_MaterialEmissive},
{GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GLES_GPU::Execute_MaterialAmbient},
{GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GLES_GPU::Execute_MaterialAmbient},
{GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GLES_GPU::Execute_MaterialSpecular},
{GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GLES_GPU::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GLES_GPU::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GLES_GPU::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GLES_GPU::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_OFFSETADDR, FLAG_EXECUTE, 0, &GPUCommon::Execute_OffsetAddr},
{GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_Origin}, // Really?
{GE_CMD_PRIM, FLAG_EXECUTE, 0, &GLES_GPU::Execute_Prim},
{GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_Jump},
{GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_Call},
{GE_CMD_RET, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_Ret},
{GE_CMD_END, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_End}, // Flush?
{GE_CMD_VADDR, FLAG_EXECUTE, 0, &GLES_GPU::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, 0, &GLES_GPU::Execute_Iaddr},
{GE_CMD_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_BJump}, // EXECUTE
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, 0, &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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &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
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &GLES_GPU::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &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...
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GLES_GPU::Execute_LoadClut},
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC, 0, &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.
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GLES_GPU::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, 0, &GLES_GPU::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GLES_GPU::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, 0, &GLES_GPU::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GLES_GPU::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, 0, &GLES_GPU::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GLES_GPU::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, 0, &GLES_GPU::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GLES_GPU::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &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
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) {
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
UpdateVsyncInterval(true);
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
CheckGPUFeatures();
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_);
Add an experiment with using a texture for tests. Using an option for now so it's easy to test, if it works well we can maybe remove the option.
2014-08-24 22:26:38 +00:00
transformDraw_.SetFragmentTestCache(&fragmentTestCache_);
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
framebufferManager_.Init();
Initial support for texturing from framebuffers.
2013-01-31 23:18:23 +00:00
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_);
Add an experiment with using a texture for tests. Using an option for now so it's easy to test, if it works well we can maybe remove the option.
2014-08-24 22:26:38 +00:00
fragmentTestCache_.SetTextureCache(&textureCache_);
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) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
cmdInfo_[cmd].func = &GLES_GPU::Execute_Generic;
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
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
UpdateCmdInfo();
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();
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
// Update again after init to be sure of any silly driver problems.
UpdateVsyncInterval(true);
Assert state on first frame. This won't matter much for games, but makes tests run more sanely.
2014-12-30 23:26:16 +00:00
// Some of our defaults are different from hw defaults, let's assert them.
// We restore each frame anyway, but here is convenient for tests.
glstate.Restore();
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();
Add an experiment with using a texture for tests. Using an option for now so it's easy to test, if it works well we can maybe remove the option.
2014-08-24 22:26:38 +00:00
fragmentTestCache_.Clear();
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
delete shaderManager_;
Expand spline data into a separate buffer. Prevent overflowing it by reducing the size of spline draws if necessary (but shouldn't really happen). Might help #7386
2015-01-29 13:12:24 +00:00
shaderManager_ = nullptr;
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
#ifdef _WIN32
GL_SwapInterval(0);
#endif
GL: Framebuffer management using FBOs. Fixes flicker in Lumines and many others.
2012-11-19 22:29:14 +00:00
}
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
// Take the raw GL extension and versioning data and turn into feature flags.
void GLES_GPU::CheckGPUFeatures() {
u32 features = 0;
Enable EXT_blend_func_extended. Not really tested.
2015-11-28 00:01:25 +00:00
if (gl_extensions.ARB_blend_func_extended || gl_extensions.EXT_blend_func_extended) {
Fix some naming, remove NV_draw_texture, move decisions out
2015-09-05 20:11:28 +00:00
if (gl_extensions.gpuVendor == GPU_VENDOR_INTEL || !gl_extensions.VersionGEThan(3, 0, 0)) {
// Don't use this extension to off on sub 3.0 OpenGL versions as it does not seem reliable
// Also on Intel, see https://github.com/hrydgard/ppsspp/issues/4867
} else {
features |= GPU_SUPPORTS_DUALSOURCE_BLEND;
}
}
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
if (gl_extensions.IsGLES) {
if (gl_extensions.GLES3)
features |= GPU_SUPPORTS_GLSL_ES_300;
} else {
if (gl_extensions.VersionGEThan(3, 3, 0))
features |= GPU_SUPPORTS_GLSL_330;
}
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
if (gl_extensions.EXT_shader_framebuffer_fetch || gl_extensions.NV_shader_framebuffer_fetch || gl_extensions.ARM_shader_framebuffer_fetch) {
Disable FRAMEBUFFER_FETCH for all GPUs. Can be whitelisted for some in the future.
2015-10-29 18:27:55 +00:00
// This mostly seems to cause problems. Let's keep this commented out to disable it for everyone.
// If found beneficial for something, we can easily add a whitelist here.
// features |= GPU_SUPPORTS_ANY_FRAMEBUFFER_FETCH;
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
}
Cleanup of FBO+blit flags. Requires the change in native to stop lying.
2015-09-05 20:40:45 +00:00
if (gl_extensions.ARB_framebuffer_object || gl_extensions.EXT_framebuffer_object || gl_extensions.IsGLES) {
features |= GPU_SUPPORTS_FBO;
}
if (gl_extensions.ARB_framebuffer_object || gl_extensions.GLES3) {
features |= GPU_SUPPORTS_ARB_FRAMEBUFFER_BLIT;
}
if (gl_extensions.NV_framebuffer_blit) {
features |= GPU_SUPPORTS_NV_FRAMEBUFFER_BLIT;
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
}
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
bool useCPU = false;
if (!gl_extensions.IsGLES) {
// Urrgh, we don't even define FB_READFBOMEMORY_CPU on mobile
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
#ifndef USING_GLES2
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
useCPU = g_Config.iRenderingMode == FB_READFBOMEMORY_CPU;
#endif
// Some cards or drivers seem to always dither when downloading a framebuffer to 16-bit.
// This causes glitches in games that expect the exact values.
// It has not been experienced on NVIDIA cards, so those are left using the GPU (which is faster.)
if (g_Config.iRenderingMode == FB_BUFFERED_MODE) {
if (gl_extensions.gpuVendor != GPU_VENDOR_NVIDIA || gl_extensions.ver[0] < 3) {
useCPU = true;
}
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
}
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
} else {
useCPU = true;
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
}
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
if (useCPU)
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
features |= GPU_PREFER_CPU_DOWNLOAD;
if ((gl_extensions.gpuVendor == GPU_VENDOR_NVIDIA) || (gl_extensions.gpuVendor == GPU_VENDOR_AMD))
features |= GPU_PREFER_REVERSE_COLOR_ORDER;
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
if (gl_extensions.OES_texture_npot)
features |= GPU_SUPPORTS_OES_TEXTURE_NPOT;
if (gl_extensions.EXT_unpack_subimage || !gl_extensions.IsGLES)
features |= GPU_SUPPORTS_UNPACK_SUBIMAGE;
if (gl_extensions.EXT_blend_minmax || gl_extensions.GLES3)
features |= GPU_SUPPORTS_BLEND_MINMAX;
Use glCopyImageSubData() when it's available. There's 4 different extensions providing this functionality. NV is supported on desktop and mobile, EXT/OES on mobile, and ARB on desktop. Mostly these are only supported by desktop cards and NVIDIA mobile. Good improvement in performance on NVIDIA when blit is called a lot, since it doesn't need to rebind anything or change state. Example is in desert city in Tales of Phantasia.
2015-12-06 18:39:21 +00:00
if (gl_extensions.OES_copy_image || gl_extensions.NV_copy_image || gl_extensions.EXT_copy_image || gl_extensions.ARB_copy_image)
features |= GPU_SUPPORTS_ANY_COPY_IMAGE;
Fix some naming, remove NV_draw_texture, move decisions out
2015-09-05 20:11:28 +00:00
if (!gl_extensions.IsGLES)
features |= GPU_SUPPORTS_LOGIC_OP;
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
if (gl_extensions.GLES3 || !gl_extensions.IsGLES)
Reduce use of #ifdef USING_GLES2 some more
2015-09-05 21:09:06 +00:00
features |= GPU_SUPPORTS_TEXTURE_LOD_CONTROL;
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
// In the future, also disable this when we get a proper 16-bit depth buffer.
Only enable fragment shader depth rounding for Heroes Phantasia, should reduce flicker. Doens't fix but helps #6485
2015-10-11 18:44:58 +00:00
if ((!gl_extensions.IsGLES || gl_extensions.GLES3) && PSP_CoreParameter().compat.flags().PixelDepthRounding) {
features |= GPU_ROUND_FRAGMENT_DEPTH_TO_16BIT;
} else {
if (!PSP_CoreParameter().compat.flags().NoDepthRounding) {
features |= GPU_ROUND_DEPTH_TO_16BIT;
}
}
Reduce use of #ifdef USING_GLES2 some more
2015-09-05 21:09:06 +00:00
Remove the depth range hack option, turning it into an ugly game specific compatibility hack. I hate doing this, but it's not really better off as an option. See #8171
2015-11-05 21:02:06 +00:00
// The Phantasy Star hack :(
if (PSP_CoreParameter().compat.flags().DepthRangeHack) {
features |= GPU_USE_DEPTH_RANGE_HACK;
}
Move more GPU feature checks upfront. Re-check when exiting settings menu.
2015-09-05 19:23:58 +00:00
#ifdef MOBILE_DEVICE
// Arguably, we should turn off GPU_IS_MOBILE on like modern Tegras, etc.
features |= GPU_IS_MOBILE;
#endif
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
gstate_c.featureFlags = features;
}
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);
Add an experiment with using a texture for tests. Using an option for now so it's easy to test, if it works well we can maybe remove the option.
2014-08-24 22:26:38 +00:00
fragmentTestCache_.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();
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
UpdateVsyncInterval(true);
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);
}
Destroy all FBOs/textures upon sceKernelLoadExec(). It can confuse our heuristics about size, attachment, memcpy, etc.
2014-06-28 19:29:09 +00:00
void GLES_GPU::Reinitialize() {
GPUCommon::Reinitialize();
ScheduleEvent(GPU_EVENT_REINITIALIZE);
}
void GLES_GPU::ReinitializeInternal() {
textureCache_.Clear(true);
depalShaderCache_.Clear();
framebufferManager_.DestroyAllFBOs();
framebufferManager_.Resized();
}
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::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);
}
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
inline void GLES_GPU::UpdateVsyncInterval(bool force) {
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
int desiredVSyncInterval = g_Config.bVSync ? 1 : 0;
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
if (PSP_CoreParameter().unthrottle) {
Add VSync option in Windows. Turns itself off when unthrottled.
2013-06-16 21:45:06 +00:00
desiredVSyncInterval = 0;
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
}
if (PSP_CoreParameter().fpsLimit == 1) {
// For an alternative speed that is a clean factor of 60, the user probably still wants vsync.
if (g_Config.iFpsLimit == 0 || (g_Config.iFpsLimit != 15 && g_Config.iFpsLimit != 30 && g_Config.iFpsLimit != 60)) {
desiredVSyncInterval = 0;
}
}
if (desiredVSyncInterval != lastVsync_ || force) {
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...
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
//if (gl_extensions.EXT_swap_control_tear) {
// // 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 {
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
GL_SwapInterval(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
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
}
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
void GLES_GPU::UpdateCmdInfo() {
if (g_Config.bPrescaleUV) {
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;
} else {
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 (g_Config.bSoftwareSkinning) {
cmdInfo_[GE_CMD_VERTEXTYPE].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GLES_GPU::Execute_VertexTypeSkinning;
} else {
cmdInfo_[GE_CMD_VERTEXTYPE].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GLES_GPU::Execute_VertexType;
}
}
Remove glstate usage except in the GPU implementation. Prepare for moving it into PPSSPP.
2015-09-06 10:23:14 +00:00
void GLES_GPU::ReapplyGfxStateInternal() {
glstate.Restore();
GPUCommon::ReapplyGfxStateInternal();
}
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
void GLES_GPU::BeginFrameInternal() {
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
if (resized_) {
Move the CheckGPUFeatures call to the Resize check
2015-09-05 22:13:46 +00:00
CheckGPUFeatures();
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
UpdateCmdInfo();
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
transformDraw_.Resized();
}
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
UpdateVsyncInterval(resized_);
resized_ = false;
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();
Add an experiment with using a texture for tests. Using an option for now so it's easy to test, if it works well we can maybe remove the option.
2014-08-24 22:26:38 +00:00
fragmentTestCache_.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() {
Allow switching cpu thread on/off ingame.
2014-12-21 00:11:19 +00:00
if (ThreadEnabled()) {
Temporary fix issue #3167 in non-multithread mode #1
2013-08-14 19:43:40 +00:00
// 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() {
Allow switching cpu thread on/off ingame.
2014-12-21 00:11:19 +00:00
if (ThreadEnabled()) {
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
// 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();
Clear vertex attrib arrays before output to screen. Doesn't seem to help the mis-enabled arrays, though.
2014-06-23 04:03:33 +00:00
shaderManager_->DirtyLastShader();
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
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) {
Profile a few more scopes
2015-05-25 22:39:27 +00:00
PROFILE_THIS_SCOPE("gpuloop");
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_;
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
int dc = downcount;
for (; dc > 0; --dc) {
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))) {
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
downcount = dc;
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);
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
dc = downcount;
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;
}
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
downcount = 0;
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
}
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +00:00
void GLES_GPU::FinishDeferred() {
// This finishes reading any vertex data that is pending.
transformDraw_.FinishDeferred();
}
GLES: Add some currently unused information to the opcode table. Keep downcount in a local as much as possible.
2014-12-06 10:21:07 +00:00
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;
Destroy all FBOs/textures upon sceKernelLoadExec(). It can confuse our heuristics about size, attachment, memcpy, etc.
2014-06-28 19:29:09 +00:00
case GPU_EVENT_REINITIALIZE:
ReinitializeInternal();
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;
}
Add timing for all the basics. This way we can see overall stats for a frame.
2015-07-03 19:05:08 +00:00
// This also makes skipping drawing very effective.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
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;
}
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) {
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
void GLES_GPU::Execute_VertexTypeSkinning(u32 op, u32 diff) {
// 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;
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
Track bone matrix updates for future morph usage. This makes them upload later, if/when they're needed. Fixes #7746, Shadow of Destiny artifacts when software skinning is enabled.
2015-05-17 04:49:25 +00:00
// In this case, we may be doing weights and morphs.
// Update any bone matrix uniforms so it uses them correctly.
if ((op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
shaderManager_->DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.deferredVertTypeDirty = 0;
}
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
}
}
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.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
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);
}
[spline/bezier]Support drawing primitives lines and points.
2014-11-25 13:32:50 +00:00
if (gstate.getPatchPrimitiveType() == GE_PATCHPRIM_UNKNOWN) {
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
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;
Get rid of more uses of gstate from SplineCommon
2015-07-29 10:04:52 +00:00
bool computeNormals = gstate.isLightingEnabled();
bool patchFacing = gstate.patchfacing & 1;
transformDraw_.SubmitBezier(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), bz_ucount, bz_vcount, patchPrim, computeNormals, patchFacing, gstate.vertType);
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
}
void GLES_GPU::Execute_Spline(u32 op, u32 diff) {
// This also make skipping drawing very effective.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
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);
}
[spline/bezier]Support drawing primitives lines and points.
2014-11-25 13:32:50 +00:00
if (gstate.getPatchPrimitiveType() == GE_PATCHPRIM_UNKNOWN) {
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
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();
refactor: Remove some uses of gstate from SplineCommon and a fex texcache functions
2015-07-29 09:38:42 +00:00
bool computeNormals = gstate.isLightingEnabled();
Get rid of more uses of gstate from SplineCommon
2015-07-29 10:04:52 +00:00
bool patchFacing = gstate.patchfacing & 1;
u32 vertType = gstate.vertType;
transformDraw_.SubmitSpline(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), sp_ucount, sp_vcount, sp_utype, sp_vtype, patchPrim, computeNormals, patchFacing, vertType);
Move spline and bezier as well to separate funcs.
2014-04-17 15:09:44 +00:00
}
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;
Minor optimization
2015-08-26 16:46:55 +00:00
}
void GLES_GPU::Execute_ViewportZType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
shaderManager_->DirtyUniform(DIRTY_DEPTHRANGE);
Split out viewport type commands.
2014-04-18 05:49:09 +00:00
}
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;
refactor: Remove some uses of gstate from SplineCommon and a fex texcache functions
2015-07-29 09:38:42 +00:00
textureCache_.LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes());
Move out texformat as well.
2014-04-17 15:29:44 +00:00
// 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) {
Support alpha / color test masks on desktop/gles3. Won't work on GLES 2, though...
2014-06-16 07:33:48 +00:00
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
void GLES_GPU::Execute_AlphaTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
Support alpha / color test masks on desktop/gles3. Won't work on GLES 2, though...
2014-06-16 07:33:48 +00:00
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
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.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
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.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
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.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
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.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
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.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
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;
}
}
Track bone matrix updates for future morph usage. This makes them upload later, if/when they're needed. Fixes #7746, Shadow of Destiny artifacts when software skinning is enabled.
2015-05-17 04:49:25 +00:00
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
}
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
}
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));
Track bone matrix updates for future morph usage. This makes them upload later, if/when they're needed. Fixes #7746, Shadow of Destiny artifacts when software skinning is enabled.
2015-05-17 04:49:25 +00:00
} else {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
Move matrix loads to separate op cmds.
2014-04-17 15:00:01 +00:00
}
((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?
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
DoBlockTransfer(gstate_c.skipDrawReason);
Move out block transfer too, common in GoW.
2014-04-17 15:05:16 +00:00
// Fixes Gran Turismo's funky text issue, since it overwrites the current texture.
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
void GLES_GPU::Execute_Generic(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;
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
case GE_CMD_VIEWPORTXSCALE:
case GE_CMD_VIEWPORTYSCALE:
case GE_CMD_VIEWPORTXCENTER:
case GE_CMD_VIEWPORTYCENTER:
case GE_CMD_VIEWPORTZSCALE:
case GE_CMD_VIEWPORTZCENTER:
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) {
Track bone matrix updates for future morph usage. This makes them upload later, if/when they're needed. Fixes #7746, Shadow of Destiny artifacts when software skinning is enabled.
2015-05-17 04:49:25 +00:00
const int num = gstate.boneMatrixNumber & 0x7F;
const int mtxNum = num / 12;
uint32_t uniformsToDirty = DIRTY_BONEMATRIX0 << mtxNum;
if ((num - 12 * mtxNum) != 0) {
uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);
}
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();
Fix bug in FastLoadBoneMatrix where the wrong uniform could be dirtied
2014-03-22 08:27:21 +00:00
shaderManager_->DirtyUniform(uniformsToDirty);
Track bone matrix updates for future morph usage. This makes them upload later, if/when they're needed. Fixes #7746, Shadow of Destiny artifacts when software skinning is enabled.
2015-05-17 04:49:25 +00:00
} else {
gstate_c.deferredVertTypeDirty |= 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
}
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
void GLES_GPU::DoBlockTransfer(u32 skipDrawReason) {
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
Minor cleanups
2015-11-01 17:05:17 +00:00
u32 srcLastAddr = srcBasePtr + ((srcY + height - 1) * srcStride + (srcX + width - 1)) * bpp;
u32 dstLastAddr = dstBasePtr + ((dstY + height - 1) * dstStride + (dstX + width - 1)) * bpp;
Try a different approach to the problem in #5117
2014-01-16 21:52:14 +00:00
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.
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyBlockTransferBefore(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason)) {
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
// 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);
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
framebufferManager_.NotifyBlockTransferAfter(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason);
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
Eat cycles during block transfers. Tests show this takes a number very close to 1.9 times the number of bytes in cycles @222. Using that value caused a tiny fps drop in one area of the God of War demo, which may be correct but might also cause complaints. A lot of our other timing is not accurate, so using a lower value (1.6) to be on the safer side. This may cause things to reschedule more accurately when games drawsync, and improves the gpu/commands/blocktransfer test.
2014-08-31 05:02:28 +00:00
// TODO: Correct timing appears to be 1.9, but erring a bit low since some of our other timing is inaccurate.
cyclesExecuted += ((height * width * bpp) * 16) / 10;
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) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyFramebufferCopy(src, dest, size, false, gstate_c.skipDrawReason)) {
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) {
Make Memory::Memcpy() execute memchecks directly. This makes it easier to handle breakpoints in HLE.
2015-04-06 01:03:50 +00:00
Memory::Memcpy(dest, src, size);
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
}
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) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyFramebufferCopy(dest, dest, size, true, gstate_c.skipDrawReason)) {
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.
Double check upload/download are VRAM addresses.
2014-06-20 05:52:45 +00:00
if (Memory::IsVRAMAddress(dest)) {
Fix infinite recursion in framebuf create upload. Needs to be done *after* currentRenderVfb_ is set. Fixes #6872.
2014-09-11 06:58:07 +00:00
return PerformMemoryCopy(dest ^ 0x00400000, dest, size);
Double check upload/download are VRAM addresses.
2014-06-20 05:52:45 +00:00
}
return false;
Clean up the framebuffer force downloads.
2014-05-31 06:33:50 +00:00
}
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.
Double check upload/download are VRAM addresses.
2014-06-20 05:52:45 +00:00
if (Memory::IsVRAMAddress(dest)) {
Fix infinite recursion in framebuf create upload. Needs to be done *after* currentRenderVfb_ is set. Fixes #6872.
2014-09-11 06:58:07 +00:00
return PerformMemoryCopy(dest, dest ^ 0x00400000, size);
Double check upload/download are VRAM addresses.
2014-06-20 05:52:45 +00:00
}
return false;
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
}
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() {
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
resized_ = true;
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
}
Make sure not to leak any enabled vertex arrays. When returning to EmuScreen, we need to reset any enabled vertex arrays or we could crash in EmuScreen. Also, when starting a frame / dirting the shader, make sure also to toggle the vertex arrays.
2014-06-23 04:42:29 +00:00
void GLES_GPU::CleanupBeforeUI() {
// Clear any enabled vertex arrays.
shaderManager_->DirtyLastShader();
Fix issue where on-screen UI might be invisible in non-buffered rendering
2015-02-04 16:28:31 +00:00
glstate.arrayBuffer.bind(0);
glstate.elementArrayBuffer.bind(0);
Make sure not to leak any enabled vertex arrays. When returning to EmuScreen, we need to reset any enabled vertex arrays or we could crash in EmuScreen. Also, when starting a frame / dirting the shader, make sure also to toggle the vertex arrays.
2014-06-23 04:42:29 +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();
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
shaderManager_->ClearCache(true);
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
}
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) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
u32 fb_address = gstate.getFrameBufRawAddress();
int fb_stride = gstate.FrameBufStride();
GEBufferFormat format = gstate.FrameBufFormat();
return framebufferManager_.GetFramebuffer(fb_address, fb_stride, format, buffer);
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
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) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
u32 fb_address = gstate.getFrameBufRawAddress();
int fb_stride = gstate.FrameBufStride();
u32 z_address = gstate.getDepthBufRawAddress();
int z_stride = gstate.DepthBufStride();
return framebufferManager_.GetDepthbuffer(fb_address, fb_stride, z_address, z_stride, buffer);
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::GetCurrentStencilbuffer(GPUDebugBuffer &buffer) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
u32 fb_address = gstate.getFrameBufRawAddress();
int fb_stride = gstate.FrameBufStride();
return framebufferManager_.GetStencilbuffer(fb_address, fb_stride, buffer);
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
}
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);
Oops, fix texture preview in GE debugger.
2015-10-13 04:40:47 +00:00
textureCache_.ApplyTexture();
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;
}
Remove a whole lot of flipping special cases
2015-10-31 22:59:23 +00:00
buffer.Allocate(w, h, GE_FORMAT_8888, false);
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
dx9: Take screenshots (fixes #7197.)
2014-12-20 16:31:56 +00:00
bool GLES_GPU::GetDisplayFramebuffer(GPUDebugBuffer &buffer) {
return FramebufferManager::GetDisplayFramebuffer(buffer);
}
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;
}
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
std::vector<std::string> GLES_GPU::DebugGetShaderIDs(DebugShaderType type) {
Make it possible to view vertex decoders through the shader viewing mechanism (even though they aren't strictly shaders, they fit the model).
2015-10-21 21:06:32 +00:00
if (type == SHADER_TYPE_VERTEXLOADER) {
return transformDraw_.DebugGetVertexLoaderIDs();
} else {
return shaderManager_->DebugGetShaderIDs(type);
}
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
}
Make it possible to view vertex decoders through the shader viewing mechanism (even though they aren't strictly shaders, they fit the model).
2015-10-21 21:06:32 +00:00
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
std::string GLES_GPU::DebugGetShaderString(std::string id, DebugShaderType type, DebugShaderStringType stringType) {
Make it possible to view vertex decoders through the shader viewing mechanism (even though they aren't strictly shaders, they fit the model).
2015-10-21 21:06:32 +00:00
if (type == SHADER_TYPE_VERTEXLOADER) {
return transformDraw_.DebugGetVertexLoaderString(id, stringType);
} else {
return shaderManager_->DebugGetShaderString(id, type, stringType);
}
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
}
Reference in New Issue Copy Permalink