Collider rendering

GlitchyEditor/src/EditorLayer.bf

@@ -231,7 +231,7 @@ namespace GlitchyEditor
 				return Math.Clamp(1.5f - Vector3.Distance(_editor.CurrentCamera.Position, pos) / 50, 0, 1);
 			}
 
-			for (var (entity, transform, camera) in _activeScene.[Friend]_ecsWorld.Enumerate<TransformComponent, CameraComponent>())
+			for (var (entity, transform, camera) in _activeScene.GetEntities<TransformComponent, CameraComponent>())
 			{
 				if (_editor.EntityHierarchyWindow.SelectedEntities.Contains(.(entity, _activeScene)))
 				{
@@ -245,7 +245,7 @@ namespace GlitchyEditor
 				//Renderer2D.DrawQuad(world, _iconCamera, .White, .(0, 0, 1, 1), entity.Index);
 			}
 
-			for (var (entity, transform, light) in _activeScene.[Friend]_ecsWorld.Enumerate<TransformComponent, LightComponent>())
+			for (var (entity, transform, light) in _activeScene.GetEntities<TransformComponent, LightComponent>())
 			{
 				if (_editor.EntityHierarchyWindow.SelectedEntities.Contains(.(entity, _activeScene)))
 				{
@@ -263,7 +263,16 @@ namespace GlitchyEditor
 				
 				float alpha = CalculateAlpha(transform.WorldTransform.Translation);
 				Renderer2D.DrawQuad(world, _editorIcons.DirectionalLight, ColorRGBA(light.SceneLight.Color.R * alpha, light.SceneLight.Color.G * alpha, light.SceneLight.Color.B * alpha, alpha), .(0, 0, 1, 1), entity.Index);
-				//Renderer2D.DrawQuad(world, _iconDirectionalLight, ColorRGBA(light.SceneLight.Color, alpha), .(0, 0, 1, 1), entity.Index);
+			}
+			
+			for (var (entity, transform, collider) in _activeScene.GetEntities<TransformComponent, BoxCollider2DComponent>())
+			{
+				Renderer2D.DrawRect(transform.WorldTransform * Matrix.Translation(collider.Offset.X, collider.Offset.Y, 0) * Matrix.Scaling(collider.Size.X * 2, collider.Size.Y * 2, 0));
+			}
+
+			for (var (entity, transform, collider) in _activeScene.GetEntities<TransformComponent, CircleCollider2DComponent>())
+			{
+				Renderer2D.DrawCircle(transform.WorldTransform * Matrix.Translation(collider.Offset.X, collider.Offset.Y, 0) * Matrix.Scaling(collider.Radius * 2), (Texture2D)null, ColorRGBA(0f, 1f, 0f), 0.01f);
 			}
 		}
 

GlitchyEngine/src/Math/MathDefs.bf

@@ -4,5 +4,4 @@ namespace GlitchyEngine.Math
 {
 	typealias Matrix3x3 = DirectX.Math.Matrix3x3;
 	typealias Matrix4x3 = DirectX.Math.Matrix4x3;
-	typealias Matrix = DirectX.Math.Matrix;
 }

GlitchyEngine/src/Math/Matrix.bf

@@ -0,0 +1,877 @@
+using System;
+
+namespace GlitchyEngine.Math;
+
+/**
+ * Represents a 4 by 4 column-major matrix.
+ */
+[Union]
+public struct Matrix
+{
+	public struct Values
+	{
+		public float _11, _21, _31, _41,
+					_12, _22, _32, _42,
+					_13, _23, _33, _43,
+					_14, _24, _34, _44;
+	}
+
+	public const Matrix Zero = .();
+	public const Matrix Identity = .(.UnitX, .UnitY, .UnitZ, .UnitW);
+
+	public using Values V;
+	public float[4][4] Values;
+	public Vector4[4] Columns;
+	
+	/// Creates a new zero-matrix.
+	public this() => this = default;
+
+	/**
+	 * Initializes a new Matrix.
+	 * @param value The value that will be assigned to all components.
+	 */
+	/// Creates a new matrix.
+	public this(float value)
+	{
+		this = ?;
+		_11 = _12 = _13 = _14 =
+		_21 = _22 = _23 = _24 =
+		_31 = _32 = _33 = _34 =
+		_41 = _42 = _43 = _44 = value;
+	}
+
+	/// Creates a new matrix and initializes it with the given entries.
+	public this(float m00, float m01, float m02, float m03,
+	         	float m10, float m11, float m12, float m13,
+	         	float m20, float m21, float m22, float m23,
+			 	float m30, float m31, float m32, float m33)
+	{
+		Values[0][0] = m00; Values[0][1] = m10; Values[0][2] = m20; Values[0][3] = m30;
+		Values[1][0] = m01; Values[1][1] = m11; Values[1][2] = m21; Values[1][3] = m31;
+		Values[2][0] = m02; Values[2][1] = m12; Values[2][2] = m22; Values[2][3] = m32;
+		Values[3][0] = m03; Values[3][1] = m13; Values[3][2] = m23; Values[3][3] = m33;
+	}
+
+	/// Creates a new matrix and initializes it with the given column-vectors.
+	public this(Vector4 c0, Vector4 c1, Vector4 c2, Vector4 c3)
+	{
+		Columns[0] = c0;
+		Columns[1] = c1;
+		Columns[2] = c2;
+		Columns[3] = c3;
+	}
+
+	public ref Vector3 Right
+	{
+		[Inline]
+		get
+		{
+#unwarn
+			return ref *(Vector3*)&Columns[0];
+		}
+	}
+
+	public ref Vector3 Up
+	{
+		[Inline]
+		get
+		{
+#unwarn
+			return ref *(Vector3*)&Columns[1];
+		}
+	}
+
+	public ref Vector3 Forward
+	{
+		[Inline]
+		get
+		{
+#unwarn
+			return ref *(Vector3*)&Columns[2];
+		}
+	}
+
+	public ref Vector3 Translation
+	{
+		[Inline]
+		get
+		{
+#unwarn
+			return ref *(Vector3*)&Columns[3];
+		}
+	}
+
+	public Vector3 Scale
+	{
+		[Inline]
+		get => .(_11, _22, _33);
+
+		[Inline]
+		set mut
+		{
+			_11 = value.X;
+			_22 = value.Y;
+			_33 = value.Z;
+		}
+	}
+
+	public ref float this[int row, int column]
+	{
+		get
+		{
+#unwarn
+			return ref *(float*)&Values[column][row];
+		}
+
+		[Checked]
+		get
+		{
+			if(column < 0 || column > 3 || row < 0 || row > 3)
+				Internal.ThrowIndexOutOfRange();
+			
+#unwarn
+			return ref *(float*)&Values[column][row];
+		}
+	}
+	
+	public ref Vector4 this[int column]
+	{
+		get
+		{
+#unwarn
+			return ref *(Vector4*)&Columns[column];
+		}
+
+		
+		[Checked]
+		get
+		{
+			if(column < 0 || column > 3)
+				Internal.ThrowIndexOutOfRange();
+			
+#unwarn
+			return ref *(Vector4*)&Columns[column];
+		}
+	}
+
+	//
+	// Assignment Operators
+	//
+
+	// Addition
+
+	public void operator +=(Matrix value) mut
+	{	
+		Columns[0] += value.Columns[0];
+		Columns[1] += value.Columns[1];
+		Columns[2] += value.Columns[2];
+		Columns[3] += value.Columns[3];
+	}
+
+	// Matrix + Scalar : Matrix + Scalar * Identity
+	public void operator +=(float scalar) mut
+	{
+		_11 += scalar;
+		_22 += scalar;
+		_33 += scalar;
+		_44 += scalar;
+	}
+
+	// Subtraction
+
+	public void operator -=(Matrix value) mut
+	{	
+		Columns[0] -= value.Columns[0];
+		Columns[1] -= value.Columns[1];
+		Columns[2] -= value.Columns[2];
+		Columns[3] -= value.Columns[3];
+	}
+
+	// Matrix - Scalar : Matrix - Scalar * Identity
+	public void operator -=(float scalar) mut
+	{
+		_11 -= scalar;
+		_22 -= scalar;
+		_33 -= scalar;
+		_44 -= scalar;
+	}
+
+	// Multiplication
+
+	public void operator *=(float scalar) mut
+	{	
+		Columns[0] *= scalar;
+		Columns[1] *= scalar;
+		Columns[2] *= scalar;
+		Columns[3] *= scalar;
+	}
+	
+	public void operator *=(Matrix value) mut
+	{
+		this = this * value;
+	}
+
+	// Divide
+
+	public void operator /=(float scalar) mut
+	{
+		float inv = 1.0f / scalar;
+		Columns[0] *= inv;
+		Columns[1] *= inv;
+		Columns[2] *= inv;
+		Columns[3] *= inv;
+	}
+
+	//
+	// Operators
+	//
+
+	// Addition
+	
+	public static Matrix operator +(Matrix left, Matrix right)
+	{
+		return .(left.Columns[0] + right.Columns[0],
+				left.Columns[1] + right.Columns[1],
+				left.Columns[2] + right.Columns[2],
+				left.Columns[3] + right.Columns[3]);
+	}
+
+	public static Matrix operator +(Matrix left, float right)
+	{
+		Matrix result = left;
+		result._11 += right;
+		result._22 += right;
+		result._33 += right;
+		result._44 += right;
+
+		return result;
+	}
+	
+	public static Matrix operator +(float left, Matrix right)
+	{
+		Matrix result = right;
+		result._11 += left;
+		result._22 += left;
+		result._33 += left;
+		result._44 += left;
+
+		return result;
+	}
+
+	// Subtraction
+	
+	public static Matrix operator -(Matrix left, Matrix right)
+	{
+		return .(left.Columns[0] - right.Columns[0],
+				left.Columns[1] - right.Columns[1],
+				left.Columns[2] - right.Columns[2],
+				left.Columns[3] - right.Columns[3]);
+	}
+
+	public static Matrix operator -(Matrix value, float scalar)
+	{
+		Matrix result = value;
+		result._11 -= scalar;
+		result._22 -= scalar;
+		result._33 -= scalar;
+		result._44 -= scalar;
+
+		return result;
+	}
+
+	public static Matrix operator -(float scalar, Matrix value)
+	{
+		Matrix result = value;
+		result._11 -= scalar;
+		result._22 -= scalar;
+		result._33 -= scalar;
+		result._44 -= scalar;
+
+		return result;
+	}
+
+	public static Matrix operator -(Matrix value)
+	{
+		return .(-value.Columns[0],
+				-value.Columns[1],
+				-value.Columns[2],
+				-value.Columns[3]);
+	}
+
+	// Multiplication
+
+	public static Matrix operator *(Matrix left, Matrix right)
+	{
+#unwarn
+		var l = &left.V;
+#unwarn
+		var r = &right.V;
+		
+		Matrix result = ?;
+
+		result._11 = (l._11 * r._11) + (l._12 * r._21) + (l._13 * r._31) + (l._14 * r._41);
+		result._12 = (l._11 * r._12) + (l._12 * r._22) + (l._13 * r._32) + (l._14 * r._42);
+		result._13 = (l._11 * r._13) + (l._12 * r._23) + (l._13 * r._33) + (l._14 * r._43);
+		result._14 = (l._11 * r._14) + (l._12 * r._24) + (l._13 * r._34) + (l._14 * r._44);
+		
+		result._21 = (l._21 * r._11) + (l._22 * r._21) + (l._23 * r._31) + (l._24 * r._41);
+		result._22 = (l._21 * r._12) + (l._22 * r._22) + (l._23 * r._32) + (l._24 * r._42);
+		result._23 = (l._21 * r._13) + (l._22 * r._23) + (l._23 * r._33) + (l._24 * r._43);
+		result._24 = (l._21 * r._14) + (l._22 * r._24) + (l._23 * r._34) + (l._24 * r._44);
+		
+		result._31 = (l._31 * r._11) + (l._32 * r._21) + (l._33 * r._31) + (l._34 * r._41);
+		result._32 = (l._31 * r._12) + (l._32 * r._22) + (l._33 * r._32) + (l._34 * r._42);
+		result._33 = (l._31 * r._13) + (l._32 * r._23) + (l._33 * r._33) + (l._34 * r._43);
+		result._34 = (l._31 * r._14) + (l._32 * r._24) + (l._33 * r._34) + (l._34 * r._44);
+		
+		result._41 = (l._41 * r._11) + (l._42 * r._21) + (l._43 * r._31) + (l._44 * r._41);
+		result._42 = (l._41 * r._12) + (l._42 * r._22) + (l._43 * r._32) + (l._44 * r._42);
+		result._43 = (l._41 * r._13) + (l._42 * r._23) + (l._43 * r._33) + (l._44 * r._43);
+		result._44 = (l._41 * r._14) + (l._42 * r._24) + (l._43 * r._34) + (l._44 * r._44);
+
+		return result;
+	}
+
+	public static Matrix operator *(Matrix value, float scalar)
+	{
+		return .(value.Columns[0] * scalar,
+				value.Columns[1] * scalar,
+				value.Columns[2] * scalar,
+				value.Columns[3] * scalar);
+	}
+	
+	public static Matrix operator *(float scalar, Matrix value)
+	{
+		return .(value.Columns[0] * scalar,
+				value.Columns[1] * scalar,
+				value.Columns[2] * scalar,
+				value.Columns[3] * scalar);
+	}
+
+	/**
+	 * Multiplies a matrix and a column-vector resulting in a column vector.
+	 */
+	public static Vector4 operator *(Matrix matrix, Vector4 columnVector)
+	{
+#unwarn
+		var m = &matrix.V;
+
+		Vector4 result = ?;
+		result.X = (m._11 * columnVector.X) + (m._12 * columnVector.Y) + (m._13 * columnVector.Z) + (m._14 * columnVector.W);
+		result.Y = (m._21 * columnVector.X) + (m._22 * columnVector.Y) + (m._23 * columnVector.Z) + (m._24 * columnVector.W);
+		result.Z = (m._31 * columnVector.X) + (m._32 * columnVector.Y) + (m._33 * columnVector.Z) + (m._34 * columnVector.W);
+		result.W = (m._41 * columnVector.X) + (m._42 * columnVector.Y) + (m._43 * columnVector.Z) + (m._44 * columnVector.W);
+		return result;
+	}
+	
+	/**
+	 * Multiplies a row-vector and a matrix resulting in a row vector.
+	 */
+	public static Vector4 operator *(Vector4 rowVector, Matrix matrix)
+	{
+#unwarn
+		var m = &matrix.V;
+
+		Vector4 result = ?;
+		result.X = (rowVector.X * m._11) + (rowVector.Y * m._21) + (rowVector.Z * m._31) + (rowVector.W * m._41);
+		result.Y = (rowVector.X * m._12) + (rowVector.Y * m._22) + (rowVector.Z * m._32) + (rowVector.W * m._42);
+		result.Z = (rowVector.X * m._13) + (rowVector.Y * m._23) + (rowVector.Z * m._33) + (rowVector.W * m._43);
+		result.W = (rowVector.X * m._14) + (rowVector.Y * m._24) + (rowVector.Z * m._34) + (rowVector.W * m._44);
+		return result;
+	}
+
+	// Divison
+
+	public static Matrix operator /(Matrix m, float s)
+	{
+		float f = 1 / s;
+		Matrix M = m;
+
+		return .(M.Columns[0] * f, M.Columns[1] * f, M.Columns[2] * f, M.Columns[3] * f);
+	}
+
+	public static Matrix Scaling(float scale)
+	{
+		return .(scale, 0, 0, 0,
+				 0, scale, 0, 0,
+				 0, 0, scale, 0,
+				 0, 0, 0, 1);
+	}
+	
+	public static Matrix Scaling(float scaleX, float scaleY, float scaleZ)
+	{
+		return .(scaleX, 0, 0, 0,
+				 0, scaleY, 0, 0,
+				 0, 0, scaleZ, 0,
+				 0, 0, 0, 1);
+	}
+
+	public static Matrix Scaling(Vector3 scale)
+	{
+		return .(scale.X, 0, 0, 0,
+				 0, scale.Y, 0, 0,
+				 0, 0, scale.Z, 0,
+				 0, 0, 0, 1);
+	}
+
+	public static Matrix Translation(float x, float y, float z)
+	{
+		return .(1, 0, 0, x,
+				 0, 1, 0, y,
+				 0, 0, 1, z,
+				 0, 0, 0, 1);
+	}
+
+	public static Matrix Translation(Vector3 translation)
+	{
+		return .(1, 0, 0, translation.X,
+				 0, 1, 0, translation.Y,
+				 0, 0, 1, translation.Z,
+				 0, 0, 0, 1);
+	}
+
+	public static Matrix RotationX(float rot)
+	{
+		float sin = Math.Sin(rot);
+		float cos = Math.Cos(rot);
+
+		return .(1,  0,   0,   0,
+				 0, cos, -sin, 0,
+				 0, sin, cos,  0,
+				 0,  0,   0,   1);
+	}
+
+	public static Matrix RotationY(float rot)
+	{
+		float sin = Math.Sin(rot);
+		float cos = Math.Cos(rot);
+
+		return .(cos, 0, sin, 0,
+				  0,  1,  0,  0,
+				-sin, 0, cos, 0,
+				  0,  0,  0,  1);
+	}
+
+	public static Matrix RotationZ(float rot)
+	{
+		float sin = Math.Sin(rot);
+		float cos = Math.Cos(rot);
+
+		return .(cos, -sin, 0, 0,
+				 sin,  cos, 0, 0,
+				  0,    0,  1, 0,
+				  0,    0,  0, 1);
+	}
+
+	/**
+	 * Calculates a view Matrix that is located at specified postion and looks at the given target.
+	 * @param position The cameras position.
+	 * @param target The point the camera looks at.
+	 * @param up A vector defining the up direction of the camera.
+	 * @returns a view matrix.
+	 */
+	public static Matrix LookAt(Vector3 position, Vector3 target, Vector3 up)
+	{
+		Vector3 forward = target - position;
+		forward.Normalize();
+
+		Vector3 right = Vector3.Cross(up, forward);
+		right.Normalize();
+
+		Vector3 newUp = Vector3.Cross(forward, right);
+		newUp.Normalize();
+
+		Matrix result = .Identity;
+
+		result.Forward = forward;
+		result.Up = up;
+		result.Right = right;
+		result.Translation.X = -Vector3.Dot(position, right);
+		result.Translation.Y = -Vector3.Dot(position, up);
+		result.Translation.Z = -Vector3.Dot(position, forward);
+
+		return result;
+	}
+
+	/// Returns the transpose of this matrix
+	[DisableChecks]
+	public Matrix Transpose()
+	{
+		return .(_11, _21, _31, _41,
+				_12, _22, _32, _42,
+				_13, _23, _33, _43,
+				_14, _24, _34, _44);
+	}
+
+	/**
+	Calculates the inverse of the matrix.
+	*/
+	[DisableChecks]
+	public float Determinant() mut
+	{
+		// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version. 
+
+		Vector3 a = *(Vector3*)&Columns[0];
+		Vector3 b = *(Vector3*)&Columns[1];
+		Vector3 c = *(Vector3*)&Columns[2]; 
+		Vector3 d = *(Vector3*)&Columns[3];  
+
+		float x = this[3, 0];
+		float y = this[3, 1];
+		float z = this[3, 2];
+		float w = this[3, 3];
+
+		Vector3 s = Vector3.Cross(a, b);
+		Vector3 t = Vector3.Cross(c, d);
+		Vector3 u = y * a - x * b;
+		Vector3 v = w * c - z * d;
+
+		return Vector3.Dot(s, v) + Vector3.Dot(t, u);
+	}
+
+	/**
+	Calculates the inverse of the matrix.
+	*/
+	public Matrix Invert()
+	{
+		// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version. 
+
+#unwarn
+		Vector3 a = *(Vector3*)&Columns[0];
+#unwarn
+		Vector3 b = *(Vector3*)&Columns[1];
+#unwarn
+		Vector3 c = *(Vector3*)&Columns[2]; 
+#unwarn
+		Vector3 d = *(Vector3*)&Columns[3];  
+
+		float x = this[3, 0];
+		float y = this[3, 1];
+		float z = this[3, 2];
+		float w = this[3, 3];
+
+		Vector3 s = Vector3.Cross(a, b);
+		Vector3 t = Vector3.Cross(c, d);
+		Vector3 u = y * a - x * b;
+		Vector3 v = w * c - z * d;
+
+		float invDet = 1.0f / (Vector3.Dot(s, v) + Vector3.Dot(t, u));
+
+		s *= invDet;
+		t *= invDet;
+		u *= invDet;
+		v *= invDet;
+
+		Vector3 r0 = Vector3.Cross(b, v) + t * y;
+		Vector3 r1 = Vector3.Cross(v, a) - t * x;
+		Vector3 r2 = Vector3.Cross(d, u) + s * w;
+		Vector3 r3 = Vector3.Cross(u, c) - s * z;
+		return .(r0.X, r0.Y, r0.Z, -Vector3.Dot(b, t),
+				 r1.X, r1.Y, r1.Z,  Vector3.Dot(a, t),
+				 r2.X, r2.Y, r2.Z, -Vector3.Dot(d, s),
+				 r3.X, r3.Y, r3.Z,  Vector3.Dot(c, s));
+	}
+
+	/// Calculates the inverse of the matrix.
+	public static Matrix Invert(in Matrix matrix)
+	{
+		// From: Lengyel, Eric. Foundations of Game Engine Development, Volume 1: Mathematics (S.61). Kindle-Version. 
+		
+#unwarn
+		Vector3 a = *(Vector3*)&matrix.Columns[0];
+#unwarn
+		Vector3 b = *(Vector3*)&matrix.Columns[1];
+#unwarn
+		Vector3 c = *(Vector3*)&matrix.Columns[2]; 
+#unwarn
+		Vector3 d = *(Vector3*)&matrix.Columns[3];  
+
+		float x = matrix[3, 0];
+		float y = matrix[3, 1];
+		float z = matrix[3, 2];
+		float w = matrix[3, 3];
+
+		Vector3 s = Vector3.Cross(a, b);
+		Vector3 t = Vector3.Cross(c, d);
+		Vector3 u = y * a - x * b;
+		Vector3 v = w * c - z * d;
+
+		float invDet = 1.0f / (Vector3.Dot(s, v) + Vector3.Dot(t, u));
+
+		s *= invDet;
+		t *= invDet;
+		u *= invDet;
+		v *= invDet;
+
+		Vector3 r0 = Vector3.Cross(b, v) + t * y;
+		Vector3 r1 = Vector3.Cross(v, a) - t * x;
+		Vector3 r2 = Vector3.Cross(d, u) + s * w;
+		Vector3 r3 = Vector3.Cross(u, c) - s * z;
+		return .(r0.X, r0.Y, r0.Z, -Vector3.Dot(b, t),
+				 r1.X, r1.Y, r1.Z,  Vector3.Dot(a, t),
+				 r2.X, r2.Y, r2.Z, -Vector3.Dot(d, s),
+				 r3.X, r3.Y, r3.Z,  Vector3.Dot(c, s));
+	}
+	
+	/**
+	 * Creates a perspective projection matrix.
+	 * @param fovY The vertical field of view.
+	 * @param aspectRation The aspect ratio of the viewport.
+	 * @param nearPlane The distance to the near plane.
+	 * @param farPlane The distance to the far plane.
+	 */
+	public static Matrix PerspectiveProjection(float fovY, float aspectRatio, float nearPlane, float farPlane)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite82).  . Kindle-Version. 
+
+		float g = 1.0f / Math.Tan(fovY * 0.5f);
+		float k = farPlane / (farPlane - nearPlane);
+
+		return .(g / aspectRatio, 0, 0, 0,
+				0, g, 0, 0,
+				0, 0, k, -nearPlane * k,
+				0, 0, 1, 0);
+	}
+	
+	/**
+	 * Creates a perspective projection matrix with reversed near- and far plane.
+	 * (i.e. Points on near plane have z-value of 1 and points of far plane have z-value of 0)
+	 * @param fovY The vertical field of view.
+	 * @param aspectRation The aspect ratio of the viewport.
+	 * @param nearPlane The distance to the near plane.
+	 * @param farPlane The distance to the far plane.
+	 */
+	public static Matrix ReversedPerspectiveProjection(float fovY, float aspectRatio, float nearPlane, float farPlane)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite86).  . Kindle-Version. 
+
+		float g = 1.0f / Math.Tan(fovY * 0.5f);
+		float k = nearPlane / (nearPlane - farPlane);
+
+		return .(g / aspectRatio, 0, 0, 0,
+				0, g, 0, 0,
+				0, 0, k, -farPlane * k,
+				0, 0, 1, 0);
+	}
+
+	/**
+	 * Creates a perspective projection matrix with a far plane at infinity.
+	 * @param fovY The vertical field of view.
+	 * @param aspectRation The aspect ratio of the viewport.
+	 * @param nearPlane The distance to the near plane.
+	 * @param ε An offset to account for floating point round-off errors at infinity.
+	 *			Note: Use a tiny value significant compared to the floating-point value of one.
+	 */
+	public static Matrix InfinitePerspectiveProjection(float fovY, float aspectRatio, float nearPlane, float ε = 1e-6f)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite83).  . Kindle-Version.
+
+		float g = 1.0f / Math.Tan(fovY * 0.5f);
+
+		float f = 1 - ε;
+
+		return .(g / aspectRatio, 0, 0, 0,
+				0, g, 0, 0,
+				0, 0, f, -nearPlane * f,
+				0, 0, 1, 0);
+	}
+	
+	/**
+	 * Creates a perspective projection matrix with a far plane at infinity with reversed near- and far plane.
+	 * (i.e. Points on near plane have z-value of 1 and points of far plane have z-value of 0)
+	 * @param fovY The vertical field of view.
+	 * @param aspectRation The aspect ratio of the viewport.
+	 * @param nearPlane The distance to the near plane.
+	 * @param ε An offset to account for floating point round-off errors at infinity.
+	 *			Note: Use a tiny value significant compared to the floating-point value of one.
+	 */
+	public static Matrix ReversedInfinitePerspectiveProjection(float fovY, float aspectRatio, float nearPlane, float ε = 1e-6f)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite88).  . Kindle-Version. 
+
+		float g = 1.0f / Math.Tan(fovY * 0.5f);
+
+		return .(g / aspectRatio, 0, 0, 0,
+				0, g, 0, 0,
+				0, 0, ε, nearPlane * (1 - ε),
+				0, 0, 1, 0);
+	}
+	
+	/**
+	 * Creates an orthographic projection matrix with the camera centered at the near-plane.
+	 * @param width The width of the view volume.
+	 * @param height The height of the view volume.
+	 * @param depth The depth of the view volume.
+	 */
+	public static Matrix OrthographicProjection(float width, float height, float depth)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite91).  . Kindle-Version. 
+		return .(2.0f / width, 0, 0, 0,
+				0, 2.0f/height, 0, 0,
+				0, 0, 1.0f / depth, 0,
+				0, 0, 0, 1);
+	}
+	
+	/**
+	 * Creates an orthographic projection matrix.
+	 * @param left The left side of the view volume.
+	 * @param right The right side of the view volume.
+	 * @param top The top side of the view volume.
+	 * @param bottom The bottom side of the view volume.
+	 * @param near The near plane of the view volume.
+	 * @param far The far plane of the view volume.
+	 */
+	public static Matrix OrthographicProjectionOffCenter(float left, float right, float top, float bottom, float near, float far)
+	{
+		// Lengyel, Eric. Foundations of Game Engine Development, Volume 2: Rendering (Seite91).  . Kindle-Version.
+
+		float w_inv = 1.0f / (right - left);
+		float h_inv = 1.0f / (top - bottom);
+		float d_inv = 1.0f / (far - near);
+
+		return .(2.0f * w_inv,	0.0f, 	  0.0f, -(right + left) * w_inv,
+					0.0f,	2.0f * h_inv, 0.0f, -(bottom + top) * h_inv,
+					0.0f, 		0.0f,     d_inv, 	-near * d_inv,
+					0.0f, 		0.0f, 	  0.0f, 		1.0f);
+	}
+
+	public static bool operator ==(Matrix left, Matrix right)
+	{
+		return Matrix.Equals(left, right);
+	}
+	
+	public static bool operator !=(Matrix left, Matrix right)
+	{
+		return !Matrix.Equals(left, right);
+	}
+
+	public static bool Equals(Matrix left, Matrix right)
+	{
+		return left.Values == right.Values;
+	}
+
+	public static explicit operator Matrix3x3(Matrix value)
+	{
+		return .(value.Right, value.Up, value.Forward);
+	}
+
+	public static void Exponent(ref Matrix matrix, int exponent, out Matrix result)
+	{
+		if(exponent == 0)
+			result = .Identity;
+		else if(exponent == 1)
+			result = matrix;
+		else if(exponent > 1)
+		{
+			result = .Identity;
+			Matrix b = matrix;
+
+			var exponent;
+
+			for(;exponent > 0;)
+			{
+				if(exponent & 1 > 0)
+					result *= b;
+
+				exponent >>= 1;
+
+				if(exponent > 0)
+					b *= b;
+			}
+
+		}
+		else // Exponent < 0
+		{
+			Matrix m = matrix.Invert();
+			Exponent(ref m, -exponent, out result);
+		}
+	}
+	
+	/**
+	 * Orthogonalizes the matrix.
+	*/
+	public void Orthogonalize() mut
+	{
+		Columns[1] -= .Project(Columns[1], Columns[0]);
+		Columns[2] -= .Project(Columns[2], Columns[0]) + .Project(Columns[2], Columns[1]);
+		Columns[3] -= .Project(Columns[3], Columns[0]) + .Project(Columns[3], Columns[1]) + .Project(Columns[3], Columns[2]);
+	}
+
+	/**
+	 * Orthonormalizes the matrix.
+	*/
+	public void Orthonormalize() mut
+	{
+		Columns[0].Normalize();
+		Columns[1] = .Normalize(.Reject(Columns[1], Columns[0]));
+		Columns[2] = .Normalize(.Reject(.Reject(Columns[2], Columns[0]), Columns[1]));
+		Columns[3] = .Normalize(.Reject(.Reject(.Reject(Columns[2], Columns[0]), Columns[1]), Columns[2]));
+	}
+	public static Self RotationQuaternion(Quaternion rotation)
+	{
+		float xSq = 2 * rotation.X * rotation.X;
+		float ySq = 2 * rotation.Y * rotation.Y;
+		float zSq = 2 * rotation.Z * rotation.Z;
+
+		float xy = 2 * rotation.X * rotation.Y;
+		float xz = 2 * rotation.X * rotation.Z;
+		float xw = 2 * rotation.X * rotation.W;
+		float yz = 2 * rotation.Y * rotation.Z;
+		float yw = 2 * rotation.Y * rotation.W;
+		float zw = 2 * rotation.Z * rotation.W;
+
+		Self result = ?;
+
+		result._11 = 1 - ySq - zSq;
+		result._21 = xy + zw;
+		result._31 = xz - yw;
+		result._41 = 0;
+
+		result._12 = xy - zw;
+		result._22 = 1 - xSq - zSq;
+		result._32 = yz + xw;
+		result._42 = 0;
+
+		result._13 = xz + yw;
+		result._23 = yz - xw;
+		result._33 = 1 - xSq - ySq;
+		result._43 = 0;
+
+		result._14 = 0;
+		result._24 = 0;
+		result._34 = 0;
+		result._44 = 1;
+		
+		return result;
+	}
+
+	public static void Decompose(Self matrix, out Vector3 position, out Quaternion rotation, out Vector3 scale)
+	{
+		var matrix;
+
+		// Translation -> get last column
+		position = matrix.Translation;
+		// Zero translation for next step
+		matrix.Translation = .Zero;
+
+		// TODO: this doesn't detect mirroring
+
+		// Extract scaling from matrix
+		scale.X = (*(Vector3*)&matrix.Columns[0]).Magnitude();
+		scale.Y = (*(Vector3*)&matrix.Columns[1]).Magnitude();
+		scale.Z = (*(Vector3*)&matrix.Columns[2]).Magnitude();
+
+		if(MathHelper.IsZero(scale.X) || MathHelper.IsZero(scale.Y) || MathHelper.IsZero(scale.Z))
+		{
+			rotation = .Identity;
+			return;
+		}
+
+		// Remove scale from matrix (normalize the columns)
+		matrix.Columns[0] /= scale.X;
+		matrix.Columns[1] /= scale.Y;
+		matrix.Columns[2] /= scale.Z;
+
+		rotation = Quaternion.FromMatrix(matrix);
+	}
+}

GlitchyEngine/src/Math/MatrixExtension.bf

@@ -1,89 +0,0 @@
-using System;
-using GlitchyEngine.Math;
-using GlitchyEngine;
-
-namespace DirectX.Math
-{
-	extension Matrix
-	{
-		typealias Vec3 = GlitchyEngine.Math.Vector3;
-
-		public static Self RotationQuaternion(Quaternion rotation)
-		{
-			float xSq = 2 * rotation.X * rotation.X;
-			float ySq = 2 * rotation.Y * rotation.Y;
-			float zSq = 2 * rotation.Z * rotation.Z;
-
-			float xy = 2 * rotation.X * rotation.Y;
-			float xz = 2 * rotation.X * rotation.Z;
-			float xw = 2 * rotation.X * rotation.W;
-			float yz = 2 * rotation.Y * rotation.Z;
-			float yw = 2 * rotation.Y * rotation.W;
-			float zw = 2 * rotation.Z * rotation.W;
-
-			Self result = ?;
-
-			result.V._11 = 1 - ySq - zSq;
-			result.V._21 = xy + zw;
-			result.V._31 = xz - yw;
-			result.V._41 = 0;
-
-			result.V._12 = xy - zw;
-			result.V._22 = 1 - xSq - zSq;
-			result.V._32 = yz + xw;
-			result.V._42 = 0;
-
-			result.V._13 = xz + yw;
-			result.V._23 = yz - xw;
-			result.V._33 = 1 - xSq - ySq;
-			result.V._43 = 0;
-
-			result.V._14 = 0;
-			result.V._24 = 0;
-			result.V._34 = 0;
-			result.V._44 = 1;
-			
-			return result;
-		}
-
-		public static void Decompose(Self matrix, out Vec3 position, out Quaternion rotation, out Vec3 scale)
-		{
-			var matrix;
-
-			// Translation -> get last column
-			position = matrix.Translation;
-			// Zero translation for next step
-			matrix.Translation = .Zero;
-
-			// TODO: this doesn't detect mirroring
-
-			// Extract scaling from matrix
-			scale.X = (*(Vec3*)&matrix.Columns[0]).Magnitude();
-			scale.Y = (*(Vec3*)&matrix.Columns[1]).Magnitude();
-			scale.Z = (*(Vec3*)&matrix.Columns[2]).Magnitude();
-
-			if(MathHelper.IsZero(scale.X) || MathHelper.IsZero(scale.Y) || MathHelper.IsZero(scale.Z))
-			{
-				rotation = .Identity;
-				return;
-			}
-
-			// Remove scale from matrix (normalize the columns)
-			matrix.Columns[0] /= scale.X;
-			matrix.Columns[1] /= scale.Y;
-			matrix.Columns[2] /= scale.Z;
-
-			rotation = Quaternion.FromMatrix(matrix);
-		}
-
-		/*[Test]
-		static void TestQuaternionToMatrix()
-		{
-			// Rotation around Z-Axis by 90°
-			Quaternion quat = .(0, 0, 0.707107f, 0.707107f);
-			quat.Normalize();
-
-
-		}*/
-	}
-}

GlitchyEngine/src/Math/Quaternion.bf

@@ -144,7 +144,7 @@ namespace GlitchyEngine.Math
 		{
 			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
 
-			var m = matrix.V;
+			var m = matrix;
 
 			Quaternion result = ?;
 

GlitchyEngine/src/Renderer/DebugRenderer.bf

@@ -111,15 +111,15 @@ namespace GlitchyEngine.Renderer
 			
 			Vector4[8] corners;
 			// Perspective
-			if(projection.V._43 != 0.0f)
+			if(projection._43 != 0.0f)
 			{
 				// near plane for perspective projection, far plane if reversed
-				float d1 = -projection.V._34 / projection.V._33;
+				float d1 = -projection._34 / projection._33;
 
-				float d2 = projection.V._34 / (1.0f - projection.V._33);
+				float d2 = projection._34 / (1.0f - projection._33);
 
-				float gOverS = projection.V._11;
+				float gOverS = projection._11;
-				float g = projection.V._22;
+				float g = projection._22;
 
 				//var corners = //(Vector4*)&_vbFrustum.Data;
 
@@ -158,14 +158,14 @@ namespace GlitchyEngine.Renderer
 			}
 			else
 			{
-				float l = -(projection.V._14 + 1.0f) / projection.V._11;
+				float l = -(projection._14 + 1.0f) / projection._11;
-				float r = (1.0f - projection.V._14) / projection.V._11;
+				float r = (1.0f - projection._14) / projection._11;
 
-				float t = -(projection.V._24 + 1.0f) / projection.V._22;
+				float t = -(projection._24 + 1.0f) / projection._22;
-				float b = (1.0f - projection.V._24) / projection.V._22;
+				float b = (1.0f - projection._24) / projection._22;
 
-				float n = -projection.V._34 / projection.V._33;
+				float n = -projection._34 / projection._33;
-				float f = (1 - projection.V._34) / projection.V._33;
+				float f = (1 - projection._34) / projection._33;
 				
 				//var corners = (Vector4*)&_vbFrustum.Data;
 				corners[0] = .(r, t, n, 1.0f);

GlitchyEngine/src/World/Scene.bf

@@ -491,5 +491,25 @@ namespace GlitchyEngine.World
 				handler(entity, componentType, component);
 			}
 		}
+
+		public WorldEnumerator<TComponent> GetEntities<TComponent>() where TComponent : struct
+		{
+			return _ecsWorld.Enumerate<TComponent>();
+		}
+
+		public WorldEnumerator<TComponent1, TComponent2> GetEntities<TComponent1, TComponent2>()
+			where TComponent1 : struct
+			where TComponent2 : struct
+		{
+			return _ecsWorld.Enumerate<TComponent1, TComponent2>();
+		}
+
+		public WorldEnumerator<TComponent1, TComponent2, TComponent3> GetEntities<TComponent1, TComponent2, TComponent3>()
+			where TComponent1 : struct
+			where TComponent2 : struct
+			where TComponent3 : struct
+		{
+			return _ecsWorld.Enumerate<TComponent1, TComponent2, TComponent3>();
+		}
 	}
-}
+}