Rendering: Shadows pt 2

.gitignore

@@ -6,6 +6,7 @@
 
 # Engine specific files
 console.log
+*.dump # shader content dumps for debuging
 
 # Engine local configurations
 AssetsPathConfig.json
@@ -69,4 +70,3 @@ xcuserdata/
 
 # Exculdes from ignore
 !**/ThirdParty/**
-

PolyEngine/Core/Src/Math/AABox.cpp

@@ -5,28 +5,28 @@
 using namespace Poly;
 
 //------------------------------------------------------------------------------
-AABox::AABox(const Vector& position, const Vector& size)
-	: Pos(position), Size(size)
+AABox::AABox(const Vector& min, const Vector& size)
+	: Min(min), Size(size)
 {
 	ASSERTE(Size.X >= 0 && Size.Y >= 0 && Size.Z >= 0, "Invalid aabox size!");
 }
 
 //------------------------------------------------------------------------------
 AABox AABox::GetIntersectionVolume(const AABox& rhs) const
 {
-	const float r1MinX = std::min(Pos.X, Pos.X + Size.X);
-	const float r1MaxX = std::max(Pos.X, Pos.X + Size.X);
-	const float r1MinY = std::min(Pos.Y, Pos.Y + Size.Y);
-	const float r1MaxY = std::max(Pos.Y, Pos.Y + Size.Y);
-	const float r1MinZ = std::min(Pos.Z, Pos.Z + Size.Z);
-	const float r1MaxZ = std::max(Pos.Z, Pos.Z + Size.Z);
+	const float r1MinX = std::min(Min.X, Min.X + Size.X);
+	const float r1MaxX = std::max(Min.X, Min.X + Size.X);
+	const float r1MinY = std::min(Min.Y, Min.Y + Size.Y);
+	const float r1MaxY = std::max(Min.Y, Min.Y + Size.Y);
+	const float r1MinZ = std::min(Min.Z, Min.Z + Size.Z);
+	const float r1MaxZ = std::max(Min.Z, Min.Z + Size.Z);
 
-	const float r2MinX = std::min(rhs.Pos.X, rhs.Pos.X + rhs.Size.X);
-	const float r2MaxX = std::max(rhs.Pos.X, rhs.Pos.X + rhs.Size.X);
-	const float r2MinY = std::min(rhs.Pos.Y, rhs.Pos.Y + rhs.Size.Y);
-	const float r2MaxY = std::max(rhs.Pos.Y, rhs.Pos.Y + rhs.Size.Y);
-	const float r2MinZ = std::min(rhs.Pos.Z, rhs.Pos.Z + rhs.Size.Z);
-	const float r2MaxZ = std::max(rhs.Pos.Z, rhs.Pos.Z + rhs.Size.Z);
+	const float r2MinX = std::min(rhs.Min.X, rhs.Min.X + rhs.Size.X);
+	const float r2MaxX = std::max(rhs.Min.X, rhs.Min.X + rhs.Size.X);
+	const float r2MinY = std::min(rhs.Min.Y, rhs.Min.Y + rhs.Size.Y);
+	const float r2MaxY = std::max(rhs.Min.Y, rhs.Min.Y + rhs.Size.Y);
+	const float r2MinZ = std::min(rhs.Min.Z, rhs.Min.Z + rhs.Size.Z);
+	const float r2MaxZ = std::max(rhs.Min.Z, rhs.Min.Z + rhs.Size.Z);
 
 	const float interLeft = std::max(r1MinX, r2MinX);
 	const float interTop = std::max(r1MinY, r2MinY);
@@ -36,9 +36,7 @@ AABox AABox::GetIntersectionVolume(const AABox& rhs) const
 	const float interDown = std::min(r1MaxZ, r2MaxZ);
 
 	if ((interLeft < interRight) && (interTop < interBottom) && (interUp < interDown))
-	{
 		return AABox(Vector(interLeft, interTop, interUp), Vector(interRight - interLeft, interBottom - interTop, interDown - interUp));
-	}
 	else
 		return AABox(Vector::ZERO, Vector::ZERO);
 }
@@ -47,34 +45,34 @@ std::array<Vector, 8> Poly::AABox::GetVertices() const
 {
     SILENCE_CLANG_WARNING(-Wmissing-braces, "Everything is ok here.");
 	return std::array<Vector, 8>{
-	    Pos,
-		Pos + Vector(Size.X, 0, 0),
-		Pos + Vector(Size.X, Size.Y, 0),
-		Pos + Vector(Size.X, Size.Y, Size.Z),
-		Pos + Vector(0, Size.Y, Size.Z),
-		Pos + Vector(0, 0, Size.Z),
-		Pos + Vector(0, Size.Y, 0),
-		Pos + Vector(Size.X, 0, Size.Z)
+	    Min,
+		Min + Vector(Size.X, 0, 0),
+		Min + Vector(Size.X, Size.Y, 0),
+		Min + Vector(Size.X, Size.Y, Size.Z),
+		Min + Vector(0, Size.Y, Size.Z),
+		Min + Vector(0, 0, Size.Z),
+		Min + Vector(0, Size.Y, 0),
+		Min + Vector(Size.X, 0, Size.Z)
 	};
     UNSILENCE_CLANG_WARNING();
 }
 
 AABox Poly::AABox::GetTransformed(const Matrix& transform) const
 {
-	Vector min = transform * Pos;
+	Vector min = transform * Min;
 	Vector max = min;
 
 	// Gather other 7 points
     SILENCE_CLANG_WARNING(-Wmissing-braces, "Everything is ok here.");
 	std::array<Vector, 7> points =
 	{
-		Pos + Vector(Size.X, 0, 0),
-		Pos + Vector(Size.X, Size.Y, 0),
-		Pos + Vector(Size.X, Size.Y, Size.Z),
-		Pos + Vector(0, Size.Y, Size.Z),
-		Pos + Vector(0, 0, Size.Z),
-		Pos + Vector(0, Size.Y, 0),
-		Pos + Vector(Size.X, 0, Size.Z)
+		Min + Vector(Size.X, 0, 0),
+		Min + Vector(Size.X, Size.Y, 0),
+		Min + Vector(Size.X, Size.Y, Size.Z),
+		Min + Vector(0, Size.Y, Size.Z),
+		Min + Vector(0, 0, Size.Z),
+		Min + Vector(0, Size.Y, 0),
+		Min + Vector(Size.X, 0, Size.Z)
 	};
     UNSILENCE_CLANG_WARNING();
 
@@ -93,7 +91,16 @@ Poly::AABox& Poly::AABox::Expand(const AABox& rhs)
 {
 	Vector min = Vector::Min(GetMin(), rhs.GetMin());
 	Vector max = Vector::Max(GetMax(), rhs.GetMax());
-	Pos = min;
+	Min = min;
+	Size = max - min;
+	return *this;
+}
+
+Poly::AABox& Poly::AABox::Expand(const Vector& rhs)
+{
+	Vector min = Vector::Min(GetMin(), rhs);
+	Vector max = Vector::Max(GetMax(), rhs);
+	Min = min;
 	Size = max - min;
 	return *this;
 }
@@ -102,6 +109,6 @@ Poly::AABox& Poly::AABox::Expand(const AABox& rhs)
 namespace Poly {
 	std::ostream & operator<<(std::ostream& stream, const AABox& rect)
 	{
-		return stream << "AABox[Pos: " << rect.Pos << " Size: " << rect.Size << " ]";
+		return stream << "AABox[Pos: " << rect.Min << " Size: " << rect.Size << " ]";
 	}
 }

PolyEngine/Core/Src/Math/AABox.hpp

@@ -12,54 +12,92 @@ namespace Poly {
 	{
 	public:
 
-		/// <summary>Constructor from position and size.</summary>
-		/// <param name="position">Position of the min point of the box.</param>
+		/// <summary>Constructor from min and size.</summary>
+		/// <param name="min">Position of the min point of the box.</param>
 		/// <param name="size">Size (extent) of the box in each of the directions.</param>
-		AABox(const Vector& position, const Vector& size);
+		AABox(const Vector& min, const Vector& size);
 		AABox() = default;
 
 		/// <summary>Calculates center of the box.</summary>
 		/// <returns>Center of the box.</returns>
-		Vector GetCenter() const { return Pos + (Size * 0.5f); }
+		Vector GetCenter() const { return Min + (Size * 0.5f); }
 
 		/// <summary>Returns the min point of the box. (posiiton)</summary>
 		/// <returns>Min point of the box.</returns>
-		const Vector& GetMin() const { return Pos; }
+		const Vector& GetMin() const { return Min; }
 
 		/// <summary>Returns the max point of the box.</summary>
 		/// <returns>Max point of the box.</returns>
-		Vector GetMax() const { return Pos + Size; }
+		Vector GetMax() const { return Min + Size; }
 
 		/// <summary>Returns Size of the box in all three dimensions.</summary>
 		/// <returns>Size of the box. (extent)</returns>
 		const Vector& GetSize() const { return Size; }
 
 		/// <summary>Sets position of the box.</summary>
 		/// <param name="pos">New position</param>
-		void SetPosition(const Vector& pos) { Pos = pos; }
+		void SetMin(const Vector& pos) { Min = pos; }
 
 		/// <summary>Sets size of the box.</summary>
 		/// <param name="size">New size</param>
 		void SetSize(const Vector& size) { Size = size; }
 
+		/// <summary>Checks whether a given AABox is interecting with this AABox.</summary>
+		/// <param name="rhs">Other box.</param>
+		/// <see cref="AABox.Contains()"/>
+		inline bool Intersects(const AABox& rhs) const
+		{	
+			return (abs(Min.X - rhs.Min.X) * 2.0f < (Size.X + rhs.Size.X))
+				&& (abs(Min.Y - rhs.Min.Y) * 2.0f < (Size.Y + rhs.Size.Y))
+				&& (abs(Min.Z - rhs.Min.Z) * 2.0f < (Size.Z + rhs.Size.Z));
+		}
+
 		/// <summary>Checks whether this AABox contains a given point.</summary>
 		/// <param name="point">Point to be checked.</param>
 		/// <see cref="AABox.IsCollidingWith()"/>
 		inline bool Contains(const Vector& point) const 
 		{ 
-			return point.X >= Pos.X && point.X <= (Pos.X + Size.X) 
-			&& point.Y >= Pos.Y && point.Y <= (Pos.Y + Size.Y) 
-			&& point.Z >= Pos.Z && point.Z <= (Pos.Z + Size.Z);
+			return point.X >= Min.X && point.X <= (Min.X + Size.X) 
+				&& point.Y >= Min.Y && point.Y <= (Min.Y + Size.Y) 
+				&& point.Z >= Min.Z && point.Z <= (Min.Z + Size.Z);
 		}
 
-		/// <summary>Checks whether a given AABox is interecting with this AABox.</summary>
+		/// <summary>Checks whether a given AABox contains this AABox on all axes.</summary>
 		/// <param name="rhs">Other box.</param>
-		/// <see cref="AABox.Contains()"/>
-		inline bool Intersects(const AABox& rhs) const
-		{	
-			return (abs(Pos.X - rhs.Pos.X) * 2 < (Size.X + rhs.Size.X))
-			&& (abs(Pos.Y - rhs.Pos.Y) * 2 < (Size.Y + rhs.Size.Y))
-			&& (abs(Pos.Z - rhs.Pos.Z) * 2 < (Size.Z + rhs.Size.Z));
+		inline bool Contains(const AABox& rhs) const
+		{
+			return ContainsX(rhs) && ContainsY(rhs) && ContainsZ(rhs);
+		}
+
+		/// <summary>Checks whether a given AABox contains this AABox on XY plane.</summary>
+		/// <param name="rhs">Other box.</param>
+		inline bool ContainsXY(const AABox& rhs) const
+		{
+			return ContainsX(rhs) && ContainsY(rhs);
+		}
+
+		/// <summary>Checks whether a given AABox contains this AABox on X axis.</summary>
+		/// <param name="rhs">Other box.</param>
+		inline bool ContainsX(const AABox& rhs) const
+		{
+			return (Min.X			<= rhs.Min.X + rhs.Size.X)
+				&& (Min.X + Size.X	>= rhs.Min.X);
+		}
+
+		/// <summary>Checks whether a given AABox contains this AABox on Y axis.</summary>
+		/// <param name="rhs">Other box.</param>
+		inline bool ContainsY(const AABox& rhs) const
+		{
+			return (Min.Y			<= rhs.Min.Y + rhs.Size.Y)
+				&& (Min.Y + Size.Y	>= rhs.Min.Y);
+		}
+
+		/// <summary>Checks whether a given AABox contains this AABox on Z axis.</summary>
+		/// <param name="rhs">Other box.</param>
+		inline bool ContainsZ(const AABox& rhs) const
+		{
+			return (Min.Z			<= rhs.Min.Z + rhs.Size.Z)
+				&& (Min.Z + Size.Z	>= rhs.Min.Z);
 		}
 
 		std::array<Vector, 8> GetVertices() const;
@@ -74,9 +112,11 @@ namespace Poly {
 
 		AABox& Expand(const AABox& rhs);
 
+		AABox& Expand(const Vector& rhs);
+
 		CORE_DLLEXPORT friend std::ostream& operator<< (std::ostream& stream, const AABox& color);
 	private:
-		Vector Pos;
+		Vector Min;
 		Vector Size;
 	};
 }

PolyEngine/Core/Src/Math/Matrix.cpp

@@ -224,25 +224,27 @@ Matrix& Matrix::SetScale(const Vector& scale) {
 //------------------------------------------------------------------------------
 Matrix& Matrix::SetLookAt(const Vector& pos, const Vector& lookAt, const Vector& up)
 {
+	const Vector front((lookAt - pos).GetNormalized());
+	const Vector side(front.Cross(up).GetNormalized());
+	const Vector newUp(side.Cross(front));
+
 	SetIdentity();
+									// same as GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	Data[0]  = side.X;				// glm[0][0]
+	Data[1]  = side.Y;				// glm[1][0] 
+	Data[2]  = side.Z;				// glm[2][0] 
 
-	Vector zAxis = pos - lookAt;
-	zAxis.Normalize();
-	Vector xAxis = up.Cross(zAxis);
-	xAxis.Normalize();
-	Vector yAxis = zAxis.Cross(xAxis);
+	Data[4]  = newUp.X;				// glm[0][1]
+	Data[5]  = newUp.Y;				// glm[1][1]
+	Data[6]  = newUp.Z;				// glm[2][1]
 
-	Data[0] = xAxis.X;
-	Data[1] = yAxis.X;
-	Data[2] = zAxis.X;
+	Data[8]  = -front.X;			// glm[0][2]
+	Data[9]  = -front.Y;			// glm[1][2]
+	Data[10] = -front.Z;			// glm[2][2]
 
-	Data[4] = xAxis.Y;
-	Data[5] = yAxis.Y;
-	Data[6] = zAxis.Y;
-
-	Data[8] = xAxis.Z;
-	Data[9] = yAxis.Z;
-	Data[10] = zAxis.Z;
+	Data[12] = -(side.Dot(pos));	// glm[3][0]
+	Data[13] = -(newUp.Dot(pos));	// glm[3][1]
+	Data[14] = front.Dot(pos);		// glm[3][2]
 
 	return *this;
 }
@@ -276,27 +278,47 @@ Matrix& Poly::Matrix::SetPerspective(Angle fov, float aspect, float near, float
 }
 
 //------------------------------------------------------------------------------
-Matrix& Poly::Matrix::SetOrthographic(float bottom, float top,  float left, float right, float near, float far)
+Matrix& Poly::Matrix::SetOrthographicZO(float bottom, float top, float left, float right, float near, float far)
 {
-	Data[0] = 2.0f / (right - left);
-	Data[1] = 0;
-	Data[2] = 0;
-	Data[3] = -(right + left) / (right - left);
-
-	Data[4] = 0;
-	Data[5] = 2.0f / (top - bottom);
-	Data[6] = 0;
-	Data[7] = -(top + bottom) / (top - bottom);
+	SetIdentity();
+													//  same as orthoRH_ZO: GLM_RIGHT_HANDED && GLM_DEPTH_ZERO_TO_ONE
+	Data[0] = 2.0f / (right - left);				// glm[0][0]
+	Data[1] = 0.0f;
+	Data[2] = 0.0f;
+	Data[3] = -(right + left) / (right - left);		// glm[3][0] 
+
+	Data[4] = 0.0f;
+	Data[5] = 2.0f / (top - bottom);				// glm[1][1]
+	Data[6] = 0.0f;
+	Data[7] = -(top + bottom) / (top - bottom);		// glm[3][1]
+
+	Data[8] = 0.0f;
+	Data[9] = 0.0f;
+	Data[10] = 1.0f / (far - near);					// glm[2][2]
+	Data[11] = near / (far - near);					// glm[3][2]
 
-	Data[8] = 0;
-	Data[9] = 0;
-	Data[10] = 2.0f / (far - near);
-	Data[11] = -(far + near) / (far - near);
+	return *this;
+}
 
-	Data[12] = 0;
-	Data[13] = 0;
-	Data[14] = 0;
-	Data[15] = 1;
+//------------------------------------------------------------------------------
+Matrix& Poly::Matrix::SetOrthographic(float bottom, float top,  float left, float right, float near, float far)
+{
+	SetIdentity();
+													// same as orthoRH_NO: GLM_RIGHT_HANDED && GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+	Data[0] = 2.0f / (right - left);				// glm[0][0]
+	Data[1] = 0.0f;
+	Data[2] = 0.0f;
+	Data[3] = -(right + left) / (right - left);		// glm[3][0] 
+
+	Data[4] = 0.0f;
+	Data[5] = 2.0f / (top - bottom);				// glm[1][1]
+	Data[6] = 0.0f;
+	Data[7] = -(top + bottom) / (top - bottom);		// glm[3][1]
+
+	Data[8] = 0.0f; 
+	Data[9] = 0.0f;
+	Data[10] = 2.0f / (far - near);					// glm[2][2]
+	Data[11] = -(far + near) / (far - near);		// glm[3][2]
 
 	return *this;
 }

PolyEngine/Core/Src/Math/Matrix.hpp

@@ -92,6 +92,15 @@ namespace Poly
 		/// <returns>Reference to itself.</returns>
 		Matrix& SetPerspective(Angle fov, float aspect, float near, float far);
 
+		/// <summary>Initializes matrix with orthographics projection in range of [0, 1]</summary>
+		/// <param name="top">Top dimension.</param>
+		/// <param name="bottom">Bottom dimension.</param>
+		/// <param name="left">Left dimension.</param>
+		/// <param name="right">Right dimension</param>
+		/// <param name="near">Near Z plane.</param>
+		/// <param name="far">Far Z plane.</param>
+		/// <returns>Reference to itself.</returns>
+		Matrix& SetOrthographicZO(float top, float bottom, float left, float right, float near, float far);
 
 		/// <summary>Initializes matrix with orthographics projection</summary>
 		/// <param name="top">Top dimension.</param>