Some unification in DrawEngine

GPU/Common/DrawEngineCommon.cpp

@@ -131,7 +131,7 @@ u32 DrawEngineCommon::NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr,
 	return DrawEngineCommon::NormalizeVertices(outPtr, bufPtr, inPtr, dec, lowerBound, upperBound, vertType);
 }
 
-// This code is HIGHLY unoptimized!
+// This code has plenty of potential for optimization.
 //
 // It does the simplest and safest test possible: If all points of a bbox is outside a single of
 // our clipping planes, we reject the box. Tighter bounds would be desirable but would take more calculations.
@@ -195,7 +195,6 @@ bool DrawEngineCommon::TestBoundingBox(void* control_points, int vertexCount, u3
 		// Any out. For testing that the planes are in the right locations.
 		// if (out != 0) return false;
 	}
-
 	return true;
 }
 
@@ -311,7 +310,6 @@ bool DrawEngineCommon::GetCurrentSimpleVertices(int count, std::vector<GPUDebugV
 	return true;
 }
 
-
 // This normalizes a set of vertices in any format to SimpleVertex format, by processing away morphing AND skinning.
 // The rest of the transform pipeline like lighting will go as normal, either hardware or software.
 // The implementation is initially a bit inefficient but shouldn't be a big deal.
@@ -442,3 +440,156 @@ bool DrawEngineCommon::ApplyShaderBlending() {
 	gstate_c.Dirty(DIRTY_SHADERBLEND);
 	return true;
 }
+
+void DrawEngineCommon::DecodeVertsStep(u8 *dest, int &i, int &decodedVerts) {
+	PROFILE_THIS_SCOPE("vertdec");
+
+	const DeferredDrawCall &dc = drawCalls[i];
+
+	indexGen.SetIndex(decodedVerts);
+	int indexLowerBound = dc.indexLowerBound;
+	int indexUpperBound = dc.indexUpperBound;
+
+	void *inds = dc.inds;
+	if (dc.indexType == GE_VTYPE_IDX_NONE >> GE_VTYPE_IDX_SHIFT) {
+		// Decode the verts and apply morphing. Simple.
+		dec_->DecodeVerts(dest + decodedVerts * (int)dec_->GetDecVtxFmt().stride,
+			dc.verts, indexLowerBound, indexUpperBound);
+		decodedVerts += indexUpperBound - indexLowerBound + 1;
+		indexGen.AddPrim(dc.prim, dc.vertexCount);
+	} else {
+		// It's fairly common that games issue long sequences of PRIM calls, with differing
+		// inds pointer but the same base vertex pointer. We'd like to reuse vertices between
+		// these as much as possible, so we make sure here to combine as many as possible
+		// into one nice big drawcall, sharing data.
+
+		// 1. Look ahead to find the max index, only looking as "matching" drawcalls.
+		//    Expand the lower and upper bounds as we go.
+		int lastMatch = i;
+		const int total = numDrawCalls;
+		for (int j = i + 1; j < total; ++j) {
+			if (drawCalls[j].verts != dc.verts)
+				break;
+
+			indexLowerBound = std::min(indexLowerBound, (int)drawCalls[j].indexLowerBound);
+			indexUpperBound = std::max(indexUpperBound, (int)drawCalls[j].indexUpperBound);
+			lastMatch = j;
+		}
+
+		// 2. Loop through the drawcalls, translating indices as we go.
+		switch (dc.indexType) {
+		case GE_VTYPE_IDX_8BIT >> GE_VTYPE_IDX_SHIFT:
+			for (int j = i; j <= lastMatch; j++) {
+				indexGen.TranslatePrim(drawCalls[j].prim, drawCalls[j].vertexCount, (const u8 *)drawCalls[j].inds, indexLowerBound);
+			}
+			break;
+		case GE_VTYPE_IDX_16BIT >> GE_VTYPE_IDX_SHIFT:
+			for (int j = i; j <= lastMatch; j++) {
+				indexGen.TranslatePrim(drawCalls[j].prim, drawCalls[j].vertexCount, (const u16_le *)drawCalls[j].inds, indexLowerBound);
+			}
+			break;
+		case GE_VTYPE_IDX_32BIT >> GE_VTYPE_IDX_SHIFT:
+			for (int j = i; j <= lastMatch; j++) {
+				indexGen.TranslatePrim(drawCalls[j].prim, drawCalls[j].vertexCount, (const u32_le *)drawCalls[j].inds, indexLowerBound);
+			}
+			break;
+		}
+
+		const int vertexCount = indexUpperBound - indexLowerBound + 1;
+
+		// This check is a workaround for Pangya Fantasy Golf, which sends bogus index data when switching items in "My Room" sometimes.
+		if (decodedVerts + vertexCount > VERTEX_BUFFER_MAX) {
+			return;
+		}
+
+		// 3. Decode that range of vertex data.
+		dec_->DecodeVerts(dest + decodedVerts * (int)dec_->GetDecVtxFmt().stride,
+			dc.verts, indexLowerBound, indexUpperBound);
+		decodedVerts += vertexCount;
+
+		// 4. Advance indexgen vertex counter.
+		indexGen.Advance(vertexCount);
+		i = lastMatch;
+	}
+}
+
+inline u32 ComputeMiniHashRange(const void *ptr, size_t sz) {
+	// Switch to u32 units.
+	const u32 *p = (const u32 *)ptr;
+	sz >>= 2;
+
+	if (sz > 100) {
+		size_t step = sz / 4;
+		u32 hash = 0;
+		for (size_t i = 0; i < sz; i += step) {
+			hash += DoReliableHash32(p + i, 100, 0x3A44B9C4);
+		}
+		return hash;
+	} else {
+		return p[0] + p[sz - 1];
+	}
+}
+
+u32 DrawEngineCommon::ComputeMiniHash() {
+	u32 fullhash = 0;
+	const int vertexSize = dec_->GetDecVtxFmt().stride;
+	const int indexSize = IndexSize(dec_->VertexType());
+
+	int step;
+	if (numDrawCalls < 3) {
+		step = 1;
+	} else if (numDrawCalls < 8) {
+		step = 4;
+	} else {
+		step = numDrawCalls / 8;
+	}
+	for (int i = 0; i < numDrawCalls; i += step) {
+		const DeferredDrawCall &dc = drawCalls[i];
+		if (!dc.inds) {
+			fullhash += ComputeMiniHashRange(dc.verts, vertexSize * dc.vertexCount);
+		} else {
+			int indexLowerBound = dc.indexLowerBound, indexUpperBound = dc.indexUpperBound;
+			fullhash += ComputeMiniHashRange((const u8 *)dc.verts + vertexSize * indexLowerBound, vertexSize * (indexUpperBound - indexLowerBound));
+			fullhash += ComputeMiniHashRange(dc.inds, indexSize * dc.vertexCount);
+		}
+	}
+
+	return fullhash;
+}
+
+ReliableHashType DrawEngineCommon::ComputeHash() {
+	ReliableHashType fullhash = 0;
+	const int vertexSize = dec_->GetDecVtxFmt().stride;
+	const int indexSize = IndexSize(dec_->VertexType());
+
+	// TODO: Add some caps both for numDrawCalls and num verts to check?
+	// It is really very expensive to check all the vertex data so often.
+	for (int i = 0; i < numDrawCalls; i++) {
+		const DeferredDrawCall &dc = drawCalls[i];
+		if (!dc.inds) {
+			fullhash += DoReliableHash((const char *)dc.verts, vertexSize * dc.vertexCount, 0x1DE8CAC4);
+		} else {
+			int indexLowerBound = dc.indexLowerBound, indexUpperBound = dc.indexUpperBound;
+			int j = i + 1;
+			int lastMatch = i;
+			while (j < numDrawCalls) {
+				if (drawCalls[j].verts != dc.verts)
+					break;
+				indexLowerBound = std::min(indexLowerBound, (int)dc.indexLowerBound);
+				indexUpperBound = std::max(indexUpperBound, (int)dc.indexUpperBound);
+				lastMatch = j;
+				j++;
+			}
+			// This could get seriously expensive with sparse indices. Need to combine hashing ranges the same way
+			// we do when drawing.
+			fullhash += DoReliableHash((const char *)dc.verts + vertexSize * indexLowerBound,
+				vertexSize * (indexUpperBound - indexLowerBound), 0x029F3EE1);
+			// Hm, we will miss some indices when combining above, but meh, it should be fine.
+			fullhash += DoReliableHash((const char *)dc.inds, indexSize * dc.vertexCount, 0x955FD1CA);
+			i = lastMatch;
+		}
+	}
+
+	fullhash += DoReliableHash(&uvScale[0], sizeof(uvScale[0]) * numDrawCalls, 0x0123e658);
+	return fullhash;
+}

GPU/Common/DrawEngineCommon.h

@@ -24,6 +24,7 @@
 
 #include "GPU/GPUState.h"
 #include "GPU/Common/GPUDebugInterface.h"
+#include "GPU/Common/IndexGenerator.h"
 #include "GPU/Common/VertexDecoderCommon.h"
 
 class VertexDecoder;
@@ -81,9 +82,9 @@ protected:
 	}
 
 	// Vertex collector buffers
-	u8 *decoded;
-	u16 *decIndex;
-	u8 *splineBuffer;
+	u8 *decoded = nullptr;
+	u16 *decIndex = nullptr;
+	u8 *splineBuffer = nullptr;
 
 	// Cached vertex decoders
 	u32 lastVType_ = -1;
@@ -92,12 +93,39 @@ protected:
 	VertexDecoderJitCache *decJitCache_;
 	VertexDecoderOptions decOptions_;
 
+	// Defer all vertex decoding to a "Flush" (except when software skinning)
+	struct DeferredDrawCall {
+		void *verts;
+		void *inds;
+		u32 vertType;
+		u8 indexType;
+		s8 prim;
+		u32 vertexCount;
+		u16 indexLowerBound;
+		u16 indexUpperBound;
+	};
+
+	enum { MAX_DEFERRED_DRAW_CALLS = 128 };
+	DeferredDrawCall drawCalls[MAX_DEFERRED_DRAW_CALLS];
+	int numDrawCalls = 0;
+	int vertexCountInDrawCalls_ = 0;
+	UVScale uvScale[MAX_DEFERRED_DRAW_CALLS];
+
+	int decimationCounter_ = 0;
+	int decodeCounter_ = 0;
+	u32 dcid_ = 0;
+
+	// Vertex collector state
+	IndexGenerator indexGen;
+	int decodedVerts_ = 0;
+	GEPrimitiveType prevPrim_ = GE_PRIM_INVALID;
+
 	// Fixed index buffer for easy quad generation from spline/bezier
-	u16 *quadIndices_;
+	u16 *quadIndices_ = nullptr;
 
 	// Shader blending state
-	bool fboTexNeedBind_;
-	bool fboTexBound_;
+	bool fboTexNeedBind_ = false;
+	bool fboTexBound_ = false;
 
 	// Hardware tessellation
 	int numPatches;

GPU/Common/IndexGenerator.cpp

@@ -15,6 +15,7 @@
 // Official git repository and contact information can be found at
 // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
 
+#include <cstring>
 #include "IndexGenerator.h"
 
 #include "Common/Common.h"
@@ -211,16 +212,24 @@ void IndexGenerator::TranslateLineStrip(int numInds, const ITypeLE *inds, int in
 template <class ITypeLE, int flag>
 void IndexGenerator::TranslateList(int numInds, const ITypeLE *inds, int indexOffset) {
 	indexOffset = index_ - indexOffset;
-	u16 *outInds = inds_;
-	int numTris = numInds / 3;  // Round to whole triangles
-	numInds = numTris * 3;
-	for (int i = 0; i < numInds; i += 3) {
-		*outInds++ = indexOffset + inds[i];
-		*outInds++ = indexOffset + inds[i + 1];
-		*outInds++ = indexOffset + inds[i + 2];
+	// We only bother doing this minor optimization in triangle list, since it's by far the most
+	// common operation that can benefit.
+	if (sizeof(ITypeLE) == sizeof(inds_[0]) && indexOffset == 0) {
+		memcpy(inds_, inds, numInds * sizeof(ITypeLE));
+		inds_ += numInds;
+		count_ += numInds;
+	} else {
+		u16 *outInds = inds_;
+		int numTris = numInds / 3;  // Round to whole triangles
+		numInds = numTris * 3;
+		for (int i = 0; i < numInds; i += 3) {
+			*outInds++ = indexOffset + inds[i];
+			*outInds++ = indexOffset + inds[i + 1];
+			*outInds++ = indexOffset + inds[i + 2];
+		}
+		inds_ = outInds;
+		count_ += numInds;
 	}
-	inds_ = outInds;
-	count_ += numInds;
 	prim_ = GE_PRIM_TRIANGLES;
 	seenPrims_ |= (1 << GE_PRIM_TRIANGLES) | flag;
 }

GPU/D3D11/DrawEngineD3D11.cpp

@@ -76,16 +76,8 @@ static const D3D11_INPUT_ELEMENT_DESC TransformedVertexElements[] = {
 DrawEngineD3D11::DrawEngineD3D11(Draw::DrawContext *draw, ID3D11Device *device, ID3D11DeviceContext *context)
 	: draw_(draw),
 		device_(device),
-		context_(context),
-		decodedVerts_(0),
-		prevPrim_(GE_PRIM_INVALID),
-		shaderManager_(0),
-		textureCache_(0),
-		framebufferManager_(0),
-		numDrawCalls(0),
-		vertexCountInDrawCalls_(0),
-		decodeCounter_(0),
-		dcid_(0) {
+		context_(context)
+{
 	device1_ = (ID3D11Device1 *)draw->GetNativeObject(Draw::NativeObject::DEVICE_EX);
 	context1_ = (ID3D11DeviceContext1 *)draw->GetNativeObject(Draw::NativeObject::CONTEXT_EX);
 	decOptions_.expandAllWeightsToFloat = true;

GPU/D3D11/DrawEngineD3D11.h

@@ -179,24 +179,6 @@ private:
 	ID3D11DeviceContext *context_;
 	ID3D11DeviceContext1 *context1_;
 
-	// Defer all vertex decoding to a Flush, so that we can hash and cache the
-	// generated buffers without having to redecode them every time.
-	struct DeferredDrawCall {
-		void *verts;
-		void *inds;
-		u32 vertType;
-		u8 indexType;
-		s8 prim;
-		u32 vertexCount;
-		u16 indexLowerBound;
-		u16 indexUpperBound;
-	};
-
-	// Vertex collector state
-	IndexGenerator indexGen;
-	int decodedVerts_;
-	GEPrimitiveType prevPrim_;
-	
 	TransformedVertex *transformed;
 	TransformedVertex *transformedExpanded;
 
@@ -217,26 +199,14 @@ private:
 	std::map<InputLayoutKey, ID3D11InputLayout *> inputLayoutMap_;
 
 	// Other
-	ShaderManagerD3D11 *shaderManager_;
-	TextureCacheD3D11 *textureCache_;
-	FramebufferManagerD3D11 *framebufferManager_;
+	ShaderManagerD3D11 *shaderManager_ = nullptr;
+	TextureCacheD3D11 *textureCache_ = nullptr;
+	FramebufferManagerD3D11 *framebufferManager_ = nullptr;
 
 	// Pushbuffers
 	PushBufferD3D11 *pushVerts_;
 	PushBufferD3D11 *pushInds_;
 
-	enum { MAX_DEFERRED_DRAW_CALLS = 128 };
-
-	DeferredDrawCall drawCalls[MAX_DEFERRED_DRAW_CALLS];
-	int numDrawCalls;
-	int vertexCountInDrawCalls_;
-
-	int decimationCounter_;
-	int decodeCounter_;
-	u32 dcid_;
-
-	UVScale uvScale[MAX_DEFERRED_DRAW_CALLS];
-
 	// D3D11 state object caches
 	std::map<uint64_t, ID3D11BlendState *> blendCache_;
 	std::map<uint64_t, ID3D11BlendState1 *> blendCache1_;

GPU/Directx9/DrawEngineDX9.cpp

@@ -85,16 +85,7 @@ static const D3DVERTEXELEMENT9 TransformedVertexElements[] = {
 	D3DDECL_END()
 };
 
-DrawEngineDX9::DrawEngineDX9(Draw::DrawContext *draw)
-	: decodedVerts_(0),
-		prevPrim_(GE_PRIM_INVALID),
-		shaderManager_(0),
-		textureCache_(0),
-		framebufferManager_(0),
-		numDrawCalls(0),
-		vertexCountInDrawCalls(0),
-		decodeCounter_(0),
-		dcid_(0) {
+DrawEngineDX9::DrawEngineDX9(Draw::DrawContext *draw) {
 	device_ = (LPDIRECT3DDEVICE9)draw->GetNativeObject(Draw::NativeObject::DEVICE);
 	decOptions_.expandAllWeightsToFloat = true;
 	decOptions_.expand8BitNormalsToFloat = true;
@@ -267,7 +258,7 @@ inline void DrawEngineDX9::SetupVertexDecoderInternal(u32 vertType) {
 }
 
 void DrawEngineDX9::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, int vertexCount, u32 vertType, int *bytesRead) {
-	if (!indexGen.PrimCompatible(prevPrim_, prim) || numDrawCalls >= MAX_DEFERRED_DRAW_CALLS || vertexCountInDrawCalls + vertexCount > VERTEX_BUFFER_MAX)
+	if (!indexGen.PrimCompatible(prevPrim_, prim) || numDrawCalls >= MAX_DEFERRED_DRAW_CALLS || vertexCountInDrawCalls_ + vertexCount > VERTEX_BUFFER_MAX)
 		Flush();
 
 	// TODO: Is this the right thing to do?
@@ -314,7 +305,7 @@ void DrawEngineDX9::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, in
 	uvScale[numDrawCalls] = gstate_c.uv;
 
 	numDrawCalls++;
-	vertexCountInDrawCalls += vertexCount;
+	vertexCountInDrawCalls_ += vertexCount;
 
 	if (g_Config.bSoftwareSkinning && (vertType & GE_VTYPE_WEIGHT_MASK)) {
 		DecodeVertsStep();
@@ -880,12 +871,12 @@ rotateVBO:
 	}
 
 	gpuStats.numDrawCalls += numDrawCalls;
-	gpuStats.numVertsSubmitted += vertexCountInDrawCalls;
+	gpuStats.numVertsSubmitted += vertexCountInDrawCalls_;
 
 	indexGen.Reset();
 	decodedVerts_ = 0;
 	numDrawCalls = 0;
-	vertexCountInDrawCalls = 0;
+	vertexCountInDrawCalls_ = 0;
 	decodeCounter_ = 0;
 	dcid_ = 0;
 	prevPrim_ = GE_PRIM_INVALID;

GPU/Directx9/DrawEngineDX9.h

@@ -167,51 +167,21 @@ private:
 	ReliableHashType ComputeHash();  // Reads deferred vertex data.
 	void MarkUnreliable(VertexArrayInfoDX9 *vai);
 
-	LPDIRECT3DDEVICE9 device_;
-
-	// Defer all vertex decoding to a Flush, so that we can hash and cache the
-	// generated buffers without having to redecode them every time.
-	struct DeferredDrawCall {
-		void *verts;
-		void *inds;
-		u32 vertType;
-		u8 indexType;
-		s8 prim;
-		u32 vertexCount;
-		u16 indexLowerBound;
-		u16 indexUpperBound;
-	};
-
-	// Vertex collector state
-	IndexGenerator indexGen;
-	int decodedVerts_;
-	GEPrimitiveType prevPrim_;
+	LPDIRECT3DDEVICE9 device_ = nullptr;
 	
-	TransformedVertex *transformed;
-	TransformedVertex *transformedExpanded;
+	TransformedVertex *transformed = nullptr;
+	TransformedVertex *transformedExpanded = nullptr;
 
 	std::unordered_map<u32, VertexArrayInfoDX9 *> vai_;
 	std::unordered_map<u32, IDirect3DVertexDeclaration9 *> vertexDeclMap_;
 
 	// SimpleVertex
-	IDirect3DVertexDeclaration9* transformedVertexDecl_;
+	IDirect3DVertexDeclaration9* transformedVertexDecl_ = nullptr;
 
 	// Other
-	ShaderManagerDX9 *shaderManager_;
-	TextureCacheDX9 *textureCache_;
-	FramebufferManagerDX9 *framebufferManager_;
-
-	enum { MAX_DEFERRED_DRAW_CALLS = 128 };
-
-	DeferredDrawCall drawCalls[MAX_DEFERRED_DRAW_CALLS];
-	int numDrawCalls;
-	int vertexCountInDrawCalls;
-
-	int decimationCounter_;
-	int decodeCounter_;
-	u32 dcid_;
-
-	UVScale uvScale[MAX_DEFERRED_DRAW_CALLS];
+	ShaderManagerDX9 *shaderManager_ = nullptr;
+	TextureCacheDX9 *textureCache_ = nullptr;
+	FramebufferManagerDX9 *framebufferManager_ = nullptr;
 
 	// Hardware tessellation
 	class TessellationDataTransferDX9 : public TessellationDataTransfer {

GPU/GLES/DrawEngineGLES.cpp

@@ -115,16 +115,7 @@ enum {
 
 enum { VAI_KILL_AGE = 120, VAI_UNRELIABLE_KILL_AGE = 240, VAI_UNRELIABLE_KILL_MAX = 4 };
 
-DrawEngineGLES::DrawEngineGLES()
-	: decodedVerts_(0),
-		prevPrim_(GE_PRIM_INVALID),
-		shaderManager_(nullptr),
-		textureCache_(nullptr),
-		framebufferManager_(nullptr),
-		numDrawCalls(0),
-		vertexCountInDrawCalls(0),
-		decodeCounter_(0),
-		dcid_(0) {
+DrawEngineGLES::DrawEngineGLES() {
 
 	decOptions_.expandAllWeightsToFloat = false;
 	decOptions_.expand8BitNormalsToFloat = false;
@@ -282,7 +273,7 @@ inline void DrawEngineGLES::SetupVertexDecoderInternal(u32 vertType) {
 }
 
 void DrawEngineGLES::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, int vertexCount, u32 vertType, int *bytesRead) {
-	if (!indexGen.PrimCompatible(prevPrim_, prim) || numDrawCalls >= MAX_DEFERRED_DRAW_CALLS || vertexCountInDrawCalls + vertexCount > VERTEX_BUFFER_MAX)
+	if (!indexGen.PrimCompatible(prevPrim_, prim) || numDrawCalls >= MAX_DEFERRED_DRAW_CALLS || vertexCountInDrawCalls_ + vertexCount > VERTEX_BUFFER_MAX)
 		Flush();
 
 	// TODO: Is this the right thing to do?
@@ -329,7 +320,7 @@ void DrawEngineGLES::SubmitPrim(void *verts, void *inds, GEPrimitiveType prim, i
 	uvScale[numDrawCalls] = gstate_c.uv;
 
 	numDrawCalls++;
-	vertexCountInDrawCalls += vertexCount;
+	vertexCountInDrawCalls_ += vertexCount;
 
 	if (g_Config.bSoftwareSkinning && (vertType & GE_VTYPE_WEIGHT_MASK)) {
 		DecodeVertsStep();
@@ -984,12 +975,12 @@ rotateVBO:
 	}
 
 	gpuStats.numDrawCalls += numDrawCalls;
-	gpuStats.numVertsSubmitted += vertexCountInDrawCalls;
+	gpuStats.numVertsSubmitted += vertexCountInDrawCalls_;
 
 	indexGen.Reset();
 	decodedVerts_ = 0;
 	numDrawCalls = 0;
-	vertexCountInDrawCalls = 0;
+	vertexCountInDrawCalls_ = 0;
 	decodeCounter_ = 0;
 	dcid_ = 0;
 	prevPrim_ = GE_PRIM_INVALID;

GPU/GLES/DrawEngineGLES.h

@@ -179,24 +179,6 @@ private:
 	ReliableHashType ComputeHash();  // Reads deferred vertex data.
 	void MarkUnreliable(VertexArrayInfo *vai);
 
-	// Defer all vertex decoding to a Flush, so that we can hash and cache the
-	// generated buffers without having to redecode them every time.
-	struct DeferredDrawCall {
-		void *verts;
-		void *inds;
-		u32 vertType;
-		u8 indexType;
-		s8 prim;
-		u32 vertexCount;
-		u16 indexLowerBound;
-		u16 indexUpperBound;
-	};
-
-	// Vertex collector state
-	IndexGenerator indexGen;
-	int decodedVerts_;
-	GEPrimitiveType prevPrim_;
-
 	TransformedVertex *transformed;
 	TransformedVertex *transformedExpanded;
 
@@ -215,26 +197,16 @@ private:
 	std::multimap<size_t, GLuint> freeSizedBuffers_;
 	std::unordered_map<GLuint, BufferNameInfo> bufferNameInfo_;
 	std::vector<GLuint> buffersThisFrame_;
-	size_t bufferNameCacheSize_;
-	GLuint sharedVao_;
+	size_t bufferNameCacheSize_ = 0;
+	GLuint sharedVao_ = 0;
 
 	// Other
-	ShaderManagerGLES *shaderManager_;
-	TextureCacheGLES *textureCache_;
-	FramebufferManagerGLES *framebufferManager_;
-	FragmentTestCacheGLES *fragmentTestCache_;
+	ShaderManagerGLES *shaderManager_ = nullptr;
+	TextureCacheGLES *textureCache_ = nullptr;
+	FramebufferManagerGLES *framebufferManager_ = nullptr;
+	FragmentTestCacheGLES *fragmentTestCache_ = nullptr;
 
-	enum { MAX_DEFERRED_DRAW_CALLS = 128 };
-	DeferredDrawCall drawCalls[MAX_DEFERRED_DRAW_CALLS];
-	int numDrawCalls;
-	int vertexCountInDrawCalls;
-
-	int decimationCounter_;
-	int bufferDecimationCounter_;
-	int decodeCounter_;
-	u32 dcid_;
-
-	UVScale uvScale[MAX_DEFERRED_DRAW_CALLS];
+	int bufferDecimationCounter_ = 0;
 
 	// Hardware tessellation
 	class TessellationDataTransferGLES : public TessellationDataTransfer {

GPU/Vulkan/DrawEngineVulkan.cpp

@@ -67,8 +67,6 @@ enum {
 DrawEngineVulkan::DrawEngineVulkan(VulkanContext *vulkan, Draw::DrawContext *draw)
 	:	vulkan_(vulkan),
 		draw_(draw),
-		prevPrim_(GE_PRIM_INVALID),
-		numDrawCalls(0),
 		curFrame_(0),
 		stats_{} {
 	decOptions_.expandAllWeightsToFloat = false;

GPU/Vulkan/DrawEngineVulkan.h

@@ -181,23 +181,6 @@ private:
 	int curFrame_;
 	FrameData frame_[2];
 
-	// Defer all vertex decoding to a "Flush" (except when software skinning)
-	struct DeferredDrawCall {
-		void *verts;
-		void *inds;
-		u32 vertType;
-		u8 indexType;
-		s8 prim;
-		u32 vertexCount;
-		u16 indexLowerBound;
-		u16 indexUpperBound;
-	};
-
-	// Vertex collector state
-	IndexGenerator indexGen;
-	int decodedVerts_ = 0;
-	GEPrimitiveType prevPrim_;
-
 	TransformedVertex *transformed = nullptr;
 	TransformedVertex *transformedExpanded = nullptr;
 
@@ -209,8 +192,6 @@ private:
 
 	VkSampler depalSampler_;
 
-	enum { MAX_DEFERRED_DRAW_CALLS = 128 };
-
 	// State cache
 	uint64_t dirtyUniforms_;
 	uint32_t baseUBOOffset;
@@ -224,15 +205,6 @@ private:
 	VulkanTexture *nullTexture_ = nullptr;
 	VkSampler nullSampler_ = VK_NULL_HANDLE;
 
-	DeferredDrawCall drawCalls[MAX_DEFERRED_DRAW_CALLS];
-	int numDrawCalls = 0;
-	int vertexCountInDrawCalls_ = 0;
-	UVScale uvScale[MAX_DEFERRED_DRAW_CALLS];
-
-	int decimationCounter_ = 0;
-	int decodeCounter_ = 0;
-	u32 dcid_;
-
 	DrawEngineVulkanStats stats_;
 
 	VulkanPipelineRasterStateKey pipelineKey_{};