Emulator-Archive/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2024-11-30 17:02:19 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
116b3ba8cc
ppsspp/GPU/GPUCommon.cpp

3612 lines
125 KiB
C++
Raw Normal View History

Build: Explicitly include ppsspp_config.h. This adds it to all files that use it. Not all our builds include the file.
2021-03-03 04:42:55 +00:00
#include "ppsspp_config.h"
Fix some NEON code that had bad compile-time checks (and some didn't compile)
2022-04-14 22:35:22 +00:00
#if defined(_M_SSE)
#include <emmintrin.h>
#endif
#if PPSSPP_ARCH(ARM_NEON)
#if defined(_MSC_VER) && PPSSPP_ARCH(ARM64)
#include <arm64_neon.h>
#else
#include <arm_neon.h>
#endif
#endif
Don't trigger an interrupt when cb = -1.
2013-04-02 06:54:19 +00:00
#include <algorithm>
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
#include <type_traits>
Big mutex overhaul - remove our custom ones, make them non-recursive where possible
2017-02-27 20:57:46 +00:00
#include <mutex>
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
Move the profiler to Common
2020-10-04 08:04:01 +00:00
#include "Common/Profiler/Profiler.h"
More vulkan microoptimizations. Add more profiler scopes.
2017-08-18 11:39:42 +00:00
Common: Move ColorConv to a more appropriate place.
2021-05-01 14:15:04 +00:00
#include "Common/Data/Convert/ColorConv.h"
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
#include "Common/GraphicsContext.h"
Reporting: Fix some header includes. Particularly in Common, avoid including Core/Reporting.h.
2022-12-27 22:58:20 +00:00
#include "Common/LogReporting.h"
SaveState: Rename ChunkFile files to Serialize. Makes more sense and less weird than ChunkFileDoMap, etc.
2020-08-10 07:12:51 +00:00
#include "Common/Serialize/Serializer.h"
#include "Common/Serialize/SerializeFuncs.h"
#include "Common/Serialize/SerializeList.h"
Move timeutil to Common. (Experiment to see how much work it is to move these).
2020-08-15 18:53:08 +00:00
#include "Common/TimeUtil.h"
Add a NEON color conv for 5551 -> 1555.
2015-05-23 17:33:24 +00:00
#include "GPU/GeDisasm.h"
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
#include "GPU/GPU.h"
Add a NEON color conv for 5551 -> 1555.
2015-05-23 17:33:24 +00:00
#include "GPU/GPUCommon.h"
#include "GPU/GPUState.h"
Avoid calling time_update in GE w/o debug stats. Just wastes time, especially if the game hammers sceGeListUpdateStallAddr, which many games do.
2013-04-21 22:16:45 +00:00
#include "Core/Config.h"
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
#include "Core/CoreTiming.h"
Debugger: Add more metadata for memory usage.
2021-02-02 08:08:05 +00:00
#include "Core/Debugger/MemBlockInfo.h"
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
#include "Core/MemMap.h"
Add debug dialogs (DisAsm, Memory, VFPU). New features : Breakpoint display, thread status, display list status Update translation and start french translation
2013-02-10 15:36:06 +00:00
#include "Core/Host.h"
Add some GPU related reporting.
2013-04-05 08:13:54 +00:00
#include "Core/Reporting.h"
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
#include "Core/HLE/HLE.h"
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
#include "Core/HLE/sceKernelMemory.h"
Return yet more errors while inside interrupts.
2013-08-29 06:15:13 +00:00
#include "Core/HLE/sceKernelInterrupt.h"
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
#include "Core/HLE/sceKernelThread.h"
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
#include "Core/HLE/sceGe.h"
Display: Account for stepping time in graphs. Frame times should count that as sleep too.
2022-01-30 18:46:50 +00:00
#include "Core/HW/Display.h"
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
#include "Core/MemMapHelpers.h"
UWP: Fix dialog rendering (PPGe).
2020-12-20 11:11:02 +00:00
#include "Core/Util/PPGeDraw.h"
GPU: Use hw tess only for hw transform. This may be needed if we start using software for points/lines.
2018-06-29 02:47:33 +00:00
#include "GPU/Common/DrawEngineCommon.h"
Rename FramebufferCommon.cpp/h to FramebufferManagerCommon.cpp/h for consistency
2020-08-03 21:17:22 +00:00
#include "GPU/Common/FramebufferManagerCommon.h"
GPU: Use hw tess only for hw transform. This may be needed if we start using software for points/lines.
2018-06-29 02:47:33 +00:00
#include "GPU/Common/SplineCommon.h"
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
#include "GPU/Common/TextureCacheCommon.h"
GE Debugger: Factor out host calls some. Moving more of this to cross platform for the web debugger.
2018-09-01 15:32:03 +00:00
#include "GPU/Debugger/Debugger.h"
GE Debugger: Initial structure for GE data dumping. This snapshots the GE commands and drawing to facilitate debugging.
2017-06-03 04:53:20 +00:00
#include "GPU/Debugger/Record.h"
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
const CommonCommandTableEntry commonCommandTable[] = {
Unify the control commands in the tables
2017-03-14 12:35:09 +00:00
// From Common. No flushing but definitely need execute.
{ GE_CMD_OFFSETADDR, FLAG_EXECUTE, 0, &GPUCommon::Execute_OffsetAddr },
{ GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_Origin },
{ 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 },
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
{ GE_CMD_END, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_End },
Unify the control commands in the tables
2017-03-14 12:35:09 +00:00
{ GE_CMD_VADDR, FLAG_EXECUTE, 0, &GPUCommon::Execute_Vaddr },
{ GE_CMD_IADDR, FLAG_EXECUTE, 0, &GPUCommon::Execute_Iaddr },
{ GE_CMD_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_BJump }, // EXECUTE
softgpu: Add a table and initial dirty flags. Not actually using the dirty flags to skip state, but have moved to Execute_* functions and everything else like other graphics backends.
2022-01-23 06:41:41 +00:00
{ GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, 0, &GPUCommon::Execute_BoundingBox }, // Shouldn't need to FLUSHBEFORE.
Unify the control commands in the tables
2017-03-14 12:35:09 +00:00
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
{ GE_CMD_PRIM, FLAG_EXECUTE, 0, &GPUCommon::Execute_Prim },
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
{ GE_CMD_BEZIER, FLAG_EXECUTE, 0, &GPUCommon::Execute_Bezier },
{ GE_CMD_SPLINE, FLAG_EXECUTE, 0, &GPUCommon::Execute_Spline },
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
// Changing the vertex type requires us to flush.
{ GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_VertexType },
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
Unify Execute_LoadClut
2018-02-26 10:26:52 +00:00
{ GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPUCommon::Execute_LoadClut },
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
// These two are actually processed in CMD_END.
{ GE_CMD_SIGNAL },
{ GE_CMD_FINISH },
Restore two accidentally deleted command table entries.
2017-03-14 14:44:39 +00:00
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
// Changes that dirty the framebuffer
{ GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS },
GPU: Dirty more correctly for cullrange params. Was previously missing some settings which might convince us to use large viewports, and more importantly some that would impact the depth settings under certain settings.
2018-09-22 04:55:11 +00:00
{ GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
GPU: Reset shader state on shader reset. Was ending up with lastFSID being -1, but being used. Seen in gpu/commands/blend test.
2017-09-20 15:30:34 +00:00
{ GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_FRAGMENTSHADER_STATE },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
{ GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE },
{ GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE },
{ GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOLOR },
Make fog-enable driven by uniform instead of fragment shader flag bit
2022-12-19 18:11:06 +00:00
{ GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE },
{ GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
Unify most of the rest of the command table entries
2017-03-14 12:47:34 +00:00
// These affect the fragment shader so need flushing.
GPU: Add dirtying for geo shader state. Not yet used, but dirtied at the right times.
2022-10-02 02:22:16 +00:00
{ GE_CMD_CLEARMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE | DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE },
{ GE_CMD_TEXTUREMAPENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE },
Make fog-enable driven by uniform instead of fragment shader flag bit
2022-12-19 18:11:06 +00:00
{ GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS | DIRTY_FRAGMENTSHADER_STATE },
All: Only recompute the vertex shader ID when dirty
2017-01-30 13:04:20 +00:00
{ GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
D3D9: Implement flat shading via state.
2018-04-28 23:31:39 +00:00
// Raster state for Direct3D 9, uncommon.
{ GE_CMD_SHADEMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_RASTER_STATE },
Switch the 2x flag to a uniform
2023-01-05 16:05:42 +00:00
{ GE_CMD_TEXFUNC, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAGMENTSHADER_STATE | DIRTY_TEX_ALPHA_MUL },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_COLORTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_ALPHATESTENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_COLORTESTENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORMASK | DIRTY_FRAGMENTSHADER_STATE },
Unify most of the rest of the command table entries
2017-03-14 12:47:34 +00:00
Unify some vertex shader related settings in the command tables
2017-03-14 12:44:18 +00:00
// These change the vertex shader so need flushing.
All: Only recompute the vertex shader ID when dirty
2017-01-30 13:04:20 +00:00
{ GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
GPU: Add dirtying for geo shader state. Not yet used, but dirtied at the right times.
2022-10-02 02:22:16 +00:00
{ GE_CMD_LIGHTINGENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE },
Experiment: Generate "Ubershaders" that can handle all lighting configurations This drastically reduces the shader compile stutter that happens when a lot of new light setups are created, like on the first punch in Tekken 6. There's more stuff that might benefit from being made dynamic like this. These branches are very cheap on modern GPUs since they're branching on a uniform variable, so no divergence. Only tested on Vulkan. I think we'll need to keep the old path too for gpus like Mali-450...
2022-09-25 11:59:52 +00:00
{ GE_CMD_LIGHTENABLE0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
{ GE_CMD_LIGHTENABLE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
{ GE_CMD_LIGHTENABLE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
{ GE_CMD_LIGHTENABLE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
Fix updating light constants when light type changes (we handle dir/pos lights differently). Fixes #10132
2018-03-24 23:19:53 +00:00
{ GE_CMD_LIGHTTYPE0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_LIGHT0 },
{ GE_CMD_LIGHTTYPE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_LIGHT1 },
{ GE_CMD_LIGHTTYPE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_LIGHT2 },
{ GE_CMD_LIGHTTYPE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_LIGHT3 },
Remove suspicious dirty flag
2022-09-26 09:07:19 +00:00
{ GE_CMD_MATERIALUPDATE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
Unify some vertex shader related settings in the command tables
2017-03-14 12:44:18 +00:00
Removes LM flag from vshader in the common case, if ubershader is enabled.
2022-12-30 21:39:35 +00:00
// These change vertex shaders (in non uber shader mode) so need flushing.
{ GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
Unify some vertex shader related settings in the command tables
2017-03-14 12:44:18 +00:00
{ GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS | DIRTY_FRAGMENTSHADER_STATE },
Unify some vertex shader related settings in the command tables
2017-03-14 12:44:18 +00:00
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
// Uniform changes. though the fragmentshader optimizes based on these sometimes.
{ GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_ALPHACOLORMASK | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_ALPHACOLORREF | DIRTY_FRAGMENTSHADER_STATE },
Unify most of the rest of the command table entries
2017-03-14 12:47:34 +00:00
{ GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXENV },
// Simple render state changes. Handled in StateMapping.cpp.
All: Only convert raster state if dirty
2017-01-30 11:07:26 +00:00
{ GE_CMD_CULL, FLAG_FLUSHBEFOREONCHANGE, DIRTY_RASTER_STATE },
{ GE_CMD_CULLFACEENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_RASTER_STATE },
{ GE_CMD_DITHERENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_RASTER_STATE },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_STENCILOP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_FRAGMENTSHADER_STATE },
Clean up a small inconsistency
2017-12-07 20:08:34 +00:00
{ GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_STENCILREPLACEVALUE | DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_BLENDFIXEDA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_BLENDFIXEDB, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
GPU: Write stencil fail to alpha is RGB masked. See #15813 (Hunter x Hunter) which does this for shadows.
2022-08-10 01:45:27 +00:00
{ GE_CMD_MASKRGB, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_COLORWRITEMASK },
Get shader color write masking going on all backends.
2020-11-08 22:17:06 +00:00
{ GE_CMD_MASKALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_COLORWRITEMASK },
All: Only convert depth stencil state if dirty
2017-01-30 11:02:14 +00:00
{ GE_CMD_ZTEST, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHSTENCIL_STATE },
GPU: Dirty frag shader on depth write. We use this flag to determine whether we use discard, so it changes shader ids. Fixes the layering part of #11535.
2018-11-07 05:16:51 +00:00
{ GE_CMD_ZTESTENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHSTENCIL_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_ZWRITEDISABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHSTENCIL_STATE | DIRTY_FRAGMENTSHADER_STATE },
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_LOGICOP, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
{ GE_CMD_LOGICOPENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_FRAGMENTSHADER_STATE },
Unify fragment shader settings in the command table
2017-03-14 12:42:48 +00:00
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
{ GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE },
Fastpath in fastrunloop when diff=0. Remove need for Execute for UV scale/offset.
2017-08-17 11:53:13 +00:00
// These are read on every SubmitPrim, no need for dirtying or flushing.
{ GE_CMD_TEXSCALEU },
{ GE_CMD_TEXSCALEV },
{ GE_CMD_TEXOFFSETU },
{ GE_CMD_TEXOFFSETV },
Unify texture settings in the command tables
2017-03-14 12:39:32 +00:00
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
{ GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, 0, &GPUCommon::Execute_TexSize0 },
Unify texture settings in the command tables
2017-03-14 12:39:32 +00:00
{ GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE },
{ GE_CMD_TEXLEVEL, FLAG_EXECUTEONCHANGE, DIRTY_TEXTURE_PARAMS, &GPUCommon::Execute_TexLevel },
GPU: Flush on mipmap slope change.
2017-05-13 03:05:35 +00:00
{ GE_CMD_TEXLODSLOPE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
Unify texture settings in the command tables
2017-03-14 12:39:32 +00:00
{ GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE | DIRTY_UVSCALEOFFSET },
{ GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_IMAGE },
{ GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
{ GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS },
// These must flush on change, so that LoadClut doesn't have to always flush.
{ GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE },
{ GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE },
Shader depal: Implement bilinear filtering.
2018-04-13 10:45:10 +00:00
{ GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS | DIRTY_DEPAL },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
Unify morph weight, patch parameter command table entries
2017-03-14 12:30:03 +00:00
// Morph weights. TODO: Remove precomputation?
{ GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
{ GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, 0, &GPUCommon::Execute_MorphWeight },
// Control spline/bezier patches. Don't really require flushing as such, but meh.
{ GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE },
{ GE_CMD_PATCHPRIMITIVE, FLAG_FLUSHBEFOREONCHANGE },
All: Only recompute the vertex shader ID when dirty
2017-01-30 13:04:20 +00:00
{ GE_CMD_PATCHFACING, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE },
Unify morph weight, patch parameter command table entries
2017-03-14 12:30:03 +00:00
{ GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE },
Unify logicop, antialias in the command table
2017-03-14 12:37:12 +00:00
// Can probably ignore this one as we don't support AA lines.
{ GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE },
Unify viewport/region/scissor command table entries
2017-03-14 12:28:28 +00:00
// Viewport.
GPU: Dirty more correctly for cullrange params. Was previously missing some settings which might convince us to use large viewports, and more importantly some that would impact the depth settings under certain settings.
2018-09-22 04:55:11 +00:00
{ GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
{ GE_CMD_OFFSETY, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
GLES: Update proj matrix on viewport change. This is necessary because, for large (or negative) viewports, we adjust it to account for what GL cannot do. Fixes #12115.
2019-06-23 23:47:44 +00:00
{ GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
{ GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
{ GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
{ GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
GLES: Implement vertex range culling. Based on tests, skips triangles with any point outside the 4096x4096 box, except when depth clamping would engage.
2018-09-17 05:52:43 +00:00
{ GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
{ GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_CULLRANGE | DIRTY_DEPTHRANGE | DIRTY_PROJMATRIX | DIRTY_VIEWPORTSCISSOR_STATE },
{ GE_CMD_DEPTHCLAMPENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE | DIRTY_RASTER_STATE },
Unify viewport/region/scissor command table entries
2017-03-14 12:28:28 +00:00
Unify minz/maxz in command tables
2017-03-14 12:41:13 +00:00
// Z clip
GPU: Dirty more correctly for cullrange params. Was previously missing some settings which might convince us to use large viewports, and more importantly some that would impact the depth settings under certain settings.
2018-09-22 04:55:11 +00:00
{ GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
{ GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE, DIRTY_DEPTHRANGE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
Unify minz/maxz in command tables
2017-03-14 12:41:13 +00:00
Unify viewport/region/scissor command table entries
2017-03-14 12:28:28 +00:00
// Region
GPU: Dirty more correctly for cullrange params. Was previously missing some settings which might convince us to use large viewports, and more importantly some that would impact the depth settings under certain settings.
2018-09-22 04:55:11 +00:00
{ GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
{ GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
Unify viewport/region/scissor command table entries
2017-03-14 12:28:28 +00:00
// Scissor
GPU: Dirty more correctly for cullrange params. Was previously missing some settings which might convince us to use large viewports, and more importantly some that would impact the depth settings under certain settings.
2018-09-22 04:55:11 +00:00
{ GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
{ GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAMEBUF | DIRTY_TEXTURE_PARAMS | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE },
Unify viewport/region/scissor command table entries
2017-03-14 12:28:28 +00:00
Unify the light parameter table entries
2017-03-14 12:26:53 +00:00
// Lighting base colors
{ GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT },
{ GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_AMBIENT },
{ GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATDIFFUSE },
{ GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATEMISSIVE },
{ GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA },
{ GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATAMBIENTALPHA },
{ GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR },
{ GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE, DIRTY_MATSPECULAR },
// Light parameters
{ GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT0 },
{ GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT1 },
{ GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT2 },
{ GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
{ GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE, DIRTY_LIGHT3 },
Unify some ignored command table entries
2017-03-14 12:25:52 +00:00
// Ignored commands
{ GE_CMD_TEXFLUSH, 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 },
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
{ GE_CMD_TRANSFERSTART, FLAG_EXECUTE | FLAG_READS_PC, 0, &GPUCommon::Execute_BlockTransferStart },
Unify some ignored command table entries
2017-03-14 12:25:52 +00:00
Unify matrix, dither and signal table entries
2017-03-14 12:24:35 +00:00
// We don't use the dither table.
{ GE_CMD_DITH0 },
{ GE_CMD_DITH1 },
{ GE_CMD_DITH2 },
{ GE_CMD_DITH3 },
// These handle their own flushing.
{ GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_WorldMtxNum },
{ GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_WorldMtxData },
{ GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_ViewMtxNum },
{ GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_ViewMtxData },
{ GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_ProjMtxNum },
{ GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_ProjMtxData },
{ GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_TgenMtxNum },
{ GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_TgenMtxData },
{ GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, 0, &GPUCommon::Execute_BoneMtxNum },
{ GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, 0, &GPUCommon::Execute_BoneMtxData },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
// Vertex Screen/Texture/Color
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
{ GE_CMD_VSCX },
{ GE_CMD_VSCY },
{ GE_CMD_VSCZ },
{ GE_CMD_VTCS },
{ GE_CMD_VTCT },
{ GE_CMD_VTCQ },
{ GE_CMD_VCV },
{ GE_CMD_VAP, FLAG_EXECUTE, 0, &GPUCommon::Execute_ImmVertexAlphaPrim },
{ GE_CMD_VFC },
{ GE_CMD_VSCV },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
// "Missing" commands (gaps in the sequence)
{ GE_CMD_UNKNOWN_03, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_0D, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_11, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_29, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_34, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_35, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_39, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_4E, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_4F, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_52, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_59, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_5A, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_B6, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_B7, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_D1, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_ED, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_EF, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_FA, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_FB, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_FC, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_FD, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
{ GE_CMD_UNKNOWN_FE, FLAG_EXECUTE, 0, &GPUCommon::Execute_Unknown },
// Appears to be debugging related or something? Hit a lot in GoW.
Minor GPU disassembler update
2017-08-05 16:15:01 +00:00
{ GE_CMD_NOP_FF, 0 },
Setup a global GPU command table, and start moving stuff into it.
2017-03-14 12:21:24 +00:00
};
GPU: Unify command table (cmdInfo_)
2018-02-26 10:44:02 +00:00
// TODO: Make class member?
GPUCommon::CommandInfo GPUCommon::cmdInfo_[256];
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
void GPUCommon::Flush() {
drawEngineCommon_->DispatchFlush();
}
GE Debugger: Add option to auto flush. This makes it easier to see what's happening in each draw.
2022-01-22 21:12:59 +00:00
void GPUCommon::DispatchFlush() {
drawEngineCommon_->DispatchFlush();
}
Pass in the DrawContext to all backends
2017-01-30 15:50:35 +00:00
GPUCommon::GPUCommon(GraphicsContext *gfxCtx, Draw::DrawContext *draw) :
gfxCtx_(gfxCtx),
draw_(draw)
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
{
Fix and clarify comments
2015-10-11 16:42:32 +00:00
// This assert failed on GCC x86 32-bit (but not MSVC 32-bit!) before adding the
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
// "padding" field at the end. This is important for save state compatibility.
Fix and clarify comments
2015-10-11 16:42:32 +00:00
// The compiler was not rounding the struct size up to an 8 byte boundary, which
// you'd expect due to the int64 field, but the Linux ABI apparently does not require that.
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
static_assert(sizeof(DisplayList) == 456, "Bad DisplayList size");
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
Reinitialize();
Minor GPU interface cleanup
2016-01-06 22:49:02 +00:00
gstate.Reset();
gstate_c.Reset();
Forgot to remove these from the debug string.
2016-04-02 08:28:38 +00:00
gpuStats.Reset();
GPU: Unify command table (cmdInfo_)
2018-02-26 10:44:02 +00:00
memset(cmdInfo_, 0, sizeof(cmdInfo_));
Turn off the inner interpreter when stepping in the GE debugger. Fix comment.
2018-03-02 06:06:58 +00:00
// Convert the command table to a faster format, and check for dupes.
GPU: Unify command table (cmdInfo_)
2018-02-26 10:44:02 +00:00
std::set<u8> dupeCheck;
softgpu: Add a table and initial dirty flags. Not actually using the dirty flags to skip state, but have moved to Execute_* functions and everything else like other graphics backends.
2022-01-23 06:41:41 +00:00
for (size_t i = 0; i < ARRAY_SIZE(commonCommandTable); i++) {
GPU: Unify command table (cmdInfo_)
2018-02-26 10:44:02 +00:00
const u8 cmd = commonCommandTable[i].cmd;
if (dupeCheck.find(cmd) != dupeCheck.end()) {
ERROR_LOG(G3D, "Command table Dupe: %02x (%i)", (int)cmd, (int)cmd);
} else {
dupeCheck.insert(cmd);
}
cmdInfo_[cmd].flags |= (uint64_t)commonCommandTable[i].flags | (commonCommandTable[i].dirty << 8);
cmdInfo_[cmd].func = commonCommandTable[i].func;
if ((cmdInfo_[cmd].flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) && !cmdInfo_[cmd].func) {
Turn off the inner interpreter when stepping in the GE debugger. Fix comment.
2018-03-02 06:06:58 +00:00
// Can't have FLAG_EXECUTE commands without a function pointer to execute.
GPU: Unify command table (cmdInfo_)
2018-02-26 10:44:02 +00:00
Crash();
}
}
// 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);
}
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
UpdateCmdInfo();
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
UpdateVsyncInterval(true);
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
ResetMatrices();
UWP: Fix dialog rendering (PPGe).
2020-12-20 11:11:02 +00:00
PPGeSetDrawContext(draw);
Don't refer directly to g_Config.iMultiSampleLevel, it can contain unsupported modes.
2022-12-14 14:15:31 +00:00
UpdateMSAALevel(draw);
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
}
GPUCommon::~GPUCommon() {
UWP: Fix dialog rendering (PPGe).
2020-12-20 11:11:02 +00:00
// Probably not necessary.
PPGeSetDrawContext(nullptr);
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
void GPUCommon::UpdateCmdInfo() {
if (g_Config.bSoftwareSkinning) {
cmdInfo_[GE_CMD_VERTEXTYPE].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GPUCommon::Execute_VertexTypeSkinning;
} else {
cmdInfo_[GE_CMD_VERTEXTYPE].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &GPUCommon::Execute_VertexType;
}
Ge: Keep jump/call optim when fast memory on. This gives a way to validate with fast memory off, and get less crashes.
2018-08-25 17:38:56 +00:00
if (g_Config.bFastMemory) {
cmdInfo_[GE_CMD_JUMP].func = &GPUCommon::Execute_JumpFast;
cmdInfo_[GE_CMD_CALL].func = &GPUCommon::Execute_CallFast;
} else {
cmdInfo_[GE_CMD_JUMP].func = &GPUCommon::Execute_Jump;
cmdInfo_[GE_CMD_CALL].func = &GPUCommon::Execute_Call;
}
Experiment: Generate "Ubershaders" that can handle all lighting configurations This drastically reduces the shader compile stutter that happens when a lot of new light setups are created, like on the first punch in Tekken 6. There's more stuff that might benefit from being made dynamic like this. These branches are very cheap on modern GPUs since they're branching on a uniform variable, so no divergence. Only tested on Vulkan. I think we'll need to keep the old path too for gpus like Mali-450...
2022-09-25 11:59:52 +00:00
// Reconfigure for light ubershader or not.
for (int i = 0; i < 4; i++) {
Rename gstate_c.Supports to gstate_c.Use
2022-10-17 06:27:49 +00:00
if (gstate_c.Use(GPU_USE_LIGHT_UBERSHADER)) {
Experiment: Generate "Ubershaders" that can handle all lighting configurations This drastically reduces the shader compile stutter that happens when a lot of new light setups are created, like on the first punch in Tekken 6. There's more stuff that might benefit from being made dynamic like this. These branches are very cheap on modern GPUs since they're branching on a uniform variable, so no divergence. Only tested on Vulkan. I think we'll need to keep the old path too for gpus like Mali-450...
2022-09-25 11:59:52 +00:00
cmdInfo_[GE_CMD_LIGHTENABLE0 + i].RemoveDirty(DIRTY_VERTEXSHADER_STATE);
cmdInfo_[GE_CMD_LIGHTENABLE0 + i].AddDirty(DIRTY_LIGHT_CONTROL);
cmdInfo_[GE_CMD_LIGHTTYPE0 + i].RemoveDirty(DIRTY_VERTEXSHADER_STATE);
cmdInfo_[GE_CMD_LIGHTTYPE0 + i].AddDirty(DIRTY_LIGHT_CONTROL);
} else {
cmdInfo_[GE_CMD_LIGHTENABLE0 + i].RemoveDirty(DIRTY_LIGHT_CONTROL);
cmdInfo_[GE_CMD_LIGHTENABLE0 + i].AddDirty(DIRTY_VERTEXSHADER_STATE);
cmdInfo_[GE_CMD_LIGHTTYPE0 + i].RemoveDirty(DIRTY_LIGHT_CONTROL);
cmdInfo_[GE_CMD_LIGHTTYPE0 + i].AddDirty(DIRTY_VERTEXSHADER_STATE);
}
}
Fold the "materialUpdate" flag into the light ubershader part. This reduces the number of vertex shaders and thus pipelines by quite a bit more in a few games, like Tekken and GoW, continuing the fight against shader compile stutter. The perf impact should be minimal if not positive due to less pipeline changes. GLES fixes Make the vertex input declarations match (always declare fog input). Fixes D3D11 validation Tess fix
2022-09-26 09:20:17 +00:00
Rename gstate_c.Supports to gstate_c.Use
2022-10-17 06:27:49 +00:00
if (gstate_c.Use(GPU_USE_LIGHT_UBERSHADER)) {
Fold the "materialUpdate" flag into the light ubershader part. This reduces the number of vertex shaders and thus pipelines by quite a bit more in a few games, like Tekken and GoW, continuing the fight against shader compile stutter. The perf impact should be minimal if not positive due to less pipeline changes. GLES fixes Make the vertex input declarations match (always declare fog input). Fixes D3D11 validation Tess fix
2022-09-26 09:20:17 +00:00
cmdInfo_[GE_CMD_MATERIALUPDATE].RemoveDirty(DIRTY_VERTEXSHADER_STATE);
cmdInfo_[GE_CMD_MATERIALUPDATE].AddDirty(DIRTY_LIGHT_CONTROL);
Removes LM flag from vshader in the common case, if ubershader is enabled.
2022-12-30 21:39:35 +00:00
cmdInfo_[GE_CMD_LIGHTMODE].AddDirty(DIRTY_LIGHT_CONTROL);
Fold the "materialUpdate" flag into the light ubershader part. This reduces the number of vertex shaders and thus pipelines by quite a bit more in a few games, like Tekken and GoW, continuing the fight against shader compile stutter. The perf impact should be minimal if not positive due to less pipeline changes. GLES fixes Make the vertex input declarations match (always declare fog input). Fixes D3D11 validation Tess fix
2022-09-26 09:20:17 +00:00
} else {
cmdInfo_[GE_CMD_MATERIALUPDATE].RemoveDirty(DIRTY_LIGHT_CONTROL);
cmdInfo_[GE_CMD_MATERIALUPDATE].AddDirty(DIRTY_VERTEXSHADER_STATE);
Removes LM flag from vshader in the common case, if ubershader is enabled.
2022-12-30 21:39:35 +00:00
cmdInfo_[GE_CMD_LIGHTMODE].RemoveDirty(DIRTY_LIGHT_CONTROL);
Fold the "materialUpdate" flag into the light ubershader part. This reduces the number of vertex shaders and thus pipelines by quite a bit more in a few games, like Tekken and GoW, continuing the fight against shader compile stutter. The perf impact should be minimal if not positive due to less pipeline changes. GLES fixes Make the vertex input declarations match (always declare fog input). Fixes D3D11 validation Tess fix
2022-09-26 09:20:17 +00:00
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
}
Minor GPU interface change needed for a WIP backend
2016-01-06 22:53:21 +00:00
void GPUCommon::BeginHostFrame() {
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
UpdateVsyncInterval(displayResized_);
Minor GPU interface change needed for a WIP backend
2016-01-06 22:53:21 +00:00
ReapplyGfxState();
Ensure everything is dirty on frame start.
2017-03-19 17:40:23 +00:00
// TODO: Assume config may have changed - maybe move to resize.
gstate_c.Dirty(DIRTY_ALL);
Some minor "centralization"
2022-11-21 16:55:30 +00:00
UpdateCmdInfo();
Don't refer directly to g_Config.iMultiSampleLevel, it can contain unsupported modes.
2022-12-14 14:15:31 +00:00
UpdateMSAALevel(draw_);
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
CheckConfigChanged();
CheckDisplayResized();
CheckRenderResized();
Minor GPU interface change needed for a WIP backend
2016-01-06 22:53:21 +00:00
}
void GPUCommon::EndHostFrame() {
Some minor "centralization"
2022-11-21 16:55:30 +00:00
// Probably not necessary.
Test crashfix
2022-11-21 18:57:59 +00:00
if (draw_) {
Add a flags parameter to InvalidateCachedState and rename it Invalidate. Also rename the old InvalidationFlags enum to InvalidateCallbackFlags.
2022-12-01 18:15:38 +00:00
draw_->Invalidate(InvalidationFlags::CACHED_RENDER_STATE);
Test crashfix
2022-11-21 18:57:59 +00:00
}
Minor GPU interface change needed for a WIP backend
2016-01-06 22:53:21 +00:00
}
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
void GPUCommon::Reinitialize() {
Fix a vshader id bit collision, avoid color test when set to 'ALWAYS', zeroinitialize dls.
2013-04-15 20:57:54 +00:00
memset(dls, 0, sizeof(dls));
Implement sceGeListSync().
2013-04-06 09:28:49 +00:00
for (int i = 0; i < DisplayListMaxCount; ++i) {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
dls[i].state = PSP_GE_DL_STATE_NONE;
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
dls[i].waitTicks = 0;
Implement sceGeListSync().
2013-04-06 09:28:49 +00:00
}
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
nextListID = 0;
Delete the mutex in GPUCommon.
2017-11-05 18:44:07 +00:00
currentList = nullptr;
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
isbreak = false;
drawCompleteTicks = 0;
busyTicks = 0;
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
timeSpentStepping_ = 0.0;
Reinitialize the GE on sceKernelLoadExec(). Mostly, reset the lists and draw completion, etc. May be required for Capcom Classic Collection Reloaded to work.
2013-11-28 23:34:41 +00:00
interruptsEnabled_ = true;
GPU: Centralize DestroyAllFBOs(). This cleans up the postshader update code.
2020-05-13 07:06:13 +00:00
if (textureCache_)
textureCache_->Clear(true);
if (framebufferManager_)
framebufferManager_->DestroyAllFBOs();
Get rid of a bunch of sync stuff that's no longer needed.
2017-11-05 19:10:05 +00:00
}
Reorganize the DeviceLost code a little. FramebufferManagerCommon now sees it.
2020-11-06 23:56:48 +00:00
// Call at the END of the GPU implementation's DeviceLost
void GPUCommon::DeviceLost() {
framebufferManager_->DeviceLost();
draw_ = nullptr;
}
// Call at the start of the GPU implementation's DeviceRestore
void GPUCommon::DeviceRestore() {
draw_ = (Draw::DrawContext *)PSP_CoreParameter().graphicsContext->GetDrawContext();
framebufferManager_->DeviceRestore(draw_);
UWP: Fix dialog rendering (PPGe).
2020-12-20 11:11:02 +00:00
PPGeSetDrawContext(draw_);
Reorganize the DeviceLost code a little. FramebufferManagerCommon now sees it.
2020-11-06 23:56:48 +00:00
}
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
void GPUCommon::UpdateVsyncInterval(bool force) {
UI: Fix consistency in vsync setting for iOS.
2020-07-20 00:02:01 +00:00
#if !(PPSSPP_PLATFORM(ANDROID) || defined(USING_QT_UI) || PPSSPP_PLATFORM(UWP) || PPSSPP_PLATFORM(IOS))
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
int desiredVSyncInterval = g_Config.bVSync ? 1 : 0;
Rename Unthrottle to Fast-forward globally
2021-08-17 14:48:47 +00:00
if (PSP_CoreParameter().fastForward) {
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
desiredVSyncInterval = 0;
}
if (PSP_CoreParameter().fpsLimit != FPSLimit::NORMAL) {
UI: Add analog speed limit mapping. Only shows up as a setting if mapped, to avoid cluttering settings.
2022-07-04 20:10:42 +00:00
int limit;
if (PSP_CoreParameter().fpsLimit == FPSLimit::CUSTOM1)
limit = g_Config.iFpsLimit1;
else if (PSP_CoreParameter().fpsLimit == FPSLimit::CUSTOM2)
limit = g_Config.iFpsLimit2;
else
limit = PSP_CoreParameter().analogFpsLimit;
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
// For an alternative speed that is a clean factor of 60, the user probably still wants vsync.
if (limit == 0 || (limit >= 0 && limit != 15 && limit != 30 && limit != 60)) {
desiredVSyncInterval = 0;
}
}
if (desiredVSyncInterval != lastVsync_ || force) {
// 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... (gl_extensions.EXT_swap_control_tear)
// See http://developer.download.nvidia.com/opengl/specs/WGL_EXT_swap_control_tear.txt
Headless: Prevent crash running graphics tests.
2020-03-08 18:10:16 +00:00
if (gfxCtx_)
gfxCtx_->SwapInterval(desiredVSyncInterval);
GPU: Centralize vsync interval logic. We already do unthrottle checking here.
2020-03-01 06:27:00 +00:00
lastVsync_ = desiredVSyncInterval;
}
#endif
}
Further centralization of EstimatePerVertexCost, now moved to GPUCommon
2017-01-23 20:00:44 +00:00
int GPUCommon::EstimatePerVertexCost() {
// TODO: This is transform cost, also account for rasterization cost somehow... although it probably
// runs in parallel with transform.
// Also, this is all pure guesswork. If we can find a way to do measurements, that would be great.
// GTA wants a low value to run smooth, GoW wants a high value (otherwise it thinks things
// went too fast and starts doing all the work over again).
int cost = 20;
if (gstate.isLightingEnabled()) {
cost += 10;
for (int i = 0; i < 4; i++) {
if (gstate.isLightChanEnabled(i))
Reduce the estimated transform cost of an additional light from 10 to 7 cycles, see #5530.
2018-07-15 10:13:25 +00:00
cost += 7;
Further centralization of EstimatePerVertexCost, now moved to GPUCommon
2017-01-23 20:00:44 +00:00
}
}
if (gstate.getUVGenMode() != GE_TEXMAP_TEXTURE_COORDS) {
cost += 20;
}
int morphCount = gstate.getNumMorphWeights();
if (morphCount > 1) {
cost += 5 * morphCount;
}
return cost;
}
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
void GPUCommon::PopDLQueue() {
if(!dlQueue.empty()) {
dlQueue.pop_front();
if(!dlQueue.empty()) {
bool running = currentList->state == PSP_GE_DL_STATE_RUNNING;
currentList = &dls[dlQueue.front()];
if (running)
currentList->state = PSP_GE_DL_STATE_RUNNING;
} else {
Delete GPUCommon::ScheduleEvent
2017-11-05 19:15:57 +00:00
currentList = nullptr;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
}
}
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
}
A paused list will allow a context save. Just not stall, drawing, etc.
2013-09-22 02:31:54 +00:00
bool GPUCommon::BusyDrawing() {
u32 state = DrawSync(1);
if (state == PSP_GE_LIST_DRAWING || state == PSP_GE_LIST_STALLING) {
if (currentList && currentList->state != PSP_GE_DL_STATE_PAUSED) {
return true;
}
}
return false;
}
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
void GPUCommon::NotifyConfigChanged() {
configChanged_ = true;
}
void GPUCommon::NotifyRenderResized() {
renderResized_ = true;
}
void GPUCommon::NotifyDisplayResized() {
displayResized_ = true;
Centralize "Resized()"
2016-12-21 17:13:58 +00:00
}
Safer and simpler alternative to cbfa4bf. See #16483
2022-12-03 10:14:08 +00:00
void GPUCommon::ClearCacheNextFrame() {
textureCache_->ClearNextFrame();
}
Fix resizing issue. Took some refactoring.
2022-11-20 11:57:32 +00:00
// Called once per frame. Might also get called during the pause screen
// if "transparent".
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
void GPUCommon::CheckConfigChanged() {
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
if (configChanged_) {
Revert "Centralize ClearCacheNextFrame" This reverts commit cbfa4bfc8eef3a5f0e09e0ea2c3113bb2a88a7d5.
2022-12-02 13:32:27 +00:00
ClearCacheNextFrame();
Add accessor for UseFlags
2022-12-13 15:53:53 +00:00
gstate_c.SetUseFlags(CheckGPUFeatures());
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
drawEngineCommon_->NotifyConfigChanged();
textureCache_->NotifyConfigChanged();
Move post-processing settings to DisplayLayoutScreen
2022-11-22 22:29:50 +00:00
framebufferManager_->NotifyConfigChanged();
Fix resizing issue. Took some refactoring.
2022-11-20 11:57:32 +00:00
BuildReportingInfo();
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
configChanged_ = false;
}
Move post-processing settings to DisplayLayoutScreen
2022-11-22 22:29:50 +00:00
Test fix
2022-11-23 07:52:46 +00:00
// Check needed when running tests.
if (framebufferManager_) {
framebufferManager_->CheckPostShaders();
}
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
}
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
void GPUCommon::CheckDisplayResized() {
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
if (displayResized_) {
One more refactoring step
2022-11-21 13:54:48 +00:00
framebufferManager_->NotifyDisplayResized();
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
displayResized_ = false;
}
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
}
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
Only check for display resized in emuscreen-under-pause-screen, not the other changes.
2022-11-21 16:59:56 +00:00
void GPUCommon::CheckRenderResized() {
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
if (renderResized_) {
Don't refer directly to g_Config.iMultiSampleLevel, it can contain unsupported modes.
2022-12-14 14:15:31 +00:00
framebufferManager_->NotifyRenderResized(msaaLevel_);
Split up the GPU config change notifications
2022-11-21 14:14:20 +00:00
renderResized_ = false;
Fix resizing issue. Took some refactoring.
2022-11-20 11:57:32 +00:00
}
}
GPU: Refactor common frame dumping code.
2017-06-03 02:39:11 +00:00
void GPUCommon::DumpNextFrame() {
dumpNextFrame_ = true;
}
Refactor some GPU methods to return errors.
2013-04-01 06:23:03 +00:00
u32 GPUCommon::DrawSync(int mode) {
Count listsyncs and drawsyncs in gpu stats. Eat some cycles in listSync Chose a conservative number (same as sceGeContinue)
2023-02-07 21:59:46 +00:00
gpuStats.numDrawSyncs++;
Cleanup a few GPU error codes.
2013-04-01 06:42:56 +00:00
if (mode < 0 || mode > 1)
return SCE_KERNEL_ERROR_INVALID_MODE;
Return more correct values in sceGeDrawSync().
2013-04-04 06:31:01 +00:00
if (mode == 0) {
Refuse a few more waits w/ dispatch/intr disabled.
2013-08-28 15:13:44 +00:00
if (!__KernelIsDispatchEnabled()) {
return SCE_KERNEL_ERROR_CAN_NOT_WAIT;
}
Return yet more errors while inside interrupts.
2013-08-29 06:15:13 +00:00
if (__IsInInterrupt()) {
return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT;
}
Refuse a few more waits w/ dispatch/intr disabled.
2013-08-28 15:13:44 +00:00
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
if (drawCompleteTicks > CoreTiming::GetTicks()) {
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
__GeWaitCurrentThread(GPU_SYNC_DRAW, 1, "GeDrawSync");
Implement sceGeDrawSync().
2013-04-06 05:38:19 +00:00
} else {
for (int i = 0; i < DisplayListMaxCount; ++i) {
if (dls[i].state == PSP_GE_DL_STATE_COMPLETED) {
dls[i].state = PSP_GE_DL_STATE_NONE;
}
}
}
Return more correct values in sceGeDrawSync().
2013-04-04 06:31:01 +00:00
return 0;
}
Implement sceGeDrawSync().
2013-04-06 05:38:19 +00:00
// If there's no current list, it must be complete.
DisplayList *top = NULL;
for (auto it = dlQueue.begin(), end = dlQueue.end(); it != end; ++it) {
if (dls[*it].state != PSP_GE_DL_STATE_COMPLETED) {
top = &dls[*it];
break;
}
}
if (!top || top->state == PSP_GE_DL_STATE_COMPLETED)
Return more correct values in sceGeDrawSync().
2013-04-04 06:31:01 +00:00
return PSP_GE_LIST_COMPLETED;
if (currentList->pc == currentList->stall)
return PSP_GE_LIST_STALLING;
return PSP_GE_LIST_DRAWING;
Refactor some GPU methods to return errors.
2013-04-01 06:23:03 +00:00
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
void GPUCommon::CheckDrawSync() {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (dlQueue.empty()) {
for (int i = 0; i < DisplayListMaxCount; ++i)
dls[i].state = PSP_GE_DL_STATE_NONE;
}
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
int GPUCommon::ListSync(int listid, int mode) {
Count listsyncs and drawsyncs in gpu stats. Eat some cycles in listSync Chose a conservative number (same as sceGeContinue)
2023-02-07 21:59:46 +00:00
gpuStats.numListSyncs++;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (listid < 0 || listid >= DisplayListMaxCount)
return SCE_KERNEL_ERROR_INVALID_ID;
Cleanup a few GPU error codes.
2013-04-01 06:42:56 +00:00
if (mode < 0 || mode > 1)
return SCE_KERNEL_ERROR_INVALID_MODE;
Implement sceGeListSync().
2013-04-06 09:28:49 +00:00
DisplayList& dl = dls[listid];
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
if (mode == 1) {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
switch (dl.state) {
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
case PSP_GE_DL_STATE_QUEUED:
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (dl.interrupted)
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
return PSP_GE_LIST_PAUSED;
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
return PSP_GE_LIST_QUEUED;
case PSP_GE_DL_STATE_RUNNING:
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (dl.pc == dl.stall)
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
return PSP_GE_LIST_STALLING;
return PSP_GE_LIST_DRAWING;
case PSP_GE_DL_STATE_COMPLETED:
return PSP_GE_LIST_COMPLETED;
case PSP_GE_DL_STATE_PAUSED:
return PSP_GE_LIST_PAUSED;
default:
return SCE_KERNEL_ERROR_INVALID_ID;
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
}
}
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
Refuse a few more waits w/ dispatch/intr disabled.
2013-08-28 15:13:44 +00:00
if (!__KernelIsDispatchEnabled()) {
return SCE_KERNEL_ERROR_CAN_NOT_WAIT;
Return yet more errors while inside interrupts.
2013-08-29 06:15:13 +00:00
}
if (__IsInInterrupt()) {
return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT;
Refuse a few more waits w/ dispatch/intr disabled.
2013-08-28 15:13:44 +00:00
}
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
if (dl.waitTicks > CoreTiming::GetTicks()) {
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
__GeWaitCurrentThread(GPU_SYNC_LIST, listid, "GeListSync");
Implement sceGeListSync().
2013-04-06 09:28:49 +00:00
}
Handle displaylist state more like the PSP. All these changes from Orphis' hard work. Things still looking good.
2013-04-04 06:05:54 +00:00
return PSP_GE_LIST_COMPLETED;
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
}
Add support for sceGeGetStack() for debugging.
2013-09-21 17:03:49 +00:00
int GPUCommon::GetStack(int index, u32 stackPtr) {
Delete the mutex in GPUCommon.
2017-11-05 18:44:07 +00:00
if (!currentList) {
Add support for sceGeGetStack() for debugging.
2013-09-21 17:03:49 +00:00
// Seems like it doesn't return an error code?
return 0;
}
if (currentList->stackptr <= index) {
return SCE_KERNEL_ERROR_INVALID_INDEX;
}
if (index >= 0) {
Global: Correct many endian types and casts.
2021-02-19 06:25:24 +00:00
auto stack = PSPPointer<u32_le>::Create(stackPtr);
Add support for sceGeGetStack() for debugging.
2013-09-21 17:03:49 +00:00
if (stack.IsValid()) {
auto entry = currentList->stack[index];
// Not really sure what most of these values are.
stack[0] = 0;
stack[1] = entry.pc + 4;
stack[2] = entry.offsetAddr;
stack[7] = entry.baseAddr;
}
}
return currentList->stackptr;
}
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
static void CopyMatrix24(u32_le *result, const float *mtx, u32 count, u32 cmdbits) {
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
for (u32 i = 0; i < count; ++i) {
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
result[i] = toFloat24(mtx[i]) | cmdbits;
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
}
}
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
bool GPUCommon::GetMatrix24(GEMatrixType type, u32_le *result, u32 cmdbits) {
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
switch (type) {
case GE_MTX_BONE0:
case GE_MTX_BONE1:
case GE_MTX_BONE2:
case GE_MTX_BONE3:
case GE_MTX_BONE4:
case GE_MTX_BONE5:
case GE_MTX_BONE6:
case GE_MTX_BONE7:
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
CopyMatrix24(result, gstate.boneMatrix + (type - GE_MTX_BONE0) * 12, 12, cmdbits);
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
break;
case GE_MTX_TEXGEN:
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
CopyMatrix24(result, gstate.tgenMatrix, 12, cmdbits);
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
break;
case GE_MTX_WORLD:
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
CopyMatrix24(result, gstate.worldMatrix, 12, cmdbits);
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
break;
case GE_MTX_VIEW:
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
CopyMatrix24(result, gstate.viewMatrix, 12, cmdbits);
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
break;
case GE_MTX_PROJECTION:
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
CopyMatrix24(result, gstate.projMatrix, 16, cmdbits);
Ge: Move matrix reading into GPU. Let's keep managing its state / registers internal.
2022-09-28 03:20:46 +00:00
break;
default:
return false;
}
return true;
}
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
void GPUCommon::ResetMatrices() {
// This means we restored a context, so update the visible matrix data.
for (size_t i = 0; i < ARRAY_SIZE(gstate.boneMatrix); ++i)
matrixVisible.bone[i] = toFloat24(gstate.boneMatrix[i]);
for (size_t i = 0; i < ARRAY_SIZE(gstate.worldMatrix); ++i)
matrixVisible.world[i] = toFloat24(gstate.worldMatrix[i]);
for (size_t i = 0; i < ARRAY_SIZE(gstate.viewMatrix); ++i)
matrixVisible.view[i] = toFloat24(gstate.viewMatrix[i]);
for (size_t i = 0; i < ARRAY_SIZE(gstate.projMatrix); ++i)
matrixVisible.proj[i] = toFloat24(gstate.projMatrix[i]);
for (size_t i = 0; i < ARRAY_SIZE(gstate.tgenMatrix); ++i)
matrixVisible.tgen[i] = toFloat24(gstate.tgenMatrix[i]);
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
// Assume all the matrices changed, so dirty things related to them.
gstate_c.Dirty(DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_PROJMATRIX | DIRTY_TEXMATRIX | DIRTY_FRAGMENTSHADER_STATE | DIRTY_BONE_UNIFORMS);
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
}
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
u32 GPUCommon::EnqueueList(u32 listpc, u32 stall, int subIntrBase, PSPPointer<PspGeListArgs> args, bool head) {
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
// TODO Check the stack values in missing arg and ajust the stack depth
// Check alignment
// TODO Check the context and stack alignement too
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
if (((listpc | stall) & 3) != 0 || !Memory::IsValidAddress(listpc)) {
ERROR_LOG_REPORT(G3D, "sceGeListEnqueue: invalid address %08x", listpc);
Add errors and rescheduling to sceDmac*. The functionality seems pretty straight-forward.
2013-09-29 23:51:49 +00:00
return SCE_KERNEL_ERROR_INVALID_POINTER;
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
}
Move the check from #12908 into the firmware version check. The original change took care of #11660, let's hope it stay fixed. This fixes Toca (#12936).
2020-05-20 08:25:54 +00:00
Ge: Check stack depth based on args struct size. Matches tests against firmware.
2020-05-22 05:16:13 +00:00
// If args->size is below 16, it's the old struct without stack info.
if (args.IsValid() && args->size >= 16 && args->numStacks >= 256) {
return hleLogError(G3D, SCE_KERNEL_ERROR_INVALID_SIZE, "invalid stack depth %d", args->numStacks);
}
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
int id = -1;
EnqueueList: Relocate code that depends on compatibility check to simplify the code
2013-10-26 17:38:59 +00:00
u64 currentTicks = CoreTiming::GetTicks();
Global: Correct many endian types and casts.
2021-02-19 06:25:24 +00:00
u32 stackAddr = args.IsValid() && args->size >= 16 ? (u32)args->stackAddr : 0;
EnqueueList: Relocate code that depends on compatibility check to simplify the code
2013-10-26 17:38:59 +00:00
// Check compatibility
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (sceKernelGetCompiledSdkVersion() > 0x01FFFFFF) {
//numStacks = 0;
//stack = NULL;
EnqueueList: Relocate code that depends on compatibility check to simplify the code
2013-10-26 17:38:59 +00:00
for (int i = 0; i < DisplayListMaxCount; ++i) {
if (dls[i].state != PSP_GE_DL_STATE_NONE && dls[i].state != PSP_GE_DL_STATE_COMPLETED) {
Don't block duplicate enqueues when intr pending. Fixes #6138.
2014-05-26 01:52:31 +00:00
// Logically, if the CPU has not interrupted yet, it hasn't seen the latest pc either.
// Exit enqueues right after an END, which fails without ignoring pendingInterrupt lists.
if (dls[i].pc == listpc && !dls[i].pendingInterrupt) {
EnqueueList: Relocate code that depends on compatibility check to simplify the code
2013-10-26 17:38:59 +00:00
ERROR_LOG(G3D, "sceGeListEnqueue: can't enqueue, list address %08X already used", listpc);
return 0x80000021;
fix bracing
2014-08-18 23:04:36 +00:00
} else if (stackAddr != 0 && dls[i].stackAddr == stackAddr && !dls[i].pendingInterrupt) {
check for duplicated stack addresses Based on https://code.google.com/p/jpcsp/source/detail?r=3569 Fix WWE SmackDown! vs. RAW 2006
2014-08-13 13:15:30 +00:00
ERROR_LOG(G3D, "sceGeListEnqueue: can't enqueue, stack address %08X already used", stackAddr);
return 0x80000021;
}
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
}
}
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
}
VSync codepath only works on _WIN32 so only show it and check it there.
2013-10-27 13:09:46 +00:00
// TODO Check if list stack dls[i].stack already used then return 0x80000021 as above
EnqueueList: Relocate code that depends on compatibility check to simplify the code
2013-10-26 17:38:59 +00:00
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
for (int i = 0; i < DisplayListMaxCount; ++i) {
int possibleID = (i + nextListID) % DisplayListMaxCount;
auto possibleList = dls[possibleID];
if (possibleList.pendingInterrupt) {
continue;
}
if (possibleList.state == PSP_GE_DL_STATE_NONE) {
id = possibleID;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
break;
}
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
if (possibleList.state == PSP_GE_DL_STATE_COMPLETED && possibleList.waitTicks < currentTicks) {
id = possibleID;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
}
}
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
if (id < 0) {
Add some GPU related reporting.
2013-04-05 08:13:54 +00:00
ERROR_LOG_REPORT(G3D, "No DL ID available to enqueue");
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
for (auto it = dlQueue.begin(); it != dlQueue.end(); ++it) {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
DisplayList &dl = dls[*it];
DEBUG_LOG(G3D, "DisplayList %d status %d pc %08x stall %08x", *it, dl.state, dl.pc, dl.stall);
}
return SCE_KERNEL_ERROR_OUT_OF_MEMORY;
}
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
nextListID = id + 1;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
DisplayList &dl = dls[id];
dl.id = id;
Avoid some dangerous hex constant widths.
2013-08-23 06:23:48 +00:00
dl.startpc = listpc & 0x0FFFFFFF;
dl.pc = listpc & 0x0FFFFFFF;
dl.stall = stall & 0x0FFFFFFF;
Don't trigger an interrupt when cb = -1.
2013-04-02 06:54:19 +00:00
dl.subIntrBase = std::max(subIntrBase, -1);
Maintain the stack per displaylist, not globally.
2013-04-01 06:28:35 +00:00
dl.stackptr = 0;
Don't trigger an interrupt when cb = -1.
2013-04-02 06:54:19 +00:00
dl.signal = PSP_GE_SIGNAL_NONE;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
dl.interrupted = false;
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
dl.waitTicks = (u64)-1;
Enable interrupts as a property of the list. This way there's no behavior change when enqueue is async.
2013-08-07 06:59:28 +00:00
dl.interruptsEnabled = interruptsEnabled_;
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
dl.started = false;
Preseve offsetAddr on stall, instead of reset to 0. Only for new lists is it reset to 0, afaict.
2013-09-22 03:47:35 +00:00
dl.offsetAddr = 0;
Move GE_CMD_BJUMP to GPUCommon. Add the flag. (no actual bbox impl yet)
2013-09-24 10:59:34 +00:00
dl.bboxResult = false;
check for duplicated stack addresses Based on https://code.google.com/p/jpcsp/source/detail?r=3569 Fix WWE SmackDown! vs. RAW 2006
2014-08-13 13:15:30 +00:00
dl.stackAddr = stackAddr;
Move GE_CMD_BJUMP to GPUCommon. Add the flag. (no actual bbox impl yet)
2013-09-24 10:59:34 +00:00
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
if (args.IsValid() && args->context.IsValid())
dl.context = args->context;
else
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
dl.context = 0;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
if (head) {
if (currentList) {
if (currentList->state != PSP_GE_DL_STATE_PAUSED)
return SCE_KERNEL_ERROR_INVALID_VALUE;
currentList->state = PSP_GE_DL_STATE_QUEUED;
GPU: Forget pause signal on new list. Otherwise, when the list gets executed again, we just pause it when it finishes instead of letting it finish properly.
2019-07-07 20:10:28 +00:00
// Make sure we clear the signal so we don't try to pause it again.
currentList->signal = PSP_GE_SIGNAL_NONE;
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
}
dl.state = PSP_GE_DL_STATE_PAUSED;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
currentList = &dl;
dlQueue.push_front(id);
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
} else if (currentList) {
dl.state = PSP_GE_DL_STATE_QUEUED;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
dlQueue.push_back(id);
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
} else {
dl.state = PSP_GE_DL_STATE_RUNNING;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
currentList = &dl;
dlQueue.push_front(id);
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
drawCompleteTicks = (u64)-1;
Implement sceGeDrawSync().
2013-04-06 05:38:19 +00:00
Don't actually run sceGeListEnqueueHead right away.
2013-04-04 07:04:24 +00:00
// TODO save context when starting the list if param is set
ProcessDLQueue();
}
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
return id;
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
u32 GPUCommon::DequeueList(int listid) {
Implement sceGeListDeQueue(). Doesn't seem often used, though.
2013-04-05 06:25:13 +00:00
if (listid < 0 || listid >= DisplayListMaxCount || dls[listid].state == PSP_GE_DL_STATE_NONE)
return SCE_KERNEL_ERROR_INVALID_ID;
Refuse to dequeue a running/completed list.
2013-09-21 21:58:39 +00:00
auto &dl = dls[listid];
if (dl.started)
return SCE_KERNEL_ERROR_BUSY;
Implement sceGeListDeQueue(). Doesn't seem often used, though.
2013-04-05 06:25:13 +00:00
Refuse to dequeue a running/completed list.
2013-09-21 21:58:39 +00:00
dl.state = PSP_GE_DL_STATE_NONE;
Implement sceGeListDeQueue(). Doesn't seem often used, though.
2013-04-05 06:25:13 +00:00
if (listid == dlQueue.front())
PopDLQueue();
else
dlQueue.remove(listid);
Refuse to dequeue a running/completed list.
2013-09-21 21:58:39 +00:00
dl.waitTicks = 0;
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
__GeTriggerWait(GPU_SYNC_LIST, listid);
Implement sceGeListDeQueue(). Doesn't seem often used, though.
2013-04-05 06:25:13 +00:00
CheckDrawSync();
Refactor some GPU methods to return errors.
2013-04-01 06:23:03 +00:00
return 0;
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
u32 GPUCommon::UpdateStall(int listid, u32 newstall) {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (listid < 0 || listid >= DisplayListMaxCount || dls[listid].state == PSP_GE_DL_STATE_NONE)
Implement sceGeListDeQueue(). Doesn't seem often used, though.
2013-04-05 06:25:13 +00:00
return SCE_KERNEL_ERROR_INVALID_ID;
Don't update stall address on completed lists.
2013-09-21 21:54:07 +00:00
auto &dl = dls[listid];
if (dl.state == PSP_GE_DL_STATE_COMPLETED)
return SCE_KERNEL_ERROR_ALREADY;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
Don't update stall address on completed lists.
2013-09-21 21:54:07 +00:00
dl.stall = newstall & 0x0FFFFFFF;
Move display list management to common GPU class
2012-12-28 20:58:00 +00:00
ProcessDLQueue();
Refactor some GPU methods to return errors.
2013-04-01 06:23:03 +00:00
return 0;
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
u32 GPUCommon::Continue() {
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
if (!currentList)
return 0;
if (currentList->state == PSP_GE_DL_STATE_PAUSED)
{
GPU: Forget pause signal on new list. Otherwise, when the list gets executed again, we just pause it when it finishes instead of letting it finish properly.
2019-07-07 20:10:28 +00:00
if (!isbreak) {
Handle GE pause signals per tests. They really should pause, but we were resetting them incorrectly. And most importantly, sceGeContinue() inside the signal handler absolutely must work. Games use this a lot.
2014-04-12 06:32:34 +00:00
// TODO: Supposedly this returns SCE_KERNEL_ERROR_BUSY in some case, previously it had
// currentList->signal == PSP_GE_SIGNAL_HANDLER_PAUSE, but it doesn't reproduce.
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
currentList->state = PSP_GE_DL_STATE_RUNNING;
currentList->signal = PSP_GE_SIGNAL_NONE;
// TODO Restore context of DL is necessary
// TODO Restore BASE
Implement sceGeDrawSync().
2013-04-06 05:38:19 +00:00
// We have a list now, so it's not complete.
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
drawCompleteTicks = (u64)-1;
GPU: Forget pause signal on new list. Otherwise, when the list gets executed again, we just pause it when it finishes instead of letting it finish properly.
2019-07-07 20:10:28 +00:00
} else {
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
currentList->state = PSP_GE_DL_STATE_QUEUED;
GPU: Forget pause signal on new list. Otherwise, when the list gets executed again, we just pause it when it finishes instead of letting it finish properly.
2019-07-07 20:10:28 +00:00
currentList->signal = PSP_GE_SIGNAL_NONE;
}
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
}
else if (currentList->state == PSP_GE_DL_STATE_RUNNING)
{
if (sceKernelGetCompiledSdkVersion() >= 0x02000000)
return 0x80000020;
return -1;
}
else
{
if (sceKernelGetCompiledSdkVersion() >= 0x02000000)
return 0x80000004;
return -1;
}
ProcessDLQueue();
Refactor some GPU methods to return errors.
2013-04-01 06:23:03 +00:00
return 0;
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
u32 GPUCommon::Break(int mode) {
Cleanup a few GPU error codes.
2013-04-01 06:42:56 +00:00
if (mode < 0 || mode > 1)
return SCE_KERNEL_ERROR_INVALID_MODE;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
if (!currentList)
Error and reporting for sceGeBreak's second param.
2013-09-22 02:07:02 +00:00
return SCE_KERNEL_ERROR_ALREADY;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
if (mode == 1)
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
{
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
// Clear the queue
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
dlQueue.clear();
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
for (int i = 0; i < DisplayListMaxCount; ++i)
{
dls[i].state = PSP_GE_DL_STATE_NONE;
dls[i].signal = PSP_GE_SIGNAL_NONE;
}
Allocate ge list ids using round robin. Even if you enqueue and then dequeue 0, you don't get it again right away.
2013-09-21 20:18:20 +00:00
nextListID = 0;
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
currentList = NULL;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
return 0;
}
if (currentList->state == PSP_GE_DL_STATE_NONE || currentList->state == PSP_GE_DL_STATE_COMPLETED)
{
if (sceKernelGetCompiledSdkVersion() >= 0x02000000)
return 0x80000004;
return -1;
}
if (currentList->state == PSP_GE_DL_STATE_PAUSED)
{
if (sceKernelGetCompiledSdkVersion() > 0x02000010)
{
if (currentList->signal == PSP_GE_SIGNAL_HANDLER_PAUSE)
{
Add some GPU related reporting.
2013-04-05 08:13:54 +00:00
ERROR_LOG_REPORT(G3D, "sceGeBreak: can't break signal-pausing list");
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
}
else
Error and reporting for sceGeBreak's second param.
2013-09-22 02:07:02 +00:00
return SCE_KERNEL_ERROR_ALREADY;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
}
Error and reporting for sceGeBreak's second param.
2013-09-22 02:07:02 +00:00
return SCE_KERNEL_ERROR_BUSY;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
}
if (currentList->state == PSP_GE_DL_STATE_QUEUED)
{
currentList->state = PSP_GE_DL_STATE_PAUSED;
return currentList->id;
}
// TODO Save BASE
// TODO Adjust pc to be just before SIGNAL/END
// TODO: Is this right?
if (currentList->signal == PSP_GE_SIGNAL_SYNC)
currentList->pc += 8;
currentList->interrupted = true;
currentList->state = PSP_GE_DL_STATE_PAUSED;
currentList->signal = PSP_GE_SIGNAL_HANDLER_SUSPEND;
isbreak = true;
return currentList->id;
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
}
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
void GPUCommon::NotifySteppingEnter() {
Core: Separate collecting and displaying stats.
2017-03-24 01:57:18 +00:00
if (coreCollectDebugStats) {
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
timeSteppingStarted_ = time_now_d();
}
}
void GPUCommon::NotifySteppingExit() {
Core: Separate collecting and displaying stats.
2017-03-24 01:57:18 +00:00
if (coreCollectDebugStats) {
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
if (timeSteppingStarted_ <= 0.0) {
ERROR_LOG(G3D, "Mismatched stepping enter/exit.");
}
Core: Assert debug stats remain positive.
2021-01-31 23:06:11 +00:00
double total = time_now_d() - timeSteppingStarted_;
_dbg_assert_msg_(total >= 0.0, "Time spent stepping became negative");
timeSpentStepping_ += total;
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
timeSteppingStarted_ = 0.0;
}
}
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
bool GPUCommon::InterpretList(DisplayList &list) {
Avoid calling time_update in GE w/o debug stats. Just wastes time, especially if the game hammers sceGeListUpdateStallAddr, which many games do.
2013-04-21 22:16:45 +00:00
// Initialized to avoid a race condition with bShowDebugStats changing.
double start = 0.0;
Core: Separate collecting and displaying stats.
2017-03-24 01:57:18 +00:00
if (coreCollectDebugStats) {
Avoid calling time_update in GE w/o debug stats. Just wastes time, especially if the game hammers sceGeListUpdateStallAddr, which many games do.
2013-04-21 22:16:45 +00:00
start = time_now_d();
}
Handle GE pause signals per tests. They really should pause, but we were resetting them incorrectly. And most importantly, sceGeContinue() inside the signal handler absolutely must work. Games use this a lot.
2014-04-12 06:32:34 +00:00
if (list.state == PSP_GE_DL_STATE_PAUSED)
return false;
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
currentList = &list;
Implement the pause signal a bit better.
2013-04-06 16:59:24 +00:00
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
if (!list.started && list.context.IsValid()) {
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
gstate.Save(list.context);
}
list.started = true;
Preseve offsetAddr on stall, instead of reset to 0. Only for new lists is it reset to 0, afaict.
2013-09-22 03:47:35 +00:00
gstate_c.offsetAddr = list.offsetAddr;
Don't check that the pc is valid every single op.
2013-01-29 16:07:36 +00:00
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
if (!Memory::IsValidAddress(list.pc)) {
ERROR_LOG_REPORT(G3D, "DL PC = %08x WTF!!!!", list.pc);
return true;
}
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
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
cycleLastPC = list.pc;
Try to use a smaller value for cyclesExecuted
2013-10-12 08:20:27 +00:00
cyclesExecuted += 60;
Avoid some dangerous hex constant widths.
2013-08-23 06:23:48 +00:00
downcount = list.stall == 0 ? 0x0FFFFFFF : (list.stall - list.pc) / 4;
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
list.state = PSP_GE_DL_STATE_RUNNING;
list.interrupted = false;
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
gpuState = list.pc == list.stall ? GPUSTATE_STALL : GPUSTATE_RUNNING;
Small opt. for common immediately stalled list.
2013-04-28 21:56:38 +00:00
GE Debugger: Allow modify/breakpoint on matrix.
2022-02-06 08:16:35 +00:00
// To enable breakpoints, we don't do fast matrix loads while debugger active.
debugRecording_ = GPUDebug::IsActive() || GPURecord::IsActive();
const bool useFastRunLoop = !dumpThisFrame_ && !debugRecording_;
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
while (gpuState == GPUSTATE_RUNNING) {
Simplify easy_guard to avoid coding errors.
2013-08-09 08:03:54 +00:00
{
if (list.pc == list.stall) {
gpuState = GPUSTATE_STALL;
downcount = 0;
}
Keep a flag to indicate display list bailout.
2013-04-04 08:07:30 +00:00
}
Add displayList debug dialog
2013-02-17 00:06:06 +00:00
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
if (useFastRunLoop) {
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
FastRunLoop(list);
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
} else {
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
SlowRunLoop(list);
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
Simplify easy_guard to avoid coding errors.
2013-08-09 08:03:54 +00:00
{
Avoid some dangerous hex constant widths.
2013-08-23 06:23:48 +00:00
downcount = list.stall == 0 ? 0x0FFFFFFF : (list.stall - list.pc) / 4;
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
Simplify easy_guard to avoid coding errors.
2013-08-09 08:03:54 +00:00
if (gpuState == GPUSTATE_STALL && list.stall != list.pc) {
// Unstalled.
gpuState = GPUSTATE_RUNNING;
}
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
}
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +00:00
FinishDeferred();
Debugger: Track unchanged VRAM to avoid copy. See #15251, the framedump here reused a VRAM texture for many draws, and this caused it to recopy the texture over and over again. Use a flag to skip if possible.
2022-02-20 21:51:40 +00:00
if (debugRecording_)
GPURecord::NotifyCPU();
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +00:00
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
// We haven't run the op at list.pc, so it shouldn't count.
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
if (cycleLastPC != list.pc) {
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
UpdatePC(list.pc - 4, list.pc);
Be more careful with the stall address. In case it's moved while running the list.
2013-08-09 06:46:10 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
Preseve offsetAddr on stall, instead of reset to 0. Only for new lists is it reset to 0, afaict.
2013-09-22 03:47:35 +00:00
list.offsetAddr = gstate_c.offsetAddr;
Core: Separate collecting and displaying stats.
2017-03-24 01:57:18 +00:00
if (coreCollectDebugStats) {
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
double total = time_now_d() - start - timeSpentStepping_;
Core: Assert debug stats remain positive.
2021-01-31 23:06:11 +00:00
_dbg_assert_msg_(total >= 0.0, "Time spent DL processing became negative");
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
hleSetSteppingTime(timeSpentStepping_);
Display: Account for stepping time in graphs. Frame times should count that as sleep too.
2022-01-30 18:46:50 +00:00
DisplayNotifySleep(timeSpentStepping_);
Skip debug stepping time in list/func time. Just makes the debug stats actually useful while stepping. A bit of overengineering, but it makes it easy to go frame-by-frame looking for perf issues.
2014-06-14 15:42:18 +00:00
timeSpentStepping_ = 0.0;
gpuStats.msProcessingDisplayLists += total;
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
}
return gpuState == GPUSTATE_DONE || gpuState == GPUSTATE_ERROR;
}
Unify FastRunLoop for the hardware backends.
2018-02-26 10:52:16 +00:00
// Maybe should write this in ASM...
void GPUCommon::FastRunLoop(DisplayList &list) {
PROFILE_THIS_SCOPE("gpuloop");
GPUCommon::FastRunLoop: Try not to crash
2023-01-02 21:01:20 +00:00
if (!Memory::IsValidAddress(list.pc)) {
// We're having some serious problems here, just bail and try to limp along and not crash the app.
downcount = 0;
return;
}
Unify FastRunLoop for the hardware backends.
2018-02-26 10:52:16 +00:00
const CommandInfo *cmdInfo = cmdInfo_;
int dc = downcount;
for (; dc > 0; --dc) {
// We know that display list PCs have the upper nibble == 0 - no need to mask the pointer
Global: Correct many endian types and casts.
2021-02-19 06:25:24 +00:00
const u32 op = *(const u32_le *)(Memory::base + list.pc);
Unify FastRunLoop for the hardware backends.
2018-02-26 10:52:16 +00:00
const u32 cmd = op >> 24;
const CommandInfo &info = cmdInfo[cmd];
const u32 diff = op ^ gstate.cmdmem[cmd];
if (diff == 0) {
if (info.flags & FLAG_EXECUTE) {
downcount = dc;
(this->*info.func)(op, diff);
dc = downcount;
}
} else {
uint64_t flags = info.flags;
if (flags & FLAG_FLUSHBEFOREONCHANGE) {
Avoid the most common virtual call when possible.
2018-02-26 12:51:14 +00:00
if (drawEngineCommon_->GetNumDrawCalls()) {
drawEngineCommon_->DispatchFlush();
}
Unify FastRunLoop for the hardware backends.
2018-02-26 10:52:16 +00:00
}
gstate.cmdmem[cmd] = op;
if (flags & (FLAG_EXECUTE | FLAG_EXECUTEONCHANGE)) {
downcount = dc;
(this->*info.func)(op, diff);
dc = downcount;
} else {
uint64_t dirty = flags >> 8;
if (dirty)
gstate_c.Dirty(dirty);
}
}
list.pc += 4;
}
downcount = 0;
}
GE Debugger: Fix recording in softgpu.
2017-06-04 05:28:29 +00:00
void GPUCommon::BeginFrame() {
Improve reporting for imm buffer exceeded. Reset the immCount_ every frame to avoid getting "stuck" permanently in case some garbage is executed..
2017-12-01 19:01:13 +00:00
immCount_ = 0;
GPU: Refactor common frame dumping code.
2017-06-03 02:39:11 +00:00
if (dumpNextFrame_) {
NOTICE_LOG(G3D, "DUMPING THIS FRAME");
dumpThisFrame_ = true;
dumpNextFrame_ = false;
} else if (dumpThisFrame_) {
dumpThisFrame_ = false;
}
GE Debugger: Add separate step based on vsync. I think there were some games where this would step in the middle of a frame, but not seeing it commonly now. So make it the default, but allow both methods in the menu. Fixes #15893.
2022-08-24 02:48:34 +00:00
GPUDebug::NotifyBeginFrame();
GE Debugger: Record 1 flip if no display calls. Before we were waiting 4 flips before ending recording.
2022-08-24 02:20:14 +00:00
GPURecord::NotifyBeginFrame();
GPU: Automatically reduce depth range on == test. Fixes graphic issues in Blade Dancer, possibly other games.
2022-11-13 16:13:22 +00:00
if (drawEngineCommon_->EverUsedExactEqualDepth() && !sawExactEqualDepth_) {
sawExactEqualDepth_ = true;
Add accessor for UseFlags
2022-12-13 15:53:53 +00:00
gstate_c.SetUseFlags(CheckGPUFeatures());
GPU: Automatically reduce depth range on == test. Fixes graphic issues in Blade Dancer, possibly other games.
2022-11-13 16:13:22 +00:00
}
GPU: Refactor common frame dumping code.
2017-06-03 02:39:11 +00:00
}
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
void GPUCommon::SlowRunLoop(DisplayList &list)
{
const bool dumpThisFrame = dumpThisFrame_;
while (downcount > 0)
{
GE Debugger: Add filter to skip prim calls. This allows you to cut prims from the scene as desired.
2022-02-07 05:25:33 +00:00
bool process = GPUDebug::NotifyCommand(list.pc);
if (process) {
GPURecord::NotifyCommand(list.pc);
u32 op = Memory::ReadUnchecked_U32(list.pc);
u32 cmd = op >> 24;
u32 diff = op ^ gstate.cmdmem[cmd];
PreExecuteOp(op, diff);
if (dumpThisFrame) {
char temp[256];
u32 prev;
if (Memory::IsValidAddress(list.pc - 4)) {
prev = Memory::ReadUnchecked_U32(list.pc - 4);
} else {
prev = 0;
}
GeDisassembleOp(list.pc, op, prev, temp, 256);
NOTICE_LOG(G3D, "%08x: %s", op, temp);
Crashfix dumping display lists that start at the start of VRAM (seems to hit this in GTA). Add a couple of comments.
2013-10-07 20:57:44 +00:00
}
GE Debugger: Add filter to skip prim calls. This allows you to cut prims from the scene as desired.
2022-02-07 05:25:33 +00:00
gstate.cmdmem[cmd] = op;
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
GE Debugger: Add filter to skip prim calls. This allows you to cut prims from the scene as desired.
2022-02-07 05:25:33 +00:00
ExecuteOp(op, diff);
}
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
list.pc += 4;
--downcount;
Avoid calling time_update in GE w/o debug stats. Just wastes time, especially if the game hammers sceGeListUpdateStallAddr, which many games do.
2013-04-21 22:16:45 +00:00
}
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
}
Centralize state and pc changes in the GE. To make later things easier.
2013-04-28 20:34:29 +00:00
// The newPC parameter is used for jumps, we don't count cycles between.
GCC buildfix
2014-03-04 10:38:25 +00:00
void GPUCommon::UpdatePC(u32 currentPC, u32 newPC) {
Slow down the GPU clock estimate. This makes Fat Princess for example much faster.
2013-04-07 23:55:48 +00:00
// Rough estimate, 2 CPU ticks (it's double the clock rate) per GPU instruction.
Avoid some debug stats when disabled. This function can get called a lot sometimes, and an if helps on ARM a little.
2014-04-05 08:41:54 +00:00
u32 executed = (currentPC - cycleLastPC) / 4;
Fix gpu cycle call level counting, of course halving the numbers I mentioned in the previous commit comment.
2013-08-23 09:42:15 +00:00
cyclesExecuted += 2 * executed;
Super stupid typo.
2014-04-05 21:08:44 +00:00
cycleLastPC = newPC;
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
Avoid leaving the fast runloop on jumps. Jumps are actually very common in some games, like FF4 and Crisis Core, and tons more. They are used to jump around vertex data. Improves performance by a few percent in FF4.
2014-03-06 07:24:18 +00:00
// Exit the runloop and recalculate things. This happens a lot in some games.
if (currentList)
Super stupid typo.
2014-04-05 21:08:44 +00:00
downcount = currentList->stall == 0 ? 0x0FFFFFFF : (currentList->stall - newPC) / 4;
Avoid leaving the fast runloop on jumps. Jumps are actually very common in some games, like FF4 and Crisis Core, and tons more. They are used to jump around vertex data. Improves performance by a few percent in FF4.
2014-03-06 07:24:18 +00:00
else
downcount = 0;
Centralize state and pc changes in the GE. To make later things easier.
2013-04-28 20:34:29 +00:00
}
Add a simple message event system to the GE. With this, the CPU thread feature now mostly works.
2013-08-08 06:59:32 +00:00
void GPUCommon::ReapplyGfxState() {
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
// The commands are embedded in the command memory so we can just reexecute the words. Convenient.
Avoid some dangerous hex constant widths.
2013-08-23 06:23:48 +00:00
// To be safe we pass 0xFFFFFFFF as the diff.
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
Exclude a couple more commands from re-execution in ReapplyGfxState. See
2020-05-24 14:30:37 +00:00
// TODO: Consider whether any of this should really be done. We might be able to get all the way
// by simplying dirtying the appropriate gstate_c dirty flags.
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
for (int i = GE_CMD_VERTEXTYPE; i < GE_CMD_BONEMATRIXNUMBER; i++) {
Don't reset OFFSETADDR, changes offsetAddr.
2014-04-16 14:53:07 +00:00
if (i != GE_CMD_ORIGIN && i != GE_CMD_OFFSETADDR) {
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
ExecuteOp(gstate.cmdmem[i], 0xFFFFFFFF);
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
}
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
}
// Can't write to bonematrixnumber here
Include GE_CMD_PATCHFACING just in case.
2013-09-20 07:43:45 +00:00
for (int i = GE_CMD_MORPHWEIGHT0; i <= GE_CMD_PATCHFACING; i++) {
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
ExecuteOp(gstate.cmdmem[i], 0xFFFFFFFF);
}
// There are a few here in the middle that we shouldn't execute...
Exclude a couple more commands from re-execution in ReapplyGfxState. See
2020-05-24 14:30:37 +00:00
// 0x42 to 0xEA
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
for (int i = GE_CMD_VIEWPORTXSCALE; i < GE_CMD_TRANSFERSTART; i++) {
Exclude a couple more commands from re-execution in ReapplyGfxState. See
2020-05-24 14:30:37 +00:00
switch (i) {
case GE_CMD_LOADCLUT:
case GE_CMD_TEXSYNC:
case GE_CMD_TEXFLUSH:
break;
default:
GPU: Don't reapply LoadClut each frame. Definitely don't need to reapply this one.
2020-05-24 07:12:41 +00:00
ExecuteOp(gstate.cmdmem[i], 0xFFFFFFFF);
Exclude a couple more commands from re-execution in ReapplyGfxState. See
2020-05-24 14:30:37 +00:00
break;
GPU: Don't reapply LoadClut each frame. Definitely don't need to reapply this one.
2020-05-24 07:12:41 +00:00
}
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
}
Include GE_CMD_PATCHFACING just in case.
2013-09-20 07:43:45 +00:00
// Let's just skip the transfer size stuff, it's just values.
Move ReapplyGfxState() to GPUCommon. This way it can be overridden, and simplifies some other things.
2013-08-04 22:15:50 +00:00
}
Ge: Report and save Edram translation value. See #16126 for some details on its usage and effects.
2022-10-02 06:18:42 +00:00
uint32_t GPUCommon::SetAddrTranslation(uint32_t value) {
std::swap(edramTranslation_, value);
return value;
}
uint32_t GPUCommon::GetAddrTranslation() {
return edramTranslation_;
}
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
inline void GPUCommon::UpdateState(GPURunState state) {
Centralize state and pc changes in the GE. To make later things easier.
2013-04-28 20:34:29 +00:00
gpuState = state;
Use a downcount and fast run loop in the GE.
2013-04-28 21:23:30 +00:00
if (state != GPUSTATE_RUNNING)
downcount = 0;
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
}
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
int GPUCommon::GetNextListIndex() {
auto iter = dlQueue.begin();
if (iter != dlQueue.end()) {
return *iter;
} else {
return -1;
}
}
Get rid of GPUCommon's "Internal" functions.
2017-11-05 19:33:28 +00:00
void GPUCommon::ProcessDLQueue() {
Count cycles in the GPU, rough guess at timing. Doesn't actually do anything yet with the count, though.
2013-04-03 15:10:35 +00:00
startingTicks = CoreTiming::GetTicks();
cyclesExecuted = 0;
Fix hang in Project Diva 2nd in single-threaded mode. Doesn't seem to affect other games, but I don't have every game in existence, so there could be one or two out there that might break from this.
2013-08-25 01:13:34 +00:00
// Seems to be correct behaviour to process the list anyway?
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
if (startingTicks < busyTicks) {
Change a few more log types.
2013-09-07 20:31:14 +00:00
DEBUG_LOG(G3D, "Can't execute a list yet, still busy for %lld ticks", busyTicks - startingTicks);
Fix hang in Project Diva 2nd in single-threaded mode. Doesn't seem to affect other games, but I don't have every game in existence, so there could be one or two out there that might break from this.
2013-08-25 01:13:34 +00:00
//return;
Block dlist execution while in virtual progress. Fixes #1224. Also, fix drawsync late by a GPU cycle, so interrupts line up. It would break at least Ys Seven without that.
2013-04-09 07:56:04 +00:00
}
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
for (int listIndex = GetNextListIndex(); listIndex != -1; listIndex = GetNextListIndex()) {
DisplayList &l = dls[listIndex];
Profile a few more scopes
2015-05-25 22:39:27 +00:00
DEBUG_LOG(G3D, "Starting DL execution at %08x - stall = %08x", l.pc, l.stall);
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
if (!InterpretList(l)) {
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
return;
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
} else {
Fix another race condition with multithreading. It's possible that after it's marked completed, the CPU will grab it to enqueue. This actually happened to mean with decent reproducibility.
2014-05-04 01:40:27 +00:00
// Some other list could've taken the spot while we dilly-dallied around.
if (l.state != PSP_GE_DL_STATE_QUEUED) {
// At the end, we can remove it from the queue and continue.
dlQueue.erase(std::remove(dlQueue.begin(), dlQueue.end(), listIndex), dlQueue.end());
}
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
}
}
Simplify ProcessDLQueue() slightly.
2013-08-04 23:31:11 +00:00
Delete the mutex in GPUCommon.
2017-11-05 18:44:07 +00:00
currentList = nullptr;
Implement sceGeDrawSync().
2013-04-06 05:38:19 +00:00
Remove gpuCommandsAtCallLevel stats, compute another stat more efficiently These stats have proven rather useless since we don't plan to cache and optimize display lists.
2023-01-01 20:18:53 +00:00
if (coreCollectDebugStats) {
gpuStats.otherGPUCycles += cyclesExecuted;
}
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
drawCompleteTicks = startingTicks + cyclesExecuted;
Block dlist execution while in virtual progress. Fixes #1224. Also, fix drawsync late by a GPU cycle, so interrupts line up. It would break at least Ys Seven without that.
2013-04-09 07:56:04 +00:00
busyTicks = std::max(busyTicks, drawCompleteTicks);
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
__GeTriggerSync(GPU_SYNC_DRAW, 1, drawCompleteTicks);
Use a timer to keep gpu/cpu in sync periodically. Fixes Diva Extend demo, at least, losing FPS.
2013-08-11 20:41:42 +00:00
// Since the event is in CoreTiming, we're in sync. Just set 0 now.
Move InterpretList and ProcessDLQueue to GPUCommon
2012-12-29 01:10:29 +00:00
}
void GPUCommon::PreExecuteOp(u32 op, u32 diff) {
// Nothing to do
Save more of the GPU's state, fix a crash. Well, ReapplyGfxState() seems kinda dangerous now...
2012-12-29 19:41:33 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_OffsetAddr(u32 op, u32 diff) {
gstate_c.offsetAddr = op << 8;
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Minor cleanup in GPU dispatch tables
2017-01-28 10:53:28 +00:00
void GPUCommon::Execute_Vaddr(u32 op, u32 diff) {
gstate_c.vertexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
void GPUCommon::Execute_Iaddr(u32 op, u32 diff) {
gstate_c.indexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_Origin(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (currentList)
gstate_c.offsetAddr = currentList->pc;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_Jump(u32 op, u32 diff) {
CALLs and JUMPs to misaligned addresses round down. Fixes Pac-Man World 3. Matches tests on hardware.
2014-05-05 00:58:44 +00:00
const u32 target = gstate_c.getRelativeAddress(op & 0x00FFFFFC);
Restores a lost optimization from uv prescale - avoiding flushing. Should fix #9219. Also #ifdef away some invalid-address checks in hot paths in the GPU.
2017-01-28 10:39:34 +00:00
if (!Memory::IsValidAddress(target)) {
Remove some reporting that's normally just the result of garbage-as-display-list-execution.
2020-09-22 19:57:51 +00:00
ERROR_LOG(G3D, "JUMP to illegal address %08x - ignoring! data=%06x", target, op & 0x00FFFFFF);
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
UpdateState(GPUSTATE_ERROR);
Restores a lost optimization from uv prescale - avoiding flushing. Should fix #9219. Also #ifdef away some invalid-address checks in hot paths in the GPU.
2017-01-28 10:39:34 +00:00
return;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
Restores a lost optimization from uv prescale - avoiding flushing. Should fix #9219. Also #ifdef away some invalid-address checks in hot paths in the GPU.
2017-01-28 10:39:34 +00:00
UpdatePC(currentList->pc, target - 4);
currentList->pc = target - 4; // pc will be increased after we return, counteract that
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Ge: Keep jump/call optim when fast memory on. This gives a way to validate with fast memory off, and get less crashes.
2018-08-25 17:38:56 +00:00
void GPUCommon::Execute_JumpFast(u32 op, u32 diff) {
const u32 target = gstate_c.getRelativeAddress(op & 0x00FFFFFC);
UpdatePC(currentList->pc, target - 4);
currentList->pc = target - 4; // pc will be increased after we return, counteract that
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_BJump(u32 op, u32 diff) {
if (!currentList->bboxResult) {
// bounding box jump.
CALLs and JUMPs to misaligned addresses round down. Fixes Pac-Man World 3. Matches tests on hardware.
2014-05-05 00:58:44 +00:00
const u32 target = gstate_c.getRelativeAddress(op & 0x00FFFFFC);
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (Memory::IsValidAddress(target)) {
UpdatePC(currentList->pc, target - 4);
currentList->pc = target - 4; // pc will be increased after we return, counteract that
} else {
Remove some reporting that's normally just the result of garbage-as-display-list-execution.
2020-09-22 19:57:51 +00:00
ERROR_LOG(G3D, "BJUMP to illegal address %08x - ignoring! data=%06x", target, op & 0x00FFFFFF);
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
UpdateState(GPUSTATE_ERROR);
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
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_Call(u32 op, u32 diff) {
More vulkan microoptimizations. Add more profiler scopes.
2017-08-18 11:39:42 +00:00
PROFILE_THIS_SCOPE("gpu_call");
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
CALLs and JUMPs to misaligned addresses round down. Fixes Pac-Man World 3. Matches tests on hardware.
2014-05-05 00:58:44 +00:00
const u32 target = gstate_c.getRelativeAddress(op & 0x00FFFFFC);
Avoid crashing when calling an invalid address. We already have a check, let's use it properly.
2014-09-23 15:31:29 +00:00
if (!Memory::IsValidAddress(target)) {
Remove some reporting that's normally just the result of garbage-as-display-list-execution.
2020-09-22 19:57:51 +00:00
ERROR_LOG(G3D, "CALL to illegal address %08x - ignoring! data=%06x", target, op & 0x00FFFFFF);
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
UpdateState(GPUSTATE_ERROR);
Avoid crashing when calling an invalid address. We already have a check, let's use it properly.
2014-09-23 15:31:29 +00:00
return;
}
Ge: Keep jump/call optim when fast memory on. This gives a way to validate with fast memory off, and get less crashes.
2018-08-25 17:38:56 +00:00
DoExecuteCall(target);
}
void GPUCommon::Execute_CallFast(u32 op, u32 diff) {
PROFILE_THIS_SCOPE("gpu_call");
const u32 target = gstate_c.getRelativeAddress(op & 0x00FFFFFC);
DoExecuteCall(target);
}
void GPUCommon::DoExecuteCall(u32 target) {
// Saint Seiya needs correct support for relative calls.
const u32 retval = currentList->pc + 4;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
// Bone matrix optimization - many games will CALL a bone matrix (!).
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
// We don't optimize during recording - so the matrix data gets recorded.
Check for valid memory range when doing fast bone matrix loads In reality, this is probably very rarely a real concern but we do get a measurable amount of crash reports here. Though if that first access crashes, which it seems to, we'd probably likely crash soon after this anyway...
2023-01-01 19:42:29 +00:00
if (!debugRecording_ && Memory::IsValidRange(target, 13 * 4) && (Memory::ReadUnchecked_U32(target) >> 24) == GE_CMD_BONEMATRIXDATA) {
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
// Check for the end
if ((Memory::ReadUnchecked_U32(target + 11 * 4) >> 24) == GE_CMD_BONEMATRIXDATA &&
Check for valid memory range when doing fast bone matrix loads In reality, this is probably very rarely a real concern but we do get a measurable amount of crash reports here. Though if that first access crashes, which it seems to, we'd probably likely crash soon after this anyway...
2023-01-01 19:42:29 +00:00
(Memory::ReadUnchecked_U32(target + 12 * 4) >> 24) == GE_CMD_RET &&
(gstate.boneMatrixNumber & 0x00FFFFFF) <= 96 - 12) {
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
// Yep, pretty sure this is a bone matrix call. Double check stall first.
if (target > currentList->stall || target + 12 * 4 < currentList->stall) {
FastLoadBoneMatrix(target);
return;
}
Move GE_CMD_BJUMP to GPUCommon. Add the flag. (no actual bbox impl yet)
2013-09-24 10:59:34 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
Bone matrix loading speedup. Bit of a hack but seems reliable enough.
2013-11-14 13:02:31 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (currentList->stackptr == ARRAY_SIZE(currentList->stack)) {
Remove some reporting that's normally just the result of garbage-as-display-list-execution.
2020-09-22 19:57:51 +00:00
ERROR_LOG(G3D, "CALL: Stack full!");
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
} else {
auto &stackEntry = currentList->stack[currentList->stackptr++];
stackEntry.pc = retval;
stackEntry.offsetAddr = gstate_c.offsetAddr;
// The base address is NOT saved/restored for a regular call.
UpdatePC(currentList->pc, target - 4);
currentList->pc = target - 4; // pc will be increased after we return, counteract that
}
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_Ret(u32 op, u32 diff) {
if (currentList->stackptr == 0) {
Remove some reporting that's normally just the result of garbage-as-display-list-execution.
2020-09-22 19:57:51 +00:00
DEBUG_LOG(G3D, "RET: Stack empty!");
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
} else {
auto &stackEntry = currentList->stack[--currentList->stackptr];
gstate_c.offsetAddr = stackEntry.offsetAddr;
CALLs and JUMPs to misaligned addresses round down. Fixes Pac-Man World 3. Matches tests on hardware.
2014-05-05 00:58:44 +00:00
// We always clear the top (uncached/etc.) bits
const u32 target = stackEntry.pc & 0x0FFFFFFF;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
UpdatePC(currentList->pc, target - 4);
currentList->pc = target - 4;
Restores a lost optimization from uv prescale - avoiding flushing. Should fix #9219. Also #ifdef away some invalid-address checks in hot paths in the GPU.
2017-01-28 10:39:34 +00:00
#ifdef _DEBUG
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (!Memory::IsValidAddress(currentList->pc)) {
ERROR_LOG_REPORT(G3D, "Invalid DL PC %08x on return", currentList->pc);
UpdateState(GPUSTATE_ERROR);
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
}
Restores a lost optimization from uv prescale - avoiding flushing. Should fix #9219. Also #ifdef away some invalid-address checks in hot paths in the GPU.
2017-01-28 10:39:34 +00:00
#endif
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::Execute_End(u32 op, u32 diff) {
softgpu: Avoid flush on END. We only, but always, flush when exiting list interp in FinishDeferred. It's not necessary at END, and hurts for simple signals that don't stop list processing.
2022-02-01 03:32:46 +00:00
if (flushOnParams_)
Flush();
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
const u32 prev = Memory::ReadUnchecked_U32(currentList->pc - 4);
Big mutex overhaul - remove our custom ones, make them non-recursive where possible
2017-02-27 20:57:46 +00:00
UpdatePC(currentList->pc, currentList->pc);
Eat a few more cycles on END cmds. Fixes #3049, which apparently expects an END/FINISH to not immediately trigger (it drawsyncs soon after, and completely expects that to reschedule.) Either way, it seems plausible an END would take a few more cycles than most instructions, since it generates an interrupt.
2014-04-29 07:08:43 +00:00
// Count in a few extra cycles on END.
cyclesExecuted += 60;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
switch (prev >> 24) {
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
case GE_CMD_SIGNAL:
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{
// TODO: see http://code.google.com/p/jpcsp/source/detail?r=2935#
SignalBehavior behaviour = static_cast<SignalBehavior>((prev >> 16) & 0xFF);
Comment out a few unsafe replacement funcs.
2014-04-22 15:07:10 +00:00
const int signal = prev & 0xFFFF;
const int enddata = op & 0xFFFF;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
bool trigger = true;
currentList->subIntrToken = signal;
switch (behaviour) {
case PSP_GE_SIGNAL_HANDLER_SUSPEND:
// Suspend the list, and call the signal handler. When it's done, resume.
// Before sdkver 0x02000010, listsync should return paused.
if (sceKernelGetCompiledSdkVersion() <= 0x02000010)
currentList->state = PSP_GE_DL_STATE_PAUSED;
currentList->signal = behaviour;
DEBUG_LOG(G3D, "Signal with wait. signal/end: %04x %04x", signal, enddata);
break;
case PSP_GE_SIGNAL_HANDLER_CONTINUE:
// Resume the list right away, then call the handler.
currentList->signal = behaviour;
DEBUG_LOG(G3D, "Signal without wait. signal/end: %04x %04x", signal, enddata);
break;
case PSP_GE_SIGNAL_HANDLER_PAUSE:
// Pause the list instead of ending at the next FINISH.
// Call the handler with the PAUSE signal value at that FINISH.
// Technically, this ought to trigger an interrupt, but it won't do anything.
// But right now, signal is always reset by interrupts, so that causes pause to not work.
trigger = false;
currentList->signal = behaviour;
DEBUG_LOG(G3D, "Signal with Pause. signal/end: %04x %04x", signal, enddata);
break;
case PSP_GE_SIGNAL_SYNC:
// Acts as a memory barrier, never calls any user code.
// Technically, this ought to trigger an interrupt, but it won't do anything.
// Triggering here can cause incorrect rescheduling, which breaks 3rd Birthday.
// However, this is likely a bug in how GE signal interrupts are handled.
trigger = false;
currentList->signal = behaviour;
DEBUG_LOG(G3D, "Signal with Sync. signal/end: %04x %04x", signal, enddata);
break;
case PSP_GE_SIGNAL_JUMP:
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
case PSP_GE_SIGNAL_RJUMP:
case PSP_GE_SIGNAL_OJUMP:
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{
Avoid triggering SYNC ge signals. Fixes #5806, bcause it avoids rescheduling at the signal, which it should not do. Possibly this is incorrect for all GE signals, but we don't need to trigger any behavior on a sync anyway.
2014-04-09 05:20:33 +00:00
trigger = false;
Implement sync signal in display lists. Makes dialogs show up in 3rd Birthday.
2013-04-06 17:05:09 +00:00
currentList->signal = behaviour;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
// pc will be increased after we return, counteract that.
GPU: Fix alignment on signal jump/call. It shouldn't be possible to make the pc unaligned, and this may have been causing it previously.
2017-08-20 20:30:39 +00:00
u32 target = (((signal << 16) | enddata) & 0xFFFFFFFC) - 4;
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
const char *targetType = "absolute";
if (behaviour == PSP_GE_SIGNAL_RJUMP) {
target += currentList->pc - 4;
targetType = "relative";
} else if (behaviour == PSP_GE_SIGNAL_OJUMP) {
target = gstate_c.getRelativeAddress(target);
targetType = "origin";
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (!Memory::IsValidAddress(target)) {
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
ERROR_LOG_REPORT(G3D, "Signal with Jump (%s): bad address. signal/end: %04x %04x", targetType, signal, enddata);
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
UpdateState(GPUSTATE_ERROR);
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
} else {
UpdatePC(currentList->pc, target);
currentList->pc = target;
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
DEBUG_LOG(G3D, "Signal with Jump (%s). signal/end: %04x %04x", targetType, signal, enddata);
Implement the jump, call, and ret signals. Still buggy, but more things show...
2013-04-06 17:30:12 +00:00
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
break;
case PSP_GE_SIGNAL_CALL:
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
case PSP_GE_SIGNAL_RCALL:
case PSP_GE_SIGNAL_OCALL:
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
{
trigger = false;
currentList->signal = behaviour;
// pc will be increased after we return, counteract that.
GPU: Fix alignment on signal jump/call. It shouldn't be possible to make the pc unaligned, and this may have been causing it previously.
2017-08-20 20:30:39 +00:00
u32 target = (((signal << 16) | enddata) & 0xFFFFFFFC) - 4;
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
const char *targetType = "absolute";
if (behaviour == PSP_GE_SIGNAL_RCALL) {
target += currentList->pc - 4;
targetType = "relative";
} else if (behaviour == PSP_GE_SIGNAL_OCALL) {
target = gstate_c.getRelativeAddress(target);
targetType = "origin";
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (currentList->stackptr == ARRAY_SIZE(currentList->stack)) {
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
ERROR_LOG_REPORT(G3D, "Signal with Call (%s): stack full. signal/end: %04x %04x", targetType, signal, enddata);
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
} else if (!Memory::IsValidAddress(target)) {
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
ERROR_LOG_REPORT(G3D, "Signal with Call (%s): bad address. signal/end: %04x %04x", targetType, signal, enddata);
Ge: Avoid executing invalid pointers. May help #3407 and related errors, as well as crashes and execution of garbage. This stops immediately on a bad pointer, rather than trying to push through.
2018-08-25 17:32:32 +00:00
UpdateState(GPUSTATE_ERROR);
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
} else {
// TODO: This might save/restore other state...
auto &stackEntry = currentList->stack[currentList->stackptr++];
stackEntry.pc = currentList->pc;
stackEntry.offsetAddr = gstate_c.offsetAddr;
stackEntry.baseAddr = gstate.base;
UpdatePC(currentList->pc, target);
currentList->pc = target;
GPU: Allow relative jumps and calls. These are tested in gpu/signals/jumps, so they ought to work. Doesn't seem like games generally use them, though.
2022-01-24 07:03:30 +00:00
DEBUG_LOG(G3D, "Signal with Call (%s). signal/end: %04x %04x", targetType, signal, enddata);
Don't trash a list the GE interrupt handler needs. Even after it's marked COMPLETED, the CPU needs it to start and finish the interrupt. Fixes #2956, where an existing completed list was not having its interrupt run correctly.
2013-09-01 17:16:29 +00:00
}
Correct wait signal handling.
2013-04-05 07:21:47 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
break;
case PSP_GE_SIGNAL_RET:
{
trigger = false;
currentList->signal = behaviour;
if (currentList->stackptr == 0) {
ERROR_LOG_REPORT(G3D, "Signal with Return: stack empty. signal/end: %04x %04x", signal, enddata);
} else {
// TODO: This might save/restore other state...
auto &stackEntry = currentList->stack[--currentList->stackptr];
gstate_c.offsetAddr = stackEntry.offsetAddr;
gstate.base = stackEntry.baseAddr;
UpdatePC(currentList->pc, stackEntry.pc);
currentList->pc = stackEntry.pc;
DEBUG_LOG(G3D, "Signal with Return. signal/end: %04x %04x", signal, enddata);
Don't trash a list the GE interrupt handler needs. Even after it's marked COMPLETED, the CPU needs it to start and finish the interrupt. Fixes #2956, where an existing completed list was not having its interrupt run correctly.
2013-09-01 17:16:29 +00:00
}
Implement the pause signal a bit better.
2013-04-06 16:59:24 +00:00
}
break;
default:
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
ERROR_LOG_REPORT(G3D, "UNKNOWN Signal UNIMPLEMENTED %i ! signal/end: %04x %04x", behaviour, signal, enddata);
break;
}
// TODO: Technically, jump/call/ret should generate an interrupt, but before the pc change maybe?
if (currentList->interruptsEnabled && trigger) {
if (__GeTriggerInterrupt(currentList->id, currentList->pc, startingTicks + cyclesExecuted)) {
Don't trash a list the GE interrupt handler needs. Even after it's marked COMPLETED, the CPU needs it to start and finish the interrupt. Fixes #2956, where an existing completed list was not having its interrupt run correctly.
2013-09-01 17:16:29 +00:00
currentList->pendingInterrupt = true;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
UpdateState(GPUSTATE_INTERRUPT);
}
}
}
break;
case GE_CMD_FINISH:
switch (currentList->signal) {
case PSP_GE_SIGNAL_HANDLER_PAUSE:
currentList->state = PSP_GE_DL_STATE_PAUSED;
if (currentList->interruptsEnabled) {
if (__GeTriggerInterrupt(currentList->id, currentList->pc, startingTicks + cyclesExecuted)) {
currentList->pendingInterrupt = true;
UpdateState(GPUSTATE_INTERRUPT);
Implement the pause signal a bit better.
2013-04-06 16:59:24 +00:00
}
Don't listsync until after the signal handler.
2013-04-06 15:19:54 +00:00
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
break;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
case PSP_GE_SIGNAL_SYNC:
currentList->signal = PSP_GE_SIGNAL_NONE;
// TODO: Technically this should still cause an interrupt. Probably for memory sync.
break;
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
default:
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
FlushImm();
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
currentList->subIntrToken = prev & 0xFFFF;
UpdateState(GPUSTATE_DONE);
Ge: Restore saved context when ending a list. Otherwise another list queued by a Head push could use the wrong context data. See #13346.
2021-01-31 08:28:42 +00:00
// Since we marked done, we have to restore the context now before the next list runs.
if (currentList->started && currentList->context.IsValid()) {
gstate.Restore(currentList->context);
ReapplyGfxState();
// Don't restore the context again.
currentList->started = false;
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
if (currentList->interruptsEnabled && __GeTriggerInterrupt(currentList->id, currentList->pc, startingTicks + cyclesExecuted)) {
currentList->pendingInterrupt = true;
} else {
currentList->state = PSP_GE_DL_STATE_COMPLETED;
currentList->waitTicks = startingTicks + cyclesExecuted;
busyTicks = std::max(busyTicks, currentList->waitTicks);
__GeTriggerSync(GPU_SYNC_LIST, currentList->id, currentList->waitTicks);
}
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
break;
}
break;
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
default:
DEBUG_LOG(G3D,"Ah, not finished: %06x", prev & 0xFFFFFF);
break;
GPUCommon: Get rid of prev variable.
2013-04-20 22:23:35 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
}
Move wasted checks in FastRunLoop() to Execute_TexLevel()
2017-02-13 21:02:26 +00:00
void GPUCommon::Execute_TexLevel(u32 op, u32 diff) {
Inner interpreter: Add support for the Gran Turismo hack.
2018-03-17 22:57:50 +00:00
// TODO: If you change the rules here, don't forget to update the inner interpreter in Execute_Prim.
if (diff == 0xFFFFFFFF)
return;
Possible flicker fix for Macross
2022-07-30 22:37:21 +00:00
Fix small issue.
2017-02-14 15:51:56 +00:00
gstate.texlevel ^= diff;
Initial implementation of 3D texturing through equal-size mips (see #6357) Vulkan-only currently, though all the other backends except ES 2.0 without GL_OES_texture_3d can support it with some work.
2022-07-25 16:51:08 +00:00
if (diff & 0xFF0000) {
// Piggyback on this flag for 3D textures.
Give the mip bias its own uniform flag.
2022-07-31 08:43:12 +00:00
gstate_c.Dirty(DIRTY_MIPBIAS);
Initial implementation of 3D texturing through equal-size mips (see #6357) Vulkan-only currently, though all the other backends except ES 2.0 without GL_OES_texture_3d can support it with some work.
2022-07-25 16:51:08 +00:00
}
Possible flicker fix for Macross
2022-07-30 22:37:21 +00:00
if (gstate.getTexLevelMode() != GE_TEXLEVEL_MODE_AUTO && (0x00FF0000 & gstate.texlevel) != 0) {
Flush();
}
gstate.texlevel ^= diff;
Initial implementation of 3D texturing through equal-size mips (see #6357) Vulkan-only currently, though all the other backends except ES 2.0 without GL_OES_texture_3d can support it with some work.
2022-07-25 16:51:08 +00:00
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS | DIRTY_FRAGMENTSHADER_STATE);
Move wasted checks in FastRunLoop() to Execute_TexLevel()
2017-02-13 21:02:26 +00:00
}
More duplicate code removal
2017-11-13 17:57:59 +00:00
void GPUCommon::Execute_TexSize0(u32 op, u32 diff) {
// Render to texture may have overridden the width/height.
// Don't reset it unless the size is different / the texture has changed.
if (diff || gstate_c.IsDirty(DIRTY_TEXTURE_IMAGE | DIRTY_TEXTURE_PARAMS)) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
}
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
void GPUCommon::Execute_VertexType(u32 op, u32 diff) {
if (diff)
gstate_c.Dirty(DIRTY_VERTEXSHADER_STATE);
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Make fog-enable driven by uniform instead of fragment shader flag bit
2022-12-19 18:11:06 +00:00
// Switching between through and non-through, we need to invalidate a bunch of stuff.
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
if (diff & GE_VTYPE_THROUGH_MASK)
Make fog-enable driven by uniform instead of fragment shader flag bit
2022-12-19 18:11:06 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE | DIRTY_CULLRANGE | DIRTY_FOGCOEFENABLE);
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
}
}
Unify Execute_LoadClut
2018-02-26 10:26:52 +00:00
void GPUCommon::Execute_LoadClut(u32 op, u32 diff) {
gstate_c.Dirty(DIRTY_TEXTURE_PARAMS);
textureCache_->LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes());
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
void GPUCommon::Execute_VertexTypeSkinning(u32 op, u32 diff) {
Remove checks that disabled software skinning if there was morph.
2018-03-02 12:59:11 +00:00
// Don't flush when weight count changes.
if (diff & ~GE_VTYPE_WEIGHTCOUNT_MASK) {
More duplicate code removal
2017-11-13 17:57:59 +00:00
// Restore and flush
gstate.vertType ^= diff;
Flush();
gstate.vertType ^= diff;
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Revert "Remove gstate_c.deferredVertTypeDirty" This reverts commit fcdb816235d46e582f797e41d7ee344c81194cd4.
2018-04-10 10:22:26 +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) {
gstate_c.Dirty(gstate_c.deferredVertTypeDirty);
gstate_c.deferredVertTypeDirty = 0;
}
More duplicate code removal
2017-11-13 17:57:59 +00:00
gstate_c.Dirty(DIRTY_VERTEXSHADER_STATE);
}
if (diff & GE_VTYPE_THROUGH_MASK)
Fix minor state dirtying issue with FOGCOEFENABLE
2023-01-05 15:56:13 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE | DIRTY_CULLRANGE | DIRTY_FOGCOEFENABLE);
More duplicate code removal
2017-11-13 17:57:59 +00:00
}
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
void GPUCommon::CheckDepthUsage(VirtualFramebuffer *vfb) {
if (!gstate_c.usingDepth) {
GPU: Ignore depth when masked and ALWAYS. Seen in NFS Pro Street, for example. Shouldn't be interpreted as depth usage.
2022-10-09 00:33:14 +00:00
bool isReadingDepth = false;
bool isClearingDepth = false;
bool isWritingDepth = false;
if (gstate.isModeClear()) {
isClearingDepth = gstate.isClearModeDepthMask();
isWritingDepth = isClearingDepth;
} else if (gstate.isDepthTestEnabled()) {
isWritingDepth = gstate.isDepthWriteEnabled();
isReadingDepth = gstate.getDepthTestFunction() > GE_COMP_ALWAYS;
}
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
GPU: Ignore depth when masked and ALWAYS. Seen in NFS Pro Street, for example. Shouldn't be interpreted as depth usage.
2022-10-09 00:33:14 +00:00
if (isWritingDepth || isReadingDepth) {
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
gstate_c.usingDepth = true;
gstate_c.clearingDepth = isClearingDepth;
vfb->last_frame_depth_render = gpuStats.numFlips;
GPU: Ignore depth when masked and ALWAYS. Seen in NFS Pro Street, for example. Shouldn't be interpreted as depth usage.
2022-10-09 00:33:14 +00:00
if (isWritingDepth) {
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
vfb->last_frame_depth_updated = gpuStats.numFlips;
}
Restore the clearing optimization, avoiding unnecessary depth copies
2022-08-20 07:46:15 +00:00
framebufferManager_->SetDepthFrameBuffer(isClearingDepth);
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
}
}
}
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
void GPUCommon::Execute_Prim(u32 op, u32 diff) {
// This drives all drawing. All other state we just buffer up, then we apply it only
// when it's time to draw. As most PSP games set state redundantly ALL THE TIME, this is a huge optimization.
PROFILE_THIS_SCOPE("execprim");
u32 data = op & 0xFFFFFF;
u32 count = data & 0xFFFF;
if (count == 0)
return;
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
FlushImm();
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
// Upper bits are ignored.
GEPrimitiveType prim = static_cast<GEPrimitiveType>((data >> 16) & 7);
SetDrawType(DRAW_PRIM, prim);
// Discard AA lines as we can't do anything that makes sense with these anyway. The SW plugin might, though.
if (gstate.isAntiAliasEnabled()) {
New heuristic for getting rid of unnecessary "antialias-lines". Should fix #12558, while keeping the other aa line issues also fixed. Heuristic derived from discussions in #12558 and #6483.
2020-03-09 23:49:16 +00:00
// Heuristic derived from discussions in #6483 and #12588.
// Discard AA lines in Persona 3 Portable, DOA Paradise and Summon Night 5, while still keeping AA lines in Echochrome.
if ((prim == GE_PRIM_LINE_STRIP || prim == GE_PRIM_LINES) && gstate.getTextureFunction() == GE_TEXFUNC_REPLACE)
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
return;
}
Move framebufFormat to gstate_c, so we can override it
2022-04-24 15:30:33 +00:00
// Update cached framebuffer format.
// We store it in the cache so it can be modified for blue-to-alpha, next.
gstate_c.framebufFormat = gstate.FrameBufFormat();
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
ERROR_LOG(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
return;
}
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
// See the documentation for gstate_c.blueToAlpha.
bool blueToAlpha = false;
if (PSP_CoreParameter().compat.flags().BlueToAlpha) {
Disable BlueToAlpha mode when logic op is present. Re-enable for Outrun and DiRT.
2022-09-05 07:42:38 +00:00
if (gstate_c.framebufFormat == GEBufferFormat::GE_FORMAT_565 && gstate.getColorMask() == 0x0FFFFF && !gstate.isLogicOpEnabled()) {
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
blueToAlpha = true;
Fix BlueToAlpha together with reinterpret. Add back fake reinterpret for now.
2022-08-23 11:09:29 +00:00
gstate_c.framebufFormat = GEBufferFormat::GE_FORMAT_4444;
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
}
if (blueToAlpha != gstate_c.blueToAlpha) {
gstate_c.blueToAlpha = blueToAlpha;
Fix BlueToAlpha together with reinterpret. Add back fake reinterpret for now.
2022-08-23 11:09:29 +00:00
gstate_c.Dirty(DIRTY_FRAMEBUF | DIRTY_FRAGMENTSHADER_STATE | DIRTY_BLEND_STATE);
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
}
}
KillZone: Fix margin detection on the title screen, fixing some glitches. Need more fixes though to fix the shimmer effect. See #6207 comments
2022-08-31 09:40:10 +00:00
if (PSP_CoreParameter().compat.flags().SplitFramebufferMargin) {
switch (gstate.vertType & 0xFFFFFF) {
case 0x00800102: // through, u16 uv, u16 pos (used for the framebuffer effect in-game)
case 0x0080011c: // through, 8888 color, s16 pos (used for clearing in the margin of the title screen)
case 0x00000183: // float uv, float pos (used for drawing in the margin of the title screen)
// Need to re-check the framebuffer every one of these draws, to update the split if needed.
gstate_c.Dirty(DIRTY_FRAMEBUF);
}
Check X coordinate of through-mode drawcalls to figure out which of the splits to render to
2022-08-30 23:09:23 +00:00
}
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
// This also makes skipping drawing very effective.
VirtualFramebuffer *vfb = framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
if (blueToAlpha) {
vfb->usageFlags |= FB_USAGE_BLUE_TO_ALPHA;
}
GPU: Fix skip buffer effects rendering. Broken by blue-to-alpha changes. Without calling SetRenderFramebuffer, we were never reconsidering the initial SKIPDRAW_NON_DISPLAYED_FB flag and all drawing was getting skipped.
2022-05-22 19:24:03 +00:00
// Must check this after SetRenderFrameBuffer so we know SKIPDRAW_NON_DISPLAYED_FB.
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// Rough estimate, not sure what's correct.
cyclesExecuted += EstimatePerVertexCost() * count;
if (gstate.isModeClear()) {
gpuStats.numClears++;
}
return;
}
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
CheckDepthUsage(vfb);
Defer depth copies until depth buffer is actually used. Fixes
2022-08-01 21:55:58 +00:00
Split GetPointer into two versions, to help with const correctness
2022-07-20 10:40:22 +00:00
const void *verts = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
const void *inds = nullptr;
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
u32 vertexType = gstate.vertType;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
if ((vertexType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
u32 indexAddr = gstate_c.indexAddr;
if (!Memory::IsValidAddress(indexAddr)) {
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
ERROR_LOG(G3D, "Bad index address %08x!", indexAddr);
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
return;
}
inds = Memory::GetPointerUnchecked(indexAddr);
}
if (gstate_c.dirty & DIRTY_VERTEXSHADER_STATE) {
vertexCost_ = EstimatePerVertexCost();
}
int bytesRead = 0;
UpdateUVScaleOffset();
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
// cull mode
handle cullface, help to #10597
2018-08-23 04:46:09 +00:00
int cullMode = gstate.getCullMode();
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
GPU: Use skinned position always in bounding check. Meanwhile, move to a flag on decoder options instead of global check.
2022-11-06 16:09:01 +00:00
uint32_t vertTypeID = GetVertTypeID(vertexType, gstate.getUVGenMode(), g_Config.bSoftwareSkinning);
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
drawEngineCommon_->SubmitPrim(verts, inds, prim, count, vertTypeID, cullMode, &bytesRead);
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
// 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.
// The VADDR/IADDR registers are NOT updated.
AdvanceVerts(vertexType, count, bytesRead);
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
int totalVertCount = count;
// PRIMs are often followed by more PRIMs. Save some work and submit them immediately.
Global: Correct many endian types and casts.
2021-02-19 06:25:24 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
const u32_le *stall = currentList->stall ? (const u32_le *)Memory::GetPointerUnchecked(currentList->stall) : 0;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
int cmdCount = 0;
// Optimized submission of sequences of PRIM. Allows us to avoid going through all the mess
// above for each one. This can be expanded to support additional games that intersperse
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
// PRIM commands with other commands. A special case is Earth Defence Force 2 that changes culling mode
// between each prim, we just change the triangle winding right here to still be able to join draw calls.
Don't use the inner interpreter when debug recording
2018-02-28 00:26:43 +00:00
Inner interpreter safety check - in hw skinning mode, we need to flush if any part of the vertex format changes.
2018-04-10 12:37:32 +00:00
uint32_t vtypeCheckMask = ~GE_VTYPE_WEIGHTCOUNT_MASK;
if (!g_Config.bSoftwareSkinning)
vtypeCheckMask = 0xFFFFFFFF;
GE Debugger: Allow modify/breakpoint on matrix.
2022-02-06 08:16:35 +00:00
if (debugRecording_)
Buildfix.
2018-04-10 14:28:06 +00:00
goto bail;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
while (src != stall) {
uint32_t data = *src;
switch (data >> 24) {
case GE_CMD_PRIM:
{
u32 count = data & 0xFFFF;
if (count == 0) {
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
// Ignore.
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
break;
}
GEPrimitiveType newPrim = static_cast<GEPrimitiveType>((data >> 16) & 7);
GPU: Force use of indexes on cull mode flip. Since we flip in the index, it can't be pure in this case.
2018-11-30 15:22:28 +00:00
SetDrawType(DRAW_PRIM, newPrim);
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
// TODO: more efficient updating of verts/inds
verts = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
GPU: Force use of indexes on cull mode flip. Since we flip in the index, it can't be pure in this case.
2018-11-30 15:22:28 +00:00
inds = nullptr;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
if ((vertexType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
inds = Memory::GetPointerUnchecked(gstate_c.indexAddr);
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
}
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
drawEngineCommon_->SubmitPrim(verts, inds, newPrim, count, vertTypeID, cullMode, &bytesRead);
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
AdvanceVerts(vertexType, count, bytesRead);
totalVertCount += count;
break;
}
case GE_CMD_VERTEXTYPE:
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
{
uint32_t diff = data ^ vertexType;
// don't mask upper bits, vertexType is unmasked
Inner interpreter safety check - in hw skinning mode, we need to flush if any part of the vertex format changes.
2018-04-10 12:37:32 +00:00
if (diff & vtypeCheckMask) {
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
goto bail;
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
} else {
vertexType = data;
GPU: Use skinned position always in bounding check. Meanwhile, move to a flag on decoder options instead of global check.
2022-11-06 16:09:01 +00:00
vertTypeID = GetVertTypeID(vertexType, gstate.getUVGenMode(), g_Config.bSoftwareSkinning);
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
}
break;
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
}
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
case GE_CMD_VADDR:
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
gstate.cmdmem[GE_CMD_VADDR] = data;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
gstate_c.vertexAddr = gstate_c.getRelativeAddress(data & 0x00FFFFFF);
break;
GPU: Maintain a bit more state in inner-prim loop. Trying to make dumps properly trigger this optimization, but they still sometimes get flattened and don't.
2018-11-30 03:28:10 +00:00
case GE_CMD_IADDR:
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
gstate.cmdmem[GE_CMD_IADDR] = data;
GPU: Maintain a bit more state in inner-prim loop. Trying to make dumps properly trigger this optimization, but they still sometimes get flattened and don't.
2018-11-30 03:28:10 +00:00
gstate_c.indexAddr = gstate_c.getRelativeAddress(data & 0x00FFFFFF);
break;
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
case GE_CMD_OFFSETADDR:
gstate.cmdmem[GE_CMD_OFFSETADDR] = data;
gstate_c.offsetAddr = data << 8;
break;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
case GE_CMD_BASE:
gstate.cmdmem[GE_CMD_BASE] = data;
break;
handle cullface, help to #10597
2018-08-23 04:46:09 +00:00
case GE_CMD_CULLFACEENABLE:
// Earth Defence Force 2
if (gstate.cmdmem[GE_CMD_CULLFACEENABLE] != data) {
goto bail;
}
break;
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
case GE_CMD_CULL:
handle cullface, help to #10597
2018-08-23 04:46:09 +00:00
// flip face by indices for triangles
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
cullMode = data & 1;
break;
GPU: Maintain a bit more state in inner-prim loop. Trying to make dumps properly trigger this optimization, but they still sometimes get flattened and don't.
2018-11-30 03:28:10 +00:00
case GE_CMD_TEXFLUSH:
inner interpreter: support skipping regular nops
2018-02-28 22:22:33 +00:00
case GE_CMD_NOP:
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
case GE_CMD_NOP_FF:
GPU: Maintain a bit more state in inner-prim loop. Trying to make dumps properly trigger this optimization, but they still sometimes get flattened and don't.
2018-11-30 03:28:10 +00:00
gstate.cmdmem[data >> 24] = data;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
break;
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
case GE_CMD_BONEMATRIXNUMBER:
gstate.cmdmem[GE_CMD_BONEMATRIXNUMBER] = data;
break;
case GE_CMD_TEXSCALEU:
gstate.cmdmem[GE_CMD_TEXSCALEU] = data;
gstate_c.uv.uScale = getFloat24(data);
break;
case GE_CMD_TEXSCALEV:
gstate.cmdmem[GE_CMD_TEXSCALEV] = data;
gstate_c.uv.vScale = getFloat24(data);
break;
handle cull mode by indices, improve performance for GVGNP, refer to #10172
2018-04-27 08:33:35 +00:00
case GE_CMD_TEXOFFSETU:
gstate.cmdmem[GE_CMD_TEXOFFSETU] = data;
gstate_c.uv.uOff = getFloat24(data);
break;
case GE_CMD_TEXOFFSETV:
gstate.cmdmem[GE_CMD_TEXOFFSETV] = data;
gstate_c.uv.vOff = getFloat24(data);
break;
Inner interpreter: Add support for the Gran Turismo hack.
2018-03-17 22:57:50 +00:00
case GE_CMD_TEXLEVEL:
// Same Gran Turismo hack from Execute_TexLevel
if ((data & 3) != GE_TEXLEVEL_MODE_AUTO && (0x00FF0000 & data) != 0) {
goto bail;
}
gstate.cmdmem[GE_CMD_TEXLEVEL] = data;
break;
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
case GE_CMD_CALL:
{
// A bone matrix probably. If not we bail.
const u32 target = gstate_c.getRelativeAddress(data & 0x00FFFFFC);
if ((Memory::ReadUnchecked_U32(target) >> 24) == GE_CMD_BONEMATRIXDATA &&
(Memory::ReadUnchecked_U32(target + 11 * 4) >> 24) == GE_CMD_BONEMATRIXDATA &&
(Memory::ReadUnchecked_U32(target + 12 * 4) >> 24) == GE_CMD_RET &&
GPU: Fix bone matrix CALL opt corruption. If the matrix number is high and we have extra CALLs, we can't load it into the memory after the bone matrixes.
2022-01-01 23:26:00 +00:00
(target > currentList->stall || target + 12 * 4 < currentList->stall) &&
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
(gstate.boneMatrixNumber & 0x00FFFFFF) <= 96 - 12) {
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
FastLoadBoneMatrix(target);
} else {
goto bail;
}
break;
}
GPU: Maintain a bit more state in inner-prim loop. Trying to make dumps properly trigger this optimization, but they still sometimes get flattened and don't.
2018-11-30 03:28:10 +00:00
case GE_CMD_TEXBUFWIDTH0:
case GE_CMD_TEXADDR0:
if (data != gstate.cmdmem[data >> 24])
goto bail;
break;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
default:
// All other commands might need a flush or something, stop this inner loop.
goto bail;
}
cmdCount++;
src++;
}
bail:
Optimize the "inner interpreter" for God of War character drawing. Speeds the games up by 4% or so. (measured on the title screen though..)
2018-03-05 11:49:55 +00:00
gstate.cmdmem[GE_CMD_VERTEXTYPE] = vertexType;
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
// Skip over the commands we just read out manually.
if (cmdCount > 0) {
UpdatePC(currentList->pc, currentList->pc + cmdCount * 4);
currentList->pc += cmdCount * 4;
flush back cull mode
2018-04-27 13:49:43 +00:00
// flush back cull mode
handle cullface, help to #10597
2018-08-23 04:46:09 +00:00
if (cullMode != gstate.getCullMode()) {
GPU: Correctly flush on cull mode change. Fixes #11593 and fixes #11591.
2018-11-26 00:56:39 +00:00
// We rewrote everything to the old cull mode, so flush first.
drawEngineCommon_->DispatchFlush();
// Now update things for next time.
flush back cull mode
2018-04-27 13:49:43 +00:00
gstate.cmdmem[GE_CMD_CULL] ^= 1;
gstate_c.Dirty(DIRTY_RASTER_STATE);
}
Execute_Prim: Add a smaller "inner interpreter" to avoid going back to the runloop during long sequences of PRIM commands. Helps performance by a quite measurable 1-4% in several PRIM-heavy games.
2018-02-27 23:01:02 +00:00
}
gpuStats.vertexGPUCycles += vertexCost_ * totalVertCount;
cyclesExecuted += vertexCost_ * totalVertCount;
Unify Execute_Prim
2018-02-26 10:18:52 +00:00
}
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
void GPUCommon::Execute_Bezier(u32 op, u32 diff) {
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
// We don't dirty on normal changes anymore as we prescale, but it's needed for splines/bezier.
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Oops, gotta update the cached framebuffer format in the other drawing paths too
2022-04-24 21:23:54 +00:00
gstate_c.framebufFormat = gstate.FrameBufFormat();
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
// This also make skipping drawing very effective.
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
VirtualFramebuffer *vfb = framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +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;
}
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
CheckDepthUsage(vfb);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
Split GetPointer into two versions, to help with const correctness
2022-07-20 10:40:22 +00:00
const void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
const void *indices = NULL;
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
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);
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Unusual bezier/spline vtype: %08x, morph: %d, bones: %d", gstate.vertType, (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT, vertTypeGetNumBoneWeights(gstate.vertType));
}
Bezier/Spline: Fix logical error (must flush buffered data before we modify submitType). Should fix #14774
2021-09-07 21:52:06 +00:00
// Can't flush after setting gstate_c.submitType below since it'll be a mess - it must be done already.
softgpu: Avoid unnecessary flushing for curves. We don't need to flush all drawing between curves in softgpu, let them queue up.
2022-09-22 07:08:38 +00:00
if (flushOnParams_)
drawEngineCommon_->DispatchFlush();
Bezier/Spline: Fix logical error (must flush buffered data before we modify submitType). Should fix #14774
2021-09-07 21:52:06 +00:00
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
Spline::BezierSurface surface;
surface.tess_u = gstate.getPatchDivisionU();
surface.tess_v = gstate.getPatchDivisionV();
surface.num_points_u = op & 0xFF;
surface.num_points_v = (op >> 8) & 0xFF;
surface.num_patches_u = (surface.num_points_u - 1) / 3;
surface.num_patches_v = (surface.num_points_v - 1) / 3;
surface.primType = gstate.getPatchPrimitiveType();
surface.patchFacing = gstate.patchfacing & 1;
SetDrawType(DRAW_BEZIER, PatchPrimToPrim(surface.primType));
D3D9: Avoid curve Z clip to be safe. I think it does actually happen, but we don't do it in the shader, so let's not do it here.
2022-12-18 20:01:28 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VERTEXSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE);
GPU: Move hw transform decision to draw engine.
2020-04-04 18:14:32 +00:00
if (drawEngineCommon_->CanUseHardwareTessellation(surface.primType)) {
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
gstate_c.submitType = SubmitType::HW_BEZIER;
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
if (gstate_c.spline_num_points_u != surface.num_points_u) {
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
gstate_c.Dirty(DIRTY_BEZIERSPLINE);
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
gstate_c.spline_num_points_u = surface.num_points_u;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
}
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
} else {
gstate_c.submitType = SubmitType::BEZIER;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
}
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
int bytesRead = 0;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
UpdateUVScaleOffset();
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
drawEngineCommon_->SubmitCurve(control_points, indices, surface, gstate.vertType, &bytesRead, "bezier");
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
D3D9: Avoid curve Z clip to be safe. I think it does actually happen, but we don't do it in the shader, so let's not do it here.
2022-12-18 20:01:28 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VERTEXSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE);
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
gstate_c.submitType = SubmitType::DRAW;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
// After drawing, we advance pointers - see SubmitPrim which does the same.
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
int count = surface.num_points_u * surface.num_points_v;
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
AdvanceVerts(gstate.vertType, count, bytesRead);
}
void GPUCommon::Execute_Spline(u32 op, u32 diff) {
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
// We don't dirty on normal changes anymore as we prescale, but it's needed for splines/bezier.
gstate_c.Dirty(DIRTY_UVSCALEOFFSET);
Oops, gotta update the cached framebuffer format in the other drawing paths too
2022-04-24 21:23:54 +00:00
gstate_c.framebufFormat = gstate.FrameBufFormat();
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
// This also make skipping drawing very effective.
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
VirtualFramebuffer *vfb = framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +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;
}
Fix deferred-depth for bezier/spline. Move updating of last_frame_depth_render to GPUCommon.
2022-08-18 07:38:17 +00:00
CheckDepthUsage(vfb);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
Split GetPointer into two versions, to help with const correctness
2022-07-20 10:40:22 +00:00
const void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
const void *indices = NULL;
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
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);
}
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Unusual bezier/spline vtype: %08x, morph: %d, bones: %d", gstate.vertType, (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT, vertTypeGetNumBoneWeights(gstate.vertType));
}
Bezier/Spline: Fix logical error (must flush buffered data before we modify submitType). Should fix #14774
2021-09-07 21:52:06 +00:00
// Can't flush after setting gstate_c.submitType below since it'll be a mess - it must be done already.
softgpu: Avoid unnecessary flushing for curves. We don't need to flush all drawing between curves in softgpu, let them queue up.
2022-09-22 07:08:38 +00:00
if (flushOnParams_)
drawEngineCommon_->DispatchFlush();
Bezier/Spline: Fix logical error (must flush buffered data before we modify submitType). Should fix #14774
2021-09-07 21:52:06 +00:00
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
Spline::SplineSurface surface;
surface.tess_u = gstate.getPatchDivisionU();
surface.tess_v = gstate.getPatchDivisionV();
surface.type_u = (op >> 16) & 0x3;
surface.type_v = (op >> 18) & 0x3;
surface.num_points_u = op & 0xFF;
surface.num_points_v = (op >> 8) & 0xFF;
surface.num_patches_u = surface.num_points_u - 3;
surface.num_patches_v = surface.num_points_v - 3;
surface.primType = gstate.getPatchPrimitiveType();
surface.patchFacing = gstate.patchfacing & 1;
SetDrawType(DRAW_SPLINE, PatchPrimToPrim(surface.primType));
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
D3D9: Avoid curve Z clip to be safe. I think it does actually happen, but we don't do it in the shader, so let's not do it here.
2022-12-18 20:01:28 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VERTEXSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE);
GPU: Move hw transform decision to draw engine.
2020-04-04 18:14:32 +00:00
if (drawEngineCommon_->CanUseHardwareTessellation(surface.primType)) {
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
gstate_c.submitType = SubmitType::HW_SPLINE;
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
if (gstate_c.spline_num_points_u != surface.num_points_u) {
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
gstate_c.Dirty(DIRTY_BEZIERSPLINE);
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
gstate_c.spline_num_points_u = surface.num_points_u;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
}
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
} else {
gstate_c.submitType = SubmitType::SPLINE;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
}
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
int bytesRead = 0;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
UpdateUVScaleOffset();
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
drawEngineCommon_->SubmitCurve(control_points, indices, surface, gstate.vertType, &bytesRead, "spline");
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
D3D9: Avoid curve Z clip to be safe. I think it does actually happen, but we don't do it in the shader, so let's not do it here.
2022-12-18 20:01:28 +00:00
gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VERTEXSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE);
Turn off vertex range culling in bezier/spline calls. When we do lower res tess than the real PSP, we cant trust the game to not cause range culling to kick in. Fixes #11692
2020-12-13 15:04:16 +00:00
gstate_c.submitType = SubmitType::DRAW;
Unify Execute_Bezier and Execute_Spline
2017-11-13 09:42:05 +00:00
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
// After drawing, we advance pointers - see SubmitPrim which does the same.
[spline/bezier]Unify SubmitSpline/Bezier.
2018-11-13 08:12:41 +00:00
int count = surface.num_points_u * surface.num_points_v;
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
AdvanceVerts(gstate.vertType, count, bytesRead);
}
void GPUCommon::Execute_BoundingBox(u32 op, u32 diff) {
// Just resetting, nothing to check bounds for.
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
const u32 count = op & 0xFFFF;
GPU: Advance the vertex pointer after BBOX vertices are sent. Fixes #6554, finally!
2017-11-17 12:36:48 +00:00
if (count == 0) {
GPU: Consider bbox failed with zero verts. This seems to match behavior in tests.
2017-08-20 20:30:10 +00:00
currentList->bboxResult = false;
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
return;
}
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
GPU: Consume cycles in bounding box check.
2022-10-22 16:09:17 +00:00
// Approximate based on timings of several counts on a PSP.
cyclesExecuted += count * 22;
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
const bool useInds = (gstate.vertType & GE_VTYPE_IDX_MASK) != 0;
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
VertexDecoder *dec = drawEngineCommon_->GetVertexDecoder(gstate.vertType);
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
int bytesRead = (useInds ? 1 : dec->VertexSize()) * count;
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
if (Memory::IsValidRange(gstate_c.vertexAddr, bytesRead)) {
const void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
GPU: Advance the vertex pointer after BBOX vertices are sent. Fixes #6554, finally!
2017-11-17 12:36:48 +00:00
if (!control_points) {
softgpu: Add a table and initial dirty flags. Not actually using the dirty flags to skip state, but have moved to Execute_* functions and everything else like other graphics backends.
2022-01-23 06:41:41 +00:00
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Invalid verts in bounding box check");
currentList->bboxResult = true;
GPU: Advance the vertex pointer after BBOX vertices are sent. Fixes #6554, finally!
2017-11-17 12:36:48 +00:00
return;
}
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
const void *inds = nullptr;
if (useInds) {
int indexShift = ((gstate.vertType & GE_VTYPE_IDX_MASK) >> GE_VTYPE_IDX_SHIFT) - 1;
inds = Memory::GetPointerUnchecked(gstate_c.indexAddr);
if (!inds || !Memory::IsValidRange(gstate_c.indexAddr, count << indexShift)) {
ERROR_LOG_REPORT_ONCE(boundingboxInds, G3D, "Invalid inds in bounding box check");
currentList->bboxResult = true;
return;
}
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
}
// Test if the bounding box is within the drawing region.
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
// The PSP only seems to vary the result based on a single range of 0x100.
if (count > 0x200) {
// The second to last set of 0x100 is checked (even for odd counts.)
size_t skipSize = (count - 0x200) * dec->VertexSize();
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
currentList->bboxResult = drawEngineCommon_->TestBoundingBox((const uint8_t *)control_points + skipSize, inds, 0x100, gstate.vertType);
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
} else if (count > 0x100) {
int checkSize = count - 0x100;
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
currentList->bboxResult = drawEngineCommon_->TestBoundingBox(control_points, inds, checkSize, gstate.vertType);
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
} else {
GPU: Allow/use indices in bounding box check. Not sure any games actually use this, but it's supported.
2022-10-22 17:01:56 +00:00
currentList->bboxResult = drawEngineCommon_->TestBoundingBox(control_points, inds, count, gstate.vertType);
GPU: Correct bounding box for larger counts. Matches tests on a PSP with float/transform format.
2022-10-22 16:06:33 +00:00
}
GPU: Advance the vertex pointer after BBOX vertices are sent. Fixes #6554, finally!
2017-11-17 12:36:48 +00:00
AdvanceVerts(gstate.vertType, count, bytesRead);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
} else {
GPU: Advance the vertex pointer after BBOX vertices are sent. Fixes #6554, finally!
2017-11-17 12:36:48 +00:00
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Bad bounding box data: %06x", count);
Centralize the spline/bezier/bbox execute functions into GPUCommon
2017-01-21 19:42:40 +00:00
// Data seems invalid. Let's assume the box test passed.
currentList->bboxResult = true;
}
}
Centralize EstimatePerVertexCost and Execute_BlockTransferStart
2017-01-23 15:57:16 +00:00
void GPUCommon::Execute_BlockTransferStart(u32 op, u32 diff) {
Make FLAG_FLUSHBEFORE a no-op, move flushes into the execution functions. It would only be necessary if we needed the previous value, which we don't do in any of these.
2017-08-17 11:05:13 +00:00
Flush();
GPUCommon: Remove misleading flag FLUSHBEFORE. Fixes the new problem in #13967 Though of course doesn't fix the vertical lines.
2022-01-31 22:57:56 +00:00
PROFILE_THIS_SCOPE("block"); // don't include the flush in the profile, would be misleading.
Oops, gotta update the cached framebuffer format in the other drawing paths too
2022-04-24 21:23:54 +00:00
gstate_c.framebufFormat = gstate.FrameBufFormat();
Centralize EstimatePerVertexCost and Execute_BlockTransferStart
2017-01-23 15:57:16 +00:00
// and take appropriate action. This is a block transfer between RAM and VRAM, or vice versa.
// Can we skip this on SkipDraw?
DoBlockTransfer(gstate_c.skipDrawReason);
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
void GPUCommon::Execute_WorldMtxNum(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (!currentList) {
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (op & 0xF);
return;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// This is almost always followed by GE_CMD_WORLDMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.worldMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
// We must record the individual data commands while debugRecording_.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
bool fastLoad = !debugRecording_ && end > 0;
More vulkan microoptimizations. Add more profiler scopes.
2017-08-18 11:39:42 +00:00
// Stalling in the middle of a matrix would be stupid, I doubt this check is necessary.
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
if (currentList->pc < currentList->stall && currentList->pc + end * 4 >= currentList->stall) {
fastLoad = false;
}
if (fastLoad) {
while ((src[i] >> 24) == GE_CMD_WORLDMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
gstate_c.Dirty(DIRTY_WORLDMATRIX);
}
if (++i >= end) {
break;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
}
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
const int count = i;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | ((op & 0xF) + count);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GPUCommon::Execute_WorldMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
int num = gstate.worldmtxnum & 0x00FFFFFF;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) {
Flush();
((u32 *)gstate.worldMatrix)[num] = newVal;
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_WORLDMATRIX);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
num++;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0x00FFFFFF);
softgpu: Implement matrix data wrap-around. Overflow writes to other matrices. Matches hardware tests.
2022-09-06 02:38:54 +00:00
gstate.worldmtxdata = GE_CMD_WORLDMATRIXDATA << 24;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
void GPUCommon::Execute_ViewMtxNum(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (!currentList) {
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (op & 0xF);
return;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// This is almost always followed by GE_CMD_VIEWMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.viewMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
bool fastLoad = !debugRecording_ && end > 0;
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
if (currentList->pc < currentList->stall && currentList->pc + end * 4 >= currentList->stall) {
fastLoad = false;
}
if (fastLoad) {
while ((src[i] >> 24) == GE_CMD_VIEWMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
gstate_c.Dirty(DIRTY_VIEWMATRIX);
}
if (++i >= end) {
break;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
}
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
const int count = i;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | ((op & 0xF) + count);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GPUCommon::Execute_ViewMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
int num = gstate.viewmtxnum & 0x00FFFFFF;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) {
Flush();
((u32 *)gstate.viewMatrix)[num] = newVal;
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_VIEWMATRIX);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
num++;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0x00FFFFFF);
softgpu: Implement matrix data wrap-around. Overflow writes to other matrices. Matches hardware tests.
2022-09-06 02:38:54 +00:00
gstate.viewmtxdata = GE_CMD_VIEWMATRIXDATA << 24;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
void GPUCommon::Execute_ProjMtxNum(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (!currentList) {
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (op & 0xF);
return;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// This is almost always followed by GE_CMD_PROJMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.projMatrix + (op & 0xF));
const int end = 16 - (op & 0xF);
int i = 0;
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
bool fastLoad = !debugRecording_;
if (currentList->pc < currentList->stall && currentList->pc + end * 4 >= currentList->stall) {
fastLoad = false;
}
if (fastLoad) {
while ((src[i] >> 24) == GE_CMD_PROJMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
gstate_c.Dirty(DIRTY_PROJMATRIX);
}
if (++i >= end) {
break;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
}
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
const int count = i;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | ((op & 0xF) + count);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GPUCommon::Execute_ProjMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
int num = gstate.projmtxnum & 0x00FFFFFF;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
u32 newVal = op << 8;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
if (num < 16 && newVal != ((const u32 *)gstate.projMatrix)[num]) {
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
Flush();
((u32 *)gstate.projMatrix)[num] = newVal;
Merge the texture flags into the dirty flags
2017-01-24 08:41:38 +00:00
gstate_c.Dirty(DIRTY_PROJMATRIX);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
num++;
Limit Projection Matrix Data count to <= 16
2017-01-24 01:33:16 +00:00
if (num <= 16)
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0x00FFFFFF);
softgpu: Implement matrix data wrap-around. Overflow writes to other matrices. Matches hardware tests.
2022-09-06 02:38:54 +00:00
gstate.projmtxdata = GE_CMD_PROJMATRIXDATA << 24;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
void GPUCommon::Execute_TgenMtxNum(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (!currentList) {
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (op & 0xF);
return;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// This is almost always followed by GE_CMD_TGENMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.tgenMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
bool fastLoad = !debugRecording_ && end > 0;
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
if (currentList->pc < currentList->stall && currentList->pc + end * 4 >= currentList->stall) {
fastLoad = false;
}
if (fastLoad) {
while ((src[i] >> 24) == GE_CMD_TGENMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
GPU: Fix missed dirtying when fast loading tgen.
2022-09-30 05:29:30 +00:00
// We check the matrix to see if we need projection.
gstate_c.Dirty(DIRTY_TEXMATRIX | DIRTY_FRAGMENTSHADER_STATE);
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
}
if (++i >= end) {
break;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
}
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
const int count = i;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | ((op & 0xF) + count);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GPUCommon::Execute_TgenMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
int num = gstate.texmtxnum & 0x00FFFFFF;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) {
Flush();
((u32 *)gstate.tgenMatrix)[num] = newVal;
Dirty-flag the fragment shader ID.
2017-03-19 10:32:29 +00:00
gstate_c.Dirty(DIRTY_TEXMATRIX | DIRTY_FRAGMENTSHADER_STATE); // We check the matrix to see if we need projection
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
num++;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0x00FFFFFF);
softgpu: Implement matrix data wrap-around. Overflow writes to other matrices. Matches hardware tests.
2022-09-06 02:38:54 +00:00
gstate.texmtxdata = GE_CMD_TGENMATRIXDATA << 24;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
void GPUCommon::Execute_BoneMtxNum(u32 op, u32 diff) {
GPU: Restore matrices with dirtying. Without this, it's possible we might not notice or apply a change whether in uniforms or etc.
2022-09-30 04:36:53 +00:00
if (!currentList) {
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (op & 0x7F);
return;
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// This is almost always followed by GE_CMD_BONEMATRIXDATA.
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
u32 *dst = (u32 *)(gstate.boneMatrix + (op & 0x7F));
const int end = 12 * 8 - (op & 0x7F);
int i = 0;
GPU: Avoid memory corruption on bone matrix > 96. See #9574. Seen in Zill O'll Infinite, thanks to Kitsu-neechan for tracking this down.
2017-12-26 09:08:37 +00:00
bool fastLoad = !debugRecording_ && end > 0;
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
if (currentList->pc < currentList->stall && currentList->pc + end * 4 >= currentList->stall) {
fastLoad = false;
}
if (fastLoad) {
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
// If we can't use software skinning, we have to flush and dirty.
if (!g_Config.bSoftwareSkinning) {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
}
if (++i >= end) {
break;
}
}
const unsigned int numPlusCount = (op & 0x7F) + i;
for (unsigned int num = op & 0x7F; num < numPlusCount; num += 12) {
gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12));
}
} else {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
dst[i] = src[i] << 8;
if (++i >= end) {
break;
}
}
const unsigned int numPlusCount = (op & 0x7F) + i;
for (unsigned int num = op & 0x7F; num < numPlusCount; num += 12) {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
}
GPU: Stall properly on matrix data. Hit an infinite loop because it kept passing the stall pause and looping. Found when recording the God of War demo.
2017-06-04 19:50:12 +00:00
const int count = i;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | ((op & 0x7F) + count);
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void GPUCommon::Execute_BoneMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
int num = gstate.boneMatrixNumber & 0x00FFFFFF;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
u32 newVal = op << 8;
if (num < 96 && newVal != ((const u32 *)gstate.boneMatrix)[num]) {
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
// Bone matrices should NOT flush when software skinning is enabled!
if (!g_Config.bSoftwareSkinning) {
Flush();
gstate_c.Dirty(DIRTY_BONEMATRIX0 << (num / 12));
} else {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
}
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
((u32 *)gstate.boneMatrix)[num] = newVal;
}
num++;
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x00FFFFFF);
softgpu: Implement matrix data wrap-around. Overflow writes to other matrices. Matches hardware tests.
2022-09-06 02:38:54 +00:00
gstate.boneMatrixData = GE_CMD_BONEMATRIXDATA << 24;
Centralize the matrix load functions, no need to duplicate them for each backend.
2017-01-23 19:56:25 +00:00
}
Use table-driven dirtying instead of callbacks in GPU_GLES
2017-01-24 09:44:02 +00:00
void GPUCommon::Execute_MorphWeight(u32 op, u32 diff) {
gstate_c.morphWeights[(op >> 24) - GE_CMD_MORPHWEIGHT0] = getFloat24(op);
}
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
void GPUCommon::Execute_ImmVertexAlphaPrim(u32 op, u32 diff) {
Add safety check.
2017-11-24 20:55:25 +00:00
// Safety check.
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
if (immCount_ >= MAX_IMMBUFFER_SIZE) {
// Only print once for each overrun.
if (immCount_ == MAX_IMMBUFFER_SIZE) {
Improve reporting for imm buffer exceeded. Reset the immCount_ every frame to avoid getting "stuck" permanently in case some garbage is executed..
2017-12-01 19:01:13 +00:00
ERROR_LOG_REPORT_ONCE(exceed_imm_buffer, G3D, "Exceeded immediate draw buffer size. gstate.imm_ap=%06x , prim=%d", gstate.imm_ap & 0xFFFFFF, (int)immPrim_);
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
}
if (immCount_ < 0x7fffffff) // Paranoia :)
immCount_++;
Add safety check.
2017-11-24 20:55:25 +00:00
return;
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
}
Add safety check.
2017-11-24 20:55:25 +00:00
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
int prim = (op >> 8) & 0x7;
if (prim != GE_PRIM_KEEP_PREVIOUS) {
// Flush before changing the prim type. Only continue can be used to continue a prim.
FlushImm();
}
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
TransformedVertex &v = immBuffer_[immCount_++];
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
// ThrillVille does a clear with this, additional parameters found via tests.
// The current vtype affects how the coordinate is processed.
if (gstate.isModeThrough()) {
v.x = ((int)(gstate.imm_vscx & 0xFFFF) - 0x8000) / 16.0f;
v.y = ((int)(gstate.imm_vscy & 0xFFFF) - 0x8000) / 16.0f;
} else {
int offsetX = gstate.getOffsetX16();
int offsetY = gstate.getOffsetY16();
v.x = ((int)(gstate.imm_vscx & 0xFFFF) - offsetX) / 16.0f;
v.y = ((int)(gstate.imm_vscy & 0xFFFF) - offsetY) / 16.0f;
}
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
v.z = gstate.imm_vscz & 0xFFFF;
GPU: Rename pos/uv w for clarity.
2021-10-31 04:03:01 +00:00
v.pos_w = 1.0f;
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
v.u = getFloat24(gstate.imm_vtcs);
v.v = getFloat24(gstate.imm_vtct);
GPU: Rename pos/uv w for clarity.
2021-10-31 04:03:01 +00:00
v.uv_w = getFloat24(gstate.imm_vtcq);
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
v.color0_32 = (gstate.imm_cv & 0xFFFFFF) | (gstate.imm_ap << 24);
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
// TODO: When !gstate.isModeThrough(), direct fog coefficient (0 = entirely fog), ignore fog flag (also GE_IMM_FOG.)
v.fog = (gstate.imm_fc & 0xFF) / 255.0f;
// TODO: Apply if gstate.isUsingSecondaryColor() && !gstate.isModeThrough(), ignore lighting flag.
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
v.color1_32 = gstate.imm_scv & 0xFFFFFF;
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
if (prim != GE_PRIM_KEEP_PREVIOUS) {
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
immPrim_ = (GEPrimitiveType)prim;
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
// Flags seem to only be respected from the first prim.
immFlags_ = op & 0x00FFF800;
softgpu: Fix state/continuation for imm prims.
2022-09-18 03:15:40 +00:00
immFirstSent_ = false;
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
} else if (prim == GE_PRIM_KEEP_PREVIOUS && immPrim_ != GE_PRIM_INVALID) {
static constexpr int flushPrimCount[] = { 1, 2, 0, 3, 0, 0, 2, 0 };
softgpu: Refactor imm draws to bypass vert read.
2022-09-18 01:42:59 +00:00
// Instead of finding a proper point to flush, we just emit prims when we can.
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
if (immCount_ == flushPrimCount[immPrim_ & 7])
FlushImm();
Unbreak save states, fix other minor issues from review
2017-11-25 11:13:02 +00:00
} else {
ERROR_LOG_REPORT_ONCE(imm_draw_prim, G3D, "Immediate draw: Unexpected primitive %d at count %d", prim, immCount_);
Process immediate draw commands. Not yet sending to graphics backends.
2017-11-24 16:54:56 +00:00
}
}
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
void GPUCommon::FlushImm() {
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
if (immCount_ == 0 || immPrim_ == GE_PRIM_INVALID)
return;
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
SetDrawType(DRAW_PRIM, immPrim_);
softgpu: Fix immediate rendering crash.
2022-09-06 05:38:21 +00:00
if (framebufferManager_)
framebufferManager_->SetRenderFrameBuffer(gstate_c.IsDirty(DIRTY_FRAMEBUF), gstate_c.skipDrawReason);
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// No idea how many cycles to skip, heh.
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
immCount_ = 0;
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
return;
}
UpdateUVScaleOffset();
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
bool antialias = (immFlags_ & GE_IMM_ANTIALIAS) != 0;
bool prevAntialias = gstate.isAntiAliasEnabled();
bool shading = (immFlags_ & GE_IMM_SHADING) != 0;
bool prevShading = gstate.getShadeMode() == GE_SHADE_GOURAUD;
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
bool cullEnable = (immFlags_ & GE_IMM_CULLENABLE) != 0;
bool prevCullEnable = gstate.isCullEnabled();
int cullMode = (immFlags_ & GE_IMM_CULLFACE) != 0 ? 1 : 0;
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
bool texturing = (immFlags_ & GE_IMM_TEXTURE) != 0;
bool prevTexturing = gstate.isTextureMapEnabled();
softgpu: Support fog and color1 on imm verts.
2022-09-18 02:42:41 +00:00
bool fog = (immFlags_ & GE_IMM_FOG) != 0;
bool prevFog = gstate.isFogEnabled();
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
bool dither = (immFlags_ & GE_IMM_DITHER) != 0;
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
bool prevDither = gstate.isDitherEnabled();
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
GE Debugger: Show imm prim flag detail in disasm.
2022-09-07 05:18:55 +00:00
if ((immFlags_ & GE_IMM_CLIPMASK) != 0) {
WARN_LOG_REPORT_ONCE(geimmclipvalue, G3D, "Imm vertex used clip value, flags=%06x", immFlags_);
}
GPU: Fix crash on imm vert triangles. Was crashing because the frag and vert shaders didn't match up.
2022-09-18 04:08:26 +00:00
bool changed = texturing != prevTexturing || cullEnable != prevCullEnable || dither != prevDither;
changed = changed || prevShading != shading || prevFog != fog;
if (changed) {
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
DispatchFlush();
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
gstate.antiAliasEnable = (GE_CMD_ANTIALIASENABLE << 24) | (int)antialias;
gstate.shademodel = (GE_CMD_SHADEMODE << 24) | (int)shading;
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
gstate.cullfaceEnable = (GE_CMD_CULLFACEENABLE << 24) | (int)cullEnable;
GPU: Handle more flags on imm prim command.
2022-09-07 05:03:46 +00:00
gstate.textureMapEnable = (GE_CMD_TEXTUREMAPENABLE << 24) | (int)texturing;
softgpu: Support fog and color1 on imm verts.
2022-09-18 02:42:41 +00:00
gstate.fogEnable = (GE_CMD_FOGENABLE << 24) | (int)fog;
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
gstate.ditherEnable = (GE_CMD_DITHERENABLE << 24) | (int)dither;
GPU: Fix crash on imm vert triangles. Was crashing because the frag and vert shaders didn't match up.
2022-09-18 04:08:26 +00:00
gstate_c.Dirty(DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_UVSCALEOFFSET | DIRTY_CULLRANGE);
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
}
softgpu: Fix state/continuation for imm prims.
2022-09-18 03:15:40 +00:00
drawEngineCommon_->DispatchSubmitImm(immPrim_, immBuffer_, immCount_, cullMode, immFirstSent_);
GPU: Handle immediate prims more accurately. This allows for lines, points, textures, and similar things. Also corrects offset handling. Still some flags on VAP that seemingly don't work, and this doesn't consider the texture flag on it.
2022-09-06 05:45:34 +00:00
immCount_ = 0;
softgpu: Fix state/continuation for imm prims.
2022-09-18 03:15:40 +00:00
immFirstSent_ = true;
GPU: Allow usage of texturing in immediate verts. And respect the other flags that I can reproduce working in a test. I can't seem to get the fog to work at all, or the shading mode, or the secondary color. Maybe depends on other flags or bits in other regs...
2022-09-06 06:13:16 +00:00
GPU: Fix crash on imm vert triangles. Was crashing because the frag and vert shaders didn't match up.
2022-09-18 04:08:26 +00:00
if (changed) {
DispatchFlush();
gstate.antiAliasEnable = (GE_CMD_ANTIALIASENABLE << 24) | (int)prevAntialias;
gstate.shademodel = (GE_CMD_SHADEMODE << 24) | (int)prevShading;
gstate.cullfaceEnable = (GE_CMD_CULLFACEENABLE << 24) | (int)prevCullEnable;
gstate.textureMapEnable = (GE_CMD_TEXTUREMAPENABLE << 24) | (int)prevTexturing;
gstate.fogEnable = (GE_CMD_FOGENABLE << 24) | (int)prevFog;
gstate.ditherEnable = (GE_CMD_DITHERENABLE << 24) | (int)prevDither;
gstate_c.Dirty(DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_UVSCALEOFFSET | DIRTY_CULLRANGE);
}
Hack that converts immediate draws to through-mode draws. This won't work correctly in all cases - but it's enough for Thrillville which uses it to clear only. Works around #7459.
2017-11-24 20:45:25 +00:00
}
Add the common funcs to the direct exec calls.
2014-04-16 15:12:21 +00:00
void GPUCommon::ExecuteOp(u32 op, u32 diff) {
const u32 cmd = op >> 24;
// Handle control and drawing commands here directly. The others we delegate.
switch (cmd) {
case GE_CMD_NOP:
break;
case GE_CMD_OFFSETADDR:
Execute_OffsetAddr(op, diff);
break;
case GE_CMD_ORIGIN:
Execute_Origin(op, diff);
break;
case GE_CMD_JUMP:
Execute_Jump(op, diff);
break;
case GE_CMD_BJUMP:
Execute_BJump(op, diff);
break;
case GE_CMD_CALL:
Execute_Call(op, diff);
break;
case GE_CMD_RET:
Execute_Ret(op, diff);
break;
case GE_CMD_SIGNAL:
case GE_CMD_FINISH:
// Processed in GE_END.
break;
case GE_CMD_END:
Execute_End(op, diff);
break;
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
default:
Use table-driven dirtying instead of callbacks in GPU_GLES
2017-01-24 09:44:02 +00:00
DEBUG_LOG(G3D, "DL Unknown: %08x @ %08x", op, currentList == NULL ? 0 : currentList->pc);
break;
}
}
void GPUCommon::Execute_Unknown(u32 op, u32 diff) {
Reporting: Remove unused code.
2017-12-01 17:32:23 +00:00
if ((op & 0xFFFFFF) != 0)
WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op);
Move the pc-management cmds to GPUCommon.
2013-04-01 06:02:46 +00:00
}
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
void GPUCommon::FastLoadBoneMatrix(u32 target) {
Very minor optimization (divisions by constants are faster unsigned)
2020-09-28 22:35:38 +00:00
const u32 num = gstate.boneMatrixNumber & 0x7F;
GPU: Fix bone matrix CALL opt corruption. If the matrix number is high and we have extra CALLs, we can't load it into the memory after the bone matrixes.
2022-01-01 23:26:00 +00:00
_dbg_assert_msg_(num + 12 <= 96, "FastLoadBoneMatrix would corrupt memory");
Very minor optimization (divisions by constants are faster unsigned)
2020-09-28 22:35:38 +00:00
const u32 mtxNum = num / 12;
u32 uniformsToDirty = DIRTY_BONEMATRIX0 << mtxNum;
Some GPU code cleanup. Disable some unnecessary reporting.
2020-09-24 21:00:48 +00:00
if (num != 12 * mtxNum) {
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);
}
if (!g_Config.bSoftwareSkinning) {
softgpu: Avoid flush on END. We only, but always, flush when exiting list interp in FinishDeferred. It's not necessary at END, and hurts for simple signals that don't stop list processing.
2022-02-01 03:32:46 +00:00
if (flushOnParams_)
Flush();
Revert "Remove further remains of hardware skinning." This reverts commit 40db61a6808cb7bab534d6de9010ccce7212c8ee.
2018-04-10 10:22:02 +00:00
gstate_c.Dirty(uniformsToDirty);
} else {
gstate_c.deferredVertTypeDirty |= uniformsToDirty;
}
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
gstate.FastLoadBoneMatrix(target);
Account for the GPU cycle cost of loading bone matrices. This could change timing slightly in games that use many of these, like maybe God of War for example. We should probably get it in for 1.15 and just handle any fallout.
2023-01-01 19:35:04 +00:00
cyclesExecuted += 2 * 14; // one to reset the counter, 12 to load the matrix, and a return.
if (coreCollectDebugStats) {
gpuStats.otherGPUCycles += 2 * 14;
}
Allow fast bone mtx loads w/o software skinning.
2014-03-03 02:12:40 +00:00
}
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
struct DisplayList_v1 {
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
int id;
u32 startpc;
u32 pc;
u32 stall;
DisplayListState state;
SignalBehavior signal;
int subIntrBase;
u16 subIntrToken;
DisplayListStackEntry stack[32];
int stackptr;
bool interrupted;
u64 waitTicks;
bool interruptsEnabled;
bool pendingInterrupt;
bool started;
size_t contextPtr;
u32 offsetAddr;
bool bboxResult;
};
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
struct DisplayList_v2 {
int id;
u32 startpc;
u32 pc;
u32 stall;
DisplayListState state;
SignalBehavior signal;
int subIntrBase;
u16 subIntrToken;
DisplayListStackEntry stack[32];
int stackptr;
bool interrupted;
u64 waitTicks;
bool interruptsEnabled;
bool pendingInterrupt;
bool started;
PSPPointer<u32_le> context;
u32 offsetAddr;
bool bboxResult;
};
Save more of the GPU's state, fix a crash. Well, ReapplyGfxState() seems kinda dangerous now...
2012-12-29 19:41:33 +00:00
void GPUCommon::DoState(PointerWrap &p) {
Ge: Report and save Edram translation value. See #16126 for some details on its usage and effects.
2022-10-02 06:18:42 +00:00
auto s = p.Section("GPUCommon", 1, 6);
Check version in each DoState() func. They bail on PointerWrap error or bad version.
2013-09-15 03:23:03 +00:00
if (!s)
return;
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do<int>(p, dlQueue);
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
if (s >= 4) {
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
DoArray(p, dls, ARRAY_SIZE(dls));
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
} else if (s >= 3) {
Also fix padding for DisplayList on iOS. Fixes #8199.
2015-12-24 22:31:43 +00:00
// This may have been saved with or without padding, depending on platform.
// We need to upconvert it to our consistently-padded struct.
static const size_t DisplayList_v3_size = 452;
static const size_t DisplayList_v4_size = 456;
static_assert(DisplayList_v4_size == sizeof(DisplayList), "Make sure to change here when updating DisplayList");
p.DoVoid(&dls[0], DisplayList_v3_size);
dls[0].padding = 0;
const u8 *savedPtr = *p.GetPPtr();
const u32 *savedPtr32 = (const u32 *)savedPtr;
// Here's the trick: the first member (id) is always the same as the index.
// The second member (startpc) is always an address, or 0, never 1. So we can see the padding.
const bool hasPadding = savedPtr32[1] == 1;
if (hasPadding) {
u32 padding;
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, padding);
Also fix padding for DisplayList on iOS. Fixes #8199.
2015-12-24 22:31:43 +00:00
}
for (size_t i = 1; i < ARRAY_SIZE(dls); ++i) {
p.DoVoid(&dls[i], DisplayList_v3_size);
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
dls[i].padding = 0;
Also fix padding for DisplayList on iOS. Fixes #8199.
2015-12-24 22:31:43 +00:00
if (hasPadding) {
u32 padding;
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, padding);
Also fix padding for DisplayList on iOS. Fixes #8199.
2015-12-24 22:31:43 +00:00
}
Fix for a struct padding error affecting Android-x86, making it produce savestates that were not compatible with the other platforms.
2015-10-11 12:38:26 +00:00
}
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
} else if (s >= 2) {
for (size_t i = 0; i < ARRAY_SIZE(dls); ++i) {
DisplayList_v2 oldDL;
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, oldDL);
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
// Copy over everything except the last, new member (stackAddr.)
memcpy(&dls[i], &oldDL, sizeof(DisplayList_v2));
dls[i].stackAddr = 0;
}
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
} else {
// Can only be in read mode here.
for (size_t i = 0; i < ARRAY_SIZE(dls); ++i) {
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
DisplayList_v1 oldDL;
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, oldDL);
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
// On 32-bit, they're the same, on 64-bit oldDL is bigger.
GPU: Fix an overflow loading old save states.
2020-05-17 06:49:45 +00:00
memcpy(&dls[i], &oldDL, sizeof(DisplayList_v1));
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
// Fix the other fields. Let's hope context wasn't important, it was a pointer.
dls[i].context = 0;
dls[i].offsetAddr = oldDL.offsetAddr;
dls[i].bboxResult = oldDL.bboxResult;
Fix save status Rename u32_le stackAddr to u32
2014-08-17 08:52:06 +00:00
dls[i].stackAddr = 0;
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
}
}
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
int currentID = 0;
Correct savestate of running GE list. Fixes #8459.
2016-01-22 06:14:47 +00:00
if (currentList != nullptr) {
currentID = (int)(currentList - &dls[0]);
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
}
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, currentID);
Fix some missing GPUCommon state.
2013-02-12 09:06:11 +00:00
if (currentID == 0) {
Correct savestate of running GE list. Fixes #8459.
2016-01-22 06:14:47 +00:00
currentList = nullptr;
Fix some missing GPUCommon state.
2013-02-12 09:06:11 +00:00
} else {
Switch to a fixed size displaylist queue.
2013-04-05 06:19:28 +00:00
currentList = &dls[currentID];
Fix some missing GPUCommon state.
2013-02-12 09:06:11 +00:00
}
SaveState: Split Do() into a separate header.
2020-08-10 04:20:42 +00:00
Do(p, interruptRunning);
Do(p, gpuState);
Do(p, isbreak);
Do(p, drawCompleteTicks);
Do(p, busyTicks);
softgpu: Correct matrix value update wrapping. The values read back when saving a context or getting matrix data are set differently than the actual values used for rendering. This implements the wrapping and bleeding between matrices within softgpu, but leaves hardware rendering to only use the rendering registers for speed.
2022-09-28 05:29:55 +00:00
if (s >= 5) {
Do(p, matrixVisible.all);
}
Ge: Report and save Edram translation value. See #16126 for some details on its usage and effects.
2022-10-02 06:18:42 +00:00
if (s >= 6) {
Do(p, edramTranslation_);
}
Save more of the GPU's state, fix a crash. Well, ReapplyGfxState() seems kinda dangerous now...
2012-12-29 19:41:33 +00:00
}
Interrupt handler reorganization for easier GE interrupt support
2013-02-03 23:41:16 +00:00
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
void GPUCommon::InterruptStart(int listid) {
Interrupt handler reorganization for easier GE interrupt support
2013-02-03 23:41:16 +00:00
interruptRunning = true;
}
Don't queue Flush() etc. while on GPU thread. Oops, that makes it not actually flush properly of course. Also made a simpler guard wrapper to avoid extra braces in too many places. Reduced contention areas slightly.
2013-08-09 07:32:40 +00:00
void GPUCommon::InterruptEnd(int listid) {
Interrupt handler reorganization for easier GE interrupt support
2013-02-03 23:41:16 +00:00
interruptRunning = false;
Implement sceGeBreak()/sceGeContinue().
2013-04-04 07:35:38 +00:00
isbreak = false;
Don't listsync until after the signal handler.
2013-04-06 15:19:54 +00:00
DisplayList &dl = dls[listid];
Don't trash a list the GE interrupt handler needs. Even after it's marked COMPLETED, the CPU needs it to start and finish the interrupt. Fixes #2956, where an existing completed list was not having its interrupt run correctly.
2013-09-01 17:16:29 +00:00
dl.pendingInterrupt = false;
Don't listsync until after the signal handler.
2013-04-06 15:19:54 +00:00
// TODO: Unless the signal handler could change it?
Make sure lists aren't reused before they complete.
2013-04-07 23:47:29 +00:00
if (dl.state == PSP_GE_DL_STATE_COMPLETED || dl.state == PSP_GE_DL_STATE_NONE) {
Correct savestates when dls had context saving. It was wrong, and also they were different between 64/32 bit.
2013-10-07 05:07:57 +00:00
if (dl.started && dl.context.IsValid()) {
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
gstate.Restore(dl.context);
Actually apply the restored gstate.
2013-09-24 06:17:36 +00:00
ReapplyGfxState();
Support save/restore of context on list run/finish.
2013-09-20 16:42:09 +00:00
}
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
dl.waitTicks = 0;
Include sceKernelThread.h in less headers.
2014-03-30 00:02:41 +00:00
__GeTriggerWait(GPU_SYNC_LIST, listid);
GPU: Forget pause signal on new list. Otherwise, when the list gets executed again, we just pause it when it finishes instead of letting it finish properly.
2019-07-07 20:10:28 +00:00
// Make sure the list isn't still queued since it's now completed.
if (!dlQueue.empty()) {
if (listid == dlQueue.front())
PopDLQueue();
else
dlQueue.remove(listid);
}
Don't listsync until after the signal handler.
2013-04-06 15:19:54 +00:00
}
Interrupt handler reorganization for easier GE interrupt support
2013-02-03 23:41:16 +00:00
ProcessDLQueue();
}
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
// TODO: Maybe cleaner to keep this in GE and trigger the clear directly?
Reduce some includes under GPU/.
2014-03-29 23:51:38 +00:00
void GPUCommon::SyncEnd(GPUSyncType waitType, int listid, bool wokeThreads) {
if (waitType == GPU_SYNC_DRAW && wokeThreads)
Delay GPU signals and waits to simulate cycles.
2013-04-07 19:45:42 +00:00
{
for (int i = 0; i < DisplayListMaxCount; ++i) {
if (dls[i].state == PSP_GE_DL_STATE_COMPLETED) {
dls[i].state = PSP_GE_DL_STATE_NONE;
}
}
}
}
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
bool GPUCommon::GetCurrentDisplayList(DisplayList &list) {
if (!currentList) {
return false;
}
list = *currentList;
return true;
}
std::vector<DisplayList> GPUCommon::ActiveDisplayLists() {
std::vector<DisplayList> result;
for (auto it = dlQueue.begin(), end = dlQueue.end(); it != end; ++it) {
result.push_back(dls[*it]);
}
return result;
}
void GPUCommon::ResetListPC(int listID, u32 pc) {
if (listID < 0 || listID >= DisplayListMaxCount) {
Remove category from _assert_msg_ functions. We don't filter these by category anyway. Fixes the inconsistency where we _assert_ didn't take a category but _assert_msg_ did.
2020-07-19 15:47:02 +00:00
_dbg_assert_msg_(false, "listID out of range: %d", listID);
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
return;
}
Reporting: Disable when debugger methods used. This won't catch all means of hacking memory, but will catch some. Trying to reduce noise in reporting from debugging.
2022-07-31 01:21:32 +00:00
Reporting::NotifyDebugger();
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
dls[listID].pc = pc;
GE Debugger: Flush downcount when changing lists. In case you step ahead or similar.
2022-02-06 00:57:36 +00:00
downcount = 0;
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
}
void GPUCommon::ResetListStall(int listID, u32 stall) {
if (listID < 0 || listID >= DisplayListMaxCount) {
Remove category from _assert_msg_ functions. We don't filter these by category anyway. Fixes the inconsistency where we _assert_ didn't take a category but _assert_msg_ did.
2020-07-19 15:47:02 +00:00
_dbg_assert_msg_(false, "listID out of range: %d", listID);
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
return;
}
Reporting: Disable when debugger methods used. This won't catch all means of hacking memory, but will catch some. Trying to reduce noise in reporting from debugging.
2022-07-31 01:21:32 +00:00
Reporting::NotifyDebugger();
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
dls[listID].stall = stall;
GE Debugger: Flush downcount when changing lists. In case you step ahead or similar.
2022-02-06 00:57:36 +00:00
downcount = 0;
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
}
void GPUCommon::ResetListState(int listID, DisplayListState state) {
if (listID < 0 || listID >= DisplayListMaxCount) {
Remove category from _assert_msg_ functions. We don't filter these by category anyway. Fixes the inconsistency where we _assert_ didn't take a category but _assert_msg_ did.
2020-07-19 15:47:02 +00:00
_dbg_assert_msg_(false, "listID out of range: %d", listID);
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
return;
}
Reporting: Disable when debugger methods used. This won't catch all means of hacking memory, but will catch some. Trying to reduce noise in reporting from debugging.
2022-07-31 01:21:32 +00:00
Reporting::NotifyDebugger();
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
dls[listID].state = state;
GE Debugger: Flush downcount when changing lists. In case you step ahead or similar.
2022-02-06 00:57:36 +00:00
downcount = 0;
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
}
GPUDebugOp GPUCommon::DissassembleOp(u32 pc, u32 op) {
char buffer[1024];
GE Debugger: Fix bad read on step at start of VRAM.
2022-08-24 02:50:01 +00:00
u32 prev = Memory::IsValidAddress(pc - 4) ? Memory::ReadUnchecked_U32(pc - 4) : 0;
GeDisassembleOp(pc, op, prev, buffer, sizeof(buffer));
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
GPUDebugOp info;
info.pc = pc;
info.cmd = op >> 24;
info.op = op;
info.desc = buffer;
return info;
}
std::vector<GPUDebugOp> GPUCommon::DissassembleOpRange(u32 startpc, u32 endpc) {
char buffer[1024];
std::vector<GPUDebugOp> result;
GPUDebugOp info;
Handle it better when viewing an invalid addr.
2013-10-06 22:07:54 +00:00
// Don't trigger a pause.
u32 prev = Memory::IsValidAddress(startpc - 4) ? Memory::Read_U32(startpc - 4) : 0;
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
for (u32 pc = startpc; pc < endpc; pc += 4) {
Handle it better when viewing an invalid addr.
2013-10-06 22:07:54 +00:00
u32 op = Memory::IsValidAddress(pc) ? Memory::Read_U32(pc) : 0;
Slightly improve GPU disassembly
2014-09-13 21:50:42 +00:00
GeDisassembleOp(pc, op, prev, buffer, sizeof(buffer));
Add some initial methods to GPUDebugInterface.
2013-09-22 17:22:33 +00:00
prev = op;
info.pc = pc;
info.cmd = op >> 24;
info.op = op;
info.desc = buffer;
result.push_back(info);
}
return result;
}
u32 GPUCommon::GetRelativeAddress(u32 data) {
return gstate_c.getRelativeAddress(data);
}
u32 GPUCommon::GetVertexAddress() {
return gstate_c.vertexAddr;
}
u32 GPUCommon::GetIndexAddress() {
return gstate_c.indexAddr;
}
GPUgstate GPUCommon::GetGState() {
return gstate;
}
Make it possible to flip flags in the ge debugger.
2013-10-07 02:17:06 +00:00
void GPUCommon::SetCmdValue(u32 op) {
u32 cmd = op >> 24;
u32 diff = op ^ gstate.cmdmem[cmd];
Reporting: Disable when debugger methods used. This won't catch all means of hacking memory, but will catch some. Trying to reduce noise in reporting from debugging.
2022-07-31 01:21:32 +00:00
Reporting::NotifyDebugger();
Make it possible to flip flags in the ge debugger.
2013-10-07 02:17:06 +00:00
PreExecuteOp(op, diff);
gstate.cmdmem[cmd] = op;
ExecuteOp(op, diff);
GE Debugger: Flush downcount when changing lists. In case you step ahead or similar.
2022-02-06 00:57:36 +00:00
downcount = 0;
Make it possible to flip flags in the ge debugger.
2013-10-07 02:17:06 +00:00
}
Reduce some repetitive code.
2016-04-10 20:07:08 +00:00
GPU: Centralize SetDisplayFramebuffer().
2022-08-24 02:29:06 +00:00
void GPUCommon::SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) {
framebufferManager_->SetDisplayFramebuffer(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
void GPUCommon::DoBlockTransfer(u32 skipDrawReason) {
u32 srcBasePtr = gstate.getTransferSrcAddress();
u32 srcStride = gstate.getTransferSrcStride();
u32 dstBasePtr = gstate.getTransferDstAddress();
u32 dstStride = gstate.getTransferDstStride();
int srcX = gstate.getTransferSrcX();
int srcY = gstate.getTransferSrcY();
int dstX = gstate.getTransferDstX();
int dstY = gstate.getTransferDstY();
int width = gstate.getTransferWidth();
int height = gstate.getTransferHeight();
int bpp = gstate.getTransferBpp();
DEBUG_LOG(G3D, "Block transfer: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
// For VRAM, we wrap around when outside valid memory (mirrors still work.)
if ((srcBasePtr & 0x04800000) == 0x04800000)
srcBasePtr &= ~0x00800000;
if ((dstBasePtr & 0x04800000) == 0x04800000)
dstBasePtr &= ~0x00800000;
// Use height less one to account for width, which can be greater or less than stride.
const uint32_t src = srcBasePtr + (srcY * srcStride + srcX) * bpp;
GPU: Oops, simplify an expression.
2022-12-01 03:20:52 +00:00
const uint32_t srcSize = (height - 1) * (srcStride + width) * bpp;
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
const uint32_t dst = dstBasePtr + (dstY * dstStride + dstX) * bpp;
GPU: Oops, simplify an expression.
2022-12-01 03:20:52 +00:00
const uint32_t dstSize = (height - 1) * (dstStride + width) * bpp;
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
bool srcDstOverlap = src + srcSize > dst && dst + dstSize > src;
bool srcValid = Memory::IsValidRange(src, srcSize);
bool dstValid = Memory::IsValidRange(dst, dstSize);
bool srcWraps = Memory::IsVRAMAddress(srcBasePtr) && !srcValid;
bool dstWraps = Memory::IsVRAMAddress(dstBasePtr) && !dstValid;
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
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
char tag[128];
size_t tagSize;
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
// Tell the framebuffer manager to take action if possible. If it does the entire thing, let's just return.
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
if (!framebufferManager_ || !framebufferManager_->NotifyBlockTransferBefore(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason)) {
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
// Do the copy! (Hm, if we detect a drawn video frame (see below) then we could maybe skip this?)
// Can use GetPointerUnchecked because we checked the addresses above. We could also avoid them
// entirely by walking a couple of pointers...
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
// Simple case: just a straight copy, no overlap or wrapping.
if (srcStride == dstStride && (u32)width == srcStride && !srcDstOverlap && srcValid && dstValid) {
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 srcLineStartAddr = srcBasePtr + (srcY * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + (dstY * dstStride + dstX) * bpp;
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
u32 bytesToCopy = width * height * bpp;
const u8 *srcp = Memory::GetPointer(srcLineStartAddr);
u8 *dstp = Memory::GetPointerWrite(dstLineStartAddr);
memcpy(dstp, srcp, bytesToCopy);
if (MemBlockInfoDetailed(bytesToCopy)) {
Couple more FormatMemWriteTagAt
2022-12-01 15:00:31 +00:00
tagSize = FormatMemWriteTagAt(tag, sizeof(tag), "GPUBlockTransfer/", src, bytesToCopy);
NotifyMemInfo(MemBlockFlags::READ, src, bytesToCopy, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, dst, bytesToCopy, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
} else if ((srcDstOverlap || srcWraps || dstWraps) && (srcValid || srcWraps) && (dstValid || dstWraps)) {
// This path means we have either src/dst overlap, OR one or both of src and dst wrap.
// This should be uncommon so it's the slowest path.
u32 bytesToCopy = width * bpp;
bool notifyDetail = MemBlockInfoDetailed(srcWraps || dstWraps ? 64 : bytesToCopy);
bool notifyAll = !notifyDetail && MemBlockInfoDetailed(srcSize, dstSize);
if (notifyDetail || notifyAll) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
tagSize = FormatMemWriteTagAt(tag, sizeof(tag), "GPUBlockTransfer/", src, srcSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
auto notifyingMemmove = [&](u32 d, u32 s, u32 sz) {
const u8 *srcp = Memory::GetPointer(s);
u8 *dstp = Memory::GetPointerWrite(d);
memmove(dstp, srcp, sz);
if (notifyDetail) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, s, sz, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, d, sz, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
};
for (int y = 0; y < height; y++) {
u32 srcLineStartAddr = srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp;
// If we already passed a wrap, we can use the quicker path.
if ((srcLineStartAddr & 0x04800000) == 0x04800000)
srcLineStartAddr &= ~0x00800000;
if ((dstLineStartAddr & 0x04800000) == 0x04800000)
dstLineStartAddr &= ~0x00800000;
// These flags mean there's a wrap inside this line.
bool srcLineWrap = !Memory::IsValidRange(srcLineStartAddr, bytesToCopy);
bool dstLineWrap = !Memory::IsValidRange(dstLineStartAddr, bytesToCopy);
if (!srcLineWrap && !dstLineWrap) {
const u8 *srcp = Memory::GetPointer(srcLineStartAddr);
u8 *dstp = Memory::GetPointerWrite(dstLineStartAddr);
for (u32 i = 0; i < bytesToCopy; i += 64) {
u32 chunk = i + 64 > bytesToCopy ? bytesToCopy - i : 64;
memmove(dstp + i, srcp + i, chunk);
}
// If we're tracking detail, it's useful to have the gaps illustrated properly.
if (notifyDetail) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, srcLineStartAddr, bytesToCopy, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, dstLineStartAddr, bytesToCopy, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
} else {
// We can wrap at any point, so along with overlap this gets a bit complicated.
// We're just going to do this the slow and easy way.
u32 srcLinePos = srcLineStartAddr;
u32 dstLinePos = dstLineStartAddr;
for (u32 i = 0; i < bytesToCopy; i += 64) {
u32 chunk = i + 64 > bytesToCopy ? bytesToCopy - i : 64;
u32 srcValid = Memory::ValidSize(srcLinePos, chunk);
u32 dstValid = Memory::ValidSize(dstLinePos, chunk);
// First chunk, for which both are valid.
u32 bothSize = std::min(srcValid, dstValid);
if (bothSize != 0)
notifyingMemmove(dstLinePos, srcLinePos, bothSize);
// Now, whichever side has more valid (or the rest, if only one side must wrap.)
u32 exclusiveSize = std::max(srcValid, dstValid) - bothSize;
if (exclusiveSize != 0 && srcValid >= dstValid) {
notifyingMemmove(PSP_GetVidMemBase(), srcLineStartAddr + bothSize, exclusiveSize);
} else if (exclusiveSize != 0 && srcValid < dstValid) {
notifyingMemmove(dstLineStartAddr + bothSize, PSP_GetVidMemBase(), exclusiveSize);
}
// Finally, if both src and dst wrapped, that portion.
u32 wrappedSize = chunk - bothSize - exclusiveSize;
if (wrappedSize != 0 && srcValid >= dstValid) {
notifyingMemmove(PSP_GetVidMemBase() + exclusiveSize, PSP_GetVidMemBase(), wrappedSize);
} else if (wrappedSize != 0 && srcValid < dstValid) {
notifyingMemmove(PSP_GetVidMemBase(), PSP_GetVidMemBase() + exclusiveSize, wrappedSize);
}
srcLinePos += chunk;
dstLinePos += chunk;
if ((srcLinePos & 0x04800000) == 0x04800000)
srcLinePos &= ~0x00800000;
if ((dstLinePos & 0x04800000) == 0x04800000)
dstLinePos &= ~0x00800000;
}
}
}
if (notifyAll) {
if (srcWraps) {
u32 validSize = Memory::ValidSize(src, srcSize);
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, src, validSize, tag, tagSize);
NotifyMemInfo(MemBlockFlags::READ, PSP_GetVidMemBase(), srcSize - validSize, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
} else {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, src, srcSize, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
if (dstWraps) {
u32 validSize = Memory::ValidSize(dst, dstSize);
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::WRITE, dst, validSize, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, PSP_GetVidMemBase(), dstSize - validSize, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
} else {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::WRITE, dst, dstSize, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
}
} else if (srcValid && dstValid) {
u32 bytesToCopy = width * bpp;
bool notifyDetail = MemBlockInfoDetailed(bytesToCopy);
bool notifyAll = !notifyDetail && MemBlockInfoDetailed(srcSize, dstSize);
if (notifyDetail || notifyAll) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
tagSize = FormatMemWriteTagAt(tag, sizeof(tag), "GPUBlockTransfer/", src, srcSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12: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
for (int y = 0; y < height; y++) {
u32 srcLineStartAddr = srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp;
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
const u8 *srcp = Memory::GetPointer(srcLineStartAddr);
u8 *dstp = Memory::GetPointerWrite(dstLineStartAddr);
memcpy(dstp, srcp, bytesToCopy);
// If we're tracking detail, it's useful to have the gaps illustrated properly.
if (notifyDetail) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, srcLineStartAddr, bytesToCopy, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, dstLineStartAddr, bytesToCopy, tag, tagSize);
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
}
}
if (notifyAll) {
Restore optimization of memory info strings, avoiding allocations
2022-12-01 14:39:22 +00:00
NotifyMemInfo(MemBlockFlags::READ, src, srcSize, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, dst, dstSize, tag, tagSize);
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
}
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
} else {
// This seems to cause the GE to require a break/reset on a PSP.
// TODO: Handle that and figure out which bytes are still copied?
ERROR_LOG_REPORT_ONCE(invalidtransfer, G3D, "Block transfer invalid: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY);
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
}
GPU: Use common block transfer logic in all cases.
2022-12-01 03:12:06 +00:00
if (framebufferManager_) {
// Fixes Gran Turismo's funky text issue, since it overwrites the current texture.
textureCache_->Invalidate(dstBasePtr + (dstY * dstStride + dstX) * bpp, height * dstStride * bpp, GPU_INVALIDATE_HINT);
framebufferManager_->NotifyBlockTransferAfter(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason);
}
Debugger: Avoid write tag lookup on small alloc.
2022-02-06 17:28:48 +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
// TODO: Correct timing appears to be 1.9, but erring a bit low since some of our other timing is inaccurate.
cyclesExecuted += ((height * width * bpp) * 16) / 10;
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
}
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
bool GPUCommon::PerformMemoryCopy(u32 dest, u32 src, int size, GPUCopyFlag flags) {
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
// Track stray copies of a framebuffer in RAM. MotoGP does this.
if (framebufferManager_->MayIntersectFramebuffer(src) || framebufferManager_->MayIntersectFramebuffer(dest)) {
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
if (!framebufferManager_->NotifyFramebufferCopy(src, dest, size, flags, gstate_c.skipDrawReason)) {
GPU: Avoid self memcpy().
2022-11-08 15:29:36 +00:00
// We use matching values in PerformReadbackToMemory/PerformWriteColorFromMemory.
Get rid of GPUCommon's "Internal" functions.
2017-11-05 19:33:28 +00:00
// Since they're identical we don't need to copy.
GPU: Avoid self memcpy().
2022-11-08 15:29:36 +00:00
if (dest != src) {
Debugger: Avoid write tag lookup on small alloc.
2022-02-06 17:28:48 +00:00
if (MemBlockInfoDetailed(size)) {
Couple more FormatMemWriteTagAt
2022-12-01 15:00:31 +00:00
char tag[128];
size_t tagSize = FormatMemWriteTagAt(tag, sizeof(tag), "GPUMemcpy/", src, size);
Memory::Memcpy(dest, src, size, tag, tagSize);
Debugger: Avoid write tag lookup on small alloc.
2022-02-06 17:28:48 +00:00
} else {
Memory::Memcpy(dest, src, size, "GPUMemcpy");
}
Get rid of GPUCommon's "Internal" functions.
2017-11-05 19:33:28 +00:00
}
}
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
return true;
}
Debugger: Avoid write tag lookup on small alloc.
2022-02-06 17:28:48 +00:00
if (MemBlockInfoDetailed(size)) {
Couple more FormatMemWriteTagAt
2022-12-01 15:00:31 +00:00
char tag[128];
size_t tagSize = FormatMemWriteTagAt(tag, sizeof(tag), "GPUMemcpy/", src, size);
NotifyMemInfo(MemBlockFlags::READ, src, size, tag, tagSize);
NotifyMemInfo(MemBlockFlags::WRITE, dest, size, tag, tagSize);
Debugger: Avoid write tag lookup on small alloc.
2022-02-06 17:28:48 +00:00
}
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
if (!(flags & GPUCopyFlag::DEBUG_NOTIFIED))
GPURecord::NotifyMemcpy(dest, src, size);
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
return false;
}
bool GPUCommon::PerformMemorySet(u32 dest, u8 v, int size) {
// This may indicate a memset, usually to 0, of a framebuffer.
if (framebufferManager_->MayIntersectFramebuffer(dest)) {
Debugger: Notate memset tags directly.
2021-02-03 07:53:16 +00:00
Memory::Memset(dest, v, size, "GPUMemset");
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
if (!framebufferManager_->NotifyFramebufferCopy(dest, dest, size, GPUCopyFlag::MEMSET, gstate_c.skipDrawReason)) {
Get rid of GPUCommon's "Internal" functions.
2017-11-05 19:33:28 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
}
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
return true;
}
Debugger: Notate memset tags directly.
2021-02-03 07:53:16 +00:00
NotifyMemInfo(MemBlockFlags::WRITE, dest, size, "GPUMemset");
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
// Or perhaps a texture, let's invalidate.
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
GE Debugger: Record memcpy/memset too.
2017-06-03 07:09:58 +00:00
GPURecord::NotifyMemset(dest, v, size);
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
return false;
}
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
bool GPUCommon::PerformReadbackToMemory(u32 dest, int size) {
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
if (Memory::IsVRAMAddress(dest)) {
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
return PerformMemoryCopy(dest, dest, size, GPUCopyFlag::FORCE_DST_MEM);
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
}
return false;
}
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
bool GPUCommon::PerformWriteColorFromMemory(u32 dest, int size) {
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
if (Memory::IsVRAMAddress(dest)) {
GE Debugger: Record memcpy/memset too.
2017-06-03 07:09:58 +00:00
GPURecord::NotifyUpload(dest, size);
GPU: Use flags to fix triggered upload/download. No longer using mirror hacks.
2022-10-04 03:17:25 +00:00
return PerformMemoryCopy(dest, dest, size, GPUCopyFlag::FORCE_SRC_MEM | GPUCopyFlag::DEBUG_NOTIFIED);
Centralize "PerformMemory*" functions
2016-12-21 17:26:06 +00:00
}
return false;
}
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
void GPUCommon::InvalidateCache(u32 addr, int size, GPUInvalidationType type) {
if (size > 0)
textureCache_->Invalidate(addr, size, type);
else
textureCache_->InvalidateAll(type);
if (type != GPU_INVALIDATE_ALL && framebufferManager_->MayIntersectFramebuffer(addr)) {
// Vempire invalidates (with writeback) after drawing, but before blitting.
Better framebuffer checks, remove all ways that framebuffer formats can change.
2022-08-29 08:14:29 +00:00
// TODO: Investigate whether we can get this to work some other way.
Only gate really expensive block transfers behind the setting.
2019-02-08 13:50:47 +00:00
if (type == GPU_INVALIDATE_SAFE) {
Address feedback
2022-08-30 04:41:37 +00:00
framebufferManager_->UpdateFromMemory(addr, size);
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
}
}
}
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
void GPUCommon::PerformWriteFormattedFromMemory(u32 addr, int size, int frameWidth, GEBufferFormat format) {
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
if (Memory::IsVRAMAddress(addr)) {
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
framebufferManager_->PerformWriteFormattedFromMemory(addr, size, frameWidth, format);
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
}
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
textureCache_->NotifyWriteFormattedFromMemory(addr, size, frameWidth, format);
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
InvalidateCache(addr, size, GPU_INVALIDATE_SAFE);
}
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
bool GPUCommon::PerformWriteStencilFromMemory(u32 dest, int size, WriteStencil flags) {
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
if (framebufferManager_->MayIntersectFramebuffer(dest)) {
GPU: Rename readback and buffer write operations. Avoid download/upload and pack, which don't have clear directions.
2022-10-09 20:49:41 +00:00
framebufferManager_->PerformWriteStencilFromMemory(dest, size, flags);
Centralize PerformStencil* and Invalidate* functions
2016-12-21 17:33:08 +00:00
return true;
}
return false;
}
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
bool GPUCommon::GetCurrentFramebuffer(GPUDebugBuffer &buffer, GPUDebugFramebufferType type, int maxRes) {
GE Debugger: Fix handling for framebuf changes.
2018-11-17 16:56:32 +00:00
u32 fb_address = type == GPU_DBG_FRAMEBUF_RENDER ? (gstate.getFrameBufRawAddress() | 0x04000000) : framebufferManager_->DisplayFramebufAddr();
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
int fb_stride = type == GPU_DBG_FRAMEBUF_RENDER ? gstate.FrameBufStride() : framebufferManager_->DisplayFramebufStride();
Move framebufFormat to gstate_c, so we can override it
2022-04-24 15:30:33 +00:00
GEBufferFormat format = type == GPU_DBG_FRAMEBUF_RENDER ? gstate_c.framebufFormat : framebufferManager_->DisplayFramebufFormat();
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
return framebufferManager_->GetFramebuffer(fb_address, fb_stride, format, buffer, maxRes);
}
bool GPUCommon::GetCurrentDepthbuffer(GPUDebugBuffer &buffer) {
GE Debugger: Fix handling for framebuf changes.
2018-11-17 16:56:32 +00:00
u32 fb_address = gstate.getFrameBufRawAddress() | 0x04000000;
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
int fb_stride = gstate.FrameBufStride();
GE Debugger: Fix handling for framebuf changes.
2018-11-17 16:56:32 +00:00
u32 z_address = gstate.getDepthBufRawAddress() | 0x04000000;
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
int z_stride = gstate.DepthBufStride();
return framebufferManager_->GetDepthbuffer(fb_address, fb_stride, z_address, z_stride, buffer);
}
bool GPUCommon::GetCurrentStencilbuffer(GPUDebugBuffer &buffer) {
GE Debugger: Fix handling for framebuf changes.
2018-11-17 16:56:32 +00:00
u32 fb_address = gstate.getFrameBufRawAddress() | 0x04000000;
D3D11: Implement basic framebuffer readback. Also make debug interfaces more consistent.
2017-02-14 11:42:35 +00:00
int fb_stride = gstate.FrameBufStride();
return framebufferManager_->GetStencilbuffer(fb_address, fb_stride, buffer);
}
D3D11: Implement screenshots.
2017-02-17 23:43:02 +00:00
bool GPUCommon::GetOutputFramebuffer(GPUDebugBuffer &buffer) {
Fix crash when pressing F12 in software mode.
2017-05-24 09:09:08 +00:00
// framebufferManager_ can be null here when taking screens in software rendering mode.
// TODO: Actually grab the framebuffer anyway.
return framebufferManager_ ? framebufferManager_->GetOutputFramebuffer(buffer) : false;
D3D11: Implement screenshots.
2017-02-17 23:43:02 +00:00
}
GE Debugger D3D11: Support displaying the current texture
2017-03-06 15:46:15 +00:00
Assorted minor cleanup
2022-08-16 08:55:44 +00:00
std::vector<FramebufferInfo> GPUCommon::GetFramebufferList() const {
Unify GetFramebufferList() (trivial)
2017-10-18 10:49:15 +00:00
return framebufferManager_->GetFramebufferList();
}
Unify and move around code to cleanup some debug accessors
2017-10-18 11:03:49 +00:00
bool GPUCommon::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
GE Debugger: Correct UV display with prescale. Sometimes these weren't flushed yet, and it made the texture preview and vertices confusing and wrong (using old factors, not just no factors.)
2022-10-26 05:14:16 +00:00
UpdateUVScaleOffset();
Unify and move around code to cleanup some debug accessors
2017-10-18 11:03:49 +00:00
return drawEngineCommon_->GetCurrentSimpleVertices(count, vertices, indices);
}
bool GPUCommon::GetCurrentClut(GPUDebugBuffer &buffer) {
return textureCache_->GetCurrentClutBuffer(buffer);
}
GE Debugger: Display if tex is framebuf. Rather than guessing based on size, let's show explicitly.
2022-10-11 05:35:42 +00:00
bool GPUCommon::GetCurrentTexture(GPUDebugBuffer &buffer, int level, bool *isFramebuffer) {
Unify and move around code to cleanup some debug accessors
2017-10-18 11:03:49 +00:00
if (!gstate.isTextureMapEnabled()) {
return false;
}
GE Debugger: Display if tex is framebuf. Rather than guessing based on size, let's show explicitly.
2022-10-11 05:35:42 +00:00
return textureCache_->GetCurrentTextureDebug(buffer, level, isFramebuffer);
Unify and move around code to cleanup some debug accessors
2017-10-18 11:03:49 +00:00
}
Another minor cleanup (DescribeCodePtr)
2017-10-20 09:06:06 +00:00
bool GPUCommon::DescribeCodePtr(const u8 *ptr, std::string &name) {
if (drawEngineCommon_->IsCodePtrVertexDecoder(ptr)) {
name = "VertexDecoderJit";
return true;
}
return false;
}
Unify FramebufferDirty()/FramebufferReallyDirty() for the hw backends
2018-02-26 10:58:17 +00:00
bool GPUCommon::FramebufferDirty() {
VirtualFramebuffer *vfb = framebufferManager_->GetDisplayVFB();
if (vfb) {
bool dirty = vfb->dirtyAfterDisplay;
vfb->dirtyAfterDisplay = false;
return dirty;
}
return true;
}
bool GPUCommon::FramebufferReallyDirty() {
VirtualFramebuffer *vfb = framebufferManager_->GetDisplayVFB();
if (vfb) {
bool dirty = vfb->reallyDirtyAfterDisplay;
vfb->reallyDirtyAfterDisplay = false;
return dirty;
}
return true;
}
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
Fix some NEON code that had bad compile-time checks (and some didn't compile)
2022-04-14 22:35:22 +00:00
void GPUCommon::UpdateUVScaleOffset() {
#ifdef _M_SSE
__m128i values = _mm_slli_epi32(_mm_load_si128((const __m128i *) & gstate.texscaleu), 8);
Convert the blueToAlpha bool to a usageFlag. KEEP instead of CLEAR for depth during reinterpret.
2022-04-30 16:13:24 +00:00
_mm_storeu_si128((__m128i *)&gstate_c.uv, values);
Fix some NEON code that had bad compile-time checks (and some didn't compile)
2022-04-14 22:35:22 +00:00
#elif PPSSPP_ARCH(ARM_NEON)
const uint32x4_t values = vshlq_n_u32(vld1q_u32((const u32 *)&gstate.texscaleu), 8);
vst1q_u32((u32 *)&gstate_c.uv, values);
#else
gstate_c.uv.uScale = getFloat24(gstate.texscaleu);
gstate_c.uv.vScale = getFloat24(gstate.texscalev);
gstate_c.uv.uOff = getFloat24(gstate.texoffsetu);
gstate_c.uv.vOff = getFloat24(gstate.texoffsetv);
#endif
}
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
size_t GPUCommon::FormatGPUStatsCommon(char *buffer, size_t size) {
float vertexAverageCycles = gpuStats.numVertsSubmitted > 0 ? (float)gpuStats.vertexGPUCycles / (float)gpuStats.numVertsSubmitted : 0.0f;
return snprintf(buffer, size,
Count listsyncs and drawsyncs in gpu stats. Eat some cycles in listSync Chose a conservative number (same as sceGeContinue)
2023-02-07 21:59:46 +00:00
"DL processing time: %0.2f ms, %d drawsync, %d listsync\n"
GPU debug stats: Show how many bytes of texture data we hash per frame
2020-09-20 20:03:08 +00:00
"Draw calls: %d, flushes %d, clears %d (cached: %d)\n"
"Num Tracked Vertex Arrays: %d\n"
"Vertices: %d cached: %d uncached: %d\n"
"FBOs active: %d (evaluations: %d)\n"
"Textures: %d, dec: %d, invalidated: %d, hashed: %d kB\n"
Implement delayed depth readbacks for Vulkan only
2023-02-05 15:59:23 +00:00
"readbacks %d (%d non-block), uploads %d, depal %d\n"
Add another stat, for self-tex
2022-08-29 13:57:39 +00:00
"Copies: depth %d, color %d, reint %d, blend %d, selftex %d\n"
GPU debug stats: Show how many bytes of texture data we hash per frame
2020-09-20 20:03:08 +00:00
"GPU cycles executed: %d (%f per vertex)\n",
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
gpuStats.msProcessingDisplayLists * 1000.0f,
Count listsyncs and drawsyncs in gpu stats. Eat some cycles in listSync Chose a conservative number (same as sceGeContinue)
2023-02-07 21:59:46 +00:00
gpuStats.numDrawSyncs,
gpuStats.numListSyncs,
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
gpuStats.numDrawCalls,
gpuStats.numFlushes,
gpuStats.numClears,
gpuStats.numCachedDrawCalls,
gpuStats.numTrackedVertexArrays,
gpuStats.numVertsSubmitted,
gpuStats.numCachedVertsDrawn,
gpuStats.numUncachedVertsDrawn,
(int)framebufferManager_->NumVFBs(),
gpuStats.numFramebufferEvaluations,
(int)textureCache_->NumLoadedTextures(),
gpuStats.numTexturesDecoded,
gpuStats.numTextureInvalidations,
GPU debug stats: Show how many bytes of texture data we hash per frame
2020-09-20 20:03:08 +00:00
gpuStats.numTextureDataBytesHashed / 1024,
Implement delayed depth readbacks for Vulkan only
2023-02-05 15:59:23 +00:00
gpuStats.numBlockingReadbacks,
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
gpuStats.numReadbacks,
GPU debug stats: Show how many bytes of texture data we hash per frame
2020-09-20 20:03:08 +00:00
gpuStats.numUploads,
Fix OpenGL bug when framebuffer fetch is available. Add two new stats.
2022-08-29 13:39:29 +00:00
gpuStats.numDepal,
Add GPU stat for number of depth copies per frame Will be useful for evaluating #15700
2022-07-24 15:12:43 +00:00
gpuStats.numDepthCopies,
Copy color from overlapping framebuffers on bind, under certain conditions. Leads to much faster performance in Juiced 2. This will later be expanded to handle more things in a more elegant way, like the framebuffer overlap in God of War for the shadows and color reinterpretation in a generic way. Fixes #15728
2022-08-18 08:51:50 +00:00
gpuStats.numColorCopies,
gpuStats.numReinterpretCopies,
Fix OpenGL bug when framebuffer fetch is available. Add two new stats.
2022-08-29 13:39:29 +00:00
gpuStats.numCopiesForShaderBlend,
Add another stat, for self-tex
2022-08-29 13:57:39 +00:00
gpuStats.numCopiesForSelfTex,
GPU debug stats: Show how many bytes of texture data we hash per frame
2020-09-20 20:03:08 +00:00
gpuStats.vertexGPUCycles + gpuStats.otherGPUCycles,
vertexAverageCycles
Share GPUS stats formatting code between the backends (easier to add new stats)
2020-09-20 19:33:06 +00:00
);
}
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
u32 GPUCommon::CheckGPUFeatures() const {
u32 features = 0;
if (draw_->GetDeviceCaps().logicOpSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_LOGIC_OP;
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
}
if (draw_->GetDeviceCaps().anisoSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_ANISOTROPY;
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
}
if (draw_->GetDeviceCaps().textureNPOTFullySupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_TEXTURE_NPOT;
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
}
if (draw_->GetDeviceCaps().dualSourceBlend) {
if (!g_Config.bVendorBugChecksEnabled || !draw_->GetBugs().Has(Draw::Bugs::DUAL_SOURCE_BLENDING_BROKEN)) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_DUALSOURCE_BLEND;
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
}
}
if (draw_->GetDeviceCaps().blendMinMaxSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_BLEND_MINMAX;
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
}
Unify range culling detection
2022-09-20 08:15:04 +00:00
if (draw_->GetDeviceCaps().clipDistanceSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_CLIP_DISTANCE;
Unify range culling detection
2022-09-20 08:15:04 +00:00
}
if (draw_->GetDeviceCaps().cullDistanceSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_CULL_DISTANCE;
Unify range culling detection
2022-09-20 08:15:04 +00:00
}
Unify depth texture and framebuffer fetch checks
2022-09-20 08:47:49 +00:00
if (draw_->GetDeviceCaps().textureDepthSupported) {
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_DEPTH_TEXTURE;
Unify depth texture and framebuffer fetch checks
2022-09-20 08:47:49 +00:00
}
GPU: Centralize more GPU_USE flags, like depth.
2022-11-13 16:04:47 +00:00
if (draw_->GetDeviceCaps().depthClampSupported) {
// Some backends always do GPU_USE_ACCURATE_DEPTH, but it's required for depth clamp.
features |= GPU_USE_DEPTH_CLAMP | GPU_USE_ACCURATE_DEPTH;
}
GPU: Clip against neg Z even w/o cull support. This should fix rendering issues on Apple devices.
2022-10-06 07:34:02 +00:00
bool canClipOrCull = draw_->GetDeviceCaps().clipDistanceSupported || draw_->GetDeviceCaps().cullDistanceSupported;
Fix vertex shader range culling - the bug check was wrong.
2022-12-22 22:08:48 +00:00
bool canDiscardVertex = !draw_->GetBugs().Has(Draw::Bugs::BROKEN_NAN_IN_CONDITIONAL);
Revert "OpenXR - Disable range culling properly" This reverts commit d1dabd40eea94240fa7d9ba05ca50b8ef6b78757.
2022-11-10 17:44:11 +00:00
if (canClipOrCull || canDiscardVertex) {
GPU: Clip against neg Z even w/o cull support. This should fix rendering issues on Apple devices.
2022-10-06 07:34:02 +00:00
// We'll dynamically use the parts that are supported, to reduce artifacts as much as possible.
Rename GPU_SUPPORTS_ to GPU_USE_
2022-10-17 06:30:27 +00:00
features |= GPU_USE_VS_RANGE_CULLING;
Unify range culling detection
2022-09-20 08:15:04 +00:00
}
Unify depth texture and framebuffer fetch checks
2022-09-20 08:47:49 +00:00
if (draw_->GetDeviceCaps().framebufferFetchSupported) {
Two more renames to make things read better
2022-10-17 06:34:03 +00:00
features |= GPU_USE_FRAMEBUFFER_FETCH;
Unify depth texture and framebuffer fetch checks
2022-09-20 08:47:49 +00:00
}
Don't use fragmentShaderInt32Support as a replacement for checking for bitwiseOps
2022-10-10 15:51:32 +00:00
if (draw_->GetShaderLanguageDesc().bitwiseOps) {
Experiment: Generate "Ubershaders" that can handle all lighting configurations This drastically reduces the shader compile stutter that happens when a lot of new light setups are created, like on the first punch in Tekken 6. There's more stuff that might benefit from being made dynamic like this. These branches are very cheap on modern GPUs since they're branching on a uniform variable, so no divergence. Only tested on Vulkan. I think we'll need to keep the old path too for gpus like Mali-450...
2022-09-25 11:59:52 +00:00
features |= GPU_USE_LIGHT_UBERSHADER;
}
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
if (PSP_CoreParameter().compat.flags().ClearToRAM) {
features |= GPU_USE_CLEAR_RAM_HACK;
}
GPU: Use accurate depth for depth range hack. This should be easier to ensure stays well tested.
2022-12-05 03:27:23 +00:00
// Even without depth clamp, force accurate depth on for some games that break without it.
if (PSP_CoreParameter().compat.flags().DepthRangeHack) {
features |= GPU_USE_ACCURATE_DEPTH;
}
Start unifying setting of the GPU feature flags, now that thin3d has feature detection.
2022-09-20 08:02:15 +00:00
return features;
}
GPU: Centralize more GPU_USE flags, like depth.
2022-11-13 16:04:47 +00:00
u32 GPUCommon::CheckGPUFeaturesLate(u32 features) const {
// If we already have a 16-bit depth buffer, we don't need to round.
bool prefer24 = draw_->GetDeviceCaps().preferredDepthBufferFormat == Draw::DataFormat::D24_S8;
bool prefer16 = draw_->GetDeviceCaps().preferredDepthBufferFormat == Draw::DataFormat::D16;
if (!prefer16) {
GPU: Automatically reduce depth range on == test. Fixes graphic issues in Blade Dancer, possibly other games.
2022-11-13 16:13:22 +00:00
if (sawExactEqualDepth_ && (features & GPU_USE_ACCURATE_DEPTH) != 0) {
// Exact equal tests tend to have issues unless we use the PSP's depth range.
// We use 24-bit depth virtually everwhere, the fallback is just for safety.
if (prefer24)
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
else
features |= GPU_ROUND_FRAGMENT_DEPTH_TO_16BIT;
} else if (!g_Config.bHighQualityDepth && (features & GPU_USE_ACCURATE_DEPTH) != 0) {
GPU: Centralize more GPU_USE flags, like depth.
2022-11-13 16:04:47 +00:00
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
} else if (PSP_CoreParameter().compat.flags().PixelDepthRounding) {
if (prefer24 && (features & GPU_USE_ACCURATE_DEPTH) != 0) {
// 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 {
// Use fragment rounding on where available otherwise.
features |= GPU_ROUND_FRAGMENT_DEPTH_TO_16BIT;
}
} else if (PSP_CoreParameter().compat.flags().VertexDepthRounding) {
features |= GPU_ROUND_DEPTH_TO_16BIT;
}
}
return features;
}
Don't refer directly to g_Config.iMultiSampleLevel, it can contain unsupported modes.
2022-12-14 14:15:31 +00:00
void GPUCommon::UpdateMSAALevel(Draw::DrawContext *draw) {
int level = g_Config.iMultiSampleLevel;
SoftGPU fix
2022-12-14 15:43:29 +00:00
if (draw && draw->GetDeviceCaps().multiSampleLevelsMask & (1 << level)) {
Don't refer directly to g_Config.iMultiSampleLevel, it can contain unsupported modes.
2022-12-14 14:15:31 +00:00
msaaLevel_ = level;
} else {
// Didn't support the configured level, so revert to 0.
msaaLevel_ = 0;
}
}
Reference in New Issue Copy Permalink