libretro/ppsspp
1
0
Fork 0
mirror of https://github.com/libretro/ppsspp.git synced 2024-12-13 11:38:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5b70957b1f
ppsspp/GPU/Directx9/GPU_DX9.cpp

2237 lines
77 KiB
C++
Raw Normal View History

Directx9 Gpu
2013-08-17 09:23:51 +00:00
// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
Fix some includes on Windows/etc.
2013-12-29 23:55:09 +00:00
#include <set>
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
#include "Common/ChunkFile.h"
d3d9: Use thin3d for reporting info.
2016-02-13 18:53:28 +00:00
#include "Common/GraphicsContext.h"
d3d9: Enable GPU info in D3D9 reporting.
2016-02-13 17:51:09 +00:00
#include "base/NativeApp.h"
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
#include "base/logging.h"
Profile a few more scopes
2015-05-25 22:39:27 +00:00
#include "profiler/profiler.h"
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
#include "Core/Debugger/Breakpoints.h"
Make Memory::Memcpy() execute memchecks directly. This makes it easier to handle breakpoints in HLE.
2015-04-06 01:03:50 +00:00
#include "Core/MemMapHelpers.h"
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
#include "Core/MIPS/MIPS.h"
Directx9 Gpu
2013-08-17 09:23:51 +00:00
#include "Core/Host.h"
#include "Core/Config.h"
#include "Core/Reporting.h"
#include "Core/System.h"
#include "helper/dx_state.h"
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
#include "GPU/GPUState.h"
#include "GPU/ge_constants.h"
#include "GPU/GeDisasm.h"
d3d: Begin centralizing framebuffer management.
2014-09-09 15:12:42 +00:00
#include "GPU/Common/FramebufferCommon.h"
Fix dx9 so it builds on Windows (DOES NOT WORK.)
2013-09-16 06:22:10 +00:00
#include "GPU/Directx9/helper/global.h"
Compile Ced's DX9 GPU on Windows. Not hooked up yet. This needs work, has several problems that must be fixed to run on Windows. Ced, you'll have to fix up your xb project file a bit, sorry.
2013-09-15 10:46:14 +00:00
#include "GPU/Directx9/ShaderManagerDX9.h"
#include "GPU/Directx9/GPU_DX9.h"
#include "GPU/Directx9/FramebufferDX9.h"
#include "GPU/Directx9/TransformPipelineDX9.h"
#include "GPU/Directx9/TextureCacheDX9.h"
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
#include "Core/HLE/sceKernelThread.h"
#include "Core/HLE/sceKernelInterrupt.h"
#include "Core/HLE/sceGe.h"
Put the DirectX9 stuff into a namespace. This makes it almost build on Windows, but not quite. Some required files excluded from build, still.
2013-09-15 15:53:21 +00:00
namespace DX9 {
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
enum {
FLAG_FLUSHBEFORE = 1,
FLAG_FLUSHBEFOREONCHANGE = 2,
FLAG_EXECUTE = 4, // needs to actually be executed. unused for now.
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
FLAG_EXECUTEONCHANGE = 8,
FLAG_ANY_EXECUTE = 4 | 8,
FLAG_READS_PC = 16,
FLAG_WRITES_PC = 32,
Directx9 Gpu
2013-08-17 09:23:51 +00:00
};
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
struct CommandTableEntry {
u8 cmd;
u8 flags;
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
DIRECTX9_GPU::CmdFunc func;
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
};
static const CommandTableEntry commandTable[] = {
// Changes that dirty the framebuffer
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_FRAMEBUFPTR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_FramebufType},
{GE_CMD_FRAMEBUFPIXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_FramebufType},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_ZBUFPTR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE},
// Changes that dirty uniforms
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// Should these maybe flush?
{GE_CMD_MINZ, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MAXZ, FLAG_FLUSHBEFOREONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Changes that dirty texture scaling.
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{ GE_CMD_TEXMAPMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexMapMode },
{ GE_CMD_TEXSCALEU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexScaleU },
{ GE_CMD_TEXSCALEV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexScaleV },
{ GE_CMD_TEXOFFSETU, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexOffsetU },
{ GE_CMD_TEXOFFSETV, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexOffsetV },
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Changes that dirty the current texture. Really should be possible to avoid executing these if we compile
// by adding some more flags.
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_TEXSIZE0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &DIRECTX9_GPU::Execute_TexSize0},
{GE_CMD_TEXSIZE1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXSIZE7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexSizeN},
{GE_CMD_TEXFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexFormat},
{GE_CMD_TEXLEVEL, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_TexLevel},
{GE_CMD_TEXADDR0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddr0},
{GE_CMD_TEXADDR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXADDR7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexAddrN},
{GE_CMD_TEXBUFWIDTH0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufw0},
{GE_CMD_TEXBUFWIDTH1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
{GE_CMD_TEXBUFWIDTH7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexBufwN},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_CLUTADDR, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_CLUTADDRUPPER, FLAG_FLUSHBEFOREONCHANGE},
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_CLUTFORMAT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ClutFormat},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// These affect the fragment shader so need flushing.
{GE_CMD_CLEARMODE, FLAG_FLUSHBEFOREONCHANGE},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_TEXTUREMAPENABLE, FLAG_FLUSHBEFOREONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE},
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexParamType},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_SHADEMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_TEXFUNC, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTEST, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ALPHATESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_COLORTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_COLORTESTMASK, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ColorTestMask},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// These change the vertex shader so need flushing.
Cleanup some minor vertex cache stuff.
2014-09-15 14:08:55 +00:00
{GE_CMD_REVERSENORMAL, FLAG_FLUSHBEFOREONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_LIGHTINGENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTENABLE0, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTENABLE1, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTENABLE2, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTENABLE3, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTTYPE0, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTTYPE1, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTTYPE2, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LIGHTTYPE3, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MATERIALUPDATE, FLAG_FLUSHBEFOREONCHANGE},
// This changes both shaders so need flushing.
{GE_CMD_LIGHTMODE, FLAG_FLUSHBEFOREONCHANGE},
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_TEXFILTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexParamType},
{GE_CMD_TEXWRAP, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexParamType},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Uniform changes
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_ALPHATEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_AlphaTest},
{GE_CMD_COLORREF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ColorRef},
{GE_CMD_TEXENVCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_TexEnvColor},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Simple render state changes. Handled in StateMapping.cpp.
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
{GE_CMD_OFFSETX, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_OFFSETY, FLAG_FLUSHBEFOREONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_CULL, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_CULLFACEENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_DITHERENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_STENCILOP, FLAG_FLUSHBEFOREONCHANGE},
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_STENCILTEST, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_StencilTest},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_STENCILTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ALPHABLENDENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDMODE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDFIXEDA, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_BLENDFIXEDB, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MASKRGB, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_MASKALPHA, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZTEST, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZTESTENABLE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_ZWRITEDISABLE, FLAG_FLUSHBEFOREONCHANGE},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
// These can't be emulated in D3D (except a few special cases)
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_LOGICOP, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_LOGICOPENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Can probably ignore this one as we don't support AA lines.
{GE_CMD_ANTIALIASENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Morph weights. TODO: Remove precomputation?
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_MORPHWEIGHT0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT4, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT5, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT6, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MORPHWEIGHT7, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Control spline/bezier patches. Don't really require flushing as such, but meh.
{GE_CMD_PATCHDIVISION, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHPRIMITIVE, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHFACING, FLAG_FLUSHBEFOREONCHANGE},
{GE_CMD_PATCHCULLENABLE, FLAG_FLUSHBEFOREONCHANGE},
// Viewport.
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
{GE_CMD_VIEWPORTXSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTYSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTZSCALE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTXCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTYCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
{GE_CMD_VIEWPORTZCENTER, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_ViewportType},
Simulate depth clamping. We'll allow extra space in both directions. It's not exactly right, but it's a fast approximation.
2016-01-19 04:53:38 +00:00
{GE_CMD_CLIPENABLE, FLAG_FLUSHBEFOREONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// Region
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_REGION1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Region},
{GE_CMD_REGION2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Region},
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// Scissor
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_SCISSOR1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Scissor},
{GE_CMD_SCISSOR2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Scissor},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// These dirty various vertex shader uniforms. Could embed information about that in this table and call dirtyuniform directly, hm...
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_AMBIENTCOLOR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_AMBIENTALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALDIFFUSE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALEMISSIVE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALAMBIENT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALALPHA, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALSPECULAR, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
{GE_CMD_MATERIALSPECULARCOEF, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// These precompute a value. not sure if worth it. Also dirty uniforms, which could be table-ized to avoid execute.
dx9: More execute functions
2014-09-13 18:55:29 +00:00
{GE_CMD_LX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LDX0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LDY0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LDZ0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LDX1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LDY1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LDZ1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LDX2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LDY2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LDZ2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LDX3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LDY3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LDZ3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LKA0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LKB0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LKC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LKA1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LKB1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LKC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LKA2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LKB2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LKC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LKA3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LKB3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LKC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LKS0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LKS1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LKS2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LKS3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LKO0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LKO1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LKO2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LKO3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LAC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LDC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LSC0, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light0Param},
{GE_CMD_LAC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LDC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LSC1, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light1Param},
{GE_CMD_LAC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LDC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LSC2, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light2Param},
{GE_CMD_LAC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LDC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
{GE_CMD_LSC3, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_Light3Param},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Ignored commands
{GE_CMD_TEXFLUSH, 0},
{GE_CMD_TEXLODSLOPE, 0},
{GE_CMD_TEXSYNC, 0},
// These are just nop or part of other later commands.
{GE_CMD_NOP, 0},
{GE_CMD_BASE, 0},
{GE_CMD_TRANSFERSRC, 0},
{GE_CMD_TRANSFERSRCW, 0},
{GE_CMD_TRANSFERDST, 0},
{GE_CMD_TRANSFERDSTW, 0},
{GE_CMD_TRANSFERSRCPOS, 0},
{GE_CMD_TRANSFERDSTPOS, 0},
{GE_CMD_TRANSFERSIZE, 0},
// From Common. No flushing but definitely need execute.
{GE_CMD_OFFSETADDR, FLAG_EXECUTE},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_ORIGIN, FLAG_EXECUTE | FLAG_READS_PC}, // Really?
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
{GE_CMD_PRIM, FLAG_EXECUTE},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_JUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC},
{GE_CMD_CALL, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC},
{GE_CMD_RET, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC},
{GE_CMD_END, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC}, // Flush?
{GE_CMD_VADDR, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_Vaddr},
{GE_CMD_IADDR, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_Iaddr},
{GE_CMD_BJUMP, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC}, // EXECUTE
d3d: Share the bounding box code.
2014-09-14 21:04:09 +00:00
{GE_CMD_BOUNDINGBOX, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_BoundingBox}, // + FLUSHBEFORE when we implement... or not, do we need to?
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// Changing the vertex type requires us to flush.
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_VERTEXTYPE, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTEONCHANGE, &DIRECTX9_GPU::Execute_VertexType},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
{GE_CMD_BEZIER, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &DIRECTX9_GPU::Execute_Bezier},
{GE_CMD_SPLINE, FLAG_FLUSHBEFORE | FLAG_EXECUTE, &DIRECTX9_GPU::Execute_Spline},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// These two are actually processed in CMD_END.
{GE_CMD_SIGNAL, FLAG_FLUSHBEFORE},
{GE_CMD_FINISH, FLAG_FLUSHBEFORE},
// Changes that trigger data copies. Only flushing on change for LOADCLUT must be a bit of a hack...
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
{GE_CMD_LOADCLUT, FLAG_FLUSHBEFOREONCHANGE | FLAG_EXECUTE, &DIRECTX9_GPU::Execute_LoadClut},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_TRANSFERSTART, FLAG_FLUSHBEFORE | FLAG_EXECUTE | FLAG_READS_PC},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// We don't use the dither table.
{GE_CMD_DITH0},
{GE_CMD_DITH1},
{GE_CMD_DITH2},
{GE_CMD_DITH3},
Directx9 Gpu
2013-08-17 09:23:51 +00:00
// These handle their own flushing.
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
{GE_CMD_WORLDMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &DIRECTX9_GPU::Execute_WorldMtxNum},
{GE_CMD_WORLDMATRIXDATA, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_WorldMtxData},
{GE_CMD_VIEWMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &DIRECTX9_GPU::Execute_ViewMtxNum},
{GE_CMD_VIEWMATRIXDATA, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_ViewMtxData},
{GE_CMD_PROJMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &DIRECTX9_GPU::Execute_ProjMtxNum},
{GE_CMD_PROJMATRIXDATA, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_ProjMtxData},
{GE_CMD_TGENMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &DIRECTX9_GPU::Execute_TgenMtxNum},
{GE_CMD_TGENMATRIXDATA, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_TgenMtxData},
{GE_CMD_BONEMATRIXNUMBER, FLAG_EXECUTE | FLAG_READS_PC | FLAG_WRITES_PC, &DIRECTX9_GPU::Execute_BoneMtxNum},
{GE_CMD_BONEMATRIXDATA, FLAG_EXECUTE, &DIRECTX9_GPU::Execute_BoneMtxData},
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// Vertex Screen/Texture/Color
{ GE_CMD_VSCX, FLAG_EXECUTE },
{ GE_CMD_VSCY, FLAG_EXECUTE },
{ GE_CMD_VSCZ, FLAG_EXECUTE },
{ GE_CMD_VTCS, FLAG_EXECUTE },
{ GE_CMD_VTCT, FLAG_EXECUTE },
{ GE_CMD_VTCQ, FLAG_EXECUTE },
{ GE_CMD_VCV, FLAG_EXECUTE },
{ GE_CMD_VAP, FLAG_EXECUTE },
{ GE_CMD_VFC, FLAG_EXECUTE },
{ GE_CMD_VSCV, FLAG_EXECUTE },
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
// "Missing" commands (gaps in the sequence)
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
{GE_CMD_UNKNOWN_03, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_0D, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_11, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_29, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_34, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_35, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_39, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_4E, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_4F, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_52, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_59, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_5A, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_B6, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_B7, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_D1, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_ED, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_EF, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_FA, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_FB, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_FC, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_FD, FLAG_EXECUTE},
{GE_CMD_UNKNOWN_FE, FLAG_EXECUTE},
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
// Appears to be debugging related or something? Hit a lot in GoW.
{ GE_CMD_UNKNOWN_FF, 0 },
Directx9 Gpu
2013-08-17 09:23:51 +00:00
};
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
DIRECTX9_GPU::CommandInfo DIRECTX9_GPU::cmdInfo_[256];
d3d9: Use thin3d for reporting info.
2016-02-13 18:53:28 +00:00
DIRECTX9_GPU::DIRECTX9_GPU(GraphicsContext *gfxCtx)
: resized_(false), gfxCtx_(gfxCtx) {
sync gpu with gles
2013-09-10 20:35:38 +00:00
lastVsync_ = g_Config.bVSync ? 1 : 0;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
dxstate.SetVSyncInterval(g_Config.bVSync);
Compile Ced's DX9 GPU on Windows. Not hooked up yet. This needs work, has several problems that must be fixed to run on Windows. Ced, you'll have to fix up your xb project file a bit, sorry.
2013-09-15 10:46:14 +00:00
shaderManager_ = new ShaderManagerDX9();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
transformDraw_.SetShaderManager(shaderManager_);
transformDraw_.SetTextureCache(&textureCache_);
transformDraw_.SetFramebufferManager(&framebufferManager_);
d3d: Support the Danganronpa hack.
2014-09-13 23:47:23 +00:00
framebufferManager_.Init();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
framebufferManager_.SetTextureCache(&textureCache_);
framebufferManager_.SetShaderManager(shaderManager_);
d3d: Add FlushBeforeCopy().
2014-09-13 21:23:18 +00:00
framebufferManager_.SetTransformDrawEngine(&transformDraw_);
d3d: Update the texture cache to mostly match. Now we can reduce the differences down.
2014-09-09 07:53:01 +00:00
textureCache_.SetFramebufferManager(&framebufferManager_);
DX9: Hook up the depalettize code. Doesn't work yet though.
2014-09-17 21:26:20 +00:00
textureCache_.SetDepalShaderCache(&depalShaderCache_);
d3d: Update the texture cache to mostly match. Now we can reduce the differences down.
2014-09-09 07:53:01 +00:00
textureCache_.SetShaderManager(shaderManager_);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
// Sanity check gstate
if ((int *)&gstate.transferstart - (int *)&gstate != 0xEA) {
ERROR_LOG(G3D, "gstate has drifted out of sync!");
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
// Sanity check cmdInfo_ table - no dupes please
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
std::set<u8> dupeCheck;
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
memset(cmdInfo_, 0, sizeof(cmdInfo_));
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
for (size_t i = 0; i < ARRAY_SIZE(commandTable); i++) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
const u8 cmd = commandTable[i].cmd;
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
if (dupeCheck.find(cmd) != dupeCheck.end()) {
ERROR_LOG(G3D, "Command table Dupe: %02x (%i)", (int)cmd, (int)cmd);
} else {
dupeCheck.insert(cmd);
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
cmdInfo_[cmd].flags |= commandTable[i].flags;
cmdInfo_[cmd].func = commandTable[i].func;
if (!cmdInfo_[cmd].func) {
cmdInfo_[cmd].func = &DIRECTX9_GPU::Execute_Generic;
}
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
}
// Find commands missing from the table.
for (int i = 0; i < 0xEF; i++) {
if (dupeCheck.find((u8)i) == dupeCheck.end()) {
ERROR_LOG(G3D, "Command missing from table: %02x (%i)", i, i);
Show a warning message on game start if Chainfire3D is installed.
2013-09-17 08:27:42 +00:00
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// No need to flush before the tex scale/offset commands if we are baking
// the tex scale/offset into the vertices anyway.
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
UpdateCmdInfo();
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
BuildReportingInfo();
Assert state on first frame. This won't matter much for games, but makes tests run more sanely.
2014-12-30 23:26:16 +00:00
// Some of our defaults are different from hw defaults, let's assert them.
// We restore each frame anyway, but here is convenient for tests.
dxstate.Restore();
Determine scaleFactor once per frame. This way, for auto, we can properly treat it like scaleFactor = 1 when the resolution is small.
2016-01-04 07:06:15 +00:00
textureCache_.NotifyConfigChanged();
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
}
void DIRECTX9_GPU::UpdateCmdInfo() {
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
if (g_Config.bPrescaleUV) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
cmdInfo_[GE_CMD_TEXSCALEU].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXSCALEV].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETU].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETV].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
} else {
cmdInfo_[GE_CMD_TEXSCALEU].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXSCALEV].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETU].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_TEXOFFSETV].flags |= FLAG_FLUSHBEFOREONCHANGE;
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
if (g_Config.bSoftwareSkinning) {
cmdInfo_[GE_CMD_VERTEXTYPE].flags &= ~FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &DIRECTX9_GPU::Execute_VertexTypeSkinning;
} else {
cmdInfo_[GE_CMD_VERTEXTYPE].flags |= FLAG_FLUSHBEFOREONCHANGE;
cmdInfo_[GE_CMD_VERTEXTYPE].func = &DIRECTX9_GPU::Execute_VertexType;
}
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
Remove the depth range hack option, turning it into an ugly game specific compatibility hack. I hate doing this, but it's not really better off as an option. See #8171
2015-11-05 21:02:06 +00:00
CheckGPUFeatures();
}
void DIRECTX9_GPU::CheckGPUFeatures() {
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
u32 features = 0;
features |= GPU_SUPPORTS_BLEND_MINMAX;
features |= GPU_SUPPORTS_TEXTURE_LOD_CONTROL;
Reuse more code between GPUs for download.
2016-01-05 04:40:07 +00:00
features |= GPU_PREFER_CPU_DOWNLOAD;
Switch to old-style depth in OpenGL. Some devices really aren't handling the new method well. There seem to be accuracy problems when specifying the values to OpenGL.
2016-02-07 04:18:50 +00:00
features |= GPU_SUPPORTS_ACCURATE_DEPTH;
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
Add a config setting to control depth quality. For those who want 1x PSP like behavior.
2016-01-21 06:00:07 +00:00
if (!g_Config.bHighQualityDepth) {
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
d3d9: Respect per-pixel depth rounding. Using the 16-bit depth range.
2016-01-21 06:02:07 +00:00
} else if (PSP_CoreParameter().compat.flags().PixelDepthRounding) {
// Assume we always have a 24-bit depth buffer.
features |= GPU_SCALE_DEPTH_FROM_24BIT_TO_16BIT;
Add a config setting to control depth quality. For those who want 1x PSP like behavior.
2016-01-21 06:00:07 +00:00
} else if (PSP_CoreParameter().compat.flags().VertexDepthRounding) {
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
features |= GPU_ROUND_DEPTH_TO_16BIT;
Remove the depth range hack option, turning it into an ugly game specific compatibility hack. I hate doing this, but it's not really better off as an option. See #8171
2015-11-05 21:02:06 +00:00
}
Introduce "Compatibility Flags". These should be used very restrictively, see comment in Compatibility.h. Should help #8004, by disabling depth rounding in Fight Night round 3.
2015-09-26 14:01:16 +00:00
gstate_c.featureFlags = features;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
DIRECTX9_GPU::~DIRECTX9_GPU() {
framebufferManager_.DestroyAllFBOs();
shaderManager_->ClearCache(true);
delete shaderManager_;
}
// Needs to be called on GPU thread, not reporting thread.
void DIRECTX9_GPU::BuildReportingInfo() {
d3d9: Use thin3d for reporting info.
2016-02-13 18:53:28 +00:00
Thin3DContext *thin3d = gfxCtx_->CreateThin3DContext();
d3d9: Enable GPU info in D3D9 reporting.
2016-02-13 17:51:09 +00:00
d3d9: Use thin3d for reporting info.
2016-02-13 18:53:28 +00:00
reportingPrimaryInfo_ = thin3d->GetInfoString(T3DInfo::VENDORSTRING);
reportingFullInfo_ = reportingPrimaryInfo_ + " - " + System_GetProperty(SYSPROP_GPUDRIVER_VERSION) + " - " + thin3d->GetInfoString(T3DInfo::SHADELANGVERSION);
thin3d->Release();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
void DIRECTX9_GPU::DeviceLost() {
// Simply drop all caches and textures.
update gpu code
2013-08-19 18:36:43 +00:00
// FBOs appear to survive? Or no?
Directx9 Gpu
2013-08-17 09:23:51 +00:00
shaderManager_->ClearCache(false);
textureCache_.Clear(false);
framebufferManager_.DeviceLost();
}
void DIRECTX9_GPU::InitClear() {
update gpu code
2013-08-19 18:36:43 +00:00
ScheduleEvent(GPU_EVENT_INIT_CLEAR);
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
update gpu code
2013-08-19 18:36:43 +00:00
void DIRECTX9_GPU::InitClearInternal() {
sync gpu with gles
2013-09-10 20:35:38 +00:00
bool useNonBufferedRendering = g_Config.iRenderingMode == FB_NON_BUFFERED_MODE;
if (useNonBufferedRendering) {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
dxstate.depthWrite.set(true);
dxstate.colorMask.set(true, true, true, true);
Cherry-pick a tiny part of cf41d2af29633146e5b07c8851382efe72491091
2014-08-24 07:56:01 +00:00
pD3Ddevice->Clear(0, NULL, D3DCLEAR_STENCIL|D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.f, 0);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
}
void DIRECTX9_GPU::DumpNextFrame() {
dumpNextFrame_ = true;
}
void DIRECTX9_GPU::BeginFrame() {
update gpu code
2013-08-19 18:36:43 +00:00
ScheduleEvent(GPU_EVENT_BEGIN_FRAME);
}
Remove glstate usage except in the GPU implementation. Prepare for moving it into PPSSPP.
2015-09-06 10:23:14 +00:00
void DIRECTX9_GPU::ReapplyGfxStateInternal() {
Fixes to D3D viewport management. For some reason, still having strange driver-bug-ish problems in unbuffered...
2015-11-12 13:47:43 +00:00
dxstate.Restore();
Remove glstate usage except in the GPU implementation. Prepare for moving it into PPSSPP.
2015-09-06 10:23:14 +00:00
GPUCommon::ReapplyGfxStateInternal();
}
update gpu code
2013-08-19 18:36:43 +00:00
void DIRECTX9_GPU::BeginFrameInternal() {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
if (resized_) {
UpdateCmdInfo();
transformDraw_.Resized();
Determine scaleFactor once per frame. This way, for auto, we can properly treat it like scaleFactor = 1 when the resolution is small.
2016-01-04 07:06:15 +00:00
textureCache_.NotifyConfigChanged();
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
resized_ = false;
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
// Turn off vsync when unthrottled
sync gpu with gles
2013-09-10 20:35:38 +00:00
int desiredVSyncInterval = g_Config.bVSync ? 1 : 0;
if ((PSP_CoreParameter().unthrottle) || (PSP_CoreParameter().fpsLimit == 1))
Directx9 Gpu
2013-08-17 09:23:51 +00:00
desiredVSyncInterval = 0;
if (desiredVSyncInterval != lastVsync_) {
dxstate.SetVSyncInterval(desiredVSyncInterval);
lastVsync_ = desiredVSyncInterval;
}
textureCache_.StartFrame();
transformDraw_.DecimateTrackedVertexArrays();
DX9: Hook up the depalettize code. Doesn't work yet though.
2014-09-17 21:26:20 +00:00
depalShaderCache_.Decimate();
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
// fragmentTestCache_.Decimate();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
if (dumpNextFrame_) {
NOTICE_LOG(G3D, "DUMPING THIS FRAME");
dumpThisFrame_ = true;
dumpNextFrame_ = false;
} else if (dumpThisFrame_) {
dumpThisFrame_ = false;
}
shaderManager_->DirtyShader();
framebufferManager_.BeginFrame();
}
void DIRECTX9_GPU::SetDisplayFramebuffer(u32 framebuf, u32 stride, GEBufferFormat format) {
Add GPU debugging hooks to Host, not yet in use.
2013-09-22 07:18:46 +00:00
host->GPUNotifyDisplay(framebuf, stride, format);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
framebufferManager_.SetDisplayFramebuffer(framebuf, stride, format);
}
bool DIRECTX9_GPU::FramebufferDirty() {
update gpu code
2013-08-19 18:36:43 +00:00
// FIXME: Workaround for displaylists sometimes hanging unprocessed. Not yet sure of the cause.
Allow switching cpu thread on/off ingame.
2014-12-21 00:11:19 +00:00
if (ThreadEnabled()) {
update gpu code
2013-08-19 18:36:43 +00:00
// FIXME: Workaround for displaylists sometimes hanging unprocessed. Not yet sure of the cause.
ScheduleEvent(GPU_EVENT_PROCESS_QUEUE);
// Allow it to process fully before deciding if it's dirty.
SyncThread();
}
d3d: Begin centralizing framebuffer management.
2014-09-09 15:12:42 +00:00
VirtualFramebuffer *vfb = framebufferManager_.GetDisplayVFB();
update gpu code
2013-08-19 18:36:43 +00:00
if (vfb) {
bool dirty = vfb->dirtyAfterDisplay;
vfb->dirtyAfterDisplay = false;
return dirty;
}
return true;
}
bool DIRECTX9_GPU::FramebufferReallyDirty() {
// FIXME: Workaround for displaylists sometimes hanging unprocessed. Not yet sure of the cause.
Allow switching cpu thread on/off ingame.
2014-12-21 00:11:19 +00:00
if (ThreadEnabled()) {
update gpu code
2013-08-19 18:36:43 +00:00
// FIXME: Workaround for displaylists sometimes hanging unprocessed. Not yet sure of the cause.
ScheduleEvent(GPU_EVENT_PROCESS_QUEUE);
// Allow it to process fully before deciding if it's dirty.
SyncThread();
}
d3d: Begin centralizing framebuffer management.
2014-09-09 15:12:42 +00:00
VirtualFramebuffer *vfb = framebufferManager_.GetDisplayVFB();
update gpu code
2013-08-19 18:36:43 +00:00
if (vfb) {
bool dirty = vfb->reallyDirtyAfterDisplay;
vfb->reallyDirtyAfterDisplay = false;
return dirty;
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
return true;
}
void DIRECTX9_GPU::CopyDisplayToOutput() {
update gpu code
2013-08-19 18:36:43 +00:00
ScheduleEvent(GPU_EVENT_COPY_DISPLAY_TO_OUTPUT);
}
void DIRECTX9_GPU::CopyDisplayToOutputInternal() {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
dxstate.depthWrite.set(true);
dxstate.colorMask.set(true, true, true, true);
transformDraw_.Flush();
framebufferManager_.CopyDisplayToOutput();
framebufferManager_.EndFrame();
[Gpu] Sync with gles Conflicts: GPU/Directx9/FramebufferDX9.cpp GPU/Directx9/FramebufferDX9.h GPU/Directx9/TransformPipelineDX9.cpp
2013-11-15 13:24:25 +00:00
// shaderManager_->EndFrame();
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
shaderManager_->DirtyLastShader();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
sync gpu with gles
2013-09-10 20:35:38 +00:00
// Maybe should write this in ASM...
Directx9 Gpu
2013-08-17 09:23:51 +00:00
void DIRECTX9_GPU::FastRunLoop(DisplayList &list) {
Profile a few more scopes
2015-05-25 22:39:27 +00:00
PROFILE_THIS_SCOPE("gpuloop");
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
const CommandInfo *cmdInfo = cmdInfo_;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
for (; downcount > 0; --downcount) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
// We know that display list PCs have the upper nibble == 0 - no need to mask the pointer
const u32 op = *(const u32 *)(Memory::base + list.pc);
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
const u32 cmd = op >> 24;
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
const CommandInfo info = cmdInfo[cmd];
const u8 cmdFlags = info.flags; // If we stashed the cmdFlags in the top bits of the cmdmem, we could get away with one table lookup instead of two
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
const u32 diff = op ^ gstate.cmdmem[cmd];
update gpu code
2013-08-19 18:36:43 +00:00
// Inlined CheckFlushOp here to get rid of the dumpThisFrame_ check.
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
if ((cmdFlags & FLAG_FLUSHBEFORE) || (diff && (cmdFlags & FLAG_FLUSHBEFOREONCHANGE))) {
update gpu code
2013-08-19 18:36:43 +00:00
transformDraw_.Flush();
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
gstate.cmdmem[cmd] = op; // TODO: no need to write if diff==0...
if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) {
(this->*info.func)(op, diff);
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
list.pc += 4;
}
}
Read pending vertex data before exiting gpu loop. Fixes save pictures in Crimson Gem Saga.
2015-03-15 01:11:00 +00:00
void DIRECTX9_GPU::FinishDeferred() {
// This finishes reading any vertex data that is pending.
transformDraw_.FinishDeferred();
}
update gpu code
2013-08-19 18:36:43 +00:00
void DIRECTX9_GPU::ProcessEvent(GPUEvent ev) {
switch (ev.type) {
case GPU_EVENT_INIT_CLEAR:
InitClearInternal();
break;
case GPU_EVENT_BEGIN_FRAME:
BeginFrameInternal();
break;
case GPU_EVENT_COPY_DISPLAY_TO_OUTPUT:
CopyDisplayToOutputInternal();
break;
case GPU_EVENT_INVALIDATE_CACHE:
InvalidateCacheInternal(ev.invalidate_cache.addr, ev.invalidate_cache.size, ev.invalidate_cache.type);
break;
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
case GPU_EVENT_FB_MEMCPY:
PerformMemoryCopyInternal(ev.fb_memcpy.dst, ev.fb_memcpy.src, ev.fb_memcpy.size);
break;
case GPU_EVENT_FB_MEMSET:
PerformMemorySetInternal(ev.fb_memset.dst, ev.fb_memset.v, ev.fb_memset.size);
break;
case GPU_EVENT_FB_STENCIL_UPLOAD:
PerformStencilUploadInternal(ev.fb_stencil_upload.dst, ev.fb_stencil_upload.size);
break;
update gpu code
2013-08-19 18:36:43 +00:00
default:
GPUCommon::ProcessEvent(ev);
}
}
inline void DIRECTX9_GPU::CheckFlushOp(int cmd, u32 diff) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
const u8 cmdFlags = cmdInfo_[cmd].flags;
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
if ((cmdFlags & FLAG_FLUSHBEFORE) || (diff && (cmdFlags & FLAG_FLUSHBEFOREONCHANGE))) {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
if (dumpThisFrame_) {
sync gpu with gles
2013-09-10 20:35:38 +00:00
NOTICE_LOG(G3D, "================ FLUSH ================");
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
transformDraw_.Flush();
}
}
void DIRECTX9_GPU::PreExecuteOp(u32 op, u32 diff) {
update gpu code
2013-08-19 18:36:43 +00:00
CheckFlushOp(op >> 24, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
void DIRECTX9_GPU::ExecuteOp(u32 op, u32 diff) {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
const u8 cmd = op >> 24;
const CommandInfo info = cmdInfo_[cmd];
const u8 cmdFlags = info.flags;
if ((cmdFlags & FLAG_EXECUTE) || (diff && (cmdFlags & FLAG_EXECUTEONCHANGE))) {
(this->*info.func)(op, diff);
}
}
void DIRECTX9_GPU::Execute_Vaddr(u32 op, u32 diff) {
gstate_c.vertexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
void DIRECTX9_GPU::Execute_Iaddr(u32 op, u32 diff) {
gstate_c.indexAddr = gstate_c.getRelativeAddress(op & 0x00FFFFFF);
}
void DIRECTX9_GPU::Execute_VertexType(u32 op, u32 diff) {
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
}
void DIRECTX9_GPU::Execute_VertexTypeSkinning(u32 op, u32 diff) {
// Don't flush when weight count changes, unless morph is enabled.
if ((diff & ~GE_VTYPE_WEIGHTCOUNT_MASK) || (op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
// Restore and flush
gstate.vertType ^= diff;
Flush();
gstate.vertType ^= diff;
if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK))
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
d3d9: Also track bone matrices for morph here.
2015-05-17 04:54:07 +00:00
// In this case, we may be doing weights and morphs.
// Update any bone matrix uniforms so it uses them correctly.
if ((op & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
shaderManager_->DirtyUniform(gstate_c.deferredVertTypeDirty);
gstate_c.deferredVertTypeDirty = 0;
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
}
}
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
void DIRECTX9_GPU::Execute_Prim(u32 op, u32 diff) {
// This drives all drawing. All other state we just buffer up, then we apply it only
// when it's time to draw. As most PSP games set state redundantly ALL THE TIME, this is a huge optimization.
u32 data = op & 0xFFFFFF;
u32 count = data & 0xFFFF;
GEPrimitiveType prim = static_cast<GEPrimitiveType>(data >> 16);
if (count == 0)
return;
// Discard AA lines as we can't do anything that makes sense with these anyway. The SW plugin might, though.
if (gstate.isAntiAliasEnabled()) {
// Discard AA lines in DOA
if (prim == GE_PRIM_LINE_STRIP)
return;
// Discard AA lines in Summon Night 5
if ((prim == GE_PRIM_LINES) && gstate.isSkinningEnabled())
return;
}
// This also make skipping drawing very effective.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
transformDraw_.SetupVertexDecoder(gstate.vertType);
// Rough estimate, not sure what's correct.
int vertexCost = transformDraw_.EstimatePerVertexCost();
cyclesExecuted += vertexCost * count;
return;
}
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
u32 vertexAddr = gstate_c.vertexAddr;
if (!Memory::IsValidAddress(vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", vertexAddr);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
return;
}
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
void *verts = Memory::GetPointerUnchecked(vertexAddr);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
void *inds = 0;
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
u32 vertexType = gstate.vertType;
if ((vertexType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
u32 indexAddr = gstate_c.indexAddr;
if (!Memory::IsValidAddress(indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", indexAddr);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
return;
}
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
inds = Memory::GetPointerUnchecked(indexAddr);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
}
#ifndef MOBILE_DEVICE
if (prim > GE_PRIM_RECTANGLES) {
ERROR_LOG_REPORT_ONCE(reportPrim, G3D, "Unexpected prim type: %d", prim);
}
#endif
int bytesRead = 0;
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
transformDraw_.SubmitPrim(verts, inds, prim, count, vertexType, &bytesRead);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
int vertexCost = transformDraw_.EstimatePerVertexCost() * count;
gpuStats.vertexGPUCycles += vertexCost;
cyclesExecuted += vertexCost;
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +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.
if (inds) {
int indexSize = 1;
Use unordered_map where it makes sense. Very tiny speed boost? Also some microoptimizations.
2014-10-19 19:11:09 +00:00
if ((vertexType & GE_VTYPE_IDX_MASK) == GE_VTYPE_IDX_16BIT)
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
indexSize = 2;
gstate_c.indexAddr += count * indexSize;
} else {
gstate_c.vertexAddr += bytesRead;
}
}
void DIRECTX9_GPU::Execute_Bezier(u32 op, u32 diff) {
// This also make skipping drawing very effective.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// TODO: Should this eat some cycles? Probably yes. Not sure if important.
return;
}
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
void *indices = NULL;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
if (!Memory::IsValidAddress(gstate_c.indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);
return;
}
indices = Memory::GetPointerUnchecked(gstate_c.indexAddr);
}
[spline/bezier]Fix the remains of differences between dx9 and opengl.
2014-12-16 13:27:45 +00:00
if (gstate.getPatchPrimitiveType() == GE_PATCHPRIM_UNKNOWN) {
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
ERROR_LOG_REPORT(G3D, "Unsupported patch primitive %x", gstate.getPatchPrimitiveType());
return;
}
if (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) {
DEBUG_LOG_REPORT(G3D, "Bezier + morph: %i", (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT);
}
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Bezier + skinning: %i", vertTypeGetNumBoneWeights(gstate.vertType));
}
GEPatchPrimType patchPrim = gstate.getPatchPrimitiveType();
int bz_ucount = op & 0xFF;
int bz_vcount = (op >> 8) & 0xFF;
Get rid of more uses of gstate from SplineCommon
2015-07-29 10:04:52 +00:00
bool computeNormals = gstate.isLightingEnabled();
bool patchFacing = gstate.patchfacing & 1;
transformDraw_.SubmitBezier(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), bz_ucount, bz_vcount, patchPrim, computeNormals, patchFacing, gstate.vertType);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
}
void DIRECTX9_GPU::Execute_Spline(u32 op, u32 diff) {
// This also make skipping drawing very effective.
More GPU cleaning, removing uses of GPUState.h where not needed. Want to get rid of direct accesses to GPUState in modules that may be reused in my future next-gen backends, that will reformat display lists into command lists that will then be optimized and executed, out of sync with the real GPUState. Candidate modules that may be reused in full are Framebuffer and Depal, possibly TextureCache to some degree.
2015-07-26 20:38:40 +00:00
framebufferManager_.SetRenderFrameBuffer(gstate_c.framebufChanged, gstate_c.skipDrawReason);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
if (gstate_c.skipDrawReason & (SKIPDRAW_SKIPFRAME | SKIPDRAW_NON_DISPLAYED_FB)) {
// TODO: Should this eat some cycles? Probably yes. Not sure if important.
return;
}
if (!Memory::IsValidAddress(gstate_c.vertexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad vertex address %08x!", gstate_c.vertexAddr);
return;
}
void *control_points = Memory::GetPointerUnchecked(gstate_c.vertexAddr);
void *indices = NULL;
if ((gstate.vertType & GE_VTYPE_IDX_MASK) != GE_VTYPE_IDX_NONE) {
if (!Memory::IsValidAddress(gstate_c.indexAddr)) {
ERROR_LOG_REPORT(G3D, "Bad index address %08x!", gstate_c.indexAddr);
return;
}
indices = Memory::GetPointerUnchecked(gstate_c.indexAddr);
}
[spline/bezier]Fix the remains of differences between dx9 and opengl.
2014-12-16 13:27:45 +00:00
if (gstate.getPatchPrimitiveType() == GE_PATCHPRIM_UNKNOWN) {
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
ERROR_LOG_REPORT(G3D, "Unsupported patch primitive %x", gstate.getPatchPrimitiveType());
return;
}
if (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) {
DEBUG_LOG_REPORT(G3D, "Spline + morph: %i", (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) >> GE_VTYPE_MORPHCOUNT_SHIFT);
}
if (vertTypeIsSkinningEnabled(gstate.vertType)) {
DEBUG_LOG_REPORT(G3D, "Spline + skinning: %i", vertTypeGetNumBoneWeights(gstate.vertType));
}
int sp_ucount = op & 0xFF;
int sp_vcount = (op >> 8) & 0xFF;
int sp_utype = (op >> 16) & 0x3;
int sp_vtype = (op >> 18) & 0x3;
GEPatchPrimType patchPrim = gstate.getPatchPrimitiveType();
refactor: Remove some uses of gstate from SplineCommon and a fex texcache functions
2015-07-29 09:38:42 +00:00
bool computeNormals = gstate.isLightingEnabled();
Get rid of more uses of gstate from SplineCommon
2015-07-29 10:04:52 +00:00
bool patchFacing = gstate.patchfacing & 1;
u32 vertType = gstate.vertType;
transformDraw_.SubmitSpline(control_points, indices, gstate.getPatchDivisionU(), gstate.getPatchDivisionV(), sp_ucount, sp_vcount, sp_utype, sp_vtype, patchPrim, computeNormals, patchFacing, vertType);
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
}
Fix burnout depth issue by dirtying the proj matrix on viewport change
2014-09-13 12:08:07 +00:00
void DIRECTX9_GPU::Execute_ViewportType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
switch (op >> 24) {
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
case GE_CMD_VIEWPORTZSCALE:
case GE_CMD_VIEWPORTZCENTER:
Implement vertex shader depth rounding in DX9
2015-08-26 14:07:40 +00:00
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX | DIRTY_DEPTHRANGE);
Fix burnout depth issue by dirtying the proj matrix on viewport change
2014-09-13 12:08:07 +00:00
break;
}
}
d3d: Share the bounding box code.
2014-09-14 21:04:09 +00:00
void DIRECTX9_GPU::Execute_BoundingBox(u32 op, u32 diff) {
// Just resetting, nothing to bound.
const u32 data = op & 0x00FFFFFF;
if (data == 0) {
// TODO: Should this set the bboxResult? Let's set it true for now.
currentList->bboxResult = true;
return;
}
if (((data & 7) == 0) && data <= 64) { // Sanity check
void *control_points = Memory::GetPointer(gstate_c.vertexAddr);
if (gstate.vertType & GE_VTYPE_IDX_MASK) {
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Indexed bounding box data not supported.");
// Data seems invalid. Let's assume the box test passed.
currentList->bboxResult = true;
return;
}
// Test if the bounding box is within the drawing region.
Fix DX9 bbox crash (DrawEngine::decoded wasn't initialized, because it also existed in the DX9 draw engine)
2014-09-17 19:31:22 +00:00
if (control_points) {
currentList->bboxResult = transformDraw_.TestBoundingBox(control_points, data, gstate.vertType);
}
d3d: Share the bounding box code.
2014-09-14 21:04:09 +00:00
} else {
ERROR_LOG_REPORT_ONCE(boundingbox, G3D, "Bad bounding box data: %06x", data);
// Data seems invalid. Let's assume the box test passed.
currentList->bboxResult = true;
}
}
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
void DIRECTX9_GPU::Execute_Region(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_Scissor(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_FramebufType(u32 op, u32 diff) {
gstate_c.framebufChanged = true;
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_TexScaleU(u32 op, u32 diff) {
gstate_c.uv.uScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexScaleV(u32 op, u32 diff) {
gstate_c.uv.vScale = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexOffsetU(u32 op, u32 diff) {
gstate_c.uv.uOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexOffsetV(u32 op, u32 diff) {
gstate_c.uv.vOff = getFloat24(op);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexAddr0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexAddrN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_TexBufw0(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
void DIRECTX9_GPU::Execute_TexBufwN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_TexSize0(u32 op, u32 diff) {
// Render to texture may have overridden the width/height.
// Don't reset it unless the size is different / the texture has changed.
if (diff || gstate_c.textureChanged != TEXCHANGE_UNCHANGED) {
gstate_c.curTextureWidth = gstate.getTextureWidth(0);
gstate_c.curTextureHeight = gstate.getTextureHeight(0);
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
// We will need to reset the texture now.
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
}
void DIRECTX9_GPU::Execute_TexSizeN(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_TexFormat(u32 op, u32 diff) {
gstate_c.textureChanged = TEXCHANGE_UPDATED;
}
void DIRECTX9_GPU::Execute_TexMapMode(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_UVSCALEOFFSET);
}
void DIRECTX9_GPU::Execute_TexParamType(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_TexEnvColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_TEXENV);
}
void DIRECTX9_GPU::Execute_TexLevel(u32 op, u32 diff) {
// I had hoped that this would let us avoid excessively flushing in Gran Turismo, but not so,
// as the game switches rapidly between modes 0 and 1.
/*
if (gstate.getTexLevelMode() == GE_TEXLEVEL_MODE_CONST) {
gstate.texlevel ^= diff;
Flush();
gstate.texlevel ^= diff;
}
*/
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
}
void DIRECTX9_GPU::Execute_LoadClut(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
refactor: Remove some uses of gstate from SplineCommon and a fex texcache functions
2015-07-29 09:38:42 +00:00
textureCache_.LoadClut(gstate.getClutAddress(), gstate.getClutLoadBytes());
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
// This could be used to "dirty" textures with clut.
}
void DIRECTX9_GPU::Execute_ClutFormat(u32 op, u32 diff) {
gstate_c.textureChanged |= TEXCHANGE_PARAMSONLY;
// This could be used to "dirty" textures with clut.
}
dx9: More execute functions
2014-09-13 18:55:29 +00:00
void DIRECTX9_GPU::Execute_Ambient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
}
void DIRECTX9_GPU::Execute_MaterialDiffuse(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
}
void DIRECTX9_GPU::Execute_MaterialEmissive(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
}
void DIRECTX9_GPU::Execute_MaterialAmbient(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
}
void DIRECTX9_GPU::Execute_MaterialSpecular(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
}
void DIRECTX9_GPU::Execute_Light0Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
}
void DIRECTX9_GPU::Execute_Light1Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
}
void DIRECTX9_GPU::Execute_Light2Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
}
void DIRECTX9_GPU::Execute_Light3Param(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
}
void DIRECTX9_GPU::Execute_FogColor(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
}
void DIRECTX9_GPU::Execute_FogCoef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
}
void DIRECTX9_GPU::Execute_ColorTestMask(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void DIRECTX9_GPU::Execute_AlphaTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
}
void DIRECTX9_GPU::Execute_StencilTest(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_STENCILREPLACEVALUE);
}
void DIRECTX9_GPU::Execute_ColorRef(u32 op, u32 diff) {
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
void DIRECTX9_GPU::Execute_WorldMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_WORLDMATRIXDATA.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
u32 *dst = (u32 *)(gstate.worldMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_WORLDMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
void DIRECTX9_GPU::Execute_WorldMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.worldmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.worldMatrix)[num]) {
Flush();
((u32 *)gstate.worldMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_WORLDMATRIX);
}
num++;
gstate.worldmtxnum = (GE_CMD_WORLDMATRIXNUMBER << 24) | (num & 0xF);
}
void DIRECTX9_GPU::Execute_ViewMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_VIEWMATRIXDATA.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
u32 *dst = (u32 *)(gstate.viewMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_VIEWMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void DIRECTX9_GPU::Execute_ViewMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.viewmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.viewMatrix)[num]) {
Flush();
((u32 *)gstate.viewMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_VIEWMATRIX);
}
num++;
gstate.viewmtxnum = (GE_CMD_VIEWMATRIXNUMBER << 24) | (num & 0xF);
}
void DIRECTX9_GPU::Execute_ProjMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_PROJMATRIXDATA.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
u32 *dst = (u32 *)(gstate.projMatrix + (op & 0xF));
const int end = 16 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_PROJMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void DIRECTX9_GPU::Execute_ProjMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.projmtxnum & 0xF;
u32 newVal = op << 8;
if (newVal != ((const u32 *)gstate.projMatrix)[num]) {
Flush();
((u32 *)gstate.projMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_PROJMATRIX);
}
num++;
gstate.projmtxnum = (GE_CMD_PROJMATRIXNUMBER << 24) | (num & 0xF);
}
void DIRECTX9_GPU::Execute_TgenMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_TGENMATRIXDATA.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
u32 *dst = (u32 *)(gstate.tgenMatrix + (op & 0xF));
const int end = 12 - (op & 0xF);
int i = 0;
while ((src[i] >> 24) == GE_CMD_TGENMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
}
if (++i >= end) {
break;
}
}
const int count = i;
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | ((op + count) & 0xF);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void DIRECTX9_GPU::Execute_TgenMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.texmtxnum & 0xF;
u32 newVal = op << 8;
if (num < 12 && newVal != ((const u32 *)gstate.tgenMatrix)[num]) {
Flush();
((u32 *)gstate.tgenMatrix)[num] = newVal;
shaderManager_->DirtyUniform(DIRTY_TEXMATRIX);
}
num++;
gstate.texmtxnum = (GE_CMD_TGENMATRIXNUMBER << 24) | (num & 0xF);
}
void DIRECTX9_GPU::Execute_BoneMtxNum(u32 op, u32 diff) {
// This is almost always followed by GE_CMD_BONEMATRIXDATA.
GetPointerUnchecked is ok around display list pc, checked elsewhere
2014-10-19 21:13:54 +00:00
const u32_le *src = (const u32_le *)Memory::GetPointerUnchecked(currentList->pc + 4);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
u32 *dst = (u32 *)(gstate.boneMatrix + (op & 0x7F));
const int end = 12 * 8 - (op & 0x7F);
int i = 0;
// If we can't use software skinning, we have to flush and dirty.
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
const u32 newVal = src[i] << 8;
if (dst[i] != newVal) {
Flush();
dst[i] = newVal;
}
if (++i >= end) {
break;
}
}
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
}
} else {
while ((src[i] >> 24) == GE_CMD_BONEMATRIXDATA) {
dst[i] = src[i] << 8;
if (++i >= end) {
break;
}
}
d3d9: Also track bone matrices for morph here.
2015-05-17 04:54:07 +00:00
const int numPlusCount = (op & 0x7F) + i;
for (int num = op & 0x7F; num < numPlusCount; num += 12) {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
}
const int count = i;
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | ((op + count) & 0x7F);
// Skip over the loaded data, it's done now.
UpdatePC(currentList->pc, currentList->pc + count * 4);
currentList->pc += count * 4;
}
void DIRECTX9_GPU::Execute_BoneMtxData(u32 op, u32 diff) {
// Note: it's uncommon to get here now, see above.
int num = gstate.boneMatrixNumber & 0x7F;
u32 newVal = op << 8;
if (num < 96 && newVal != ((const u32 *)gstate.boneMatrix)[num]) {
// Bone matrices should NOT flush when software skinning is enabled!
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
Flush();
shaderManager_->DirtyUniform(DIRTY_BONEMATRIX0 << (num / 12));
d3d9: Also track bone matrices for morph here.
2015-05-17 04:54:07 +00:00
} else {
gstate_c.deferredVertTypeDirty |= DIRTY_BONEMATRIX0 << (num / 12);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
}
((u32 *)gstate.boneMatrix)[num] = newVal;
}
num++;
gstate.boneMatrixNumber = (GE_CMD_BONEMATRIXNUMBER << 24) | (num & 0x7F);
}
void DIRECTX9_GPU::Execute_Generic(u32 op, u32 diff) {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
u32 cmd = op >> 24;
u32 data = op & 0xFFFFFF;
// Handle control and drawing commands here directly. The others we delegate.
switch (cmd) {
case GE_CMD_BASE:
break;
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
case GE_CMD_VADDR:
Execute_Vaddr(op, diff);
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
case GE_CMD_IADDR:
Execute_Iaddr(op, diff);
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
case GE_CMD_PRIM:
Execute_Prim(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
// The arrow and other rotary items in Puzbob are bezier patches, strangely enough.
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_BEZIER:
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
Execute_Bezier(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_SPLINE:
Move spline generation to SplineCommon, make SplineDX9.cpp identical to Spline.cpp (merge later somehow)
2014-09-13 13:13:34 +00:00
Execute_Spline(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_BOUNDINGBOX:
d3d: Share the bounding box code.
2014-09-14 21:04:09 +00:00
Execute_BoundingBox(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_REGION1:
case GE_CMD_REGION2:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_Region(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_CLIPENABLE:
//we always clip, this is opengl
break;
case GE_CMD_CULLFACEENABLE:
case GE_CMD_CULL:
break;
case GE_CMD_TEXTUREMAPENABLE:
if (diff)
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_LIGHTINGENABLE:
break;
case GE_CMD_FOGCOLOR:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOLOR);
break;
case GE_CMD_FOG1:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
break;
case GE_CMD_FOG2:
if (diff)
shaderManager_->DirtyUniform(DIRTY_FOGCOEF);
break;
case GE_CMD_FOGENABLE:
break;
case GE_CMD_DITHERENABLE:
break;
case GE_CMD_OFFSETX:
break;
case GE_CMD_OFFSETY:
break;
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
case GE_CMD_TEXSCALEU: Execute_TexScaleU(op, diff); break;
case GE_CMD_TEXSCALEV: Execute_TexScaleV(op, diff); break;
case GE_CMD_TEXOFFSETU: Execute_TexOffsetU(op, diff); break;
case GE_CMD_TEXOFFSETV: Execute_TexOffsetV(op, diff); break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_SCISSOR1:
case GE_CMD_SCISSOR2:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_Scissor(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
///
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_MINZ:
case GE_CMD_MAXZ:
break;
case GE_CMD_FRAMEBUFPTR:
case GE_CMD_FRAMEBUFWIDTH:
case GE_CMD_FRAMEBUFPIXFORMAT:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_FramebufType(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_TEXADDR0:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexAddr0(op, diff);
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_TEXADDR1:
case GE_CMD_TEXADDR2:
case GE_CMD_TEXADDR3:
case GE_CMD_TEXADDR4:
case GE_CMD_TEXADDR5:
case GE_CMD_TEXADDR6:
case GE_CMD_TEXADDR7:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexAddrN(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_TEXBUFWIDTH0:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexAddr0(op, diff);
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_TEXBUFWIDTH1:
case GE_CMD_TEXBUFWIDTH2:
case GE_CMD_TEXBUFWIDTH3:
case GE_CMD_TEXBUFWIDTH4:
case GE_CMD_TEXBUFWIDTH5:
case GE_CMD_TEXBUFWIDTH6:
case GE_CMD_TEXBUFWIDTH7:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexBufwN(op, diff);
break;
case GE_CMD_CLUTFORMAT:
Execute_ClutFormat(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_CLUTADDR:
case GE_CMD_CLUTADDRUPPER:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
// Hm, LOADCLUT actually changes the CLUT so no need to dirty here.
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_LOADCLUT:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_LoadClut(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_TEXMAPMODE:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexMapMode(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_TEXSHADELS:
break;
case GE_CMD_TRANSFERSRC:
case GE_CMD_TRANSFERSRCW:
case GE_CMD_TRANSFERDST:
case GE_CMD_TRANSFERDSTW:
case GE_CMD_TRANSFERSRCPOS:
case GE_CMD_TRANSFERDSTPOS:
break;
case GE_CMD_TRANSFERSIZE:
break;
case GE_CMD_TRANSFERSTART: // Orphis calls this TRXKICK
{
// TODO: Here we should check if the transfer overlaps a framebuffer or any textures,
// and take appropriate action. This is a block transfer between RAM and VRAM, or vice versa.
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
// Can we skip this entirely on SkipDraw? It skips some things internally.
DoBlockTransfer(gstate_c.skipDrawReason);
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// Fixes Gran Turismo's funky text issue, since it overwrites the current texture.
Use flags to avoid hashing textures when unchanged. If only parameters change (like wrapping or clut, etc.) we don't need to rehash the data - we know it hasn't changed. Should reduce the distance between lazy texture hashing on and off.
2014-04-13 21:02:00 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
}
case GE_CMD_TEXSIZE0:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexSize0(op, diff);
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_TEXSIZE1:
case GE_CMD_TEXSIZE2:
case GE_CMD_TEXSIZE3:
case GE_CMD_TEXSIZE4:
case GE_CMD_TEXSIZE5:
case GE_CMD_TEXSIZE6:
case GE_CMD_TEXSIZE7:
More convergence (tex stuff)
2014-09-13 15:20:55 +00:00
Execute_TexSizeN(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_ZBUFPTR:
case GE_CMD_ZBUFWIDTH:
break;
case GE_CMD_AMBIENTCOLOR:
case GE_CMD_AMBIENTALPHA:
if (diff)
shaderManager_->DirtyUniform(DIRTY_AMBIENT);
break;
case GE_CMD_MATERIALDIFFUSE:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATDIFFUSE);
break;
case GE_CMD_MATERIALEMISSIVE:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATEMISSIVE);
break;
case GE_CMD_MATERIALAMBIENT:
case GE_CMD_MATERIALALPHA:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATAMBIENTALPHA);
break;
case GE_CMD_MATERIALSPECULAR:
case GE_CMD_MATERIALSPECULARCOEF:
if (diff)
shaderManager_->DirtyUniform(DIRTY_MATSPECULAR);
break;
case GE_CMD_LIGHTTYPE0:
case GE_CMD_LIGHTTYPE1:
case GE_CMD_LIGHTTYPE2:
case GE_CMD_LIGHTTYPE3:
break;
case GE_CMD_LX0:case GE_CMD_LY0:case GE_CMD_LZ0:
case GE_CMD_LDX0:case GE_CMD_LDY0:case GE_CMD_LDZ0:
case GE_CMD_LKA0:case GE_CMD_LKB0:case GE_CMD_LKC0:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LKS0: // spot coef ("conv")
case GE_CMD_LKO0: // light angle ("cutoff")
case GE_CMD_LAC0:
case GE_CMD_LDC0:
case GE_CMD_LSC0:
shaderManager_->DirtyUniform(DIRTY_LIGHT0);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LX1:case GE_CMD_LY1:case GE_CMD_LZ1:
case GE_CMD_LDX1:case GE_CMD_LDY1:case GE_CMD_LDZ1:
case GE_CMD_LKA1:case GE_CMD_LKB1:case GE_CMD_LKC1:
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_LKS1:
case GE_CMD_LKO1:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LAC1:
case GE_CMD_LDC1:
case GE_CMD_LSC1:
shaderManager_->DirtyUniform(DIRTY_LIGHT1);
break;
case GE_CMD_LX2:case GE_CMD_LY2:case GE_CMD_LZ2:
case GE_CMD_LDX2:case GE_CMD_LDY2:case GE_CMD_LDZ2:
case GE_CMD_LKA2:case GE_CMD_LKB2:case GE_CMD_LKC2:
case GE_CMD_LKS2:
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_LKO2:
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LAC2:
case GE_CMD_LDC2:
case GE_CMD_LSC2:
shaderManager_->DirtyUniform(DIRTY_LIGHT2);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
Remove cached light variables to reduce work when parsing DLs. Also removes some duplication between GL and the inactive D3D code.
2014-04-18 12:30:18 +00:00
case GE_CMD_LX3:case GE_CMD_LY3:case GE_CMD_LZ3:
case GE_CMD_LDX3:case GE_CMD_LDY3:case GE_CMD_LDZ3:
case GE_CMD_LKA3:case GE_CMD_LKB3:case GE_CMD_LKC3:
case GE_CMD_LKS3:
case GE_CMD_LKO3:
case GE_CMD_LAC3:
case GE_CMD_LDC3:
case GE_CMD_LSC3:
shaderManager_->DirtyUniform(DIRTY_LIGHT3);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
Improve viewport terminology a bit. No functional change.
2015-11-04 21:03:29 +00:00
case GE_CMD_VIEWPORTXSCALE:
case GE_CMD_VIEWPORTYSCALE:
case GE_CMD_VIEWPORTXCENTER:
case GE_CMD_VIEWPORTYCENTER:
case GE_CMD_VIEWPORTZSCALE:
case GE_CMD_VIEWPORTZCENTER:
dx9: More execute functions
2014-09-13 18:55:29 +00:00
Execute_ViewportType(op, diff);
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_LIGHTENABLE0:
case GE_CMD_LIGHTENABLE1:
case GE_CMD_LIGHTENABLE2:
case GE_CMD_LIGHTENABLE3:
break;
case GE_CMD_SHADEMODE:
break;
case GE_CMD_PATCHDIVISION:
case GE_CMD_PATCHPRIMITIVE:
case GE_CMD_PATCHFACING:
break;
case GE_CMD_MATERIALUPDATE:
break;
//////////////////////////////////////////////////////////////////
// CLEARING
//////////////////////////////////////////////////////////////////
case GE_CMD_CLEARMODE:
break;
//////////////////////////////////////////////////////////////////
// ALPHA BLENDING
//////////////////////////////////////////////////////////////////
case GE_CMD_ALPHABLENDENABLE:
case GE_CMD_BLENDMODE:
case GE_CMD_BLENDFIXEDA:
case GE_CMD_BLENDFIXEDB:
break;
case GE_CMD_ALPHATESTENABLE:
case GE_CMD_COLORTESTENABLE:
// They are done in the fragment shader.
break;
case GE_CMD_COLORTEST:
case GE_CMD_COLORTESTMASK:
if (diff)
Support alpha / color test masks on desktop/gles3. Won't work on GLES 2, though...
2014-06-16 07:33:48 +00:00
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORMASK);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
case GE_CMD_ALPHATEST:
Directx9 Gpu
2013-08-17 09:23:51 +00:00
if (((data >> 16) & 0xFF) != 0xFF && (data & 7) > 1)
sync gpu with gles
2013-09-10 20:35:38 +00:00
WARN_LOG_REPORT_ONCE(alphatestmask, G3D, "Unsupported alphatest mask: %02x", (data >> 16) & 0xFF);
sync with gles
2013-09-04 09:19:36 +00:00
// Intentional fallthrough.
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_COLORREF:
if (diff)
shaderManager_->DirtyUniform(DIRTY_ALPHACOLORREF);
break;
case GE_CMD_TEXENVCOLOR:
if (diff)
shaderManager_->DirtyUniform(DIRTY_TEXENV);
break;
case GE_CMD_TEXFUNC:
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
case GE_CMD_TEXFLUSH:
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_TEXFORMAT:
dx9: More execute functions
2014-09-13 18:55:29 +00:00
Execute_TexFormat(op, diff);
break;
case GE_CMD_TEXMODE:
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
case GE_CMD_TEXFILTER:
Directx9 Gpu
2013-08-17 09:23:51 +00:00
case GE_CMD_TEXWRAP:
dx9: More execute functions
2014-09-13 18:55:29 +00:00
Execute_TexParamType(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
//////////////////////////////////////////////////////////////////
// Z/STENCIL TESTING
//////////////////////////////////////////////////////////////////
case GE_CMD_STENCILTESTENABLE:
case GE_CMD_ZTESTENABLE:
case GE_CMD_ZTEST:
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
case GE_CMD_ZWRITEDISABLE:
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
case GE_CMD_MORPHWEIGHT0:
case GE_CMD_MORPHWEIGHT1:
case GE_CMD_MORPHWEIGHT2:
case GE_CMD_MORPHWEIGHT3:
case GE_CMD_MORPHWEIGHT4:
case GE_CMD_MORPHWEIGHT5:
case GE_CMD_MORPHWEIGHT6:
case GE_CMD_MORPHWEIGHT7:
gstate_c.morphWeights[cmd - GE_CMD_MORPHWEIGHT0] = getFloat24(data);
break;
case GE_CMD_DITH0:
case GE_CMD_DITH1:
case GE_CMD_DITH2:
case GE_CMD_DITH3:
break;
case GE_CMD_LOGICOPENABLE:
case GE_CMD_LOGICOP:
break;
case GE_CMD_ANTIALIASENABLE:
if (data != 0)
WARN_LOG_REPORT_ONCE(antiAlias, G3D, "Unsupported antialias enabled: %06x", data);
break;
case GE_CMD_TEXLODSLOPE:
if (data != 0)
WARN_LOG_REPORT_ONCE(texLodSlope, G3D, "Unsupported texture lod slope: %06x", data);
break;
case GE_CMD_TEXLEVEL:
dx9: More execute functions
2014-09-13 18:55:29 +00:00
Execute_TexLevel(op, diff);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
break;
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
case GE_CMD_VSCX:
if (data != 0)
WARN_LOG_REPORT_ONCE(vscx, G3D, "Unsupported Vertex Screen Coordinate X : %06x", data);
break;
case GE_CMD_VSCY:
if (data != 0)
WARN_LOG_REPORT_ONCE(vscy, G3D, "Unsupported Vertex Screen Coordinate Y : %06x", data);
break;
case GE_CMD_VSCZ:
if (data != 0)
WARN_LOG_REPORT_ONCE(vscz, G3D, "Unsupported Vertex Screen Coordinate Z : %06x", data);
break;
case GE_CMD_VTCS:
if (data != 0)
WARN_LOG_REPORT_ONCE(vtcs, G3D, "Unsupported Vertex Texture Coordinate S : %06x", data);
break;
case GE_CMD_VTCT:
if (data != 0)
WARN_LOG_REPORT_ONCE(vtct, G3D, "Unsupported Vertex Texture Coordinate T : %06x", data);
break;
case GE_CMD_VTCQ:
if (data != 0)
WARN_LOG_REPORT_ONCE(vtcq, G3D, "Unsupported Vertex Texture Coordinate Q : %06x", data);
break;
case GE_CMD_VCV:
if (data != 0)
WARN_LOG_REPORT_ONCE(vcv, G3D, "Unsupported Vertex Color Value : %06x", data);
break;
case GE_CMD_VAP:
if (data != 0)
WARN_LOG_REPORT_ONCE(vap, G3D, "Unsupported Vertex Alpha and Primitive : %06x", data);
break;
case GE_CMD_VFC:
if (data != 0)
WARN_LOG_REPORT_ONCE(vfc, G3D, "Unsupported Vertex Fog Coefficient : %06x", data);
break;
case GE_CMD_VSCV:
if (data != 0)
WARN_LOG_REPORT_ONCE(vscv, G3D, "Unsupported Vertex Secondary Color Value : %06x", data);
break;
case GE_CMD_UNKNOWN_03:
case GE_CMD_UNKNOWN_0D:
case GE_CMD_UNKNOWN_11:
case GE_CMD_UNKNOWN_29:
case GE_CMD_UNKNOWN_34:
case GE_CMD_UNKNOWN_35:
case GE_CMD_UNKNOWN_39:
case GE_CMD_UNKNOWN_4E:
case GE_CMD_UNKNOWN_4F:
case GE_CMD_UNKNOWN_52:
case GE_CMD_UNKNOWN_59:
case GE_CMD_UNKNOWN_5A:
case GE_CMD_UNKNOWN_B6:
case GE_CMD_UNKNOWN_B7:
case GE_CMD_UNKNOWN_D1:
case GE_CMD_UNKNOWN_ED:
case GE_CMD_UNKNOWN_EF:
case GE_CMD_UNKNOWN_FA:
case GE_CMD_UNKNOWN_FB:
case GE_CMD_UNKNOWN_FC:
case GE_CMD_UNKNOWN_FD:
case GE_CMD_UNKNOWN_FE:
if (data != 0)
WARN_LOG_REPORT_ONCE(unknowncmd, G3D, "Unknown GE command : %08x ", op);
break;
case GE_CMD_UNKNOWN_FF:
// This is hit in quite a few games, supposedly it is a no-op.
// Might be used for debugging or something?
break;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
default:
GPUCommon::ExecuteOp(op, diff);
break;
}
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
void DIRECTX9_GPU::FastLoadBoneMatrix(u32 target) {
d3d9: Also track bone matrices for morph here.
2015-05-17 04:54:07 +00:00
const int num = gstate.boneMatrixNumber & 0x7F;
const int mtxNum = num / 12;
uint32_t uniformsToDirty = DIRTY_BONEMATRIX0 << mtxNum;
if ((num - 12 * mtxNum) != 0) {
uniformsToDirty |= DIRTY_BONEMATRIX0 << ((mtxNum + 1) & 7);
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
if (!g_Config.bSoftwareSkinning || (gstate.vertType & GE_VTYPE_MORPHCOUNT_MASK) != 0) {
Flush();
shaderManager_->DirtyUniform(uniformsToDirty);
d3d9: Also track bone matrices for morph here.
2015-05-17 04:54:07 +00:00
} else {
gstate_c.deferredVertTypeDirty |= uniformsToDirty;
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
}
gstate.FastLoadBoneMatrix(target);
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
void DIRECTX9_GPU::UpdateStats() {
gpuStats.numVertexShaders = shaderManager_->NumVertexShaders();
gpuStats.numFragmentShaders = shaderManager_->NumFragmentShaders();
DX9: "Linked" shaders are now pointless, so remove them.
2014-09-10 12:07:30 +00:00
gpuStats.numShaders = -1;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
gpuStats.numTextures = (int)textureCache_.NumLoadedTextures();
gpuStats.numFBOs = (int)framebufferManager_.NumVFBs();
}
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
void DIRECTX9_GPU::DoBlockTransfer(u32 skipDrawReason) {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
// TODO: This is used a lot to copy data around between render targets and textures,
// and also to quickly load textures from RAM to VRAM. So we should do checks like the following:
// * Does dstBasePtr point to an existing texture? If so maybe reload it immediately.
//
// * Does srcBasePtr point to a render target, and dstBasePtr to a texture? If so
// either copy between rt and texture or reassign the texture to point to the render target
//
// etc....
sync with gles
2013-09-04 09:19:36 +00:00
u32 srcBasePtr = gstate.getTransferSrcAddress();
u32 srcStride = gstate.getTransferSrcStride();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync with gles
2013-09-04 09:19:36 +00:00
u32 dstBasePtr = gstate.getTransferDstAddress();
u32 dstStride = gstate.getTransferDstStride();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync with gles
2013-09-04 09:19:36 +00:00
int srcX = gstate.getTransferSrcX();
int srcY = gstate.getTransferSrcY();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync with gles
2013-09-04 09:19:36 +00:00
int dstX = gstate.getTransferDstX();
int dstY = gstate.getTransferDstY();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync with gles
2013-09-04 09:19:36 +00:00
int width = gstate.getTransferWidth();
int height = gstate.getTransferHeight();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync with gles
2013-09-04 09:19:36 +00:00
int bpp = gstate.getTransferBpp();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
update gpu (break disgea)
2013-08-25 11:56:29 +00:00
DEBUG_LOG(G3D, "Block transfer: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
sync gpu with gles
2013-09-10 20:35:38 +00:00
if (!Memory::IsValidAddress(srcBasePtr)) {
ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad source transfer address %08x!", srcBasePtr);
return;
}
if (!Memory::IsValidAddress(dstBasePtr)) {
ERROR_LOG_REPORT(G3D, "BlockTransfer: Bad destination transfer address %08x!", dstBasePtr);
return;
}
Tiny optimization in block copies
2013-12-04 10:34:54 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
// Check that the last address of both source and dest are valid addresses
Directx9 Gpu
2013-08-17 09:23:51 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
u32 srcLastAddr = srcBasePtr + ((height - 1 + srcY) * srcStride + (srcX + width - 1)) * bpp;
u32 dstLastAddr = dstBasePtr + ((height - 1 + dstY) * dstStride + (dstX + width - 1)) * bpp;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
if (!Memory::IsValidAddress(srcLastAddr)) {
ERROR_LOG_REPORT(G3D, "Bottom-right corner of source of block transfer is at an invalid address: %08x", srcLastAddr);
return;
}
if (!Memory::IsValidAddress(dstLastAddr)) {
ERROR_LOG_REPORT(G3D, "Bottom-right corner of destination of block transfer is at an invalid address: %08x", srcLastAddr);
return;
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
// Tell the framebuffer manager to take action if possible. If it does the entire thing, let's just return.
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyBlockTransferBefore(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason)) {
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +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...
if (srcStride == dstStride && (u32)width == srcStride) {
// Common case in God of War, let's do it all in one chunk.
u32 srcLineStartAddr = srcBasePtr + (srcY * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + (dstY * dstStride + dstX) * bpp;
const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);
u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);
memcpy(dst, src, width * height * bpp);
} else {
for (int y = 0; y < height; y++) {
u32 srcLineStartAddr = srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp;
u32 dstLineStartAddr = dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
const u8 *src = Memory::GetPointerUnchecked(srcLineStartAddr);
u8 *dst = Memory::GetPointerUnchecked(dstLineStartAddr);
memcpy(dst, src, width * bpp);
}
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
textureCache_.Invalidate(dstBasePtr + (dstY * dstStride + dstX) * bpp, height * dstStride * bpp, GPU_INVALIDATE_HINT);
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
framebufferManager_.NotifyBlockTransferAfter(dstBasePtr, dstStride, dstX, dstY, srcBasePtr, srcStride, srcX, srcY, width, height, bpp, skipDrawReason);
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
Eat cycles during block transfers. Tests show this takes a number very close to 1.9 times the number of bytes in cycles @222. Using that value caused a tiny fps drop in one area of the God of War demo, which may be correct but might also cause complaints. A lot of our other timing is not accurate, so using a lower value (1.6) to be on the safer side. This may cause things to reschedule more accurately when games drawsync, and improves the gpu/commands/blocktransfer test.
2014-08-31 05:02:28 +00:00
d3d: Oops, switch over block transfer logic.
2014-09-14 00:28:35 +00:00
CBreakPoints::ExecMemCheck(srcBasePtr + (srcY * srcStride + srcX) * bpp, false, height * srcStride * bpp, currentMIPS->pc);
CBreakPoints::ExecMemCheck(dstBasePtr + (srcY * dstStride + srcX) * bpp, true, height * dstStride * bpp, currentMIPS->pc);
Eat cycles during block transfers. Tests show this takes a number very close to 1.9 times the number of bytes in cycles @222. Using that value caused a tiny fps drop in one area of the God of War demo, which may be correct but might also cause complaints. A lot of our other timing is not accurate, so using a lower value (1.6) to be on the safer side. This may cause things to reschedule more accurately when games drawsync, and improves the gpu/commands/blocktransfer test.
2014-08-31 05:02:28 +00:00
// TODO: Correct timing appears to be 1.9, but erring a bit low since some of our other timing is inaccurate.
cyclesExecuted += ((height * width * bpp) * 16) / 10;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
void DIRECTX9_GPU::InvalidateCache(u32 addr, int size, GPUInvalidationType type) {
update gpu code
2013-08-19 18:36:43 +00:00
GPUEvent ev(GPU_EVENT_INVALIDATE_CACHE);
ev.invalidate_cache.addr = addr;
ev.invalidate_cache.size = size;
ev.invalidate_cache.type = type;
ScheduleEvent(ev);
}
void DIRECTX9_GPU::InvalidateCacheInternal(u32 addr, int size, GPUInvalidationType type) {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
if (size > 0)
textureCache_.Invalidate(addr, size, type);
else
textureCache_.InvalidateAll(type);
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
if (type != GPU_INVALIDATE_ALL && framebufferManager_.MayIntersectFramebuffer(addr)) {
// If we're doing block transfers, we shouldn't need this, and it'll only confuse us.
// Vempire invalidates (with writeback) after drawing, but before blitting.
if (!g_Config.bBlockTransferGPU || type == GPU_INVALIDATE_SAFE) {
framebufferManager_.UpdateFromMemory(addr, size, type == GPU_INVALIDATE_SAFE);
}
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
Add a more specific interface for video frames. Since we know more about them. No functional change yet.
2016-01-17 20:43:13 +00:00
void DIRECTX9_GPU::NotifyVideoUpload(u32 addr, int size, int width, int format) {
Use video format when uploading to framebuffers. Expected to help Bounty Hound, #8392.
2016-01-17 20:52:40 +00:00
if (Memory::IsVRAMAddress(addr)) {
framebufferManager_.NotifyVideoUpload(addr, size, width, (GEBufferFormat)format);
}
Add a more specific interface for video frames. Since we know more about them. No functional change yet.
2016-01-17 20:43:13 +00:00
InvalidateCache(addr, size, GPU_INVALIDATE_SAFE);
}
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
void DIRECTX9_GPU::PerformMemoryCopyInternal(u32 dest, u32 src, int size) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyFramebufferCopy(src, dest, size, false, gstate_c.skipDrawReason)) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
// We use a little hack for Download/Upload using a VRAM mirror.
// Since they're identical we don't need to copy.
if (!Memory::IsVRAMAddress(dest) || (dest ^ 0x00400000) != src) {
Make Memory::Memcpy() execute memchecks directly. This makes it easier to handle breakpoints in HLE.
2015-04-06 01:03:50 +00:00
Memory::Memcpy(dest, src, size);
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
}
}
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
}
void DIRECTX9_GPU::PerformMemorySetInternal(u32 dest, u8 v, int size) {
Refactor: Even more getting rid of gstate access in the framebuffer manager.
2015-08-05 10:13:14 +00:00
if (!framebufferManager_.NotifyFramebufferCopy(dest, dest, size, true, gstate_c.skipDrawReason)) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
}
}
void DIRECTX9_GPU::PerformStencilUploadInternal(u32 dest, int size) {
framebufferManager_.NotifyStencilUpload(dest, size);
}
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
bool DIRECTX9_GPU::PerformMemoryCopy(u32 dest, u32 src, int size) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
// Track stray copies of a framebuffer in RAM. MotoGP does this.
if (framebufferManager_.MayIntersectFramebuffer(src) || framebufferManager_.MayIntersectFramebuffer(dest)) {
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_MEMCPY);
ev.fb_memcpy.dst = dest;
ev.fb_memcpy.src = src;
ev.fb_memcpy.size = size;
ScheduleEvent(ev);
// This is a memcpy, so we need to wait for it to complete.
SyncThread();
} else {
PerformMemoryCopyInternal(dest, src, size);
}
return true;
}
Use a separate func for gpu memset().
2014-05-27 08:14:29 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
return false;
}
bool DIRECTX9_GPU::PerformMemorySet(u32 dest, u8 v, int size) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
// This may indicate a memset, usually to 0, of a framebuffer.
if (framebufferManager_.MayIntersectFramebuffer(dest)) {
Memory::Memset(dest, v, size);
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_MEMSET);
ev.fb_memset.dst = dest;
ev.fb_memset.v = v;
ev.fb_memset.size = size;
ScheduleEvent(ev);
// We don't need to wait for the framebuffer to be updated.
} else {
PerformMemorySetInternal(dest, v, size);
}
return true;
}
// Or perhaps a texture, let's invalidate.
Directx9 Gpu
2013-08-17 09:23:51 +00:00
InvalidateCache(dest, size, GPU_INVALIDATE_HINT);
UpdateMemory() now returns whether to skip the cpy. This way it can do it itself as necessary in the right order.
2014-05-26 03:05:28 +00:00
return false;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
Clean up the framebuffer force downloads.
2014-05-31 06:33:50 +00:00
bool DIRECTX9_GPU::PerformMemoryDownload(u32 dest, int size) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
// Cheat a bit to force a download of the framebuffer.
// VRAM + 0x00400000 is simply a VRAM mirror.
if (Memory::IsVRAMAddress(dest)) {
return PerformMemoryCopy(dest ^ 0x00400000, dest, size);
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
}
Clean up the framebuffer force downloads.
2014-05-31 06:33:50 +00:00
return false;
}
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
bool DIRECTX9_GPU::PerformMemoryUpload(u32 dest, int size) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
// Cheat a bit to force an upload of the framebuffer.
// VRAM + 0x00400000 is simply a VRAM mirror.
if (Memory::IsVRAMAddress(dest)) {
return PerformMemoryCopy(dest, dest ^ 0x00400000, size);
}
Add a matching PerformMemoryUpload(). Just so we have both Download and Upload to use later.
2014-06-10 07:45:03 +00:00
return false;
}
Implement a very basic stencil upload. This is not fast or efficient, but works.
2014-06-01 01:24:35 +00:00
bool DIRECTX9_GPU::PerformStencilUpload(u32 dest, int size) {
d3d: Track memory copies/uploads/downloads.
2014-09-14 00:59:21 +00:00
if (framebufferManager_.MayIntersectFramebuffer(dest)) {
if (IsOnSeparateCPUThread()) {
GPUEvent ev(GPU_EVENT_FB_STENCIL_UPLOAD);
ev.fb_stencil_upload.dst = dest;
ev.fb_stencil_upload.size = size;
ScheduleEvent(ev);
} else {
PerformStencilUploadInternal(dest, size);
}
return true;
}
Implement a very basic stencil upload. This is not fast or efficient, but works.
2014-06-01 01:24:35 +00:00
return false;
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
void DIRECTX9_GPU::ClearCacheNextFrame() {
textureCache_.ClearNextFrame();
}
void DIRECTX9_GPU::Resized() {
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
resized_ = true;
Directx9 Gpu
2013-08-17 09:23:51 +00:00
framebufferManager_.Resized();
}
DX9: Enable vtxdec JIT, buildfix
2014-09-11 23:48:43 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
void DIRECTX9_GPU::ClearShaderCache() {
shaderManager_->ClearCache(true);
}
DX9: Enable vtxdec JIT, buildfix
2014-09-11 23:48:43 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
std::vector<FramebufferInfo> DIRECTX9_GPU::GetFramebufferList() {
Directx9 Gpu
2013-08-17 09:23:51 +00:00
return framebufferManager_.GetFramebufferList();
}
void DIRECTX9_GPU::DoState(PointerWrap &p) {
GPUCommon::DoState(p);
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
// TODO: Some of these things may not be necessary.
// None of these are necessary when saving.
if (p.mode == p.MODE_READ) {
textureCache_.Clear(true);
transformDraw_.ClearTrackedVertexArrays();
Directx9 Gpu
2013-08-17 09:23:51 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
gstate_c.textureChanged = TEXCHANGE_UPDATED;
framebufferManager_.DestroyAllFBOs();
shaderManager_->ClearCache(true);
}
Directx9 Gpu
2013-08-17 09:23:51 +00:00
}
Put the DirectX9 stuff into a namespace. This makes it almost build on Windows, but not quite. Some required files excluded from build, still.
2013-09-15 15:53:21 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
bool DIRECTX9_GPU::GetCurrentFramebuffer(GPUDebugBuffer &buffer) {
return framebufferManager_.GetCurrentFramebuffer(buffer);
}
[Gpu] Sync with gles Conflicts: GPU/Directx9/FramebufferDX9.cpp GPU/Directx9/FramebufferDX9.h GPU/Directx9/TransformPipelineDX9.cpp
2013-11-15 13:24:25 +00:00
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
bool DIRECTX9_GPU::GetCurrentDepthbuffer(GPUDebugBuffer &buffer) {
return framebufferManager_.GetCurrentDepthbuffer(buffer);
}
bool DIRECTX9_GPU::GetCurrentStencilbuffer(GPUDebugBuffer &buffer) {
return framebufferManager_.GetCurrentStencilbuffer(buffer);
}
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
bool DIRECTX9_GPU::GetCurrentTexture(GPUDebugBuffer &buffer, int level) {
[Gpu] Sync with gles Conflicts: GPU/Directx9/GPU_DX9.cpp
2013-12-05 15:37:52 +00:00
if (!gstate.isTextureMapEnabled()) {
return false;
}
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
textureCache_.SetTexture(true);
Correct texture preview in D3D9, oops.
2015-11-14 07:10:30 +00:00
textureCache_.ApplyTexture();
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
int w = gstate.getTextureWidth(level);
int h = gstate.getTextureHeight(level);
LPDIRECT3DBASETEXTURE9 baseTex;
LPDIRECT3DTEXTURE9 tex;
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
LPDIRECT3DSURFACE9 offscreen = nullptr;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
HRESULT hr;
Slightly improve GPU disassembly
2014-09-13 21:50:42 +00:00
bool success = false;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
hr = pD3Ddevice->GetTexture(0, &baseTex);
Slightly improve GPU disassembly
2014-09-13 21:50:42 +00:00
if (SUCCEEDED(hr) && baseTex != NULL) {
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
hr = baseTex->QueryInterface(IID_IDirect3DTexture9, (void **)&tex);
if (SUCCEEDED(hr)) {
D3DSURFACE_DESC desc;
D3DLOCKED_RECT locked;
tex->GetLevelDesc(level, &desc);
Make debug build nearly warning free in MSVC 2015
2015-09-17 20:02:15 +00:00
RECT rect = {0, 0, (LONG)desc.Width, (LONG)desc.Height};
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
hr = tex->LockRect(level, &locked, &rect, D3DLOCK_READONLY);
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
// If it fails, this means it's a render-to-texture, so we have to get creative.
if (FAILED(hr)) {
d3d: Fix some missing Releases() in debug code.
2014-09-12 06:52:06 +00:00
LPDIRECT3DSURFACE9 renderTarget = nullptr;
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
hr = tex->GetSurfaceLevel(level, &renderTarget);
d3d: Fix some missing Releases() in debug code.
2014-09-12 06:52:06 +00:00
if (renderTarget && SUCCEEDED(hr)) {
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
hr = pD3Ddevice->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &offscreen, NULL);
if (SUCCEEDED(hr)) {
hr = pD3Ddevice->GetRenderTargetData(renderTarget, offscreen);
if (SUCCEEDED(hr)) {
hr = offscreen->LockRect(&locked, &rect, D3DLOCK_READONLY);
}
}
d3d: Fix some missing Releases() in debug code.
2014-09-12 06:52:06 +00:00
renderTarget->Release();
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
}
}
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
if (SUCCEEDED(hr)) {
GPUDebugBufferFormat fmt;
int pixelSize;
switch (desc.Format) {
case D3DFMT_A1R5G5B5:
d3d: Handle texture swizzling in ge preview.
2014-09-09 04:25:37 +00:00
fmt = gstate_c.bgraTexture ? GPU_DBG_FORMAT_5551 : GPU_DBG_FORMAT_5551_BGRA;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
pixelSize = 2;
break;
case D3DFMT_A4R4G4B4:
d3d: Handle texture swizzling in ge preview.
2014-09-09 04:25:37 +00:00
fmt = gstate_c.bgraTexture ? GPU_DBG_FORMAT_4444 : GPU_DBG_FORMAT_4444_BGRA;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
pixelSize = 2;
break;
case D3DFMT_R5G6B5:
d3d: Handle texture swizzling in ge preview.
2014-09-09 04:25:37 +00:00
fmt = gstate_c.bgraTexture ? GPU_DBG_FORMAT_565 : GPU_DBG_FORMAT_565_BGRA;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
pixelSize = 2;
break;
case D3DFMT_A8R8G8B8:
d3d: Handle texture swizzling in ge preview.
2014-09-09 04:25:37 +00:00
fmt = gstate_c.bgraTexture ? GPU_DBG_FORMAT_8888 : GPU_DBG_FORMAT_8888_BGRA;
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
pixelSize = 4;
break;
default:
fmt = GPU_DBG_FORMAT_INVALID;
break;
}
if (fmt != GPU_DBG_FORMAT_INVALID) {
Remove a whole lot of flipping special cases
2015-10-31 22:59:23 +00:00
buffer.Allocate(locked.Pitch / pixelSize, desc.Height, fmt, false);
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
memcpy(buffer.GetData(), locked.pBits, locked.Pitch * desc.Height);
success = true;
} else {
success = false;
}
d3d: Improve GE debugger with render-to-tex. Also fix a crash in oddly sized framebuffers.
2014-09-09 08:42:21 +00:00
if (offscreen) {
offscreen->UnlockRect();
offscreen->Release();
} else {
tex->UnlockRect(level);
}
d3d: Get some initial GE previews working. Wrong colors.
2014-08-25 04:23:23 +00:00
}
tex->Release();
}
baseTex->Release();
}
return success;
[Gpu] Sync with gles Conflicts: GPU/Directx9/FramebufferDX9.cpp GPU/Directx9/FramebufferDX9.h GPU/Directx9/TransformPipelineDX9.cpp
2013-11-15 13:24:25 +00:00
}
gedbg: Add mechanics to grab CLUT buffer.
2016-01-10 17:25:19 +00:00
bool DIRECTX9_GPU::GetCurrentClut(GPUDebugBuffer &buffer) {
return textureCache_.GetCurrentClutBuffer(buffer);
}
dx9: Take screenshots (fixes #7197.)
2014-12-20 16:31:56 +00:00
bool DIRECTX9_GPU::GetDisplayFramebuffer(GPUDebugBuffer &buffer) {
return FramebufferManagerDX9::GetDisplayFramebuffer(buffer);
}
d3d: Copy over the vertex preview stuff. Really need to just centralize, I know. But want a debugger that works first.
2014-08-25 05:16:32 +00:00
bool DIRECTX9_GPU::GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
return transformDraw_.GetCurrentSimpleVertices(count, vertices, indices);
}
D3D9: Generate shaders directly from shader IDs, just like we do in GL.
2015-10-24 22:34:23 +00:00
std::vector<std::string> DIRECTX9_GPU::DebugGetShaderIDs(DebugShaderType type) {
if (type == SHADER_TYPE_VERTEXLOADER) {
return transformDraw_.DebugGetVertexLoaderIDs();
} else {
return shaderManager_->DebugGetShaderIDs(type);
}
}
std::string DIRECTX9_GPU::DebugGetShaderString(std::string id, DebugShaderType type, DebugShaderStringType stringType) {
if (type == SHADER_TYPE_VERTEXLOADER) {
return transformDraw_.DebugGetVertexLoaderString(id, stringType);
} else {
return shaderManager_->DebugGetShaderString(id, type, stringType);
}
}
Make the D3D backend cmd processing work more similar to the GL backend
2014-09-13 10:11:34 +00:00
} // namespace DX9
Reference in New Issue Copy Permalink