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/.
2013-11-15 13:24:25 +00:00
# include "base/logging.h"
2013-08-17 09:23:51 +00:00
# include "base/timeutil.h"
# include "Common/MemoryUtil.h"
# include "Core/MemMap.h"
# include "Core/Host.h"
# include "Core/System.h"
# include "Core/Reporting.h"
# include "Core/Config.h"
# include "Core/CoreTiming.h"
2017-02-05 19:54:24 +00:00
# include "gfx/d3d9_state.h"
2013-08-17 09:23:51 +00:00
# include "GPU/Math3D.h"
# include "GPU/GPUState.h"
# include "GPU/ge_constants.h"
2014-08-25 05:16:32 +00:00
# include "GPU/Common/SplineCommon.h"
2014-04-18 12:30:18 +00:00
# include "GPU/Common/TransformCommon.h"
2014-09-10 08:44:22 +00:00
# include "GPU/Common/VertexDecoderCommon.h"
2014-09-13 11:53:04 +00:00
# include "GPU/Common/SoftwareTransformCommon.h"
2013-09-15 10:46:14 +00:00
# include "GPU/Directx9/TextureCacheDX9.h"
2016-04-10 08:27:28 +00:00
# include "GPU/Directx9/DrawEngineDX9.h"
2013-09-15 10:46:14 +00:00
# include "GPU/Directx9/ShaderManagerDX9.h"
# include "GPU/Directx9/GPU_DX9.h"
2013-08-17 09:23:51 +00:00
2013-09-15 15:53:21 +00:00
namespace DX9 {
2013-08-17 09:23:51 +00:00
const D3DPRIMITIVETYPE glprim [ 8 ] = {
D3DPT_POINTLIST ,
D3DPT_LINELIST ,
D3DPT_LINESTRIP ,
D3DPT_TRIANGLELIST ,
D3DPT_TRIANGLESTRIP ,
D3DPT_TRIANGLEFAN ,
D3DPT_TRIANGLELIST , // With OpenGL ES we have to expand sprites into triangles, tripling the data instead of doubling. sigh. OpenGL ES, Y U NO SUPPORT GL_QUADS?
} ;
2013-09-15 10:46:14 +00:00
// hrydgard's quick guesses - TODO verify
static const int D3DPRIMITIVEVERTEXCOUNT [ 8 ] [ 2 ] = {
{ 0 , 0 } , // invalid
{ 1 , 0 } , // 1 = D3DPT_POINTLIST,
{ 2 , 0 } , // 2 = D3DPT_LINELIST,
{ 2 , 1 } , // 3 = D3DPT_LINESTRIP,
{ 3 , 0 } , // 4 = D3DPT_TRIANGLELIST,
{ 1 , 2 } , // 5 = D3DPT_TRIANGLESTRIP,
{ 1 , 2 } , // 6 = D3DPT_TRIANGLEFAN,
} ;
2017-02-05 19:36:00 +00:00
inline int D3DPrimCount ( D3DPRIMITIVETYPE prim , int size ) {
2013-08-17 09:23:51 +00:00
return ( size / D3DPRIMITIVEVERTEXCOUNT [ prim ] [ 0 ] ) - D3DPRIMITIVEVERTEXCOUNT [ prim ] [ 1 ] ;
}
enum {
2013-10-27 21:43:58 +00:00
TRANSFORMED_VERTEX_BUFFER_SIZE = VERTEX_BUFFER_MAX * sizeof ( TransformedVertex )
2013-08-17 09:23:51 +00:00
} ;
2013-08-20 16:47:11 +00:00
# define VERTEXCACHE_DECIMATION_INTERVAL 17
2014-09-14 20:50:57 +00:00
enum { VAI_KILL_AGE = 120 , VAI_UNRELIABLE_KILL_AGE = 240 , VAI_UNRELIABLE_KILL_MAX = 4 } ;
2017-02-05 18:38:52 +00:00
static const D3DVERTEXELEMENT9 TransformedVertexElements [ ] = {
{ 0 , 0 , D3DDECLTYPE_FLOAT4 , D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_POSITION , 0 } ,
{ 0 , 16 , D3DDECLTYPE_FLOAT3 , D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_TEXCOORD , 0 } ,
{ 0 , 28 , D3DDECLTYPE_UBYTE4N , D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_COLOR , 0 } ,
{ 0 , 32 , D3DDECLTYPE_UBYTE4N , D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_COLOR , 1 } ,
D3DDECL_END ( )
} ;
2017-08-20 09:30:19 +00:00
DrawEngineDX9 : : DrawEngineDX9 ( Draw : : DrawContext * draw ) : vai_ ( 256 ) , vertexDeclMap_ ( 64 ) {
2017-03-02 10:39:02 +00:00
device_ = ( LPDIRECT3DDEVICE9 ) draw - > GetNativeObject ( Draw : : NativeObject : : DEVICE ) ;
2014-09-11 23:38:45 +00:00
decOptions_ . expandAllWeightsToFloat = true ;
decOptions_ . expand8BitNormalsToFloat = true ;
2014-09-10 08:28:44 +00:00
2013-11-15 13:24:25 +00:00
decimationCounter_ = VERTEXCACHE_DECIMATION_INTERVAL ;
// Allocate nicely aligned memory. Maybe graphics drivers will
// appreciate it.
// All this is a LOT of memory, need to see if we can cut down somehow.
2016-08-28 10:28:17 +00:00
decoded = ( u8 * ) AllocateMemoryPages ( DECODED_VERTEX_BUFFER_SIZE , MEM_PROT_READ | MEM_PROT_WRITE ) ;
decIndex = ( u16 * ) AllocateMemoryPages ( DECODED_INDEX_BUFFER_SIZE , MEM_PROT_READ | MEM_PROT_WRITE ) ;
splineBuffer = ( u8 * ) AllocateMemoryPages ( SPLINE_BUFFER_SIZE , MEM_PROT_READ | MEM_PROT_WRITE ) ;
2013-11-15 13:24:25 +00:00
2013-12-03 15:53:30 +00:00
indexGen . Setup ( decIndex ) ;
2014-09-11 23:48:43 +00:00
2013-12-03 15:53:30 +00:00
InitDeviceObjects ( ) ;
2017-01-10 05:41:01 +00:00
tessDataTransfer = new TessellationDataTransferDX9 ( ) ;
2017-02-05 18:38:52 +00:00
2017-02-05 19:36:00 +00:00
device_ - > CreateVertexDeclaration ( TransformedVertexElements , & transformedVertexDecl_ ) ;
2013-08-17 09:23:51 +00:00
}
2016-04-10 08:21:48 +00:00
DrawEngineDX9 : : ~ DrawEngineDX9 ( ) {
2017-02-05 18:38:52 +00:00
if ( transformedVertexDecl_ ) {
transformedVertexDecl_ - > Release ( ) ;
}
2013-08-17 09:23:51 +00:00
DestroyDeviceObjects ( ) ;
FreeMemoryPages ( decoded , DECODED_VERTEX_BUFFER_SIZE ) ;
FreeMemoryPages ( decIndex , DECODED_INDEX_BUFFER_SIZE ) ;
2015-01-29 13:12:24 +00:00
FreeMemoryPages ( splineBuffer , SPLINE_BUFFER_SIZE ) ;
2017-08-20 09:30:19 +00:00
vertexDeclMap_ . Iterate ( [ & ] ( const uint32_t & key , IDirect3DVertexDeclaration9 * decl ) {
if ( decl ) {
decl - > Release ( ) ;
2014-09-08 22:29:01 +00:00
}
2017-08-20 09:30:19 +00:00
} ) ;
vertexDeclMap_ . Clear ( ) ;
2017-01-10 05:41:01 +00:00
delete tessDataTransfer ;
2013-08-17 09:23:51 +00:00
}
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : InitDeviceObjects ( ) {
2013-08-23 15:24:51 +00:00
2013-08-17 09:23:51 +00:00
}
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : DestroyDeviceObjects ( ) {
2013-08-17 09:23:51 +00:00
ClearTrackedVertexArrays ( ) ;
}
2013-08-23 15:24:51 +00:00
2013-08-21 09:10:56 +00:00
struct DeclTypeInfo {
u32 type ;
2013-09-01 06:38:40 +00:00
const char * name ;
2013-08-21 09:10:56 +00:00
} ;
2013-08-23 15:24:51 +00:00
2013-08-21 09:10:56 +00:00
static const DeclTypeInfo VComp [ ] = {
2014-09-17 20:03:44 +00:00
{ 0 , " NULL " } , // DEC_NONE,
{ D3DDECLTYPE_FLOAT1 , " D3DDECLTYPE_FLOAT1 " } , // DEC_FLOAT_1,
{ D3DDECLTYPE_FLOAT2 , " D3DDECLTYPE_FLOAT2 " } , // DEC_FLOAT_2,
{ D3DDECLTYPE_FLOAT3 , " D3DDECLTYPE_FLOAT3 " } , // DEC_FLOAT_3,
{ D3DDECLTYPE_FLOAT4 , " D3DDECLTYPE_FLOAT4 " } , // DEC_FLOAT_4,
{ 0 , " UNUSED " } , // DEC_S8_3,
{ D3DDECLTYPE_SHORT4N , " D3DDECLTYPE_SHORT4N " } , // DEC_S16_3,
{ D3DDECLTYPE_UBYTE4N , " D3DDECLTYPE_UBYTE4N " } , // DEC_U8_1,
{ D3DDECLTYPE_UBYTE4N , " D3DDECLTYPE_UBYTE4N " } , // DEC_U8_2,
{ D3DDECLTYPE_UBYTE4N , " D3DDECLTYPE_UBYTE4N " } , // DEC_U8_3,
{ D3DDECLTYPE_UBYTE4N , " D3DDECLTYPE_UBYTE4N " } , // DEC_U8_4,
{ 0 , " UNUSED_DEC_U16_1 " } , // DEC_U16_1,
{ 0 , " UNUSED_DEC_U16_2 " } , // DEC_U16_2,
{ D3DDECLTYPE_USHORT4N , " D3DDECLTYPE_USHORT4N " } , // DEC_U16_3,
{ D3DDECLTYPE_USHORT4N , " D3DDECLTYPE_USHORT4N " } , // DEC_U16_4,
2013-08-21 09:10:56 +00:00
} ;
static void VertexAttribSetup ( D3DVERTEXELEMENT9 * VertexElement , u8 fmt , u8 offset , u8 usage , u8 usage_index = 0 ) {
memset ( VertexElement , 0 , sizeof ( D3DVERTEXELEMENT9 ) ) ;
VertexElement - > Offset = offset ;
2014-08-26 14:37:19 +00:00
VertexElement - > Type = VComp [ fmt ] . type ;
2013-08-21 09:10:56 +00:00
VertexElement - > Usage = usage ;
VertexElement - > UsageIndex = usage_index ;
}
2016-04-10 08:21:48 +00:00
IDirect3DVertexDeclaration9 * DrawEngineDX9 : : SetupDecFmtForDraw ( VSShader * vshader , const DecVtxFormat & decFmt , u32 pspFmt ) {
2017-08-20 09:30:19 +00:00
IDirect3DVertexDeclaration9 * vertexDeclCached = vertexDeclMap_ . Get ( pspFmt ) ;
2013-09-01 06:38:40 +00:00
2017-08-20 09:30:19 +00:00
if ( vertexDeclCached ) {
return vertexDeclCached ;
} else {
2014-09-07 20:07:12 +00:00
D3DVERTEXELEMENT9 VertexElements [ 8 ] ;
D3DVERTEXELEMENT9 * VertexElement = & VertexElements [ 0 ] ;
2013-09-01 06:38:40 +00:00
// Vertices Elements orders
2013-08-21 09:10:56 +00:00
2013-09-01 06:38:40 +00:00
// TC
if ( decFmt . uvfmt ! = 0 ) {
2014-09-08 22:42:12 +00:00
VertexAttribSetup ( VertexElement , decFmt . uvfmt , decFmt . uvoff , D3DDECLUSAGE_TEXCOORD , 0 ) ;
2013-09-01 06:38:40 +00:00
VertexElement + + ;
}
// COLOR
if ( decFmt . c0fmt ! = 0 ) {
2014-08-25 08:16:49 +00:00
VertexAttribSetup ( VertexElement , decFmt . c0fmt , decFmt . c0off , D3DDECLUSAGE_COLOR , 0 ) ;
2013-09-01 06:38:40 +00:00
VertexElement + + ;
}
// Never used ?
if ( decFmt . c1fmt ! = 0 ) {
2014-08-25 08:16:49 +00:00
VertexAttribSetup ( VertexElement , decFmt . c1fmt , decFmt . c1off , D3DDECLUSAGE_COLOR , 1 ) ;
2013-09-01 06:38:40 +00:00
VertexElement + + ;
}
// NORMAL
if ( decFmt . nrmfmt ! = 0 ) {
VertexAttribSetup ( VertexElement , decFmt . nrmfmt , decFmt . nrmoff , D3DDECLUSAGE_NORMAL , 0 ) ;
VertexElement + + ;
}
// POSITION
// Always
VertexAttribSetup ( VertexElement , decFmt . posfmt , decFmt . posoff , D3DDECLUSAGE_POSITION , 0 ) ;
VertexElement + + ;
// End
D3DVERTEXELEMENT9 end = D3DDECL_END ( ) ;
memcpy ( VertexElement , & end , sizeof ( D3DVERTEXELEMENT9 ) ) ;
2014-09-17 22:40:25 +00:00
2014-09-07 20:07:12 +00:00
// Create declaration
2014-09-08 22:29:01 +00:00
IDirect3DVertexDeclaration9 * pHardwareVertexDecl = nullptr ;
2017-02-05 19:36:00 +00:00
HRESULT hr = device_ - > CreateVertexDeclaration ( VertexElements , & pHardwareVertexDecl ) ;
2014-08-22 19:27:13 +00:00
if ( FAILED ( hr ) ) {
2014-09-13 10:27:20 +00:00
ERROR_LOG ( G3D , " Failed to create vertex declaration! " ) ;
pHardwareVertexDecl = nullptr ;
2014-08-22 19:27:13 +00:00
}
2013-09-01 06:38:40 +00:00
// Add it to map
2017-08-20 09:30:19 +00:00
vertexDeclMap_ . Insert ( pspFmt , pHardwareVertexDecl ) ;
2014-09-07 20:07:12 +00:00
return pHardwareVertexDecl ;
2013-09-01 06:38:40 +00:00
}
2013-08-21 09:10:56 +00:00
}
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : MarkUnreliable ( VertexArrayInfoDX9 * vai ) {
2014-09-14 20:50:57 +00:00
vai - > status = VertexArrayInfoDX9 : : VAI_UNRELIABLE ;
if ( vai - > vbo ) {
vai - > vbo - > Release ( ) ;
vai - > vbo = nullptr ;
}
if ( vai - > ebo ) {
vai - > ebo - > Release ( ) ;
vai - > ebo = nullptr ;
2013-08-17 09:23:51 +00:00
}
}
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : ClearTrackedVertexArrays ( ) {
2017-08-20 09:30:19 +00:00
vai_ . Iterate ( [ & ] ( uint32_t hash , DX9 : : VertexArrayInfoDX9 * vai ) {
delete vai ;
} ) ;
vai_ . Clear ( ) ;
2013-08-17 09:23:51 +00:00
}
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : DecimateTrackedVertexArrays ( ) {
2013-08-20 16:47:11 +00:00
if ( - - decimationCounter_ < = 0 ) {
decimationCounter_ = VERTEXCACHE_DECIMATION_INTERVAL ;
} else {
return ;
}
2014-09-14 20:50:57 +00:00
const int threshold = gpuStats . numFlips - VAI_KILL_AGE ;
const int unreliableThreshold = gpuStats . numFlips - VAI_UNRELIABLE_KILL_AGE ;
int unreliableLeft = VAI_UNRELIABLE_KILL_MAX ;
2017-08-20 09:30:19 +00:00
vai_ . Iterate ( [ & ] ( uint32_t hash , DX9 : : VertexArrayInfoDX9 * vai ) {
2014-09-14 20:50:57 +00:00
bool kill ;
2017-08-20 09:30:19 +00:00
if ( vai - > status = = VertexArrayInfoDX9 : : VAI_UNRELIABLE ) {
2014-09-14 20:50:57 +00:00
// We limit killing unreliable so we don't rehash too often.
2017-08-20 09:30:19 +00:00
kill = vai - > lastFrame < unreliableThreshold & & - - unreliableLeft > = 0 ;
2014-09-14 20:50:57 +00:00
} else {
2017-08-20 09:30:19 +00:00
kill = vai - > lastFrame < threshold ;
2014-09-14 20:50:57 +00:00
}
if ( kill ) {
2017-08-20 09:30:19 +00:00
delete vai ;
vai_ . Remove ( hash ) ;
2014-09-14 20:50:57 +00:00
}
2017-08-20 09:30:19 +00:00
} ) ;
2017-12-03 02:27:18 +00:00
vai_ . Maintain ( ) ;
2013-08-17 09:23:51 +00:00
// Enable if you want to see vertex decoders in the log output. Need a better way.
#if 0
char buffer [ 16384 ] ;
for ( std : : map < u32 , VertexDecoder * > : : iterator dec = decoderMap_ . begin ( ) ; dec ! = decoderMap_ . end ( ) ; + + dec ) {
char * ptr = buffer ;
ptr + = dec - > second - > ToString ( ptr ) ;
2013-08-23 15:24:51 +00:00
// *ptr++ = '\n';
2013-09-10 20:35:38 +00:00
NOTICE_LOG ( G3D , buffer ) ;
2013-08-17 09:23:51 +00:00
}
# endif
}
2013-09-15 10:46:14 +00:00
VertexArrayInfoDX9 : : ~ VertexArrayInfoDX9 ( ) {
2013-08-17 09:23:51 +00:00
if ( vbo ) {
vbo - > Release ( ) ;
}
if ( ebo ) {
ebo - > Release ( ) ;
}
}
2017-01-21 16:45:53 +00:00
static uint32_t SwapRB ( uint32_t c ) {
return ( c & 0xFF00FF00 ) | ( ( c > > 16 ) & 0xFF ) | ( ( c < < 16 ) & 0xFF0000 ) ;
}
2014-10-18 09:26:51 +00:00
// The inline wrapper in the header checks for numDrawCalls == 0
2016-04-10 08:21:48 +00:00
void DrawEngineDX9 : : DoFlush ( ) {
2013-08-17 09:23:51 +00:00
gpuStats . numFlushes + + ;
gpuStats . numTrackedVertexArrays = ( int ) vai_ . size ( ) ;
2013-08-20 16:47:11 +00:00
// This is not done on every drawcall, we should collect vertex data
2013-08-17 09:23:51 +00:00
// until critical state changes. That's when we draw (flush).
2013-09-04 09:19:36 +00:00
GEPrimitiveType prim = prevPrim_ ;
2013-08-17 09:23:51 +00:00
ApplyDrawState ( prim ) ;
2014-09-10 12:07:30 +00:00
VSShader * vshader = shaderManager_ - > ApplyShader ( prim , lastVType_ ) ;
2013-08-21 09:10:56 +00:00
2014-09-10 12:07:30 +00:00
if ( vshader - > UseHWTransform ( ) ) {
2014-09-17 20:03:44 +00:00
LPDIRECT3DVERTEXBUFFER9 vb_ = NULL ;
LPDIRECT3DINDEXBUFFER9 ib_ = NULL ;
int vertexCount = 0 ;
int maxIndex = 0 ;
bool useElements = true ;
// Cannot cache vertex data with morph enabled.
bool useCache = g_Config . bVertexCache & & ! ( lastVType_ & GE_VTYPE_MORPHCOUNT_MASK ) ;
2018-03-02 13:57:35 +00:00
// Also avoid caching when skinning.
2018-03-02 13:19:38 +00:00
if ( lastVType_ & GE_VTYPE_WEIGHT_MASK )
2014-09-17 20:03:44 +00:00
useCache = false ;
if ( useCache ) {
2017-02-04 10:37:24 +00:00
u32 id = dcid_ ^ gstate . getUVGenMode ( ) ; // This can have an effect on which UV decoder we need to use! And hence what the decoded data will look like. See #9263
2017-08-20 09:30:19 +00:00
VertexArrayInfoDX9 * vai = vai_ . Get ( id ) ;
if ( ! vai ) {
2014-09-17 20:03:44 +00:00
vai = new VertexArrayInfoDX9 ( ) ;
2017-08-20 09:30:19 +00:00
vai_ . Insert ( id , vai ) ;
2014-09-17 20:03:44 +00:00
}
2013-08-23 15:24:51 +00:00
2014-09-17 20:03:44 +00:00
switch ( vai - > status ) {
case VertexArrayInfoDX9 : : VAI_NEW :
{
// Haven't seen this one before.
2014-10-27 00:49:24 +00:00
ReliableHashType dataHash = ComputeHash ( ) ;
2014-09-17 20:03:44 +00:00
vai - > hash = dataHash ;
vai - > minihash = ComputeMiniHash ( ) ;
vai - > status = VertexArrayInfoDX9 : : VAI_HASHING ;
vai - > drawsUntilNextFullHash = 0 ;
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ; // writes to indexGen
2014-09-17 20:03:44 +00:00
vai - > numVerts = indexGen . VertexCount ( ) ;
vai - > prim = indexGen . Prim ( ) ;
vai - > maxIndex = indexGen . MaxIndex ( ) ;
vai - > flags = gstate_c . vertexFullAlpha ? VAI_FLAG_VERTEXFULLALPHA : 0 ;
goto rotateVBO ;
}
2014-09-09 08:03:08 +00:00
2014-09-17 20:03:44 +00:00
// Hashing - still gaining confidence about the buffer.
// But if we get this far it's likely to be worth creating a vertex buffer.
case VertexArrayInfoDX9 : : VAI_HASHING :
{
vai - > numDraws + + ;
if ( vai - > lastFrame ! = gpuStats . numFlips ) {
vai - > numFrames + + ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
if ( vai - > drawsUntilNextFullHash = = 0 ) {
// Let's try to skip a full hash if mini would fail.
const u32 newMiniHash = ComputeMiniHash ( ) ;
2014-10-27 00:49:24 +00:00
ReliableHashType newHash = vai - > hash ;
2014-09-17 20:03:44 +00:00
if ( newMiniHash = = vai - > minihash ) {
newHash = ComputeHash ( ) ;
}
if ( newMiniHash ! = vai - > minihash | | newHash ! = vai - > hash ) {
MarkUnreliable ( vai ) ;
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
goto rotateVBO ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
if ( vai - > numVerts > 64 ) {
// exponential backoff up to 16 draws, then every 24
vai - > drawsUntilNextFullHash = std : : min ( 24 , vai - > numFrames ) ;
2013-08-23 15:24:51 +00:00
} else {
2014-09-17 20:03:44 +00:00
// Lower numbers seem much more likely to change.
vai - > drawsUntilNextFullHash = 0 ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
// TODO: tweak
//if (vai->numFrames > 1000) {
// vai->status = VertexArrayInfo::VAI_RELIABLE;
//}
} else {
vai - > drawsUntilNextFullHash - - ;
u32 newMiniHash = ComputeMiniHash ( ) ;
if ( newMiniHash ! = vai - > minihash ) {
MarkUnreliable ( vai ) ;
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
goto rotateVBO ;
2013-08-23 15:24:51 +00:00
}
}
2014-09-17 20:03:44 +00:00
if ( vai - > vbo = = 0 ) {
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
vai - > numVerts = indexGen . VertexCount ( ) ;
vai - > prim = indexGen . Prim ( ) ;
vai - > maxIndex = indexGen . MaxIndex ( ) ;
vai - > flags = gstate_c . vertexFullAlpha ? VAI_FLAG_VERTEXFULLALPHA : 0 ;
useElements = ! indexGen . SeenOnlyPurePrims ( ) ;
if ( ! useElements & & indexGen . PureCount ( ) ) {
vai - > numVerts = indexGen . PureCount ( ) ;
}
2015-09-13 18:09:21 +00:00
2015-09-13 21:52:10 +00:00
_dbg_assert_msg_ ( G3D , gstate_c . vertBounds . minV > = gstate_c . vertBounds . maxV , " Should not have checked UVs when caching. " ) ;
2015-09-13 18:09:21 +00:00
2014-09-17 22:40:25 +00:00
void * pVb ;
u32 size = dec_ - > GetDecVtxFmt ( ) . stride * indexGen . MaxIndex ( ) ;
2017-02-05 19:36:00 +00:00
device_ - > CreateVertexBuffer ( size , D3DUSAGE_WRITEONLY , 0 , D3DPOOL_DEFAULT , & vai - > vbo , NULL ) ;
2014-09-17 22:40:25 +00:00
vai - > vbo - > Lock ( 0 , size , & pVb , 0 ) ;
memcpy ( pVb , decoded , size ) ;
vai - > vbo - > Unlock ( ) ;
2014-09-17 20:03:44 +00:00
if ( useElements ) {
void * pIb ;
2014-10-18 09:26:51 +00:00
u32 size = sizeof ( short ) * indexGen . VertexCount ( ) ;
2017-02-05 19:36:00 +00:00
device_ - > CreateIndexBuffer ( size , D3DUSAGE_WRITEONLY , D3DFMT_INDEX16 , D3DPOOL_DEFAULT , & vai - > ebo , NULL ) ;
2014-09-17 20:03:44 +00:00
vai - > ebo - > Lock ( 0 , size , & pIb , 0 ) ;
memcpy ( pIb , decIndex , size ) ;
vai - > ebo - > Unlock ( ) ;
} else {
vai - > ebo = 0 ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
} else {
2013-08-23 15:24:51 +00:00
gpuStats . numCachedDrawCalls + + ;
2014-09-17 20:03:44 +00:00
useElements = vai - > ebo ? true : false ;
2013-08-23 15:24:51 +00:00
gpuStats . numCachedVertsDrawn + = vai - > numVerts ;
2014-09-09 08:03:08 +00:00
gstate_c . vertexFullAlpha = vai - > flags & VAI_FLAG_VERTEXFULLALPHA ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
vb_ = vai - > vbo ;
ib_ = vai - > ebo ;
vertexCount = vai - > numVerts ;
maxIndex = vai - > maxIndex ;
prim = static_cast < GEPrimitiveType > ( vai - > prim ) ;
break ;
2013-08-23 15:24:51 +00:00
}
2014-09-17 20:03:44 +00:00
// Reliable - we don't even bother hashing anymore. Right now we don't go here until after a very long time.
case VertexArrayInfoDX9 : : VAI_RELIABLE :
{
vai - > numDraws + + ;
if ( vai - > lastFrame ! = gpuStats . numFlips ) {
vai - > numFrames + + ;
}
gpuStats . numCachedDrawCalls + + ;
gpuStats . numCachedVertsDrawn + = vai - > numVerts ;
vb_ = vai - > vbo ;
ib_ = vai - > ebo ;
2013-08-23 15:24:51 +00:00
2014-09-17 20:03:44 +00:00
vertexCount = vai - > numVerts ;
2013-08-23 15:24:51 +00:00
2014-09-17 20:03:44 +00:00
maxIndex = vai - > maxIndex ;
prim = static_cast < GEPrimitiveType > ( vai - > prim ) ;
2013-08-23 15:24:51 +00:00
2014-09-17 20:03:44 +00:00
gstate_c . vertexFullAlpha = vai - > flags & VAI_FLAG_VERTEXFULLALPHA ;
break ;
}
2013-08-23 15:24:51 +00:00
2014-09-17 20:03:44 +00:00
case VertexArrayInfoDX9 : : VAI_UNRELIABLE :
{
vai - > numDraws + + ;
if ( vai - > lastFrame ! = gpuStats . numFlips ) {
vai - > numFrames + + ;
2014-08-22 19:27:13 +00:00
}
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
goto rotateVBO ;
2013-08-23 15:24:51 +00:00
}
}
2014-09-17 20:03:44 +00:00
vai - > lastFrame = gpuStats . numFlips ;
2013-08-21 09:10:56 +00:00
} else {
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
rotateVBO :
2013-08-23 15:24:51 +00:00
gpuStats . numUncachedVertsDrawn + = indexGen . VertexCount ( ) ;
2014-09-17 20:03:44 +00:00
useElements = ! indexGen . SeenOnlyPurePrims ( ) ;
vertexCount = indexGen . VertexCount ( ) ;
maxIndex = indexGen . MaxIndex ( ) ;
if ( ! useElements & & indexGen . PureCount ( ) ) {
vertexCount = indexGen . PureCount ( ) ;
}
2013-08-23 15:24:51 +00:00
prim = indexGen . Prim ( ) ;
2014-09-17 20:03:44 +00:00
}
2014-09-13 11:53:04 +00:00
2015-01-04 17:00:59 +00:00
VERBOSE_LOG ( G3D , " Flush prim %i! %i verts in one go " , prim , vertexCount ) ;
2014-09-17 20:03:44 +00:00
bool hasColor = ( lastVType_ & GE_VTYPE_COL_MASK ) ! = GE_VTYPE_COL_NONE ;
if ( gstate . isModeThrough ( ) ) {
gstate_c . vertexFullAlpha = gstate_c . vertexFullAlpha & & ( hasColor | | gstate . getMaterialAmbientA ( ) = = 255 ) ;
} else {
gstate_c . vertexFullAlpha = gstate_c . vertexFullAlpha & & ( ( hasColor & & ( gstate . materialupdate & 1 ) ) | | gstate . getMaterialAmbientA ( ) = = 255 ) & & ( ! gstate . isLightingEnabled ( ) | | gstate . getAmbientA ( ) = = 255 ) ;
}
2014-09-13 11:53:04 +00:00
2015-03-18 05:07:09 +00:00
ApplyDrawStateLate ( ) ;
vshader = shaderManager_ - > ApplyShader ( prim , lastVType_ ) ;
2014-09-17 20:03:44 +00:00
IDirect3DVertexDeclaration9 * pHardwareVertexDecl = SetupDecFmtForDraw ( vshader , dec_ - > GetDecVtxFmt ( ) , dec_ - > VertexType ( ) ) ;
2014-09-13 11:53:04 +00:00
2014-09-17 20:03:44 +00:00
if ( pHardwareVertexDecl ) {
2017-02-05 19:36:00 +00:00
device_ - > SetVertexDeclaration ( pHardwareVertexDecl ) ;
2014-09-17 20:03:44 +00:00
if ( vb_ = = NULL ) {
if ( useElements ) {
2017-02-05 19:36:00 +00:00
device_ - > DrawIndexedPrimitiveUP ( glprim [ prim ] , 0 , maxIndex + 1 , D3DPrimCount ( glprim [ prim ] , vertexCount ) , decIndex , D3DFMT_INDEX16 , decoded , dec_ - > GetDecVtxFmt ( ) . stride ) ;
2014-09-13 11:53:04 +00:00
} else {
2017-02-05 19:36:00 +00:00
device_ - > DrawPrimitiveUP ( glprim [ prim ] , D3DPrimCount ( glprim [ prim ] , vertexCount ) , decoded , dec_ - > GetDecVtxFmt ( ) . stride ) ;
2014-09-13 11:53:04 +00:00
}
2014-09-17 20:03:44 +00:00
} else {
2017-02-05 19:36:00 +00:00
device_ - > SetStreamSource ( 0 , vb_ , 0 , dec_ - > GetDecVtxFmt ( ) . stride ) ;
2014-09-13 11:53:04 +00:00
2014-09-17 20:03:44 +00:00
if ( useElements ) {
2017-02-05 19:36:00 +00:00
device_ - > SetIndices ( ib_ ) ;
2014-09-13 11:53:04 +00:00
2017-02-05 19:36:00 +00:00
device_ - > DrawIndexedPrimitive ( glprim [ prim ] , 0 , 0 , maxIndex + 1 , 0 , D3DPrimCount ( glprim [ prim ] , vertexCount ) ) ;
2014-09-17 20:03:44 +00:00
} else {
2017-02-05 19:36:00 +00:00
device_ - > DrawPrimitive ( glprim [ prim ] , 0 , D3DPrimCount ( glprim [ prim ] , vertexCount ) ) ;
2014-09-13 11:53:04 +00:00
}
2014-09-17 20:03:44 +00:00
}
}
} else {
2017-11-19 11:38:52 +00:00
DecodeVerts ( decoded ) ;
2014-09-17 20:03:44 +00:00
bool hasColor = ( lastVType_ & GE_VTYPE_COL_MASK ) ! = GE_VTYPE_COL_NONE ;
if ( gstate . isModeThrough ( ) ) {
gstate_c . vertexFullAlpha = gstate_c . vertexFullAlpha & & ( hasColor | | gstate . getMaterialAmbientA ( ) = = 255 ) ;
} else {
gstate_c . vertexFullAlpha = gstate_c . vertexFullAlpha & & ( ( hasColor & & ( gstate . materialupdate & 1 ) ) | | gstate . getMaterialAmbientA ( ) = = 255 ) & & ( ! gstate . isLightingEnabled ( ) | | gstate . getAmbientA ( ) = = 255 ) ;
}
2014-09-13 11:53:04 +00:00
2014-09-17 20:03:44 +00:00
gpuStats . numUncachedVertsDrawn + = indexGen . VertexCount ( ) ;
prim = indexGen . Prim ( ) ;
// Undo the strip optimization, not supported by the SW code yet.
if ( prim = = GE_PRIM_TRIANGLE_STRIP )
prim = GE_PRIM_TRIANGLES ;
2015-01-04 17:00:59 +00:00
VERBOSE_LOG ( G3D , " Flush prim %i SW! %i verts in one go " , prim , indexGen . VertexCount ( ) ) ;
2014-09-17 20:03:44 +00:00
int numTrans = 0 ;
bool drawIndexed = false ;
u16 * inds = decIndex ;
TransformedVertex * drawBuffer = NULL ;
2017-12-02 08:58:13 +00:00
SoftwareTransformResult result { } ;
SoftwareTransformParams params { } ;
2016-03-12 21:37:08 +00:00
params . decoded = decoded ;
params . transformed = transformed ;
params . transformedExpanded = transformedExpanded ;
params . fbman = framebufferManager_ ;
params . texCache = textureCache_ ;
2017-12-02 08:58:13 +00:00
params . allowClear = true ;
2016-03-12 21:37:08 +00:00
params . allowSeparateAlphaClear = true ;
2015-01-15 22:58:07 +00:00
int maxIndex = indexGen . MaxIndex ( ) ;
2014-09-17 20:03:44 +00:00
SoftwareTransform (
2016-03-12 21:37:08 +00:00
prim , indexGen . VertexCount ( ) ,
2015-01-15 20:26:35 +00:00
dec_ - > VertexType ( ) , inds , GE_VTYPE_IDX_16BIT , dec_ - > GetDecVtxFmt ( ) ,
2016-03-12 21:37:08 +00:00
maxIndex , drawBuffer , numTrans , drawIndexed , & params , & result ) ;
2014-09-17 20:03:44 +00:00
2015-09-13 13:53:25 +00:00
ApplyDrawStateLate ( ) ;
vshader = shaderManager_ - > ApplyShader ( prim , lastVType_ ) ;
2014-09-17 20:03:44 +00:00
if ( result . action = = SW_DRAW_PRIMITIVES ) {
if ( result . setStencil ) {
dxstate . stencilFunc . set ( D3DCMP_ALWAYS , result . stencilValue , 255 ) ;
2014-09-13 11:53:04 +00:00
}
2014-09-17 20:03:44 +00:00
// TODO: Add a post-transform cache here for multi-RECTANGLES only.
// Might help for text drawing.
// these spam the gDebugger log.
const int vertexSize = sizeof ( transformed [ 0 ] ) ;
2017-02-05 19:36:00 +00:00
device_ - > SetVertexDeclaration ( transformedVertexDecl_ ) ;
2014-09-17 20:03:44 +00:00
if ( drawIndexed ) {
2017-02-05 19:36:00 +00:00
device_ - > DrawIndexedPrimitiveUP ( glprim [ prim ] , 0 , maxIndex , D3DPrimCount ( glprim [ prim ] , numTrans ) , inds , D3DFMT_INDEX16 , drawBuffer , sizeof ( TransformedVertex ) ) ;
2014-09-17 20:03:44 +00:00
} else {
2017-02-05 19:36:00 +00:00
device_ - > DrawPrimitiveUP ( glprim [ prim ] , D3DPrimCount ( glprim [ prim ] , numTrans ) , drawBuffer , sizeof ( TransformedVertex ) ) ;
2014-09-17 20:03:44 +00:00
}
} else if ( result . action = = SW_CLEAR ) {
u32 clearColor = result . color ;
float clearDepth = result . depth ;
int mask = gstate . isClearModeColorMask ( ) ? D3DCLEAR_TARGET : 0 ;
if ( gstate . isClearModeAlphaMask ( ) ) mask | = D3DCLEAR_STENCIL ;
if ( gstate . isClearModeDepthMask ( ) ) mask | = D3DCLEAR_ZBUFFER ;
if ( mask & D3DCLEAR_ZBUFFER ) {
framebufferManager_ - > SetDepthUpdated ( ) ;
}
if ( mask & D3DCLEAR_TARGET ) {
2015-07-26 20:38:40 +00:00
framebufferManager_ - > SetColorUpdated ( gstate_c . skipDrawReason ) ;
2014-09-17 20:03:44 +00:00
}
dxstate . colorMask . set ( ( mask & D3DCLEAR_TARGET ) ! = 0 , ( mask & D3DCLEAR_TARGET ) ! = 0 , ( mask & D3DCLEAR_TARGET ) ! = 0 , ( mask & D3DCLEAR_STENCIL ) ! = 0 ) ;
2017-02-05 19:36:00 +00:00
device_ - > Clear ( 0 , NULL , mask , SwapRB ( clearColor ) , clearDepth , clearColor > > 24 ) ;
2016-05-20 03:55:34 +00:00
int scissorX2 = gstate . getScissorX2 ( ) + 1 ;
int scissorY2 = gstate . getScissorY2 ( ) + 1 ;
framebufferManager_ - > SetSafeSize ( scissorX2 , scissorY2 ) ;
2017-01-28 09:04:50 +00:00
if ( g_Config . bBlockTransferGPU & & ( gstate_c . featureFlags & GPU_USE_CLEAR_RAM_HACK ) & & gstate . isClearModeColorMask ( ) & & ( gstate . isClearModeAlphaMask ( ) | | gstate . FrameBufFormat ( ) = = GE_FORMAT_565 ) ) {
2017-02-13 00:22:55 +00:00
int scissorX1 = gstate . getScissorX1 ( ) ;
int scissorY1 = gstate . getScissorY1 ( ) ;
2017-04-09 22:10:07 +00:00
framebufferManager_ - > ApplyClearToMemory ( scissorX1 , scissorY1 , scissorX2 , scissorY2 , clearColor ) ;
2016-09-19 02:40:44 +00:00
}
2013-08-21 09:10:56 +00:00
}
2014-09-17 20:03:44 +00:00
}
2014-10-19 18:25:04 +00:00
gpuStats . numDrawCalls + = numDrawCalls ;
2017-06-02 10:03:46 +00:00
gpuStats . numVertsSubmitted + = vertexCountInDrawCalls_ ;
2014-10-19 18:25:04 +00:00
2014-09-17 20:03:44 +00:00
indexGen . Reset ( ) ;
decodedVerts_ = 0 ;
numDrawCalls = 0 ;
2017-06-02 10:03:46 +00:00
vertexCountInDrawCalls_ = 0 ;
2014-09-17 20:03:44 +00:00
decodeCounter_ = 0 ;
dcid_ = 0 ;
prevPrim_ = GE_PRIM_INVALID ;
gstate_c . vertexFullAlpha = true ;
2015-07-26 20:38:40 +00:00
framebufferManager_ - > SetColorUpdated ( gstate_c . skipDrawReason ) ;
2013-08-17 09:23:51 +00:00
2015-03-16 04:38:01 +00:00
// Now seems as good a time as any to reset the min/max coords, which we may examine later.
2015-09-13 21:52:10 +00:00
gstate_c . vertBounds . minU = 512 ;
gstate_c . vertBounds . minV = 512 ;
gstate_c . vertBounds . maxU = 0 ;
gstate_c . vertBounds . maxV = 0 ;
2015-03-16 04:38:01 +00:00
2014-09-17 20:03:44 +00:00
host - > GPUNotifyDraw ( ) ;
2013-08-17 09:23:51 +00:00
}
2014-08-24 12:21:35 +00:00
2017-02-08 17:07:34 +00:00
void DrawEngineDX9 : : TessellationDataTransferDX9 : : SendDataToShader ( const float * pos , const float * tex , const float * col , int size , bool hasColor , bool hasTexCoords )
2017-01-10 05:41:01 +00:00
{
}
2013-11-15 13:24:25 +00:00
} // namespace