RenderLoop optimization

willnode · willnode · commit 00081d15c646 · 2019-05-30T01:55:34.000+07:00
Avoid std::vector on render loop: Buffer3 + BufferGL.
std::vector -&gt; array pointer.
Result: Perf improvement from 30 FPS -&gt; 500 FPS.
diff --git a/source/CMakeLists.txt b/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
 )
 
diff --git a/source/common/Buffer3.h b/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;
 		}
 
 	};
diff --git a/source/common/BufferGL.h b/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++];
+				}
+
 			}
 		}
 	};
diff --git a/source/extras/Utils.h b/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
diff --git a/source/math/Vector3.h b/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;
diff --git a/source/math/Vector4.h b/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;
 	}
diff --git a/source/rendering/CrossSection.cpp b/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);
 		}
 
 		{
diff --git a/source/rendering/CrossSection.h b/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>
diff --git a/source/rendering/Model4.h b/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
diff --git a/source/rendering/Projector4.cpp b/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]);
 	}
 }
diff --git a/source/rendering/Scene4.h b/source/rendering/Scene4.h
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace Forth
+{
+
+}
diff --git a/source/visualizer/ParticleVisualizer.h b/source/visualizer/ParticleVisualizer.h
@@ -30,7 +30,7 @@ namespace Forth
 		// Because it's a segment, count is expected to be 2
 		void Render(const Vector4 *buffer, int count) override
 		{
-			buff->AddTris((int)buff->vertices.size());
+			buff->AddTris((int)buff->vertices_count);
 			buff->AddVert(buffer[0].ToVec3());
 		}
 
diff --git a/source/visualizer/SolidVisualizer.cpp b/source/visualizer/SolidVisualizer.cpp
@@ -1,20 +1,21 @@
 #include "SolidVisualizer.h"
 
-namespace Forth {
+namespace Forth
+{
 
 	SolidVisualizer::SolidVisualizer() {}
 
-	void SolidVisualizer::Initialize(Buffer3 & buffer)
+	void SolidVisualizer::Initialize(Buffer3 &buffer)
 	{
 		buff = &buffer;
 		buff->Clear();
 		buff->simplex = SimplexMode::SM_Triangle;
 	}
 
-	void SolidVisualizer::Render(const Vector4 * buffer, int count)
+	void SolidVisualizer::Render(const Vector4 *buffer, int count)
 	{
 		Buffer3 &b = *buff;
-		int o = (int)b.vertices.size();
+		int o = b.vertices_count;
 		b.AddVert(buffer[0].ToVec3());
 		b.AddVert(buffer[1].ToVec3());
 		for (int i = 2; i < count; i++)
@@ -31,17 +32,17 @@ namespace Forth {
 
 	void SolidVisualizer::RefineTriangleOrder()
 	{
-		std::vector<int> &t = buff->indices;
-		std::vector<Vector3> &v = buff->vertices;
+		int *t = buff->indices;
+		Vector3 *v = buff->vertices;
 
-		Vector3 median = GetAverage(v);
+		Vector3 median = GetAverage(buff->vertices, buff->vertices_count) - Vector3(.1e-4f);
 
-		for (size_t i = 0; i < t.size(); i += 3)
+		for (int i = 0; i < buff->indices_count; i += 3)
 		{
 			int a = t[i], b = t[i + 1], c = t[i + 2];
 			Vector3 &va = v[a];
 			Vector3 N = Cross(v[c] - va, v[b] - va);
-			if (Dot(N, median) < Dot(N, va))
+			if (Dot(N, median - va) < 0)
 			{
 				// Flip
 				t[i] = c;
@@ -50,13 +51,12 @@ namespace Forth {
 		}
 	}
 
-	Vector3 SolidVisualizer::GetAverage(const std::vector<Vector3>& v)
+	Vector3 SolidVisualizer::GetAverage(const Vector3 *v, const int size)
 	{
 		Vector3 median = Vector3();
-		size_t size = v.size();
 		for (size_t i = size; i-- > 0;)
 			median += v[i];
 		return median / (float)size;
 	}
 
-}
+} // namespace Forth
diff --git a/source/visualizer/SolidVisualizer.h b/source/visualizer/SolidVisualizer.h
@@ -32,7 +32,7 @@ namespace Forth
 		/// </summary>
 		void RefineTriangleOrder(void);
 
-		Vector3 GetAverage(const std::vector<Vector3> &v);
+		Vector3 GetAverage(const Vector3* v, const int size);
 	};
 
 } // namespace Forth
diff --git a/source/visualizer/WireVisualizer.h b/source/visualizer/WireVisualizer.h
@@ -30,7 +30,7 @@ namespace Forth
 		{
 			for (int i = 0; i < count; i++)
 			{
-				buff->AddTris((int)buff->vertices.size());
+				buff->AddTris(buff->vertices_count);
 				buff->AddVert(buffer[i].ToVec3());
 			}
 		}

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ set(forth_common_srcs`
`12`	`12`	`set(forth_extras_srcs`
`13`	`13`	`extras/MeshGen.h`
`14`	`14`	`extras/MeshGen.cpp`
	`15`	`+ extras/Utils.h`
`15`	`16`	`)`
`16`	`17`
`17`	`18`	`set(forth_math_srcs`
`@@ -33,6 +34,7 @@ set(forth_rendering_srcs`
`33`	`34`	`rendering/Model4.h`
`34`	`35`	`rendering/Projector4.cpp`
`35`	`36`	`rendering/Projector4.h`
	`37`	`+ rendering/Scene4.h`
`36`	`38`	`rendering/Visualizer4.h`
`37`	`39`	`)`
`38`	`40`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "../math/Vector3.h"`
`4`	`4`	`#include "../common/Color.h"`
	`5`	`+#include "../extras/Utils.h"`
`5`	`6`	`#include "VertexProfile.h"`
`6`	`7`	`#include "Enums.h"`
`7`	`8`	`#include <vector>`
`@@ -10,44 +11,49 @@ namespace Forth`
`10`	`11`	`{`
`11`	`12`	`struct Buffer3`
`12`	`13`	`{`
`13`		`- std::vector<Vector3> vertices;`
`14`		`- std::vector<int> indices;`
	`14`	`+ FORTH_ARRAY(vertices, Vector3);`
	`15`	`+ FORTH_ARRAY(indices, int);`
`15`	`16`	`Forth::SimplexMode simplex;`
`16`	`17`
`17`	`18`	`Buffer3() { simplex = SM_Triangle; }`
`18`	`19`
`19`	`20`	`~Buffer3(void)`
`20`	`21`	`{`
`21`		`- Clear();`
	`22`	`+ delete[] vertices;`
	`23`	`+ delete[] indices;`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`void Clear(void)`
`25`	`27`	`{`
`26`		`- vertices.clear();`
`27`		`- indices.clear();`
	`28`	`+ vertices_count = 0;`
	`29`	`+ indices_count = 0;`
`28`	`30`	`}`
`29`	`31`
`30`	`32`	`void AddVert(const Vector3 &v)`
`31`	`33`	`{`
`32`		`- vertices.push_back(v);`
	`34`	`+ EnsureCapacity(&vertices, vertices_count, &vertices_cap, vertices_count + 1);`
	`35`	`+ vertices[vertices_count++] = v;`
`33`	`36`	`}`
`34`	`37`
`35`	`38`	`void AddTris(const int a)`
`36`	`39`	`{`
`37`		`- indices.push_back(a);`
	`40`	`+ EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 1);`
	`41`	`+ indices[indices_count++] = a;`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`void AddTris(const int a, const int b)`
`41`	`45`	`{`
`42`		`- indices.push_back(a);`
`43`		`- indices.push_back(b);`
	`46`	`+ EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 2);`
	`47`	`+ indices[indices_count++] = a;`
	`48`	`+ indices[indices_count++] = b;`
`44`	`49`	`}`
`45`	`50`
`46`	`51`	`void AddTris(const int a, const int b, const int c)`
`47`	`52`	`{`
`48`		`- indices.push_back(a);`
`49`		`- indices.push_back(b);`
`50`		`- indices.push_back(c);`
	`53`	`+ EnsureCapacity(&indices, indices_count, &indices_cap, indices_count + 3);`
	`54`	`+ indices[indices_count++] = a;`
	`55`	`+ indices[indices_count++] = b;`
	`56`	`+ indices[indices_count++] = c;`
`51`	`57`	`}`
`52`	`58`
`53`	`59`	`};`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ namespace Forth`
`52`	`52`	`return *this;`
`53`	`53`	`}`
`54`	`54`
`55`		`- Vector3& operator*=(float f)`
	`55`	`+ Vector3& operator*=(const float f)`
`56`	`56`	`{`
`57`	`57`	`x *= f;`
`58`	`58`	`y *= f;`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ namespace Forth`
`94`	`94`	`return *this;`
`95`	`95`	`}`
`96`	`96`
`97`		`- Vector4& operator*=(float f)`
	`97`	`+ Vector4& operator*=(const float f)`
`98`	`98`	`{`
`99`	`99`	`x *= f;`
`100`	`100`	`y *= f;`
`@@ -148,7 +148,7 @@ namespace Forth`
`148`	`148`	`/// <summary>`
`149`	`149`	`/// Axis-wisely scale vector values with a number.`
`150`	`150`	`/// </summary>`
`151`		`- const Vector4 operator*(float f) const`
	`151`	`+ const Vector4 operator*(const float f) const`
`152`	`152`	`{`
`153`	`153`	`return Vector4(x * f, y * f, z * f, w * f);`
`154`	`154`	`}`
`@@ -233,7 +233,7 @@ namespace Forth`
`233`	`233`	`/// Interpolate two vector by T and clamp.`
`234`	`234`	`/// </summary>`
`235`	`235`	`/// <remarks> The interpolation is clamped between zero to one </remarks>`
`236`		`- inline Vector4 Lerp(const Vector4& a, const Vector4& b, float t)`
	`236`	`+ inline Vector4 Lerp(const Vector4& a, const Vector4& b, const float t)`
`237`	`237`	`{`
`238`	`238`	`return a + (b - a) * Clamp01(t);`
`239`	`239`	`}`
`@@ -242,7 +242,7 @@ namespace Forth`
`242`	`242`	`/// Interpolate two vector by T.`
`243`	`243`	`/// </summary>`
`244`	`244`	`/// <remarks> The interpolation is not clamped. </remarks>`
`245`		`- inline Vector4 LerpUnclamped(const Vector4& a, const Vector4& b, float t)`
	`245`	`+ inline Vector4 LerpUnclamped(const Vector4& a, const Vector4& b, const float t)`
`246`	`246`	`{`
`247`	`247`	`return a + (b - a) * t;`
`248`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -85,13 +85,14 @@ namespace Forth`
`85`	`85`	`void CrossSection::Project(const Buffer4 &source, const Transform4 &transform, Visualizer4 *dest)`
`86`	`86`	`{`
`87`	`87`	`viewmodel = view * transform;`
`88`		`- sides.clear();`
	`88`	`+`
	`89`	`+ EnsureCapacity(&sides, 0, &sides_cap, source.verticeCount);`
`89`	`90`	`{`
`90`	`91`	`// faster than "sides[i] = viewmodel * source.vertices[i] > 0"`
`91`	`92`	`Vector4 &vmw = viewmodel.rotation.ew;`
`92`		`- float vmwp = -viewmodel.position.w;`
`93`		`- for (int i = 0; i < source.verticeCount; i++)`
`94`		`- sides.push_back(Dot(vmw, source.vertices[i]) > vmwp);`
	`93`	`+ float vmwp = viewmodel.position.w;`
	`94`	`+ for (int i = 0; i < source.verticeCount; ++i)`
	`95`	`+ sides[i] = (Dot(vmw, source.vertices[i]) < vmwp);`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "../math/Transform4.h"`
`4`	`4`	`#include "Projector4.h"`
	`5`	`+#include "../extras/Utils.h"`
`5`	`6`	`#include <vector>`
`6`	`7`
`7`	`8`	`namespace Forth`
`@@ -10,7 +11,8 @@ namespace Forth`
`10`	`11`	`{`
`11`	`12`
`12`	`13`	`Transform4 view, viewmodel;`
`13`		`- std::vector<bool> sides;`
	`14`	`+ bool* sides = new bool[4];`
	`15`	`+ int sides_cap = 4;`
`14`	`16`	`Vector4 _temp[4];`
`15`	`17`	`VertexProfile _temp2[4];`
`16`	`18`
`@@ -28,7 +30,7 @@ namespace Forth`
`28`	`30`
`29`	`31`	`~CrossSection(void)`
`30`	`32`	`{`
`31`		`- sides.clear();`
	`33`	`+ delete[] sides;`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-#pragma once`
`2`	`1`
`3`	`2`	`#include "Projector4.h"`
`4`	`3`
`@@ -21,8 +20,8 @@ namespace Forth`
`21`	`20`
`22`	`21`	`Projector4::~Projector4()`
`23`	`22`	`{`
`24`		`- delete defaultVisualizers[SM_Point];`
`25`		`- delete defaultVisualizers[SM_Line];`
`26`		`- delete defaultVisualizers[SM_Triangle];`
	`23`	`+ delete (ParticleVisualizer*)(defaultVisualizers[SM_Point]);`
	`24`	`+ delete (WireVisualizer*)(defaultVisualizers[SM_Line]);`
	`25`	`+ delete (SolidVisualizer*)(defaultVisualizers[SM_Triangle]);`
`27`	`26`	`}`
`28`	`27`	`}`