RenderLoop optimization

Avoid std::vector on render loop: Buffer3 + BufferGL.
std::vector -> array pointer.
Result: Perf improvement from 30 FPS -> 500 FPS.

Author: willnode

source/CMakeLists.txt

@@ -12,6 +12,7 @@ set(forth_common_srcs
 set(forth_extras_srcs
     extras/MeshGen.h
     extras/MeshGen.cpp
+    extras/Utils.h
     )
 
 set(forth_math_srcs
@@ -33,6 +34,7 @@ set(forth_rendering_srcs
     rendering/Model4.h
     rendering/Projector4.cpp
     rendering/Projector4.h
+    rendering/Scene4.h
     rendering/Visualizer4.h
 )
 

source/common/Buffer3.h

@@ -2,6 +2,7 @@
 
 #include "../math/Vector3.h"
 #include "../common/Color.h"
+#include "../extras/Utils.h"
 #include "VertexProfile.h"
 #include "Enums.h"
 #include <vector>
@@ -10,44 +11,49 @@ namespace Forth
 {
 	struct Buffer3
 	{
-		std::vector<Vector3> vertices;
-		std::vector<int> indices;
+		FORTH_ARRAY(vertices, Vector3);
+		FORTH_ARRAY(indices, int);
 		Forth::SimplexMode simplex;
 
 		Buffer3() { simplex = SM_Triangle; }
 
 		~Buffer3(void)
 		{
-			Clear();
+			delete[] vertices;
+			delete[] indices;
 		}
 
 		void Clear(void)
 		{
-			vertices.clear();
-			indices.clear();
+			vertices_count = 0;
+			indices_count = 0;
 		}
 
 		void AddVert(const Vector3 &v)
 		{
-			vertices.push_back(v);
+			EnsureCapacity(&vertices, vertices_count, &vertices_cap, vertices_count + 1);
+			vertices[vertices_count++] = v;
 		}
 
 		void AddTris(const int a)
 		{
-			indices.push_back(a);
+			EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 1);
+			indices[indices_count++] = a;
 		}
 
 		void AddTris(const int a, const int b)
 		{
-			indices.push_back(a);
-			indices.push_back(b);
+			EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 2);
+			indices[indices_count++] = a;
+			indices[indices_count++] = b;
 		}
 
 		void AddTris(const int a, const int b, const int c)
 		{
-			indices.push_back(a);
-			indices.push_back(b);
-			indices.push_back(c);
+			EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 3);
+			indices[indices_count++] = a;
+			indices[indices_count++] = b;
+			indices[indices_count++] = c;
 		}
 
 	};

source/common/BufferGL.h

@@ -2,6 +2,7 @@
 
 #include "../common/Color.h"
 #include "../math/Vector3.h"
+#include "../extras/Utils.h"
 #include "Buffer3.h"
 #include "Enums.h"
 #include <vector>
@@ -11,26 +12,32 @@ namespace Forth
 	struct BufferGL
 	{
 		// Layout: 0-2 Position. 3-5 Normal
-		std::vector<float> vb;
+		FORTH_ARRAY(vb, float);
 
 		BufferGL(void) {}
 
 		~BufferGL(void)
 		{
-			Clear();
+			delete[] vb;
 		}
 
 		void Clear(void)
 		{
-			vb.clear();
+			vb_count = 0;
 		}
 
 		void Copy(const Buffer3 &v)
 		{
 			Clear();
-			size_t len = v.indices.size();
 
-			for (size_t i = 0; i < len;)
+			int len = v.indices_count;
+
+			const int BUFFER_PER_VERTEX = 6;
+			const int BUFFER_PER_TRIS = BUFFER_PER_VERTEX * 3;
+
+			EnsureCapacity(&vb, 0, &vb_cap, len * BUFFER_PER_VERTEX);
+
+			for (int i = 0; i < len;)
 			{
 				const int a = v.indices[i++],
 						  b = v.indices[i++],
@@ -49,7 +56,11 @@ namespace Forth
 				};
 				// clang-format on
 
-				vb.insert(vb.end(), arr, arr + 18);
+				for(int j = 0; j < BUFFER_PER_TRIS;)
+				{
+					vb[vb_count++] = arr[j++];
+				}
+
 			}
 		}
 	};

source/extras/Utils.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "../math/Math.h"
+
+namespace Forth
+{
+	template <typename T>
+	void EnsureCapacity(T **arr, const int count, int *cap, const int target)
+	{
+		if (*cap < target)
+		{
+			*cap = Max(target, *cap << 1);
+			T *newArr = new T[*cap];
+
+			if (count > 0)
+			{
+				memcpy(newArr, *arr, count * sizeof(T));
+			}
+
+			delete[] * arr;
+			*arr = newArr;
+		}
+	}
+
+#define FORTH_ARRAY(name, T) \
+	T *name = new T[4];      \
+	int name##_cap = 4;        \
+	int name##_count = 0
+
+} // namespace Forth

source/math/Vector3.h

@@ -52,7 +52,7 @@ namespace Forth
 			return *this;
 		}
 
-		Vector3& operator*=(float f)
+		Vector3& operator*=(const float f)
 		{
 			x *= f;
 			y *= f;

source/math/Vector4.h

@@ -94,7 +94,7 @@ namespace Forth
 			return *this;
 		}
 
-		Vector4& operator*=(float f)
+		Vector4& operator*=(const float f)
 		{
 			x *= f;
 			y *= f;
@@ -148,7 +148,7 @@ namespace Forth
 		/// <summary>
 		/// Axis-wisely scale vector values with a number.
 		/// </summary>
-		const Vector4 operator*(float f) const
+		const Vector4 operator*(const float f) const
 		{
 			return Vector4(x * f, y * f, z * f, w * f);
 		}
@@ -233,7 +233,7 @@ namespace Forth
 	/// Interpolate two vector by T and clamp.
 	/// </summary>
 	/// <remarks> The interpolation is clamped between zero to one </remarks>
-	inline Vector4 Lerp(const Vector4& a, const Vector4& b, float t)
+	inline Vector4 Lerp(const Vector4& a, const Vector4& b, const float t)
 	{
 		return a + (b - a) * Clamp01(t);
 	}
@@ -242,7 +242,7 @@ namespace Forth
 	/// Interpolate two vector by T.
 	/// </summary>
 	/// <remarks> The interpolation is **not** clamped. </remarks>
-	inline Vector4 LerpUnclamped(const Vector4& a, const Vector4& b, float t)
+	inline Vector4 LerpUnclamped(const Vector4& a, const Vector4& b, const float t)
 	{
 		return a + (b - a) * t;
 	}

source/rendering/CrossSection.cpp

@@ -85,13 +85,14 @@ namespace Forth
 	void CrossSection::Project(const Buffer4 &source, const Transform4 &transform, Visualizer4 *dest)
 	{
 		viewmodel = view * transform;
-		sides.clear();
+
+		EnsureCapacity(&sides, 0, &sides_cap, source.verticeCount);
 		{
 			// faster than "sides[i] = viewmodel * source.vertices[i] > 0"
 			Vector4 &vmw = viewmodel.rotation.ew;
-			float vmwp = -viewmodel.position.w;
-			for (int i = 0; i < source.verticeCount; i++)
-				sides.push_back(Dot(vmw, source.vertices[i]) > vmwp);
+			float vmwp = viewmodel.position.w;
+			for (int i = 0; i < source.verticeCount; ++i)
+				sides[i] = (Dot(vmw, source.vertices[i]) < vmwp);
 		}
 
 		{

source/rendering/CrossSection.h

@@ -2,6 +2,7 @@
 
 #include "../math/Transform4.h"
 #include "Projector4.h"
+#include "../extras/Utils.h"
 #include <vector>
 
 namespace Forth
@@ -10,7 +11,8 @@ namespace Forth
 	{
 
 		Transform4 view, viewmodel;
-		std::vector<bool> sides;
+		bool* sides = new bool[4];
+		int sides_cap = 4;
 		Vector4 _temp[4];
 		VertexProfile _temp2[4];
 
@@ -28,7 +30,7 @@ namespace Forth
 
 		~CrossSection(void)
 		{
-			sides.clear();
+			delete[] sides;
 		}
 
 		/// <summary>

source/rendering/Model4.h

@@ -18,12 +18,12 @@
 	do                                                                                                              \
 	{                                                                                                               \
 		glBindBuffer(GL_ARRAY_BUFFER, vb);                                                                          \
-		glBufferData(GL_ARRAY_BUFFER, model.driver.vb.size() * sizeof(float), &model.driver.vb[0], GL_STREAM_DRAW); \
+		glBufferData(GL_ARRAY_BUFFER, model.driver.vb_count * sizeof(float), &model.driver.vb[0], GL_STREAM_DRAW); \
 		glEnableVertexAttribArray(0);                                                                               \
 		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(0));                            \
 		glEnableVertexAttribArray(1);                                                                               \
 		glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float)));            \
-		glDrawArrays(GL_TRIANGLES, 0, model.driver.vb.size() / 6);                                                  \
+		glDrawArrays(GL_TRIANGLES, 0, model.driver.vb_count / 6);                                                  \
 	} while (0)
 
 namespace Forth

source/rendering/Projector4.cpp

@@ -1,4 +1,3 @@
-#pragma once
 
 #include "Projector4.h"
 
@@ -21,8 +20,8 @@ namespace Forth
 
 	Projector4::~Projector4()
 	{
-		delete defaultVisualizers[SM_Point];
-		delete defaultVisualizers[SM_Line];
-		delete defaultVisualizers[SM_Triangle];
+		delete (ParticleVisualizer*)(defaultVisualizers[SM_Point]);
+		delete (WireVisualizer*)(defaultVisualizers[SM_Line]);
+		delete (SolidVisualizer*)(defaultVisualizers[SM_Triangle]);
 	}
 }