libobs-d3d11: Avoid vector usage

Allocations need global heap lock, which is bad.

libobs-d3d11/d3d11-subsystem.cpp

@@ -15,6 +15,7 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ******************************************************************************/
 
+#include <cassert>
 #include <cinttypes>
 #include <util/base.h>
 #include <util/platform.h>
@@ -1439,24 +1440,28 @@ void gs_device::LoadVertexBufferData()
 	    curVertexShader == lastVertexShader)
 		return;
 
-	vector<ID3D11Buffer *> buffers;
-	vector<uint32_t> strides;
-	vector<uint32_t> offsets;
+	ID3D11Buffer *buffers[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
+	uint32_t strides[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
+	uint32_t offsets[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
+	UINT numBuffers{};
+
+	assert(curVertexShader->NumBuffersExpected() <= _countof(buffers));
+	assert(curVertexShader->NumBuffersExpected() <= _countof(strides));
+	assert(curVertexShader->NumBuffersExpected() <= _countof(offsets));
 
 	if (curVertexBuffer && curVertexShader) {
-		curVertexBuffer->MakeBufferList(curVertexShader, buffers,
-						strides);
+		numBuffers = curVertexBuffer->MakeBufferList(curVertexShader,
+							     buffers, strides);
 	} else {
-		size_t buffersToClear =
-			curVertexShader ? curVertexShader->NumBuffersExpected()
-					: 0;
-		buffers.resize(buffersToClear);
-		strides.resize(buffersToClear);
+		numBuffers = curVertexShader
+				     ? curVertexShader->NumBuffersExpected()
+				     : 0;
+		std::fill_n(buffers, numBuffers, nullptr);
+		std::fill_n(strides, numBuffers, 0);
 	}
 
-	offsets.resize(buffers.size());
-	context->IASetVertexBuffers(0, (UINT)buffers.size(), buffers.data(),
-				    strides.data(), offsets.data());
+	std::fill_n(offsets, numBuffers, 0);
+	context->IASetVertexBuffers(0, numBuffers, buffers, strides, offsets);
 
 	lastVertexBuffer = curVertexBuffer;
 	lastVertexShader = curVertexShader;

libobs-d3d11/d3d11-subsystem.hpp

@@ -364,9 +364,8 @@ struct gs_vertex_buffer : gs_obj {
 
 	void FlushBuffer(ID3D11Buffer *buffer, void *array, size_t elementSize);
 
-	void MakeBufferList(gs_vertex_shader *shader,
-			    vector<ID3D11Buffer *> &buffers,
-			    vector<uint32_t> &strides);
+	UINT MakeBufferList(gs_vertex_shader *shader, ID3D11Buffer **buffers,
+			    uint32_t *strides);
 
 	void InitBuffer(const size_t elementSize, const size_t numVerts,
 			void *array, ID3D11Buffer **buffer);

libobs-d3d11/d3d11-vertexbuffer.cpp

@@ -19,13 +19,15 @@
 #include <graphics/vec3.h>
 #include "d3d11-subsystem.hpp"
 
-static inline void PushBuffer(vector<ID3D11Buffer *> &buffers,
-			      vector<uint32_t> &strides, ID3D11Buffer *buffer,
+static inline void PushBuffer(UINT *refNumBuffers, ID3D11Buffer **buffers,
+			      uint32_t *strides, ID3D11Buffer *buffer,
 			      size_t elementSize, const char *name)
 {
+	const UINT numBuffers = *refNumBuffers;
 	if (buffer) {
-		buffers.push_back(buffer);
-		strides.push_back((uint32_t)elementSize);
+		buffers[numBuffers] = buffer;
+		strides[numBuffers] = (uint32_t)elementSize;
+		*refNumBuffers = numBuffers + 1;
 	} else {
 		blog(LOG_ERROR, "This vertex shader requires a %s buffer",
 		     name);
@@ -46,25 +48,27 @@ void gs_vertex_buffer::FlushBuffer(ID3D11Buffer *buffer, void *array,
 	device->context->Unmap(buffer, 0);
 }
 
-void gs_vertex_buffer::MakeBufferList(gs_vertex_shader *shader,
-				      vector<ID3D11Buffer *> &buffers,
-				      vector<uint32_t> &strides)
+UINT gs_vertex_buffer::MakeBufferList(gs_vertex_shader *shader,
+				      ID3D11Buffer **buffers, uint32_t *strides)
 {
-	PushBuffer(buffers, strides, vertexBuffer, sizeof(vec3), "point");
+	UINT numBuffers = 0;
+	PushBuffer(&numBuffers, buffers, strides, vertexBuffer, sizeof(vec3),
+		   "point");
 
 	if (shader->hasNormals)
-		PushBuffer(buffers, strides, normalBuffer, sizeof(vec3),
-			   "normal");
+		PushBuffer(&numBuffers, buffers, strides, normalBuffer,
+			   sizeof(vec3), "normal");
 	if (shader->hasColors)
-		PushBuffer(buffers, strides, colorBuffer, sizeof(uint32_t),
-			   "color");
+		PushBuffer(&numBuffers, buffers, strides, colorBuffer,
+			   sizeof(uint32_t), "color");
 	if (shader->hasTangents)
-		PushBuffer(buffers, strides, tangentBuffer, sizeof(vec3),
-			   "tangent");
+		PushBuffer(&numBuffers, buffers, strides, tangentBuffer,
+			   sizeof(vec3), "tangent");
 	if (shader->nTexUnits <= uvBuffers.size()) {
 		for (size_t i = 0; i < shader->nTexUnits; i++) {
-			buffers.push_back(uvBuffers[i]);
-			strides.push_back((uint32_t)uvSizes[i]);
+			buffers[numBuffers] = uvBuffers[i];
+			strides[numBuffers] = (uint32_t)uvSizes[i];
+			++numBuffers;
 		}
 	} else {
 		blog(LOG_ERROR,
@@ -72,6 +76,8 @@ void gs_vertex_buffer::MakeBufferList(gs_vertex_shader *shader,
 		     "texture buffers.",
 		     (uint32_t)shader->nTexUnits);
 	}
+
+	return numBuffers;
 }
 
 void gs_vertex_buffer::InitBuffer(const size_t elementSize,