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
e4cb44c243
ppsspp/GPU/GLES/GPU_GLES.cpp

1988 lines
68 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"
GraphicsContext: Abstract away things like swapbuffers etc before adding even more backends. Needed to prevent clutter all over the codebase. Does not go all the way yet, goal would be a common render loop between platforms but not there yet.
2015-12-31 15:59:40 +00:00
#include "Common/GraphicsContext.h"
Start untangling our include mess a little.
2013-12-29 22:28:31 +00:00
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"
GL Cleanup: No longer redundantly store the shader ID inside the shader objects
2016-01-17 19:29:34 +00:00
#include "Core/ELF/ParamSFO.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"
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
#include "GPU/GLES/ShaderManagerGLES.h"
Rename the TransformPipeline files to DrawEngine, and GLES_GPU to GPU_GLES
2016-04-10 08:27:28 +00:00
#include "GPU/GLES/GPU_GLES.h"
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
#include "GPU/GLES/FramebufferManagerGLES.h"
Rename the TransformPipeline files to DrawEngine, and GLES_GPU to GPU_GLES
2016-04-10 08:27:28 +00:00
#include "GPU/GLES/DrawEngineGLES.h"
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
#include "GPU/GLES/TextureCacheGLES.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,
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,
Move uniform dirty-flag to gstate_c, opening up for other uses.
2017-01-23 22:15:54 +00:00
FLAG_DIRTYONCHANGE = 64, // NOTE: Either this or FLAG_EXECUTE*, not both!
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 {
Move uniform dirty-flag to gstate_c, opening up for other uses.
2017-01-23 22:15:54 +00:00
uint8_t cmd;
uint8_t flags;
uint64_t dirtyUniform;
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
GPU_GLES::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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_FramebufType},
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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOLOR, &GPU_GLES::Execute_FogColor},
{GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_GLES::Execute_FogCoef},
{GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_FOGCOEF, &GPU_GLES::Execute_FogCoef},
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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexMapMode},
{GE_CMD_TEXSCALEU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexScaleU},
{GE_CMD_TEXSCALEV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexScaleV},
{GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::Execute_TexOffsetU},
{GE_CMD_TEXOFFSETV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_UVSCALEOFFSET, &GPU_GLES::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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_GLES::Execute_TexSize0},
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexSizeN},
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexFormat},
{GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexLevel},
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddr0},
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexBufwN},
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},
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::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},
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::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},
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORMASK, &GPU_GLES::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},
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK, &GPU_GLES::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_TEXENV, &GPU_GLES::Execute_TexEnvColor},
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},
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_STENCILREPLACEVALUE, &GPU_GLES::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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType},
{GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType},
{GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType},
{GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_ViewportType},
{GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_GLES::Execute_ViewportZType},
{GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_DEPTHRANGE, &GPU_GLES::Execute_ViewportZType},
Simulate depth clamping. We'll allow extra space in both directions. It's not exactly right, but it's a fast approximation.
2016-01-19 04:53:38 +00:00
{GE_CMD_CLIPENABLE, 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
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
// Region
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Region},
GLES: Add GE_CMD_ZWRITEDISABLE to ZTEST section
2013-10-08 01:29:51 +00:00
// Scissor
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::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...
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_GLES::Execute_Ambient},
{GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_AMBIENT, &GPU_GLES::Execute_Ambient},
{GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATDIFFUSE, &GPU_GLES::Execute_MaterialDiffuse},
{GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATEMISSIVE, &GPU_GLES::Execute_MaterialEmissive},
{GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_GLES::Execute_MaterialAmbient},
{GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATAMBIENTALPHA, &GPU_GLES::Execute_MaterialAmbient},
{GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_GLES::Execute_MaterialSpecular},
{GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_MATSPECULAR, &GPU_GLES::Execute_MaterialSpecular},
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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT0, &GPU_GLES::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT1, &GPU_GLES::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT2, &GPU_GLES::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, DIRTY_LIGHT3, &GPU_GLES::Execute_Light3Param},
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_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?
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_PRIM, FLAG_EXECUTE, 0, &GPU_GLES::Execute_Prim},
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_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?
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_VADDR, FLAG_EXECUTE, 0, &GPU_GLES::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, 0, &GPU_GLES::Execute_Iaddr},
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_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_BJump}, // EXECUTE
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, 0, &GPU_GLES::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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPU_GLES::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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &GPU_GLES::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, 0, &GPU_GLES::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...
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPU_GLES::Execute_LoadClut},
Centralize EstimatePerVertexCost and Execute_BlockTransferStart
2017-01-23 15:57:16 +00:00
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_GLES::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_GLES::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_GLES::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_GLES::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPU_GLES::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPU_GLES::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
};
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
GPU_GLES::CommandInfo GPU_GLES::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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
GPU_GLES::GPU_GLES(GraphicsContext *ctx)
Centralize "Resized()"
2016-12-21 17:13:58 +00:00
: gfxCtx_(ctx) {
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
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_ = new ShaderManagerGLES();
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
framebufferManagerGL_ = new FramebufferManagerGLES();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManager_ = framebufferManagerGL_;
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
textureCacheGL_ = new TextureCacheGLES();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCache_ = textureCacheGL_;
Fix crash bug
2017-01-23 20:08:16 +00:00
drawEngineCommon_ = &drawEngine_;
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManager_ = shaderManagerGL_;
Minor optimizations
2017-01-23 20:08:16 +00:00
drawEngineCommon_ = &drawEngine_;
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
drawEngine_.SetShaderManager(shaderManagerGL_);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
drawEngine_.SetTextureCache(textureCacheGL_);
drawEngine_.SetFramebufferManager(framebufferManagerGL_);
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.SetFragmentTestCache(&fragmentTestCache_);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->Init();
framebufferManagerGL_->SetTextureCache(textureCacheGL_);
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
framebufferManagerGL_->SetShaderManager(shaderManagerGL_);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->SetTransformDrawEngine(&drawEngine_);
textureCacheGL_->SetFramebufferManager(framebufferManagerGL_);
textureCacheGL_->SetDepalShaderCache(&depalShaderCache_);
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
textureCacheGL_->SetShaderManager(shaderManagerGL_);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->SetTransformDrawEngine(&drawEngine_);
fragmentTestCache_.SetTextureCache(textureCacheGL_);
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) {
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
cmdInfo_[cmd].func = &GPU_GLES::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();
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.RestoreVAO();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->NotifyConfigChanged();
Hook up GL shader cache. Cache linked shader programs.
2016-01-17 16:11:51 +00:00
// Load shader cache.
Disable the shader cache for homebrew and other things that lack disc_id
2016-01-17 20:35:24 +00:00
std::string discID = g_paramSFO.GetValueString("DISC_ID");
if (discID.size()) {
Use the app cache directory on Android for the shader cache.
2016-01-17 21:11:28 +00:00
File::CreateFullPath(GetSysDirectory(DIRECTORY_APP_CACHE));
shaderCachePath_ = GetSysDirectory(DIRECTORY_APP_CACHE) + "/" + g_paramSFO.GetValueString("DISC_ID") + ".glshadercache";
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->LoadAndPrecompile(shaderCachePath_);
Disable the shader cache for homebrew and other things that lack disc_id
2016-01-17 20:35:24 +00:00
}
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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
GPU_GLES::~GPU_GLES() {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->DestroyAllFBOs(true);
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->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();
Use the app cache directory on Android for the shader cache.
2016-01-17 21:11:28 +00:00
if (!shaderCachePath_.empty()) {
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->Save(shaderCachePath_);
Use the app cache directory on Android for the shader cache.
2016-01-17 21:11:28 +00:00
}
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
delete shaderManagerGL_;
shaderManagerGL_ = nullptr;
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
#ifdef _WIN32
GraphicsContext: Abstract away things like swapbuffers etc before adding even more backends. Needed to prevent clutter all over the codebase. Does not go all the way yet, goal would be a common render loop between platforms but not there yet.
2015-12-31 15:59:40 +00:00
gfxCtx_->SwapInterval(0);
Remove silly use of gstate.SetVSyncInterval
2015-09-06 11:36:33 +00:00
#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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::CheckGPUFeatures() {
Start moving GPU feature compatibility decisions to startup (and a single, cache-friendly flag field)
2015-09-05 17:58:47 +00:00
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 {
android: Change preprocessor define to standard __ANDROID__ ANDROID is only standard to the old Makefile buildsystem, not the platform.
2016-10-12 09:13:16 +00:00
#ifdef __ANDROID__
Disable dual source blending on nvidia Android. See #8243
2016-06-05 07:14:33 +00:00
// This appears to be broken on nVidia Shield TV.
if (gl_extensions.gpuVendor != GPU_VENDOR_NVIDIA) {
features |= GPU_SUPPORTS_DUALSOURCE_BLEND;
}
#else
Fix some naming, remove NV_draw_texture, move decisions out
2015-09-05 20:11:28 +00:00
features |= GPU_SUPPORTS_DUALSOURCE_BLEND;
Disable dual source blending on nvidia Android. See #8243
2016-06-05 07:14:33 +00:00
#endif
Fix some naming, remove NV_draw_texture, move decisions out
2015-09-05 20:11:28 +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
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) {
Allow shader framebuffer fetch on GLES3 only. Note: before we did not support it properly on GLES3 devices.
2016-04-09 19:08:43 +00:00
// This has caused problems in the past. Let's only enable on GLES3.
if (features & GPU_SUPPORTS_GLSL_ES_300) {
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
}
Add flag for core GL contexts. Since using VBOs all the time is slower.
2015-12-15 05:12:50 +00:00
if (gl_extensions.ARB_vertex_array_object && gl_extensions.IsCoreContext) {
Use a VAO for all drawing, and VBOs throughout.
2015-12-14 06:48:21 +00:00
features |= GPU_SUPPORTS_VAO;
}
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
Cleanup differences in aniso handling. Some places were not handling it as a power of two.
2016-03-18 04:56:04 +00:00
features |= GPU_SUPPORTS_ANISOTROPY;
Add fallbacks where low quality depth is required. Even on GLES2, this should work. Also check the depth before applying rounding - we might even already be 24-bit.
2016-01-21 06:01:18 +00:00
// If we already have a 16-bit depth buffer, we don't need to round.
if (fbo_standard_z_depth() > 16) {
Fallback to per-vertex depth rounding on GLES2. Instead of not-working 24->16 now that it's disabled.
2016-02-07 04:42:01 +00:00
if (!g_Config.bHighQualityDepth && (features & GPU_SUPPORTS_ACCURATE_DEPTH) != 0) {
Add fallbacks where low quality depth is required. Even on GLES2, this should work. Also check the depth before applying rounding - we might even already be 24-bit.
2016-01-21 06:01:18 +00:00
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
} else if (PSP_CoreParameter().compat.flags().PixelDepthRounding) {
if (!gl_extensions.IsGLES || gl_extensions.GLES3) {
// Use fragment rounding on desktop and GLES3, most accurate.
features |= GPU_ROUND_FRAGMENT_DEPTH_TO_16BIT;
Fallback to per-vertex depth rounding on GLES2. Instead of not-working 24->16 now that it's disabled.
2016-02-07 04:42:01 +00:00
} else if (fbo_standard_z_depth() == 24 && (features & GPU_SUPPORTS_ACCURATE_DEPTH) != 0) {
Add fallbacks where low quality depth is required. Even on GLES2, this should work. Also check the depth before applying rounding - we might even already be 24-bit.
2016-01-21 06:01:18 +00:00
// Here we can simulate a 16 bit depth buffer by scaling.
// Note that the depth buffer is fixed point, not floating, so dividing by 256 is pretty good.
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
} else {
// At least do vertex rounding if nothing else.
features |= GPU_ROUND_DEPTH_TO_16BIT;
}
} else if (PSP_CoreParameter().compat.flags().VertexDepthRounding) {
features |= GPU_ROUND_DEPTH_TO_16BIT;
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
}
}
Reduce use of #ifdef USING_GLES2 some more
2015-09-05 21:09:06 +00:00
Bring back the depth range hack.
2016-02-07 04:28:45 +00:00
// The Phantasy Star hack :(
if (PSP_CoreParameter().compat.flags().DepthRangeHack && (features & GPU_SUPPORTS_ACCURATE_DEPTH) == 0) {
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.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::BuildReportingInfo() {
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
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);
Use the new way for GL_EXTENSIONS in reporting too.
2015-12-23 23:30:08 +00:00
const char *glExtensions = nullptr;
if (gl_extensions.VersionGEThan(3, 0)) {
glExtensions = g_all_gl_extensions.c_str();
} else {
glExtensions = GetGLStringAlways(GL_EXTENSIONS);
}
Reporting: catch information about the GPU.
2013-04-29 00:49:17 +00:00
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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::DeviceLost() {
Rename the TransformPipeline files to DrawEngine, and GLES_GPU to GPU_GLES
2016-04-10 08:27:28 +00:00
ILOG("GPU_GLES: 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.
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->ClearCache(false);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->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();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->DeviceLost();
Android: Add both a lost and restore phase. Lost = delete, restore = create. Let's stick to never overlapping. May help #8912.
2016-09-11 03:29:58 +00:00
}
void GPU_GLES::DeviceRestore() {
ILOG("GPU_GLES: DeviceRestore");
Update vsync on resize, and before first FBO. May take care of #4440.
2014-06-15 22:19:49 +00:00
Workaround the lack of support for software skinning in Vulkan
2017-01-23 21:06:30 +00:00
UpdateCmdInfo();
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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::ReinitializeInternal() {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->Clear(true);
Destroy all FBOs/textures upon sceKernelLoadExec(). It can confuse our heuristics about size, attachment, memcpy, etc.
2014-06-28 19:29:09 +00:00
depalShaderCache_.Clear();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->DestroyAllFBOs(true);
framebufferManagerGL_->Resized();
Destroy all FBOs/textures upon sceKernelLoadExec(). It can confuse our heuristics about size, attachment, memcpy, etc.
2014-06-28 19:29:09 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::DumpNextFrame() {
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
dumpNextFrame_ = true;
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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);
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
inline void GPU_GLES::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 {
GraphicsContext: Abstract away things like swapbuffers etc before adding even more backends. Needed to prevent clutter all over the codebase. Does not go all the way yet, goal would be a common render loop between platforms but not there yet.
2015-12-31 15:59:40 +00:00
gfxCtx_->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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::UpdateCmdInfo() {
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
if (g_Config.bSoftwareSkinning) {
cmdInfo_[GE_CMD_VERTEXTYPE].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GPU_GLES::Execute_VertexTypeSkinning;
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
} else {
cmdInfo_[GE_CMD_VERTEXTYPE].flags |= FLAG_FLUSHBEFOREONCHANGE;
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GPU_GLES::Execute_VertexType;
Allow changing prescale uv at runtime.
2014-06-29 04:51:25 +00:00
}
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::ReapplyGfxStateInternal() {
drawEngine_.RestoreVAO();
Remove glstate usage except in the GPU implementation. Prepare for moving it into PPSSPP.
2015-09-06 10:23:14 +00:00
glstate.Restore();
GPUCommon::ReapplyGfxStateInternal();
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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();
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.Resized();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->NotifyConfigChanged();
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
}
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
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->StartFrame();
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.DecimateTrackedVertexArrays();
drawEngine_.DecimateBuffers();
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;
}
GL Cleanup: No longer redundantly store the shader ID inside the shader objects
2016-01-17 19:29:34 +00:00
Hook up GL shader cache. Cache linked shader programs.
2016-01-17 16:11:51 +00:00
// Save the cache from time to time. TODO: How often?
Use the app cache directory on Android for the shader cache.
2016-01-17 21:11:28 +00:00
if (!shaderCachePath_.empty() && (gpuStats.numFlips & 1023) == 0) {
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->Save(shaderCachePath_);
Disable the shader cache for homebrew and other things that lack disc_id
2016-01-17 20:35:24 +00:00
}
Hook up GL shader cache. Cache linked shader programs.
2016-01-17 16:11:51 +00:00
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->DirtyShader();
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
// Not sure if this is really needed.
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_ALL_UNIFORMS);
Cleanup GPU init/shutdown a bit
2012-12-25 14:28:34 +00:00
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::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
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
VirtualFramebuffer *vfb = framebufferManagerGL_->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;
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::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();
}
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
VirtualFramebuffer *vfb = framebufferManagerGL_->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;
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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.
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->RebindFramebuffer();
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.Flush();
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
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->DirtyLastShader();
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
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);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->CopyDisplayToOutput();
framebufferManagerGL_->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
Split TextureChanged into two bools, so we can later convert to dirtyflags
2017-01-24 08:31:36 +00:00
// Wait, why?
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
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...
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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))) {
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::FinishDeferred() {
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +00:00
// This finishes reading any vertex data that is pending.
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.FinishDeferred();
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
inline void GPU_GLES::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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Vaddr(u32 op, u32 diff) {
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
gstate_c.vertexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Iaddr(u32 op, u32 diff) {
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
gstate_c.indexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Prim(u32 op, u32 diff) {
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
// 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;
Ignore upper bits of prim type. This matches tests on what hardware does.
2016-04-10 20:11:55 +00:00
// Upper bits are ignored.
GEPrimitiveType prim = static_cast<GEPrimitiveType>((data >> 16) & 7);
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
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.
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), 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)) {
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.SetupVertexDecoder(gstate.vertType);
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
// Rough estimate, not sure what's correct.
Further centralization of EstimatePerVertexCost, now moved to GPUCommon
2017-01-23 20:00:44 +00:00
cyclesExecuted += EstimatePerVertexCost() * count;
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
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;
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.SubmitPrim(verts, inds, prim, count, gstate.vertType, &bytesRead);
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
Further centralization of EstimatePerVertexCost, now moved to GPUCommon
2017-01-23 20:00:44 +00:00
int vertexCost = EstimatePerVertexCost();
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
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.
Reduce some repetitive code.
2016-04-10 20:07:08 +00:00
AdvanceVerts(gstate.vertType, count, bytesRead);
Move a few GE cmds to separate funcs. 2% improvement in God Eater 2.
2014-04-16 15:01:56 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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)) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
}
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_VertexTypeSkinning(u32 op, u32 diff) {
Allow changing software skinning at runtime.
2014-06-29 04:37:41 +00:00
// 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))
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(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) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(gstate_c.deferredVertTypeDirty);
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
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
}
}
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
void GPU_GLES::Execute_Bezier(u32 op, u32 diff) {
// This also make skipping drawing very effective.
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +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);
}
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;
bool computeNormals = gstate.isLightingEnabled();
bool patchFacing = gstate.patchfacing & 1;
if (g_Config.bHardwareTessellation && g_Config.bHardwareTransform && !g_Config.bSoftwareRendering) {
gstate_c.bezier = true;
if (gstate_c.bezier_count_u != bz_ucount) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_BEZIERCOUNTU);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
gstate_c.bezier_count_u = bz_ucount;
}
}
int bytesRead = 0;
drawEngine_.SubmitBezier(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), bz_ucount, bz_vcount, patchPrim, computeNormals, patchFacing, gstate.vertType, &bytesRead);
gstate_c.bezier = false;
// After drawing, we advance pointers - see SubmitPrim which does the same.
int count = bz_ucount * bz_vcount;
AdvanceVerts(gstate.vertType, count, bytesRead);
}
void GPU_GLES::Execute_Spline(u32 op, u32 diff) {
// This also make skipping drawing very effective.
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
framebufferManagerGL_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +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);
}
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();
bool computeNormals = gstate.isLightingEnabled();
bool patchFacing = gstate.patchfacing & 1;
u32 vertType = gstate.vertType;
if (g_Config.bHardwareTessellation && g_Config.bHardwareTransform && !g_Config.bSoftwareRendering) {
gstate_c.spline = true;
if (gstate_c.spline_count_u != sp_ucount) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_SPLINECOUNTU);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
gstate_c.spline_count_u = sp_ucount;
}
if (gstate_c.spline_count_v != sp_vcount) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_SPLINECOUNTV);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
gstate_c.spline_count_v = sp_vcount;
}
if (gstate_c.spline_type_u != sp_utype) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_SPLINETYPEU);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
gstate_c.spline_type_u = sp_utype;
}
if (gstate_c.spline_type_v != sp_vtype) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_SPLINETYPEV);
[spline/bezier]Implement hardware tessellation on OpenGL.
2017-01-08 18:37:21 +00:00
gstate_c.spline_type_v = sp_vtype;
}
}
int bytesRead = 0;
drawEngine_.SubmitSpline(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), sp_ucount, sp_vcount, sp_utype, sp_vtype, patchPrim, computeNormals, patchFacing, vertType, &bytesRead);
gstate_c.spline = false;
// After drawing, we advance pointers - see SubmitPrim which does the same.
int count = sp_ucount * sp_vcount;
AdvanceVerts(gstate.vertType, count, bytesRead);
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Region(u32 op, u32 diff) {
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Scissor(u32 op, u32 diff) {
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_FramebufType(u32 op, u32 diff) {
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Move out texformat as well.
2014-04-17 15:29:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_ViewportType(u32 op, u32 diff) {
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Minor optimization
2015-08-26 16:46:55 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_ViewportZType(u32 op, u32 diff) {
Move framebufChanged into the dirty flag field
2017-01-23 22:25:09 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
gstate_c.Dirty(DIRTY_DEPTHRANGE);
Split out viewport type commands.
2014-04-18 05:49:09 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexScaleU(u32 op, u32 diff) {
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
gstate_c.uv.uScale = getFloat24(op);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexScaleV(u32 op, u32 diff) {
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
gstate_c.uv.vScale = getFloat24(op);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexOffsetU(u32 op, u32 diff) {
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
gstate_c.uv.uOff = getFloat24(op);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexOffsetV(u32 op, u32 diff) {
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
gstate_c.uv.vOff = getFloat24(op);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out the texscale/offset cmds.
2014-04-17 15:26:38 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexAddr0(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexAddrN(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexBufw0(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexBufwN(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexSize0(u32 op, u32 diff) {
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
// Render to texture may have overridden the width/height.
// Don't reset it unless the size is different / the texture has changed.
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
if (diff || gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS)) {
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
// We will need to reset the texture now.
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexSizeN(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexFormat(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
Move out texformat as well.
2014-04-17 15:29:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexMapMode(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexParamType(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out a few more common cmds.
2014-04-18 05:41:37 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexEnvColor(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXENV);
Move out texformat as well.
2014-04-17 15:29:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_TexLevel(u32 op, u32 diff) {
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
// 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;
}
*/
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_LoadClut(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes());
Move out texformat as well.
2014-04-17 15:29:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_ClutFormat(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
Split out the clutformat cmd as well.
2014-04-18 05:57:02 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Ambient(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_AMBIENT);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_MaterialDiffuse(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_MATDIFFUSE);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_MaterialEmissive(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_MATEMISSIVE);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_MaterialAmbient(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_MATAMBIENTALPHA);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_MaterialSpecular(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_MATSPECULAR);
Split out more of the top GE cmd funcs.
2014-04-17 07:22:32 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Light0Param(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_LIGHT0);
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Light1Param(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_LIGHT1);
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Light2Param(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_LIGHT2);
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_Light3Param(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_LIGHT3);
Move the light params to separate funcs.
2014-04-22 05:47:44 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_FogColor(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_FOGCOLOR);
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_FogCoef(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_FOGCOEF);
Separate out the fog color/coef executes.
2014-04-22 05:56:54 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_ColorTestMask(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_ALPHACOLORMASK);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_AlphaTest(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_StencilTest(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_STENCILREPLACEVALUE);
Split out the bounding box and stencil test cmds.
2014-04-18 05:51:45 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::Execute_ColorRef(u32 op, u32 diff) {
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_ALPHACOLORREF);
Split out some texture and testing cmds.
2014-04-17 15:18:43 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::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;
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
Centralize EstimatePerVertexCost and Execute_BlockTransferStart
2017-01-23 15:57:16 +00:00
case GE_CMD_TRANSFERSTART:
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;
}
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::GetStats(char *buffer, size_t bufsize) {
GPU stats: Have each backend format its own string.
2016-03-31 08:17:02 +00:00
float vertexAverageCycles = gpuStats.numVertsSubmitted > 0 ? (float)gpuStats.vertexGPUCycles / (float)gpuStats.numVertsSubmitted : 0.0f;
snprintf(buffer, bufsize - 1,
"DL processing time: %0.2f ms\n"
"Draw calls: %i, flushes %i\n"
"Cached Draw calls: %i\n"
"Num Tracked Vertex Arrays: %i\n"
"GPU cycles executed: %d (%f per vertex)\n"
"Commands per call level: %i %i %i %i\n"
"Vertices submitted: %i\n"
"Cached, Uncached Vertices Drawn: %i, %i\n"
"FBOs active: %i\n"
"Textures active: %i, decoded: %i invalidated: %i\n"
Forgot to remove these from the debug string.
2016-04-02 08:28:38 +00:00
"Vertex, Fragment, Programs loaded: %i, %i, %i\n",
GPU stats: Have each backend format its own string.
2016-03-31 08:17:02 +00:00
gpuStats.msProcessingDisplayLists * 1000.0f,
gpuStats.numDrawCalls,
gpuStats.numFlushes,
gpuStats.numCachedDrawCalls,
gpuStats.numTrackedVertexArrays,
gpuStats.vertexGPUCycles + gpuStats.otherGPUCycles,
vertexAverageCycles,
gpuStats.gpuCommandsAtCallLevel[0], gpuStats.gpuCommandsAtCallLevel[1], gpuStats.gpuCommandsAtCallLevel[2], gpuStats.gpuCommandsAtCallLevel[3],
gpuStats.numVertsSubmitted,
gpuStats.numCachedVertsDrawn,
gpuStats.numUncachedVertsDrawn,
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
(int)framebufferManagerGL_->NumVFBs(),
(int)textureCacheGL_->NumLoadedTextures(),
GPU stats: Have each backend format its own string.
2016-03-31 08:17:02 +00:00
gpuStats.numTexturesDecoded,
gpuStats.numTextureInvalidations,
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->NumVertexShaders(),
shaderManagerGL_->NumFragmentShaders(),
shaderManagerGL_->NumPrograms());
Reasonably correct viewport handling. Optional debug stats overlay (not always 100% working).
2012-11-26 16:35:08 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::ClearCacheNextFrame() {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->ClearNextFrame();
Fixed threading issue pointed out by unknownbrackets and made texture scaling changes apply immediately
2013-04-30 15:20:28 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::ClearShaderCache() {
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->ClearCache(true);
Better window resize handling
2013-01-26 23:15:39 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::CleanupBeforeUI() {
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
// Clear any enabled vertex arrays.
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
std::vector<FramebufferInfo> GPU_GLES::GetFramebufferList() {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
return framebufferManagerGL_->GetFramebufferList();
Add displayList debug dialog
2013-02-17 00:06:06 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
void GPU_GLES::DoState(PointerWrap &p) {
Better window resize handling
2013-01-26 23:15:39 +00:00
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) {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->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();
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
drawEngine_.ClearTrackedVertexArrays();
Better window resize handling
2013-01-26 23:15:39 +00:00
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_IMAGE);
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
framebufferManagerGL_->DestroyAllFBOs(true);
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
shaderManagerGL_->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 flag to use the display vfb for screenshots. This fixes proportions of reporting, savestate screenshots, and TAS recording for PS1 ports, mainly.
2016-09-25 23:31:38 +00:00
bool GPU_GLES::GetCurrentFramebuffer(GPUDebugBuffer &buffer, GPUDebugFramebufferType type, int maxRes) {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
u32 fb_address = type == GPU_DBG_FRAMEBUF_RENDER ? gstate.getFrameBufRawAddress() : framebufferManagerGL_->DisplayFramebufAddr();
int fb_stride = type == GPU_DBG_FRAMEBUF_RENDER ? gstate.FrameBufStride() : framebufferManagerGL_->DisplayFramebufStride();
GEBufferFormat format = type == GPU_DBG_FRAMEBUF_RENDER ? gstate.FrameBufFormat() : framebufferManagerGL_->DisplayFramebufFormat();
return framebufferManagerGL_->GetFramebuffer(fb_address, fb_stride, format, buffer, maxRes);
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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::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();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
return framebufferManagerGL_->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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::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();
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
return framebufferManagerGL_->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
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::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];
}
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
textureCacheGL_->SetTexture(true);
textureCacheGL_->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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::GetCurrentClut(GPUDebugBuffer &buffer) {
Centralize DoBlockTransfer between the GPUs. Required adding a pointer to the framebuffer manager and texture cache in GPUCommon, which took a little bit of refactoring.
2016-12-21 17:07:17 +00:00
return textureCacheGL_->GetCurrentClutBuffer(buffer);
gedbg: Add mechanics to grab CLUT buffer.
2016-01-10 17:25:19 +00:00
}
Cleanup display vs. output screenshot terminology.
2016-09-25 23:35:43 +00:00
bool GPU_GLES::GetOutputFramebuffer(GPUDebugBuffer &buffer) {
Rename GLES files to match the convention the other backends use.
2017-01-21 21:16:30 +00:00
return FramebufferManagerGLES::GetOutputFramebuffer(buffer);
dx9: Take screenshots (fixes #7197.)
2014-12-20 16:31:56 +00:00
}
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
return drawEngine_.GetCurrentSimpleVertices(count, vertices, indices);
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
}
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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
bool GPU_GLES::DescribeCodePtr(const u8 *ptr, std::string &name) {
if (drawEngine_.IsCodePtrVertexDecoder(ptr)) {
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
name = "VertexDecoderJit";
return true;
}
return false;
}
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
std::vector<std::string> GPU_GLES::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) {
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
return drawEngine_.DebugGetVertexLoaderIDs();
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
} else {
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
return shaderManagerGL_->DebugGetShaderIDs(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
}
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
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
std::string GPU_GLES::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) {
Rename some GPU classes and enums to fix some consistency issues between the backends.
2016-04-10 08:21:48 +00:00
return drawEngine_.DebugGetVertexLoaderString(id, 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
} else {
Extract the dirty flag from the shader managers so code that dirties uniform flags can be shared.
2017-01-23 19:48:23 +00:00
return shaderManagerGL_->DebugGetShaderString(id, type, 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
}
Add new shader viewing tool
2015-10-14 15:45:21 +00:00
}
Reference in New Issue Copy Permalink