simplify projection using Model4 (with bugfixes)

willnode · willnode · commit aa4b7da00e44 · 2019-05-28T15:46:52.000+07:00
+ Model4 == Buffer4 + Buffer3 + BufferGL + Model Transform in one pack.
+ No Inline in CPP
+ Handle with default visualizers
+ Vector3 init bugfix
+ FORTH_GL_DRAW macro for OpenGL
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
@@ -25,6 +25,8 @@ set(forth_math_srcs
 set(forth_rendering_srcs
     rendering/CrossSection.cpp
     rendering/CrossSection.h
+    rendering/Model4.h
+    rendering/Projector4.cpp
     rendering/Projector4.h
     rendering/Visualizer4.h
 )
diff --git a/source/common/Buffer4.cpp b/source/common/Buffer4.cpp
@@ -3,71 +3,71 @@
 
 namespace Forth
 {
-	inline void Buffer4::EnsureIndices(const int incoming)
+	void Buffer4::EnsureIndices(const int incoming)
 	{
 		if (indiceCount + incoming > indiceCap)
 		{
 			Expand(&indices, indiceCount, indiceCap = Max(indiceCount + incoming, indiceCap << 1));
 		}
 	}
-	inline void Buffer4::EnsureVertices(const int incoming)
+	void Buffer4::EnsureVertices(const int incoming)
 	{
 		if (verticeCount + incoming > verticeCap)
 		{
 			Expand(&vertices, verticeCount, verticeCap = Max(verticeCount + incoming, verticeCap << 1));
 		}
 	}
 
-	inline void Buffer4::Clear()
+	void Buffer4::Clear()
 	{
 		verticeCount = indiceCount = offset = 0;
 	}
 
-	inline void Buffer4::Clean()
+	void Buffer4::Clean()
 	{
 		Clear();
 		indices = new int[indiceCap = 4];
 		vertices = new Vector4[verticeCap = 4];
 	}
 
-	inline Buffer4::Buffer4()
+	Buffer4::Buffer4()
 	{
 		Clean();
 	}
 
-	inline void Buffer4::Align() { offset = verticeCount; }
+	void Buffer4::Align() { offset = verticeCount; }
 
-	inline void Buffer4::Align(int snapshot) { offset = snapshot; }
+	void Buffer4::Align(int snapshot) { offset = snapshot; }
 
 	/// <summary>
 	/// Send copy of current buffer position to be reused later.
 	/// </summary>
 	/// <seealso cref="Align(int)"/>
 
-	inline int Buffer4::Snapshot() { return verticeCount; }
+	int Buffer4::Snapshot() { return verticeCount; }
 
-	inline void Buffer4::AddSimplex(int i)
+	void Buffer4::AddSimplex(int i)
 	{
 		EnsureIndices(1);
 		indices[indiceCount++] = (i + offset);
 	}
 
-	inline void Buffer4::AddSimplex(int i, int j)
+	void Buffer4::AddSimplex(int i, int j)
 	{
 		EnsureIndices(2);
 		indices[indiceCount++] = (i + offset);
 		indices[indiceCount++] = (j + offset);
 	}
 
-	inline void Buffer4::AddSimplex(int i, int j, int k)
+	void Buffer4::AddSimplex(int i, int j, int k)
 	{
 		EnsureIndices(3);
 		indices[indiceCount++] = (i + offset);
 		indices[indiceCount++] = (j + offset);
 		indices[indiceCount++] = (k + offset);
 	}
 
-	inline void Buffer4::AddSimplex(int i, int j, int k, int l)
+	void Buffer4::AddSimplex(int i, int j, int k, int l)
 	{
 		EnsureIndices(2);
 		indices[indiceCount++] = (i + offset);
@@ -76,7 +76,7 @@ namespace Forth
 		indices[indiceCount++] = (l + offset);
 	}
 
-	inline void Buffer4::AddPoint(int v0)
+	void Buffer4::AddPoint(int v0)
 	{
 		switch (simplex)
 		{
@@ -86,7 +86,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddSegment(int v0, int v1)
+	void Buffer4::AddSegment(int v0, int v1)
 	{
 		switch (simplex)
 		{
@@ -99,7 +99,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddTriangle(int v0, int v1, int v2)
+	void Buffer4::AddTriangle(int v0, int v1, int v2)
 	{
 		switch (simplex)
 		{
@@ -117,7 +117,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddQuad(int v0, int v1, int v2, int v3)
+	void Buffer4::AddQuad(int v0, int v1, int v2, int v3)
 	{
 		switch (simplex)
 		{
@@ -137,7 +137,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddTrimid(int v0, int v1, int v2, int v3)
+	void Buffer4::AddTrimid(int v0, int v1, int v2, int v3)
 	{
 		switch (simplex)
 		{
@@ -165,7 +165,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddPyramid(int v0, int v1, int v2, int v3, int v4)
+	void Buffer4::AddPyramid(int v0, int v1, int v2, int v3, int v4)
 	{
 		switch (simplex)
 		{
@@ -196,7 +196,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddPrism(int v0, int v1, int v2, int v3, int v4, int v5)
+	void Buffer4::AddPrism(int v0, int v1, int v2, int v3, int v4, int v5)
 	{
 		switch (simplex)
 		{
@@ -230,7 +230,7 @@ namespace Forth
 		}
 	}
 
-	inline void Buffer4::AddCube(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)
+	void Buffer4::AddCube(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)
 	{
 		switch (simplex)
 		{
@@ -271,21 +271,21 @@ namespace Forth
 		}
 	}
 
-	inline int Buffer4::AddVertex(int idx)
+	int Buffer4::AddVertex(int idx)
 	{
 		EnsureVertices(1);
 		vertices[verticeCount] = (vertices[idx + offset]);
 		return verticeCount++ - offset;
 	}
 
-	inline int Buffer4::AddVertex(Vector4 vert)
+	int Buffer4::AddVertex(Vector4 vert)
 	{
 		EnsureVertices(1);
 		vertices[verticeCount] = vert;
 		return verticeCount++ - offset;
 	}
 
-	inline void Buffer4::Sequence(SequenceMode mode, int start, int count)
+	void Buffer4::Sequence(SequenceMode mode, int start, int count)
 	{
 		offset += start;
 		int end = count < 0 ? verticeCount - offset : count;
@@ -384,13 +384,13 @@ namespace Forth
 		offset -= start;
 	}
 
-	inline int Buffer4::SequenceIndex(int i, int j, int k, int l)
+	int Buffer4::SequenceIndex(int i, int j, int k, int l)
 	{
 		return l + _seqW * (k + _seqZ * (j + _seqY * i));
 	}
 
 	template <typename T>
-	inline void Buffer4::Expand(T **arr, int count, int newSize)
+	void Buffer4::Expand(T **arr, int count, int newSize)
 	{
 		T *newArr = new T[newSize];
 
diff --git a/source/common/BufferGL.h b/source/common/BufferGL.h
@@ -11,7 +11,7 @@ namespace Forth
 	struct BufferGL
 	{
 		// Layout: 0-2 Position. 3-5 Normal
-		std::vector<float> vertexbuffer;
+		std::vector<float> vb;
 
 		BufferGL() {}
 
@@ -22,7 +22,7 @@ namespace Forth
 
 		void Clear()
 		{
-			vertexbuffer.clear();
+			vb.clear();
 		}
 
 		void Copy(const Buffer3 &v)
@@ -49,7 +49,7 @@ namespace Forth
 				};
 				// clang-format on
 
-				vertexbuffer.insert(vertexbuffer.end(), arr, arr + 18);
+				vb.insert(vb.end(), arr, arr + 18);
 			}
 		}
 	};
diff --git a/source/forth.h b/source/forth.h
@@ -8,8 +8,10 @@
 
 #include "common/Buffer3.h"
 #include "common/Buffer4.h"
+#include "common/BufferGL.h"
 #include "math/Transform4.h"
 #include "rendering/CrossSection.h"
+#include "rendering/Model4.h"
 #include "visualizer/SolidVisualizer.h"
 #include "visualizer/WireVisualizer.h"
 #include "visualizer/ParticleVisualizer.h"
diff --git a/source/math/Matrix4.h b/source/math/Matrix4.h
@@ -247,5 +247,5 @@ namespace Forth
     /// Convert given degree rotation in given axis to orthogonal matrix rotation.
     /// </summary>
     /// <remarks>This method is much optimized than Euler(new Euler4(axis, degree))</remarks>
-	inline Matrix4 Euler(int axis, float degree);
+	Matrix4 Euler(int axis, float degree);
 }
diff --git a/source/math/Vector3.h b/source/math/Vector3.h
@@ -9,7 +9,7 @@ namespace Forth
 	{
 		float x, y, z;
 
-		Vector3() { }
+		Vector3() : x(0), y(0), z(0) { }
 		Vector3(float xyz) : x(xyz), y(xyz), z(xyz) { }
 		Vector3(float x, float y, float z) : x(x), y(y), z(z) { }
 		Vector3(float *arr) : x(arr[0]), y(arr[1]), z(arr[2]) { }
diff --git a/source/rendering/CrossSection.cpp b/source/rendering/CrossSection.cpp
@@ -4,7 +4,8 @@
 namespace Forth
 {
 
-CrossSection::CrossSection(void) {
+CrossSection::CrossSection(void) : Projector4() {
+
 	Setup(Forth::Transform4::identity());
 }
 
@@ -92,11 +93,6 @@ void CrossSection::Project(const Buffer4 &source, const Transform4 &transform, V
 			sides.push_back(Dot(vmw, source.vertices[i]) > vmwp);
 	}
 
-	//if (source.profileCount == source.indiceCount)
-	{
-
-	}
-	//else
 	{
 		switch (source.simplex)
 		{
diff --git a/source/rendering/Model4.h b/source/rendering/Model4.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "../common/Buffer3.h"
+#include "../common/Buffer4.h"
+#include "../common/BufferGL.h"
+#include "../math/Transform4.h"
+#include "Projector4.h"
+
+/** OpenGL Drawing Macro
+ *
+ * @model Model4
+ * @vb GLuint to a vertex buffer
+*/
+#define FORTH_GL_DRAW(model, vb)                                                                                    \
+	do                                                                                                              \
+	{                                                                                                               \
+		glBindBuffer(GL_ARRAY_BUFFER, vb);                                                                          \
+		glBufferData(GL_ARRAY_BUFFER, model.driver.vb.size() * 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);                                                  \
+	} while (0)
+
+namespace Forth
+{
+	class Model4
+	{
+	  public:
+		Buffer4 input = Buffer4();
+		Buffer3 output = Buffer3();
+		BufferGL driver = BufferGL();
+		Transform4 matrix;
+
+		Model4() : matrix(Transform4::identity()) {}
+
+		void Render(Projector4 &projector)
+		{
+			projector.Project(input, matrix, output);
+			this->driver.Copy(output);
+		}
+	};
+} // namespace Forth
diff --git a/source/rendering/Projector4.cpp b/source/rendering/Projector4.cpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Projector4.h"
+
+namespace Forth
+{
+
+	void Projector4::Project(const Buffer4 &from, const Transform4 &transform, Buffer3 &to) {
+		Visualizer4* viz = ((Visualizer4*)defaultVisualizers[from.simplex - 1]);
+		viz->Initialize(to);
+		this->Project(from, transform, viz);
+		viz->End();
+	}
+
+	Projector4::Projector4()
+	{
+		defaultVisualizers[SM_Point] = new ParticleVisualizer();
+		defaultVisualizers[SM_Line] = new WireVisualizer();
+		defaultVisualizers[SM_Triangle] = new SolidVisualizer();
+	}
+
+	Projector4::~Projector4()
+	{
+		delete defaultVisualizers[SM_Point];
+		delete defaultVisualizers[SM_Line];
+		delete defaultVisualizers[SM_Triangle];
+	}
+}
diff --git a/source/rendering/Projector4.h b/source/rendering/Projector4.h
diff --git a/source/visualizer/SolidVisualizer.cpp b/source/visualizer/SolidVisualizer.cpp

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@ set(forth_math_srcs`
`25`	`25`	`set(forth_rendering_srcs`
`26`	`26`	`rendering/CrossSection.cpp`
`27`	`27`	`rendering/CrossSection.h`
	`28`	`+ rendering/Model4.h`
	`29`	`+ rendering/Projector4.cpp`
`28`	`30`	`rendering/Projector4.h`
`29`	`31`	`rendering/Visualizer4.h`
`30`	`32`	`)`
Original file line number	Diff line number	Diff line change
`@@ -3,71 +3,71 @@`
`3`	`3`
`4`	`4`	`namespace Forth`
`5`	`5`	`{`
`6`		`- inline void Buffer4::EnsureIndices(const int incoming)`
	`6`	`+ void Buffer4::EnsureIndices(const int incoming)`
`7`	`7`	`{`
`8`	`8`	`if (indiceCount + incoming > indiceCap)`
`9`	`9`	`{`
`10`	`10`	`Expand(&indices, indiceCount, indiceCap = Max(indiceCount + incoming, indiceCap << 1));`
`11`	`11`	`}`
`12`	`12`	`}`
`13`		`- inline void Buffer4::EnsureVertices(const int incoming)`
	`13`	`+ void Buffer4::EnsureVertices(const int incoming)`
`14`	`14`	`{`
`15`	`15`	`if (verticeCount + incoming > verticeCap)`
`16`	`16`	`{`
`17`	`17`	`Expand(&vertices, verticeCount, verticeCap = Max(verticeCount + incoming, verticeCap << 1));`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`		`- inline void Buffer4::Clear()`
	`21`	`+ void Buffer4::Clear()`
`22`	`22`	`{`
`23`	`23`	`verticeCount = indiceCount = offset = 0;`
`24`	`24`	`}`
`25`	`25`
`26`		`- inline void Buffer4::Clean()`
	`26`	`+ void Buffer4::Clean()`
`27`	`27`	`{`
`28`	`28`	`Clear();`
`29`	`29`	`indices = new int[indiceCap = 4];`
`30`	`30`	`vertices = new Vector4[verticeCap = 4];`
`31`	`31`	`}`
`32`	`32`
`33`		`- inline Buffer4::Buffer4()`
	`33`	`+ Buffer4::Buffer4()`
`34`	`34`	`{`
`35`	`35`	`Clean();`
`36`	`36`	`}`
`37`	`37`
`38`		`- inline void Buffer4::Align() { offset = verticeCount; }`
	`38`	`+ void Buffer4::Align() { offset = verticeCount; }`
`39`	`39`
`40`		`- inline void Buffer4::Align(int snapshot) { offset = snapshot; }`
	`40`	`+ void Buffer4::Align(int snapshot) { offset = snapshot; }`
`41`	`41`
`42`	`42`	`/// <summary>`
`43`	`43`	`/// Send copy of current buffer position to be reused later.`
`44`	`44`	`/// </summary>`
`45`	`45`	`/// <seealso cref="Align(int)"/>`
`46`	`46`
`47`		`- inline int Buffer4::Snapshot() { return verticeCount; }`
	`47`	`+ int Buffer4::Snapshot() { return verticeCount; }`
`48`	`48`
`49`		`- inline void Buffer4::AddSimplex(int i)`
	`49`	`+ void Buffer4::AddSimplex(int i)`
`50`	`50`	`{`
`51`	`51`	`EnsureIndices(1);`
`52`	`52`	`indices[indiceCount++] = (i + offset);`
`53`	`53`	`}`
`54`	`54`
`55`		`- inline void Buffer4::AddSimplex(int i, int j)`
	`55`	`+ void Buffer4::AddSimplex(int i, int j)`
`56`	`56`	`{`
`57`	`57`	`EnsureIndices(2);`
`58`	`58`	`indices[indiceCount++] = (i + offset);`
`59`	`59`	`indices[indiceCount++] = (j + offset);`
`60`	`60`	`}`
`61`	`61`
`62`		`- inline void Buffer4::AddSimplex(int i, int j, int k)`
	`62`	`+ void Buffer4::AddSimplex(int i, int j, int k)`
`63`	`63`	`{`
`64`	`64`	`EnsureIndices(3);`
`65`	`65`	`indices[indiceCount++] = (i + offset);`
`66`	`66`	`indices[indiceCount++] = (j + offset);`
`67`	`67`	`indices[indiceCount++] = (k + offset);`
`68`	`68`	`}`
`69`	`69`
`70`		`- inline void Buffer4::AddSimplex(int i, int j, int k, int l)`
	`70`	`+ void Buffer4::AddSimplex(int i, int j, int k, int l)`
`71`	`71`	`{`
`72`	`72`	`EnsureIndices(2);`
`73`	`73`	`indices[indiceCount++] = (i + offset);`
`@@ -76,7 +76,7 @@ namespace Forth`
`76`	`76`	`indices[indiceCount++] = (l + offset);`
`77`	`77`	`}`
`78`	`78`
`79`		`- inline void Buffer4::AddPoint(int v0)`
	`79`	`+ void Buffer4::AddPoint(int v0)`
`80`	`80`	`{`
`81`	`81`	`switch (simplex)`
`82`	`82`	`{`
`@@ -86,7 +86,7 @@ namespace Forth`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`- inline void Buffer4::AddSegment(int v0, int v1)`
	`89`	`+ void Buffer4::AddSegment(int v0, int v1)`
`90`	`90`	`{`
`91`	`91`	`switch (simplex)`
`92`	`92`	`{`
`@@ -99,7 +99,7 @@ namespace Forth`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`- inline void Buffer4::AddTriangle(int v0, int v1, int v2)`
	`102`	`+ void Buffer4::AddTriangle(int v0, int v1, int v2)`
`103`	`103`	`{`
`104`	`104`	`switch (simplex)`
`105`	`105`	`{`
`@@ -117,7 +117,7 @@ namespace Forth`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`120`		`- inline void Buffer4::AddQuad(int v0, int v1, int v2, int v3)`
	`120`	`+ void Buffer4::AddQuad(int v0, int v1, int v2, int v3)`
`121`	`121`	`{`
`122`	`122`	`switch (simplex)`
`123`	`123`	`{`
`@@ -137,7 +137,7 @@ namespace Forth`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`		`- inline void Buffer4::AddTrimid(int v0, int v1, int v2, int v3)`
	`140`	`+ void Buffer4::AddTrimid(int v0, int v1, int v2, int v3)`
`141`	`141`	`{`
`142`	`142`	`switch (simplex)`
`143`	`143`	`{`
`@@ -165,7 +165,7 @@ namespace Forth`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
`168`		`- inline void Buffer4::AddPyramid(int v0, int v1, int v2, int v3, int v4)`
	`168`	`+ void Buffer4::AddPyramid(int v0, int v1, int v2, int v3, int v4)`
`169`	`169`	`{`
`170`	`170`	`switch (simplex)`
`171`	`171`	`{`
`@@ -196,7 +196,7 @@ namespace Forth`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`		`- inline void Buffer4::AddPrism(int v0, int v1, int v2, int v3, int v4, int v5)`
	`199`	`+ void Buffer4::AddPrism(int v0, int v1, int v2, int v3, int v4, int v5)`
`200`	`200`	`{`
`201`	`201`	`switch (simplex)`
`202`	`202`	`{`
`@@ -230,7 +230,7 @@ namespace Forth`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`		`- inline void Buffer4::AddCube(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)`
	`233`	`+ void Buffer4::AddCube(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)`
`234`	`234`	`{`
`235`	`235`	`switch (simplex)`
`236`	`236`	`{`
`@@ -271,21 +271,21 @@ namespace Forth`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`274`		`- inline int Buffer4::AddVertex(int idx)`
	`274`	`+ int Buffer4::AddVertex(int idx)`
`275`	`275`	`{`
`276`	`276`	`EnsureVertices(1);`
`277`	`277`	`vertices[verticeCount] = (vertices[idx + offset]);`
`278`	`278`	`return verticeCount++ - offset;`
`279`	`279`	`}`
`280`	`280`
`281`		`- inline int Buffer4::AddVertex(Vector4 vert)`
	`281`	`+ int Buffer4::AddVertex(Vector4 vert)`
`282`	`282`	`{`
`283`	`283`	`EnsureVertices(1);`
`284`	`284`	`vertices[verticeCount] = vert;`
`285`	`285`	`return verticeCount++ - offset;`
`286`	`286`	`}`
`287`	`287`
`288`		`- inline void Buffer4::Sequence(SequenceMode mode, int start, int count)`
	`288`	`+ void Buffer4::Sequence(SequenceMode mode, int start, int count)`
`289`	`289`	`{`
`290`	`290`	`offset += start;`
`291`	`291`	`int end = count < 0 ? verticeCount - offset : count;`
`@@ -384,13 +384,13 @@ namespace Forth`
`384`	`384`	`offset -= start;`
`385`	`385`	`}`
`386`	`386`
`387`		`- inline int Buffer4::SequenceIndex(int i, int j, int k, int l)`
	`387`	`+ int Buffer4::SequenceIndex(int i, int j, int k, int l)`
`388`	`388`	`{`
`389`	`389`	`return l + _seqW * (k + _seqZ * (j + _seqY * i));`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`template <typename T>`
`393`		`- inline void Buffer4::Expand(T **arr, int count, int newSize)`
	`393`	`+ void Buffer4::Expand(T **arr, int count, int newSize)`
`394`	`394`	`{`
`395`	`395`	`T *newArr = new T[newSize];`
`396`	`396`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace Forth`
`11`	`11`	`struct BufferGL`
`12`	`12`	`{`
`13`	`13`	`// Layout: 0-2 Position. 3-5 Normal`
`14`		`- std::vector<float> vertexbuffer;`
	`14`	`+ std::vector<float> vb;`
`15`	`15`
`16`	`16`	`BufferGL() {}`
`17`	`17`
`@@ -22,7 +22,7 @@ namespace Forth`
`22`	`22`
`23`	`23`	`void Clear()`
`24`	`24`	`{`
`25`		`- vertexbuffer.clear();`
	`25`	`+ vb.clear();`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`void Copy(const Buffer3 &v)`
`@@ -49,7 +49,7 @@ namespace Forth`
`49`	`49`	`};`
`50`	`50`	`// clang-format on`
`51`	`51`
`52`		`- vertexbuffer.insert(vertexbuffer.end(), arr, arr + 18);`
	`52`	`+ vb.insert(vb.end(), arr, arr + 18);`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`};`
Original file line number	Diff line number	Diff line change
`@@ -247,5 +247,5 @@ namespace Forth`
`247`	`247`	`/// Convert given degree rotation in given axis to orthogonal matrix rotation.`
`248`	`248`	`/// </summary>`
`249`	`249`	`/// <remarks>This method is much optimized than Euler(new Euler4(axis, degree))</remarks>`
`250`		`- inline Matrix4 Euler(int axis, float degree);`
	`250`	`+ Matrix4 Euler(int axis, float degree);`
`251`	`251`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Forth`
`9`	`9`	`{`
`10`	`10`	`float x, y, z;`
`11`	`11`
`12`		`- Vector3() { }`
	`12`	`+ Vector3() : x(0), y(0), z(0) { }`
`13`	`13`	`Vector3(float xyz) : x(xyz), y(xyz), z(xyz) { }`
`14`	`14`	`Vector3(float x, float y, float z) : x(x), y(y), z(z) { }`
`15`	`15`	`Vector3(float *arr) : x(arr[0]), y(arr[1]), z(arr[2]) { }`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,8 @@`
`4`	`4`	`namespace Forth`
`5`	`5`	`{`
`6`	`6`
`7`		`-CrossSection::CrossSection(void) {`
	`7`	`+CrossSection::CrossSection(void) : Projector4() {`
	`8`	`+`
`8`	`9`	`Setup(Forth::Transform4::identity());`
`9`	`10`	`}`
`10`	`11`
`@@ -92,11 +93,6 @@ void CrossSection::Project(const Buffer4 &source, const Transform4 &transform, V`
`92`	`93`	`sides.push_back(Dot(vmw, source.vertices[i]) > vmwp);`
`93`	`94`	`}`
`94`	`95`
`95`		`- //if (source.profileCount == source.indiceCount)`
`96`		`- {`
`97`		`-`
`98`		`- }`
`99`		`- //else`
`100`	`96`	`{`
`101`	`97`	`switch (source.simplex)`
`102`	`98`	`{`