Added batch rendering (however basic it might be)

1 files changed, 91 insertions, 137 deletions

diff --git a/source/math.h b/source/math.h
index e516569..22966ec 100755
--- a/source/math.h
+++ b/source/math.h
@@ -117,12 +117,6 @@ union Mat4 {
 	r32 buffer[16];
 };
 
-union Mat4RowMajor {
-	Vec4 xyzw[4];
-	r32 data[4][4];
-	r32 buffer[16];
-};
-
 // ==== Vec2 ====
 Vec2 v2(r32 v) {
   return Vec2{v, v};
@@ -355,47 +349,7 @@ Mat4 subtract4m(Mat4 a, Mat4 b)
 	return res;
 }
 
-#if disabled
-Vec4 multiply4mv_rm(Mat4RowMajor mat, Vec4 vec)
-{
-    /*
-     * @note: Incase I get confused about this in the future.
-     *
-     * Everything is row-order, which means that things in memory are laid out row first. So with a sample matrix
-     * we have this order in memory: r1c1 r1c2 r1c3 r1c4 r2c1 ... (r = row, c = column). The same holds true for 
-     * vectors. (maybe move this explanation to the top)
-     *
-     * Now, multiply4vm will multiply a vector with a matrix. Conventionally that does not make any sense as
-     * a vector is usually 4x1 and a matrix ix 4x4.
-     * What this function considers a vector, while it is a vector, it is infact a row from a matrix, which
-     * means that the vector is 1x4 and the matrix is 4x4.
-     * 
-     * The function is meant to supplement the matrix multiplication process to alleviate the multiple lines of code
-     * we have to write when multiplying the row of a left matrix to each column of the right matrix
-     */
-	Vec4 res = { 0 };
-	res.x = (mat.data[0][0] * vec.x) + (mat.data[0][1] * vec.y) + (mat.data[0][2] * vec.z) + (mat.data[0][3] * vec.w);
-	res.y = (mat.data[1][0] * vec.x) + (mat.data[1][1] * vec.y) + (mat.data[1][2] * vec.z) + (mat.data[1][3] * vec.w);
-	res.z = (mat.data[2][0] * vec.x) + (mat.data[2][1] * vec.y) + (mat.data[2][2] * vec.z) + (mat.data[2][3] * vec.w);
-	res.w = (mat.data[3][0] * vec.x) + (mat.data[3][1] * vec.y) + (mat.data[3][2] * vec.z) + (mat.data[3][3] * vec.w);
-	
-	return res;
-}
-
-Mat4RowMajor multiply4m_rm(Mat4RowMajor a, Mat4RowMajor b) 
-{
-  Mat4RowMajor res = { 0 };
-
-  res.xyzw[0] = multiply4mv_rm(b, a.xyzw[0]);
-  res.xyzw[1] = multiply4mv_rm(b, a.xyzw[1]);
-  res.xyzw[2] = multiply4mv_rm(b, a.xyzw[2]);
-  res.xyzw[3] = multiply4mv_rm(b, a.xyzw[3]);
-
-  return res;
-}
-#endif
-
-Vec4 multiply4vm(Vec4 v, Mat4 m)
+Vec4 multiply4mv(Mat4 m, Vec4 v)
 {
   Vec4 res = {0};
 
@@ -426,10 +380,10 @@ Mat4 multiply4m(Mat4 a, Mat4 b)
 {
   Mat4 res = { 0 };
 
-  res.row[0] = multiply4vm(b.row[0], a);
-  res.row[1] = multiply4vm(b.row[1], a);
-  res.row[2] = multiply4vm(b.row[2], a);
-  res.row[3] = multiply4vm(b.row[3], a);
+  res.row[0] = multiply4mv(a, b.row[0]);
+  res.row[1] = multiply4mv(a, b.row[1]);
+  res.row[2] = multiply4mv(a, b.row[2]);
+  res.row[3] = multiply4mv(a, b.row[3]);
 
   return res;
 }
@@ -446,20 +400,7 @@ Mat4 scaling_matrix4m(r32 x, r32 y, r32 z)
 	return res;
 }
 
-#if Disabled
-Mat4RowMajor translation_matrix4m_rm(r32 x, r32 y, r32 z)	
-{
-  // generates a 4x4 translation matrix for translation along each of the x,y,z axis
-	Mat4RowMajor res = init_value4m(1.0f);
-	res.data[0][3] = x;
-	res.data[1][3] = y;
-	res.data[2][3] = z;
-    
-	return res;
-}
-#endif
-
-Mat4 translation_matrix4m_cm(r32 x, r32 y, r32 z)
+Mat4 translation_matrix4m(r32 x, r32 y, r32 z)
 {
   Mat4 res = init_value4m(1.0f);
   res.row[3] = Vec4{x, y, z, 1.0f};
@@ -467,80 +408,46 @@ Mat4 translation_matrix4m_cm(r32 x, r32 y, r32 z)
   return res;
 }
 
-#if Disabled
-Mat4RowMajor rotation_matrix4m(r32 angle_radians, Vec3 axis)	// generates a 4x4 rotation matrix for rotation along each of the x,y,z axis
+Mat4 rotation_matrix4m(r32 angle_radians, Vec3 axis)
 {
-	Mat4RowMajor res = init_value4m(1.0f);
-	axis = normalize3v(axis);
-	
-	r32 cos_theta = cosf(angle_radians);
-	r32 sin_theta = sinf(angle_radians);
-	r32 cos_value = 1.0f - cos_theta;
-    
-	res.data[0][0] = (axis.x * axis.x * cos_value) + cos_theta;
-	res.data[0][1] = (axis.x * axis.y * cos_value) + (axis.z * sin_theta);
-	res.data[0][2] = (axis.x * axis.z * cos_value) - (axis.y * sin_theta);
-	
-	res.data[1][0] = (axis.x * axis.y * cos_value) - (axis.z * sin_theta);
-	res.data[1][1] = (axis.y * axis.y * cos_value) + cos_theta;
-	res.data[1][2] = (axis.y * axis.z * cos_value) + (axis.x * sin_theta);
-    
-	res.data[2][0] = (axis.x * axis.z * cos_value) + (axis.y * sin_theta);
-	res.data[2][1] = (axis.z * axis.y * cos_value) - (axis.x * sin_theta);
-	res.data[2][2] = (axis.z * axis.z * cos_value) + cos_theta;
-    
-	return res;
-}
+  Mat4 res = init_value4m(1.0f);
+  axis = normalize3v(axis);
 
-Mat4RowMajor perspective_projection4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far)
-{
-	Mat4RowMajor res = { 0 };
-	
-	res.data[0][0] = (2.0 * near)/(right - left);
-	res.data[0][2] = (right + left)/(right - left);
-    
-	res.data[1][1] = (2.0 * near)/(top - bottom);
-	res.data[1][2] = (top + bottom)/(top - bottom);
-    
-	res.data[2][2] = -(far + near)/(far - near);
-	res.data[2][3] = -2.0*far*near/(far - near);
-    
-	res.data[3][2] = -1.0;
-    
-	return res;
-}
+  r32 cos_theta = cosf(angle_radians);
+  r32 sin_theta = sinf(angle_radians);
+  r32 cos_value = 1.0f - cos_theta;
 
-Mat4RowMajor perspective4m(r32 fov, r32 aspect_ratio, r32 near, r32 far)
-{
-	r32 cotangent = 1.0f / tanf(fov / 2.0f);
-	
-	Mat4RowMajor res = { 0 };
-    
-	res.data[0][0] = cotangent / aspect_ratio;
-	
-	res.data[1][1] = cotangent;
-    
-	res.data[2][2] = -(far + near) / (far - near);
-	res.data[2][3] = -2.0f * far * near / (far - near);
-    
-	res.data[3][2] = -1.0f;
-    
-	return res;
+  res.data[0][0] = (axis.x * axis.x * cos_value) + cos_theta;
+  res.data[0][1] = (axis.x * axis.y * cos_value) + (axis.z * sin_theta);
+  res.data[0][2] = (axis.x * axis.z * cos_value) - (axis.y * sin_theta);
+
+  res.data[1][0] = (axis.x * axis.y * cos_value) - (axis.z * sin_theta);
+  res.data[1][1] = (axis.y * axis.y * cos_value) + cos_theta;
+  res.data[1][2] = (axis.y * axis.z * cos_value) + (axis.x * sin_theta);
+
+  res.data[2][0] = (axis.x * axis.z * cos_value) + (axis.y * sin_theta);
+  res.data[2][1] = (axis.y * axis.z * cos_value) - (axis.x * sin_theta);
+  res.data[2][2] = (axis.z * axis.z * cos_value) + cos_value;
+
+  return res;
 }
 
-Mat4RowMajor orthographic_projection4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far)
+Mat4 orthographic4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far)
 {
-  // @todo: understand the derivation once I am done experimenting
-  Mat4RowMajor res = { 0 };
-  res.data[0][0] = 2.0f/(right - left);   res.data[0][3] = -(right + left)/(right - left);
-  res.data[1][1] = 2.0f/(top - bottom);   res.data[1][3] = -(top + bottom)/(top - bottom);
-  res.data[2][2] = -2.0f/(far - near);    res.data[2][3] = -(far + near)/(far - near);
+  Mat4 res = init_value4m(0);
+
+  res.data[0][0] = 2.0f/(right - left);
+  res.data[1][1] = 2.0f/(top - bottom);
+  res.data[2][2] = 2.0f/(near - far);
+  res.data[3][0] = (right + left)/(left - right);
+  res.data[3][1] = (top + bottom)/(bottom - top);
+  res.data[3][2] = (far + near)/(near - far);
   res.data[3][3] = 1.0f;
 
   return res;
 }
 
-Mat4RowMajor lookat4m(Vec3 up, Vec3 forward, Vec3 right, Vec3 position)
+Mat4 lookat4m(Vec3 up, Vec3 forward, Vec3 right, Vec3 position)
 {
 	/*
 	* @note: The construction of the lookat matrix is not obvious. For that reason here is the supplemental matrial I have used to understand
@@ -549,14 +456,16 @@ Mat4RowMajor lookat4m(Vec3 up, Vec3 forward, Vec3 right, Vec3 position)
 	*		 It is because, we are moving from the position matrix which is a global to the view matrix which
 	*		 is a local. It won't be very clear from this illustration alone, so you would be best served watching the video and recollecting and understanding from there.
 	* 2. This article (https://twodee.org/blog/17560) derives (or rather shows), in a very shallow way how we get to the look at matrix.
-  *
-  * I am guessing this is not useful for 2D stuff
 	*/
-	Mat4RowMajor res = init_value4m(1.0);
-	res.xyzw[0] = Vec4{ right.x,		right.y,	 right.z,		-dot_multiply3v(right, position) };
-	res.xyzw[1] = Vec4{ up.x,				up.y,			 up.z,			-dot_multiply3v(up, position) };
-	res.xyzw[2] = Vec4{ forward.x,  forward.y, forward.z, -dot_multiply3v(forward, position) };
-	res.xyzw[3] = Vec4{ 0.0f,				0.0f,			 0.0f,			 1.0f };
+	Mat4 res = init_value4m(1.0f);
+	res.row[0] = Vec4{ right.x,   up.x,   forward.x,		0.0f };
+	res.row[1] = Vec4{ right.y,   up.y,   forward.y,	  0.0f };
+	res.row[2] = Vec4{ right.z,   up.z,   forward.z,    0.0f };
+
+	res.data[3][0] = -dot_multiply3v(right, position);
+	res.data[3][1] = -dot_multiply3v(up, position);
+	res.data[3][2] = -dot_multiply3v(forward, position);
+  res.data[3][3] = 1.0f;
     
 	return res;
 }
@@ -572,7 +481,7 @@ Vec3 camera_look_around(r32 angle_pitch, r32 angle_yaw)
   return camera_look;
 }
 
-Mat4RowMajor camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up)
+Mat4 camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up)
 {
 	// @note: We do this because this allows the camera to have the axis it looks at
 	// inwards be the +z axis.
@@ -582,7 +491,52 @@ Mat4RowMajor camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up)
 	Vec3 camera_right_dir   = normalize3v(cross_multiply3v(camera_up, camera_forward_dir));
 	Vec3 camera_up_dir      = normalize3v(cross_multiply3v(camera_forward_dir, camera_right_dir));
     
-	Mat4RowMajor res = lookat4m(camera_up_dir, camera_forward_dir, camera_right_dir, camera_pos);
+	Mat4 res = lookat4m(camera_up_dir, camera_forward_dir, camera_right_dir, camera_pos);
+    
+	return res;
+}
+
+Mat4 calculate_mvp4m(Mat4 Model, Mat4 View, Mat4 Projection)
+{
+  Mat4 mv = multiply4m(View, Model);
+  Mat4 mvp = multiply4m(Projection, mv);
+
+  return mvp;
+}
+
+#if Disabled
+Mat4RowMajor perspective_projection4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far)
+{
+	Mat4RowMajor res = { 0 };
+	
+	res.data[0][0] = (2.0 * near)/(right - left);
+	res.data[0][2] = (right + left)/(right - left);
+    
+	res.data[1][1] = (2.0 * near)/(top - bottom);
+	res.data[1][2] = (top + bottom)/(top - bottom);
+    
+	res.data[2][2] = -(far + near)/(far - near);
+	res.data[2][3] = -2.0*far*near/(far - near);
+    
+	res.data[3][2] = -1.0;
+    
+	return res;
+}
+
+Mat4RowMajor perspective4m(r32 fov, r32 aspect_ratio, r32 near, r32 far)
+{
+	r32 cotangent = 1.0f / tanf(fov / 2.0f);
+	
+	Mat4RowMajor res = { 0 };
+    
+	res.data[0][0] = cotangent / aspect_ratio;
+	
+	res.data[1][1] = cotangent;
+    
+	res.data[2][2] = -(far + near) / (far - near);
+	res.data[2][3] = -2.0f * far * near / (far - near);
+    
+	res.data[3][2] = -1.0f;
     
 	return res;
 }