Accumulated Fix for v0.2

+ Updated README
+ Added Frustum Projection
+ Added few math function utilities to ease procedural shape generations
+ Rendering Optimizations.
+ Fix some rendering and physics bug

Author: willnode

CMakeLists.txt

@@ -6,7 +6,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 endif()
 
-set(forth_version 0.1)
+set(forth_version 0.2)
 
 add_subdirectory(source)
 

README.md

@@ -8,14 +8,37 @@ Forth-Library is a Library to manipulate four dimensional objects via Cross Sect
 
 Forth-Library is part of higher project *Forth Engine*. Forth Engine is not just about displaying higher dimensional objects: There will be Physics, Scene Management, Import/Export, Graphics Patches, The Editor, etc.. It's future aim is to became a full blown Independent Game Engine.
 
-Playable demos is at [Forth-Engine/demo](https://github.com/forth-engine/demo)
+This Library does not depends on any other library except STL (Standard Libraries) implemented in C++11. Currently it's tested only in MSVC 15 (Windows). More platform and compiler supports is on the way.
 
-# Prelease Checklist
+Playable demos is at [Forth-Engine/demo](https://github.com/forth-engine/demo)
 
-+ ✅ Core Rendering Library
-+ ⌛ Full OpenGL integration
-+ ⌛ Physics Library
-+ ⌛ FOBJ (Forth-OBJ File) Import/Export
+# Prelease Feature Checklists
+
+*Legend: ✅ Finished ⌛ Not implemented / WIP*
+
++ ⌛ Core Rendering Functions
+  - ✅ Procedural Shape Generation Functions
+  - ✅ Primitive Shapes (Procedural)
+  - ✅ CrossSection (Flatland) Projection
+  - ✅ Frustum (Perspective) Projection
+  - ✅ (Basic) Shape Import/Export
+  - ✅ OpenGL Integration
+  - ⌛ Vertex Buffer (UV + Color)
++ ⌛ Graphic Features
+  - ✅ Simplexes (Point+Line+Surface Rendering)
+  - ✅ Culling Optimizations
+  - ⌛ Particle System
+  - ⌛ Line Trails
++ ⌛ Physics Module
+  - ✅ Collisions and Rigidbody
+  - ✅ Bounce and Frictions
+  - ✅ Primitive Collider (Box + Sphere + Capsule)
+  - ⌛ Convex Collider
+  - ⌛ Static Concave Collider
+  - ⌛ Kinematic Character Controller
+  - ⌛ Joints/Effectors
++ ⌛ Scene Managements
++ ⌛ Documentation
 + ⌛ ...etc...
 
 # LICENSE

source/CMakeLists.txt

@@ -26,6 +26,7 @@ set(forth_math_srcs
     math/SphereBounds4.h
     math/Tensor4.cpp
     math/Tensor4.h
+    math/Transform4.cpp
     math/Transform4.h
     math/Vector3.h
     math/Vector4.cpp
@@ -35,6 +36,8 @@ set(forth_math_srcs
 set(forth_rendering_srcs
     rendering/CrossSection.cpp
     rendering/CrossSection.h
+    rendering/Frustum4.cpp
+    rendering/Frustum4.h
     rendering/Model4.h
     rendering/Projector4.cpp
     rendering/Projector4.h

source/common/Buffer4.cpp

@@ -523,8 +523,8 @@ namespace Forth
 			break;
 
 		case SQM_LineLoop:
-			for (int i = 0; i < va;)
-				AddSegment(v[i], (v[++i % va]));
+			for (int i = 0; i < va; ++i)
+				AddSegment(v[i], (v[(i + 1) % va]));
 			break;
 
 		case SQM_Triangles:
@@ -553,8 +553,8 @@ namespace Forth
 			break;
 
 		case SQM_Polygon:
-			for (int i = 1; i < va;)
-				AddTriangle(v[0], v[i], (v[++i % va]));
+			for (int i = 1; i < va; ++i)
+				AddTriangle(v[(i + 1) % va], v[i], v[0]);
 			break;
 
 		case SQM_Trimids:

source/common/Buffer4.h

@@ -78,18 +78,6 @@ namespace Forth
 		/// </summary>
 		void AddPoint(int v0);
 
-		void AddPoints(int v...) // recursive variadic function
-		{
-			va_list args;
-			va_start(args, v);
-			for (int i = 0; i < v; i++)
-			{
-				int a = va_arg(args, int);
-				AddPoint(a);
-			}
-			va_end(args);
-		}
-
 		/// <summary>
 		/// Add a segment. Order doesn't matter.
 		/// </summary>

source/common/BufferGL.h

@@ -14,6 +14,20 @@ namespace Forth
 		// Layout: 0-2 Position. 3-5 Normal
 		FORTH_ARRAY(vb, float);
 
+		struct
+		{
+			int counts[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+			int slots = 0;
+			int stripe = 0;
+			int simplex = 0;
+			int vertexs = 0;
+		} attr;
+
+		struct
+		{
+			bool normal = true;
+		} generate;
+
 		BufferGL(void) {}
 
 		~BufferGL(void)
@@ -26,41 +40,62 @@ namespace Forth
 			vb_count = 0;
 		}
 
-		void Copy(const Buffer3 &v)
+		void FillVertices(const Buffer3 &v, int offset)
 		{
-			Clear();
-
-			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 < attr.vertexs; ++i)
+			{
+				auto &f = v.vertices[v.indices[i]];
+				vb[i * attr.stripe + offset + 0] = f.x;
+				vb[i * attr.stripe + offset + 1] = f.y;
+				vb[i * attr.stripe + offset + 2] = f.z;
+			}
+		}
 
-			for (int i = 0; i < len;)
+		void FillNormals(const Buffer3 &v, int offset)
+		{
+			for (int i = 0; i < attr.vertexs;i += 3)
 			{
-				const int a = v.indices[i++],
-						  b = v.indices[i++],
-						  c = v.indices[i++];
+				const int a = v.indices[i + 0],
+						  b = v.indices[i + 1],
+						  c = v.indices[i + 2];
 
-				const Vector3 av = v.vertices[a],
-							  bv = v.vertices[b],
-							  cv = v.vertices[c],
+				const Vector3 &av = v.vertices[a],
+							  &bv = v.vertices[b],
+							  &cv = v.vertices[c],
 							  nv = Forth::Normalize(Forth::Cross(bv - cv, av - cv));
 
-				// clang-format off
-				float arr[] = {
-					av.x, av.y, av.z, nv.x, nv.y, nv.z,
-					bv.x, bv.y, bv.z, nv.x, nv.y, nv.z,
-					cv.x, cv.y, cv.z, nv.x, nv.y, nv.z,
-				};
-				// clang-format on
-
-				for (int j = 0; j < BUFFER_PER_TRIS;)
+				for (int j = 0; j < 3;++j)
 				{
-					vb[vb_count++] = arr[j++];
+					vb[(i + j) * attr.stripe + offset + 0] = nv.x;
+					vb[(i + j) * attr.stripe + offset + 1] = nv.y;
+					vb[(i + j) * attr.stripe + offset + 2] = nv.z;
 				}
 			}
 		}
+
+		void Copy(const Buffer3 &v)
+		{
+			Clear();
+
+			attr.vertexs = v.indices_count;
+			attr.simplex = v.simplex + 1;
+			attr.stripe = 3;
+			attr.slots = 1;
+			attr.counts[0] = 3; // First: Vertice Positions
+
+			bool genNormal = v.simplex == SM_Triangle && generate.normal;
+			if (genNormal)
+			{
+				attr.counts[1] = 3; // Second: Normal
+				attr.slots++;
+				attr.stripe += 3;
+			}
+
+			EnsureCapacity(&vb, 0, &vb_cap, vb_count = attr.vertexs * attr.stripe);
+
+			FillVertices(v, 0);
+			if (genNormal)
+				FillNormals(v, 3);
+		}
 	};
 } // namespace Forth

source/extras/MeshGen.cpp

@@ -125,6 +125,7 @@ namespace Forth
 
 	void MeshGen::MakeTesseract(Buffer4 &input, float scale)
 	{
+		scale *= .5;
 		// Permutation of (-+1, -+1, -+1, -+1)
 		// Idk why the order have to be like this?
 		for (float w = -1; w <= 1; w += 2)
@@ -176,16 +177,16 @@ namespace Forth
 		switch (input.simplex)
 		{
 		case SM_Point:
-			input.AddPoints(a, b, c, d, e, f);
+			input.AddPoint({ a, b, c, d, e, f });
 			break;
 		case SM_Line:
 			input.AddQuad(c, d, e, f);
 			input.AddBySequence(SQM_LineFan, {a, c, d, e, f});
 			input.AddBySequence(SQM_LineFan, {b, c, d, e, f});
 			break;
 		case SM_Triangle:
-			input.AddPolygon({{a, c, d, e, f}});
-			input.AddPolygon({{b, c, d, e, f}});
+			input.AddPolygon({a, c, d, e, f});
+			input.AddPolygon({b, c, d, e, f});
 			break;
 		case SM_Tetrahedron:
 			input.AddPyramid(a, d, c, f, e);
@@ -252,9 +253,9 @@ namespace Forth
 		{
 		case SM_Point:
 
-			input.AddPoints(
+			input.AddPoint({
 				a, b, c, d, e, f, g, h, i, j,
-				k, l, m, n, o, p, q, r, s, t);
+				k, l, m, n, o, p, q, r, s, t });
 			break;
 
 		case SM_Line:

source/extras/MeshGen.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "../common/Buffer4.h"
+#include "../math/Transform4.h"
 
 namespace Forth
 {
@@ -148,5 +149,18 @@ namespace Forth
 			else
 				input.SequenceGrid(state.subdiv * 2 + 1, state.subdiv + 1, state.subdiv + 1);
 		}
+
+		static void Transform(Buffer4 &input, const Transform4& transform, bool realign = true)
+		{
+			for(int i = input.verticeCount; i-- > input.offset;)
+			{
+				input.vertices[i] = transform * input.vertices[i];
+			}
+
+			if (realign)
+			{
+				input.Align();
+			}
+		}
 	};
 } // namespace Forth

source/extras/Utils.h

@@ -21,12 +21,14 @@ namespace Forth
 		}
 	}
 
-
-	#define SWAP(a, b, c) c=a;a=b;b=c;
+#define SWAP(a, b, c) \
+	c = a;            \
+	a = b;            \
+	b = c;
 
 #define FORTH_ARRAY(name, T) \
 	T *name = new T[4];      \
-	int name##_cap = 4;        \
+	int name##_cap = 4;      \
 	int name##_count = 0
 
 } // namespace Forth

source/forth.h

@@ -4,13 +4,14 @@
 #define FORTH_H
 
 #define FORTH_MAJOR 0
-#define FORTH_MINOR 1
+#define FORTH_MINOR 2
 
 #include "common/Buffer3.h"
 #include "common/Buffer4.h"
 #include "common/BufferGL.h"
 #include "extras/MeshGen.h"
 #include "math/Transform4.h"
+#include "rendering/Frustum4.h"
 #include "rendering/CrossSection.h"
 #include "rendering/Model4.h"
 #include "visualizer/SolidVisualizer.h"

source/math/Math.h

@@ -103,6 +103,12 @@ namespace Forth
 		return a + (b - a) * t;
 	}
 
+	template <class T>
+	inline T SmoothDamp(T a, T b, T dt)
+	{
+    	return Lerp(a, b, T(1) - std::exp(-dt));
+	}
+
 	inline float Invert(float f)
 	{
 		return 1.f / f;

source/math/Matrix4.cpp

@@ -97,7 +97,7 @@ namespace Forth
 	Matrix4 Euler(int axis, float degree)
 	{
 		float s = sin(degree * DEG2RAD), c = cos(degree * DEG2RAD);
-		Matrix4 m = Matrix4::identity();
+		Matrix4 m = Matrix4::identity;
 		// clang-format off
 		switch (axis)
 		{
@@ -111,4 +111,12 @@ namespace Forth
 		}
 		// clang-format on
 	}
+
+		/// <summary>
+		/// Get a 4x4 identity matrix
+		/// </summary>
+		const Matrix4 Matrix4::identity = Matrix4(1);
+
+		const Matrix4 Matrix4::zero = Matrix4();
+
 } // namespace Forth

source/math/Matrix4.h

@@ -173,20 +173,9 @@ namespace Forth
 		/// <summary>
 		/// Get a 4x4 identity matrix
 		/// </summary>
-		static Matrix4 identity(void)
-		{
-			Matrix4 m = Matrix4();
-			m.ex.x = m.ey.y = m.ez.z = m.ew.w = 1;
-			return m;
-		}
+		static const Matrix4 identity;
 
-		/// <summary>
-		/// Get a 4x4 identity matrix
-		/// </summary>
-		static Matrix4 zero(void)
-		{
-			return Matrix4();
-		}
+		static const Matrix4 zero;
 
 	  private:
 		void Transpose(void)