From ee144f22866c7d0537b6a2215b3609432209588d Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Sat, 30 Nov 2024 22:33:28 -0600
Subject: [PATCH] Assert Style

---
 src/input.c   |  20 ++---
 src/main.c    |  34 ++++----
 src/main.o    | Bin 12824 -> 12744 bytes
 src/mesh.c    |   4 +-
 src/surface.c | 221 ++++++++++++++++++++++++++------------------------
 5 files changed, 140 insertions(+), 139 deletions(-)

diff --git a/src/input.c b/src/input.c
index 319923a..666a950 100644
--- a/src/input.c
+++ b/src/input.c
@@ -9,7 +9,7 @@ unsigned char selected_axis = 0;
 int window_width;
 int window_height;
 
-unsigned char animate_index=0;
+unsigned char animate_index = 0;
 
 versor q = GLM_QUAT_IDENTITY_INIT;
 
@@ -56,23 +56,22 @@ void __key_callback_input(
 		projection.w = projection.x;
 		projection.x = tmp;
 
-		animate_index=1;
+		animate_index = 1;
 		break;
 	case GLFW_KEY_O:
 		tmp = projection.w;
 		projection.w = projection.y;
 		projection.y = tmp;
-		animate_index=2;
+		animate_index = 2;
 		break;
 	case GLFW_KEY_P:
 		tmp = projection.w;
 		projection.w = projection.z;
 		projection.z = tmp;
-		animate_index=3;
+		animate_index = 3;
 		break;
 	}
 
-
 	return;
 }
 
@@ -114,9 +113,9 @@ void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
 	versor p = GLM_QUAT_IDENTITY_INIT;
 	versor r = GLM_QUAT_IDENTITY_INIT;
 
-	//glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);
-	glm_quatv(p, yoffset * ANGLE * 2, (vec3){-1,0,0});
-	glm_quatv(r, xoffset * ANGLE * 2, (vec3){0,1,0});
+	// glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);
+	glm_quatv(p, yoffset * ANGLE * 2, (vec3){-1, 0, 0});
+	glm_quatv(r, xoffset * ANGLE * 2, (vec3){0, 1, 0});
 	glm_quat_mul(p, q, q);
 	glm_quat_mul(r, q, q);
 
@@ -172,10 +171,11 @@ end:
 	glm_quat_normalize(q);
 
 	// LOG INFO
-	if(0)
+	if (0)
 	{
 		printf("QUAT: %2.5f %2.5f %2.5f %2.5f\n", q[0], q[1], q[2], q[3]);
-		printf("PROY: %3d %3d %3d (%3d)\n", projection.x, projection.y, projection.z, projection.w );
+		printf("PROY: %3d %3d %3d (%3d)\n", projection.x, projection.y,
+			projection.z, projection.w);
 		printf("\n");
 	}
 	return q;
diff --git a/src/main.c b/src/main.c
index 508fa1e..68e27ef 100644
--- a/src/main.c
+++ b/src/main.c
@@ -19,7 +19,7 @@
 float *generate_data_surface(unsigned int, unsigned char *);
 float *generate_normals_surface(float *, unsigned char);
 
-struct projection projection = {.x = 0, .y=1, .z=2, .w=3 };
+struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3};
 
 const char *wname = "manigraph: manifold grapher";
 
@@ -59,29 +59,27 @@ static inline
 	{
 		static float angle = 0;
 
-		if( angle > M_PI/2 )
+		if (angle > M_PI / 2)
 		{
-			animate_index=0;
+			animate_index = 0;
 			angle = 0;
 
-			load_float_to_shader( shader, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
-			set_projection_mesh( projection );
+			load_float_to_shader(shader, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
+			set_projection_mesh(projection);
 		}
 
-		if( animate_index )
+		if (animate_index)
 		{
-			load_uint_to_shader( shader, "i", animate_index-1 );
-			load_uint_to_shader( shader_plain, "i", animate_index-1 );
+			load_uint_to_shader(shader, "i", animate_index - 1);
+			load_uint_to_shader(shader_plain, "i", animate_index - 1);
 
-			angle+=0.01;
-			load_float_to_shader( shader, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
+			angle += 0.01;
+			load_float_to_shader(shader, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
 		}
 	}
 
-
-
 	clean_context();
 
 #ifndef DEBUG
@@ -93,11 +91,10 @@ static inline
 	draw_mesh(m_axis, 1);
 #endif
 	load_mdl_matrix(shader, 0, 3);
-	draw_mesh(m_surface,0);
+	draw_mesh(m_surface, 0);
 
 	load_mdl_matrix(shader_plain, 0, 3);
-	draw_mesh(m_surface,1);
-
+	draw_mesh(m_surface, 1);
 }
 
 int main(void)
@@ -170,8 +167,7 @@ int main(void)
 
 		projection.m = m;
 		projection.mesh = m_surface;
-		set_projection_mesh( projection );
-
+		set_projection_mesh(projection);
 
 		free(n_surface);
 		free(d_surface);
diff --git a/src/main.o b/src/main.o
index 36f5d064e6c5087469b5be291aefffa4c04bd2a0..55c9e3b301dfc9b4a77fe19b3fbf4d38bbe5234e 100644
GIT binary patch
literal 12744
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

literal 12824
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
CvnxUX

diff --git a/src/mesh.c b/src/mesh.c
index 0353741..59a7278 100644
--- a/src/mesh.c
+++ b/src/mesh.c
@@ -91,12 +91,12 @@ void destroy_mesh(mesh_t p)
 	free(p);
 }
 
-void draw_mesh(mesh_t p, char lines )
+void draw_mesh(mesh_t p, char lines)
 {
 	struct obj *obj = p;
 
 	glBindVertexArray(obj->vao);
-	if( lines )
+	if (lines)
 	{
 		int i;
 		for (i = 0; i < obj->vertex; i += 3)
diff --git a/src/surface.c b/src/surface.c
index 3e4aaa3..0207976 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -12,16 +12,16 @@
 #endif
 
 #ifndef CMPLX
-#define CMPLX(a,b) (a+I*b)
+#define CMPLX(a, b) (a + I * b)
 #endif
 
-void riemman(float *d_surface, int * coords, int grid_size)
+void riemman(float *d_surface, int *coords, int grid_size)
 {
 	complex double eq;
 	float u = 2 * ((float)coords[0] / grid_size) - 1;
 	float v = 2 * ((float)coords[1] / grid_size) - 1;
 
-	eq = csqrt(CMPLX(u,v));
+	eq = csqrt(CMPLX(u, v));
 
 	d_surface[0] = u;
 	d_surface[1] = v;
@@ -29,16 +29,15 @@ void riemman(float *d_surface, int * coords, int grid_size)
 	d_surface[3] = cimag(eq);
 }
 
-
-void cube( float *d_surface, int * coord, int grid_size )
+void cube(float *d_surface, int *coord, int grid_size)
 {
 	unsigned char i;
 
-	for(int i=0; i<4; i++ )
-		d_surface[i]=(float)coord[i]/grid_size;
+	for (int i = 0; i < 4; i++)
+		d_surface[i] = (float)coord[i] / grid_size;
 }
 
-void mobius(float *d_surface, int * coord, int grid_size)
+void mobius(float *d_surface, int *coord, int grid_size)
 {
 	const float width = 0.5;
 	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
@@ -49,7 +48,7 @@ void mobius(float *d_surface, int * coord, int grid_size)
 	d_surface[2] = v * sin(u / 2);
 }
 
-void torus(float *d_surface, int * coord, int grid_size)
+void torus(float *d_surface, int *coord, int grid_size)
 {
 	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
 	float v = (2 * M_PI) * ((float)coord[1] / grid_size);
@@ -59,10 +58,10 @@ void torus(float *d_surface, int * coord, int grid_size)
 	d_surface[2] = 0.5 * sin(v);
 }
 
-void klein(float *d_surface, int * coord, int grid_size)
+void klein(float *d_surface, int *coord, int grid_size)
 {
 	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
-	float v = (2 * M_PI) * ((float)coord[1]/ grid_size);
+	float v = (2 * M_PI) * ((float)coord[1] / grid_size);
 
 	d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
 	d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
@@ -75,38 +74,38 @@ typedef void (*function_t)(float *, int *, int);
 float *generate_data_surface(int grid_size, unsigned char *s)
 {
 	unsigned int i, j, k, o, p, l, n, m;
-	long size, q=0;
+	long size, q = 0;
 	function_t f;
 	float *d_surface;
 
-	const int dim =2;
+	const int dim = 2;
 	int cara[dim];
-	char bits[dim+1];
-	bits[dim]=0;
+	char bits[dim + 1];
+	bits[dim] = 0;
 
-	f =klein ;
+	f = klein;
 	*s = 4;
 
 	size = grid_size * grid_size * 6 * (*s) * 24;
 	d_surface = malloc((size + 1) * sizeof(float));
 	d_surface[0] = size;
-	
-	for(o = 0; o < dim; o ++)
-	{  
+
+	for (o = 0; o < dim; o++)
+	{
 		for (p = 0; p < o; p++)
 		{
-			for (k = 0; k < (1 << (dim-2)); k++)
+			for (k = 0; k < (1 << (dim - 2)); k++)
 			{
-				unsigned char skip=0;
-				for(n = 0; n < dim-2; n++)
+				unsigned char skip = 0;
+				for (n = 0; n < dim - 2; n++)
 				{
-					if( n==(o-1) || n==p )
+					if (n == (o - 1) || n == p)
 						skip++;
 
-					cara[n+skip] = (k & (1<<n))?grid_size:0;
+					cara[n + skip] = (k & (1 << n)) ? grid_size : 0;
 				}
 
-				for(i = 0; i < grid_size; i++)
+				for (i = 0; i < grid_size; i++)
 				{
 					for (j = 0; j < grid_size; j++)
 					{
@@ -121,136 +120,142 @@ float *generate_data_surface(int grid_size, unsigned char *s)
 						q += *s;
 
 						cara[o] = i + 1;
-						cara [p] = j + 1;
+						cara[p] = j + 1;
 						f(&d_surface[q + 1], cara, grid_size);
 						q += *s;
 
 						cara[o] = i;
-						cara [p] = j; 
+						cara[p] = j;
 						f(&d_surface[q + 1], cara, grid_size);
 						q += *s;
 
 						cara[o] = i;
-						cara [p] = j + 1;
+						cara[p] = j + 1;
 						f(&d_surface[q + 1], cara, grid_size);
 						q += *s;
 
 						cara[o] = i + 1;
-						cara [p] = j + 1;
+						cara[p] = j + 1;
 						f(&d_surface[q + 1], cara, grid_size);
 						q += *s;
 					}
 				}
-			}	
+			}
 		}
 	}
 
 	return d_surface;
 }
 
-
-
 static void __calculate_normal(
-    float *p1, float *p2, float *p3, float *normal, unsigned char n)
+	float *p1, float *p2, float *p3, float *normal, unsigned char n)
 {
-    unsigned char i;
-    float alpha;
-    float *v1, *v2, *v3;
-    float *u1, *u2, *u3;
+	unsigned char i;
+	float alpha;
+	float *v1, *v2, *v3;
+	float *u1, *u2, *u3;
 
-    v1 = malloc(n * sizeof(float));
-    v2 = malloc(n * sizeof(float));
-    v3 = malloc(n * sizeof(float));
-    u1 = malloc(n * sizeof(float));
-    u2 = malloc(n * sizeof(float));
-    u3 = malloc(n * sizeof(float));
+	v1 = malloc(n * sizeof(float));
+	v2 = malloc(n * sizeof(float));
+	v3 = malloc(n * sizeof(float));
+	u1 = malloc(n * sizeof(float));
+	u2 = malloc(n * sizeof(float));
+	u3 = malloc(n * sizeof(float));
 
-    /* 
-    	Calculate a normal vector of a plain using Gram-Schmidt process
-    */
-    {
-        for (i = 0; i < n; ++i) {
-            v1[i] = p2[i] - p1[i];  
-            v2[i] = p3[i] - p1[i]; 
-            v3[i] = p1[i];          
-        }
+	/*
+		Calculate a normal vector of a plain using Gram-Schmidt process
+	*/
+	{
+		for (i = 0; i < n; ++i)
+		{
+			v1[i] = p2[i] - p1[i];
+			v2[i] = p3[i] - p1[i];
+			v3[i] = p1[i];
+		}
 
-        for (i = 0; i < n; ++i) {
-            u1[i] = v1[i]; 
-        }
+		for (i = 0; i < n; ++i)
+		{
+			u1[i] = v1[i];
+		}
 
-        {
-            float proj[n];
-            float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
-            for (i = 0; i < n; ++i) {
-                dot_v2_u1 += v2[i] * u1[i];
-                dot_u1_u1 += u1[i] * u1[i];
-            }
-            alpha = dot_v2_u1 / dot_u1_u1;
+		{
+			float proj[n];
+			float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
+			for (i = 0; i < n; ++i)
+			{
+				dot_v2_u1 += v2[i] * u1[i];
+				dot_u1_u1 += u1[i] * u1[i];
+			}
+			alpha = dot_v2_u1 / dot_u1_u1;
 
-            for (i = 0; i < n; ++i) {
-                proj[i] = u1[i] * alpha;
-                u2[i] = v2[i] - proj[i]; 
-            }
-        }
+			for (i = 0; i < n; ++i)
+			{
+				proj[i] = u1[i] * alpha;
+				u2[i] = v2[i] - proj[i];
+			}
+		}
 
-        {
-            float proj1[n], proj2[n];
-            float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
-            float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
+		{
+			float proj1[n], proj2[n];
+			float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
+			float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
 
-            for (i = 0; i < n; ++i) {
-                dot_v3_u1 += v3[i] * u1[i];
-                dot_u1_u1 += u1[i] * u1[i];
-            }
-            for (i = 0; i < n; ++i) {
-                proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
-            }
+			for (i = 0; i < n; ++i)
+			{
+				dot_v3_u1 += v3[i] * u1[i];
+				dot_u1_u1 += u1[i] * u1[i];
+			}
+			for (i = 0; i < n; ++i)
+			{
+				proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
+			}
 
-            for (i = 0; i < n; ++i) {
-                dot_v3_u2 += v3[i] * u2[i];
-                dot_u2_u2 += u2[i] * u2[i];
-            }
-            for (i = 0; i < n; ++i) {
-                proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
-                u3[i] = v3[i] - proj1[i] - proj2[i]; 
-            }
-        }
+			for (i = 0; i < n; ++i)
+			{
+				dot_v3_u2 += v3[i] * u2[i];
+				dot_u2_u2 += u2[i] * u2[i];
+			}
+			for (i = 0; i < n; ++i)
+			{
+				proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
+				u3[i] = v3[i] - proj1[i] - proj2[i];
+			}
+		}
 
-        float magnitude = 0.0f;
-        for (i = 0; i < n; ++i) {
-            magnitude += u3[i] * u3[i];
-        }
-        magnitude = sqrtf(magnitude);
+		float magnitude = 0.0f;
+		for (i = 0; i < n; ++i)
+		{
+			magnitude += u3[i] * u3[i];
+		}
+		magnitude = sqrtf(magnitude);
 
-        for (i = 0; i < n; ++i) {
-            normal[i] = u3[i] / magnitude;  
-        }
+		for (i = 0; i < n; ++i)
+		{
+			normal[i] = u3[i] / magnitude;
+		}
 
-        free(v1);
-        free(v2);
-        free(v3);
-        free(u1);
-        free(u2);
-        free(u3);
-        return;
-    }
+		free(v1);
+		free(v2);
+		free(v3);
+		free(u1);
+		free(u2);
+		free(u3);
+		return;
+	}
 }
 
-
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
 	n = malloc((*d + 1) * sizeof(float));
 	*n = *d;
 
-	float * norm_vec;
-	norm_vec=malloc(m*sizeof(float));
+	float *norm_vec;
+	norm_vec = malloc(m * sizeof(float));
 
 	for (int i = 0; i < *d; i += 3 * m)
 	{
 
-
 		__calculate_normal(
 			(d + 1) + i, (d + 1) + i + m, (d + 1) + i + 2 * m, norm_vec, m);
 		glm_vec3_copy(norm_vec, (n + 1) + i);