From 793c11757d37d9110ff2e2294d42d5137a621a6b Mon Sep 17 00:00:00 2001
From: "roberto.mc" <roberto.qsobret@gmail.com>
Date: Mon, 18 Nov 2024 23:14:54 -0600
Subject: [PATCH 1/9] aiura pedro

---
 src/main.c | 133 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 79 insertions(+), 54 deletions(-)

diff --git a/src/main.c b/src/main.c
index 3118a4f..977dab7 100755
--- a/src/main.c
+++ b/src/main.c
@@ -23,69 +23,94 @@ unsigned char palette[] =
 	0x7A,0x1C,0xAC,0xff,
 };
 
-void calc_normal(float* p1, float* p2, float* p3,float* normal, unsigned char n)
-{
-	float alpha;
-	vec4 v1, v2, v3;
-	vec4 u1, u2, u3; 
-	
-	switch (n)
-	{
-	case 3:
+void calc_normal(float* p1, float* p2, float* p3, float* normal, unsigned char n) {
+    float alpha;
+    vec4 v1, v2, v3;
+    vec4 u1, u2, u3;
 
-		glm_vec3_sub(p2, p1, v1); 
-		glm_vec3_sub(p3, p1, v2); 
+    switch (n) {
+    case 3:
+        glm_vec3_sub(p2, p1, v1);
+        glm_vec3_sub(p3, p1, v2);
 
-		glm_vec3_cross(v1, v2, normal); 
-		glm_vec3_normalize(normal);
-		return;
+        glm_vec3_cross(v1, v2, normal);
+        glm_vec3_normalize(normal);
+        return;
 
-	case 4:
-
-		/* 
-			In Grant-Shmidth we need 3 linearly independian vector that forms a basis, 
-			so we can have a ortonormal version of that basis, since, we must have  
-				v1 = p3 - p1
-				v2 = p2 - p1
-			Then v3 = p1, will most certantly be linerly independiant to v1 and v2.
-		*/
-		glm_vec4_sub(p2, p1, v1); 
-		glm_vec4_sub(p3, p1, v2); 
-		glm_vec4_copy(p1, v3); 
+    case 4:
+        glm_vec4_sub(p2, p1, v1);
+        glm_vec4_sub(p3, p1, v2);
+        glm_vec4_copy(p1, v3);
+        glm_vec4_copy(v1, u1);
+        {
+            vec4 proj;
+            alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
+            glm_vec4_scale(u1, alpha, proj);
+            glm_vec4_sub(v2, proj, u2);
+        }
 		
-		/* Setup U1 */
-		{
-			glm_vec4_copy(v1, u1);
-		}
+        {
+            vec4 proj1, proj2;
+            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
+            glm_vec4_scale(u1, alpha, proj1);
 
-		/* Setup U2 */
-		{
-			vec4 proj;
+            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
+            glm_vec4_scale(u2, alpha, proj2);
 
-			alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
-			glm_vec4_scale(u1, alpha, proj);
+            glm_vec4_sub(v3, proj1, u3);
+            glm_vec4_sub(u3, proj2, u3);
+        }
 
-			glm_vec4_sub(v2, proj, u2); 
-		}
+        glm_vec4_copy(u3, normal);
+        glm_vec4_normalize(normal);
+        return;
 
-		/* Setup U3 */
-		{
-			vec4 proj1, proj2;
+    default:
+        float** u = malloc((n - 1) * sizeof(float*));
+        for (unsigned char i = 0; i < n - 1; i++) {
+            u[i] = malloc(n * sizeof(float));
+        }
 
-			alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
-			glm_vec4_scale(u1, alpha, proj1);
-		
-			alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
-			glm_vec4_scale(u2, alpha, proj2);
-		
-			glm_vec4_sub(v3, proj1, u3);
-			glm_vec4_sub(u3, proj2, u3);
-		}
-		
-		glm_vec4_copy(u3, normal);
-		glm_vec4_normalize(normal);
-		return;
-	}	
+        for (unsigned char i = 0; i < n - 1; i++) {
+            float* vi = malloc(n * sizeof(float));
+            for (unsigned char j = 0; j < n; j++) {
+                vi[j] = p2[j] - p1[j]; 
+            }
+
+            for (unsigned char j = 0; j < i; j++) {
+                float dot_vu = 0.0f, dot_uu = 0.0f;
+
+                for (unsigned char k = 0; k < n; k++) {
+                    dot_vu += vi[k] * u[j][k];
+                    dot_uu += u[j][k] * u[j][k];
+                }
+
+                for (unsigned char k = 0; k < n; k++) {
+                    vi[k] -= (dot_vu / dot_uu) * u[j][k];
+                }
+            }
+
+            memcpy(u[i], vi, n * sizeof(float));
+            free(vi);
+        }
+
+        memcpy(normal, u[n - 2], n * sizeof(float));
+
+        float norm = 0.0f;
+        for (unsigned char i = 0; i < n; i++) {
+            norm += normal[i] * normal[i];
+        }
+        norm = sqrtf(norm);
+        for (unsigned char i = 0; i < n; i++) {
+            normal[i] /= norm;
+        }
+
+        for (unsigned char i = 0; i < n - 1; i++) {
+            free(u[i]);
+        }
+        free(u);
+        return;
+    }
 }
 
 float * fill_normal( float * d, unsigned char m )

From d967550dd86ad5df98b73c2ed80fe53b81dcf5c8 Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Wed, 20 Nov 2024 11:08:07 -0600
Subject: [PATCH 2/9] Fix Compilation errors

---
 src/main.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main.c b/src/main.c
index 977dab7..f411065 100755
--- a/src/main.c
+++ b/src/main.c
@@ -8,6 +8,7 @@
 #define CGLM_ALL_UNALIGNED
 #include <cglm/vec3.h>
 #include <cglm/vec4.h>
+#include <string.h>
 
 #define WIDTH 512
 #define HEIGHT 512
@@ -24,6 +25,7 @@ unsigned char palette[] =
 };
 
 void calc_normal(float* p1, float* p2, float* p3, float* normal, unsigned char n) {
+    float **u;
     float alpha;
     vec4 v1, v2, v3;
     vec4 u1, u2, u3;
@@ -36,7 +38,7 @@ void calc_normal(float* p1, float* p2, float* p3, float* normal, unsigned char n
         glm_vec3_cross(v1, v2, normal);
         glm_vec3_normalize(normal);
         return;
-
+#if 0
     case 4:
         glm_vec4_sub(p2, p1, v1);
         glm_vec4_sub(p3, p1, v2);
@@ -64,9 +66,9 @@ void calc_normal(float* p1, float* p2, float* p3, float* normal, unsigned char n
         glm_vec4_copy(u3, normal);
         glm_vec4_normalize(normal);
         return;
-
+#endif
     default:
-        float** u = malloc((n - 1) * sizeof(float*));
+        u = malloc((n - 1) * sizeof(float*));
         for (unsigned char i = 0; i < n - 1; i++) {
             u[i] = malloc(n * sizeof(float));
         }

From 7888c06c41a8283ef359a4fe27d51047210c7356 Mon Sep 17 00:00:00 2001
From: "roberto.mc" <roberto.qsobret@gmail.com>
Date: Wed, 27 Nov 2024 19:08:57 -0600
Subject: [PATCH 3/9] aiura con R^n

---
 src/main.o    | Bin 0 -> 12824 bytes
 src/surface.c |  65 +++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 src/main.o

diff --git a/src/main.o b/src/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..36f5d064e6c5087469b5be291aefffa4c04bd2a0
GIT binary patch
literal 12824
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
CvnxUX

literal 0
HcmV?d00001

diff --git a/src/surface.c b/src/surface.c
index 458c3dd..7e44329 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -82,6 +82,38 @@ float *generate_data_surface(int grid_size, unsigned char *m)
 	return d_surface;
 }
 
+/* pa' rearmar la funcion _calc_normal te entendi que creara las funciones de cglm artesanalmente, entonces ps eso hago xd */
+
+void subtract(const float *v1, const float *v2, float *result, unsigned char n) 
+{
+    for (unsigned char i = 0; i < n; i++) {
+        result[i] = v1[i] - v2[i];
+    }
+}
+
+float dot_product(const float *a, const float *b, unsigned char n) 
+{
+    float result = 0.0f;
+    for (unsigned char i = 0; i < n; i++) {
+        result += a[i] * b[i];
+    }
+    return result;
+}
+
+void escalar_product(float a, const float *v1, float *result, unsigned char n) 
+{
+    for (unsigned char i = 0; i < n; i++) {
+        result[i] = a * v1[i];
+    }
+}
+
+void norm(const float *v1, float *result, unsigned char n) 
+{
+    float lenght = sqrtf(dot_product(v1, v1, n));
+    float inv_lenght = 1.0f / lenght;
+    escalar_product(inv_lenght, v1, result, n);
+}
+
 static void __calculate_normal(
 	float *p1, float *p2, float *p3, float *normal, unsigned char n)
 {
@@ -190,7 +222,7 @@ static void __calculate_normal(
 		return;
 	}
 }
-
+/*
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
@@ -209,3 +241,34 @@ float *generate_normals_surface(float *d, unsigned char m)
 	}
 	return n;
 }
+*/
+
+// Ando bien perdido u.u
+
+float *generate_normals_surface(const float *d, unsigned char m) 
+{
+    float *n = malloc((*d + 1) * sizeof(float));
+    *n = *d;
+    float v1[m], v2[m], normal[m];
+    for (int i = 0; i < *d; i += 3 * m) 
+	{
+        const float *A = (d + 1) + i;
+        const float *B = (d + 1) + i + m;
+        const float *C = (d + 1) + i + 2 * m;
+
+        subtract(B, A, v1, m);
+        subtract(C, A, v2, m);
+
+        for (unsigned char j = 0; j < m; j++) {
+            normal[j] = v1[(j + 1) % m] * v2[(j + 2) % m] - v1[(j + 2) % m] * v2[(j + 1) % m];
+        }
+        norm(normal, normal, m);
+        for (unsigned char j = 0; j < m; j++) {
+            (n + 1)[i + j] = normal[j];
+            (n + 1)[i + m + j] = normal[j];
+            (n + 1)[i + 2 * m + j] = normal[j];
+        }
+    }
+
+    return n;
+}

From 2c8795bd9f9b1c0e458645ede41be98f838f73a1 Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Wed, 27 Nov 2024 19:26:28 -0600
Subject: [PATCH 4/9] Ejemplo: de cambiar cglm por for-loops

---
 src/surface.c | 80 ++++++++++++++++++++++++---------------------------
 1 file changed, 37 insertions(+), 43 deletions(-)

diff --git a/src/surface.c b/src/surface.c
index 7e44329..a056bd3 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -117,10 +117,17 @@ void norm(const float *v1, float *result, unsigned char n)
 static void __calculate_normal(
 	float *p1, float *p2, float *p3, float *normal, unsigned char n)
 {
-	float **u;
+	unsigned char i;
 	float alpha;
-	vec4 v1, v2, v3;
-	vec4 u1, u2, u3;
+	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));
 
 	switch (n)
 	{
@@ -131,18 +138,23 @@ static void __calculate_normal(
 		glm_vec3_cross(v1, v2, normal);
 		glm_vec3_normalize(normal);
 		return;
-#if 0
 		/*
 			In Grant-Shmidth we need 3 linearly independian vector that forms a
 		   basis, so we can have a ortonormal version of that basis, since, we
 		   must have v1 = p3 - p1 v2 = p2 - p1 Then v3 = p1, will most certantly
 		   be linerly independiant to v1 and v2.
 		*/
-    case 4:
-        glm_vec4_sub(p2, p1, v1);
-        glm_vec4_sub(p3, p1, v2);
-        glm_vec4_copy(p1, v3);
-        glm_vec4_copy(v1, u1);
+    default:
+    	for( i=0; i<n; ++i )
+    	{
+    		v1[i]=p2[i]-p1[i]; //cglm_vec4_sub( p2, p1, v1 );
+    		v2[i]=p3[i]-p1[i]; //cglm_vec4_sub( p3, p1, v2 );
+    		v3[i]=p1[i];   //cglm_vec4_copy( p1, v3 );
+        }
+
+    	for( i=0; i<n; ++i )
+    		u1[i]=v1[i];   //cglm_vec4_copy( v1, u1 );
+
         {
             vec4 proj;
             alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
@@ -164,8 +176,15 @@ static void __calculate_normal(
 
         glm_vec4_copy(u3, normal);
         glm_vec4_normalize(normal);
+
+	free(v1);
+	free(v2);
+	free(v3);
+	free(u1);
+	free(u2);
+	free(u3);
         return;
-#endif
+#if 0
 	default:
 		u = malloc((n - 1) * sizeof(float *));
 		for (unsigned char i = 0; i < n - 1; i++)
@@ -220,18 +239,22 @@ static void __calculate_normal(
 		}
 		free(u);
 		return;
+#endif
 	}
 }
-/*
+
 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));
+
 	for (int i = 0; i < *d; i += 3 * m)
 	{
 
-		vec4 norm_vec;
 
 		__calculate_normal(
 			(d + 1) + i, (d + 1) + i + m, (d + 1) + i + 2 * m, norm_vec, m);
@@ -239,36 +262,7 @@ float *generate_normals_surface(float *d, unsigned char m)
 		glm_vec3_copy(norm_vec, (n + 1) + i + m);
 		glm_vec3_copy(norm_vec, (n + 1) + i + 2 * m);
 	}
+
+	free(norm_vec);
 	return n;
 }
-*/
-
-// Ando bien perdido u.u
-
-float *generate_normals_surface(const float *d, unsigned char m) 
-{
-    float *n = malloc((*d + 1) * sizeof(float));
-    *n = *d;
-    float v1[m], v2[m], normal[m];
-    for (int i = 0; i < *d; i += 3 * m) 
-	{
-        const float *A = (d + 1) + i;
-        const float *B = (d + 1) + i + m;
-        const float *C = (d + 1) + i + 2 * m;
-
-        subtract(B, A, v1, m);
-        subtract(C, A, v2, m);
-
-        for (unsigned char j = 0; j < m; j++) {
-            normal[j] = v1[(j + 1) % m] * v2[(j + 2) % m] - v1[(j + 2) % m] * v2[(j + 1) % m];
-        }
-        norm(normal, normal, m);
-        for (unsigned char j = 0; j < m; j++) {
-            (n + 1)[i + j] = normal[j];
-            (n + 1)[i + m + j] = normal[j];
-            (n + 1)[i + 2 * m + j] = normal[j];
-        }
-    }
-
-    return n;
-}

From 814f0c94a414bfc96547a629cb6a1716ecc4d171 Mon Sep 17 00:00:00 2001
From: "roberto.mc" <roberto.qsobret@gmail.com>
Date: Wed, 27 Nov 2024 23:22:31 -0600
Subject: [PATCH 5/9] ya son puros for loops xd

---
 src/surface.c | 226 ++++++++++++++++++--------------------------------
 1 file changed, 80 insertions(+), 146 deletions(-)

diff --git a/src/surface.c b/src/surface.c
index a056bd3..e505f2f 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -82,167 +82,101 @@ float *generate_data_surface(int grid_size, unsigned char *m)
 	return d_surface;
 }
 
-/* pa' rearmar la funcion _calc_normal te entendi que creara las funciones de cglm artesanalmente, entonces ps eso hago xd */
-
-void subtract(const float *v1, const float *v2, float *result, unsigned char n) 
-{
-    for (unsigned char i = 0; i < n; i++) {
-        result[i] = v1[i] - v2[i];
-    }
-}
-
-float dot_product(const float *a, const float *b, unsigned char n) 
-{
-    float result = 0.0f;
-    for (unsigned char i = 0; i < n; i++) {
-        result += a[i] * b[i];
-    }
-    return result;
-}
-
-void escalar_product(float a, const float *v1, float *result, unsigned char n) 
-{
-    for (unsigned char i = 0; i < n; i++) {
-        result[i] = a * v1[i];
-    }
-}
-
-void norm(const float *v1, float *result, unsigned char n) 
-{
-    float lenght = sqrtf(dot_product(v1, v1, n));
-    float inv_lenght = 1.0f / lenght;
-    escalar_product(inv_lenght, v1, result, n);
-}
-
 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));
 
-	switch (n)
-	{
-	case 3:
-		glm_vec3_sub(p2, p1, v1);
-		glm_vec3_sub(p3, p1, v2);
+    switch (n)
+    {
+    case 3:
+        glm_vec3_sub(p2, p1, v1);
+        glm_vec3_sub(p3, p1, v2);
 
-		glm_vec3_cross(v1, v2, normal);
-		glm_vec3_normalize(normal);
-		return;
-		/*
-			In Grant-Shmidth we need 3 linearly independian vector that forms a
-		   basis, so we can have a ortonormal version of that basis, since, we
-		   must have v1 = p3 - p1 v2 = p2 - p1 Then v3 = p1, will most certantly
-		   be linerly independiant to v1 and v2.
-		*/
-    default:
-    	for( i=0; i<n; ++i )
-    	{
-    		v1[i]=p2[i]-p1[i]; //cglm_vec4_sub( p2, p1, v1 );
-    		v2[i]=p3[i]-p1[i]; //cglm_vec4_sub( p3, p1, v2 );
-    		v3[i]=p1[i];   //cglm_vec4_copy( p1, v3 );
-        }
-
-    	for( i=0; i<n; ++i )
-    		u1[i]=v1[i];   //cglm_vec4_copy( v1, u1 );
-
-        {
-            vec4 proj;
-            alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj);
-            glm_vec4_sub(v2, proj, u2);
-        }
-		
-        {
-            vec4 proj1, proj2;
-            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj1);
-
-            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
-            glm_vec4_scale(u2, alpha, proj2);
-
-            glm_vec4_sub(v3, proj1, u3);
-            glm_vec4_sub(u3, proj2, u3);
-        }
-
-        glm_vec4_copy(u3, normal);
-        glm_vec4_normalize(normal);
-
-	free(v1);
-	free(v2);
-	free(v3);
-	free(u1);
-	free(u2);
-	free(u3);
+        glm_vec3_cross(v1, v2, normal);
+        glm_vec3_normalize(normal);
         return;
-#if 0
-	default:
-		u = malloc((n - 1) * sizeof(float *));
-		for (unsigned char i = 0; i < n - 1; i++)
-		{
-			u[i] = malloc(n * sizeof(float));
-		}
 
-		for (unsigned char i = 0; i < n - 1; i++)
-		{
-			float *vi = malloc(n * sizeof(float));
-			for (unsigned char j = 0; j < n; j++)
-			{
-				vi[j] = p2[j] - p1[j];
-			}
+    default:
+        for (i = 0; i < n; ++i) {
+            v1[i] = p2[i] - p1[i];  
+            v2[i] = p3[i] - p1[i]; 
+            v3[i] = p1[i];          
+        }
 
-			for (unsigned char j = 0; j < i; j++)
-			{
-				float dot_vu = 0.0f, dot_uu = 0.0f;
+        for (i = 0; i < n; ++i) {
+            u1[i] = v1[i]; 
+        }
 
-				for (unsigned char k = 0; k < n; k++)
-				{
-					dot_vu += vi[k] * u[j][k];
-					dot_uu += u[j][k] * u[j][k];
-				}
+        {
+            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 (unsigned char k = 0; k < n; k++)
-				{
-					vi[k] -= (dot_vu / dot_uu) * u[j][k];
-				}
-			}
+            for (i = 0; i < n; ++i) {
+                proj[i] = u1[i] * alpha;
+                u2[i] = v2[i] - proj[i]; 
+            }
+        }
 
-			memcpy(u[i], vi, n * sizeof(float));
-			free(vi);
-		}
+        {
+            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;
 
-		memcpy(normal, u[n - 2], n * sizeof(float));
+            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);
+            }
 
-		float norm = 0.0f;
-		for (unsigned char i = 0; i < n; i++)
-		{
-			norm += normal[i] * normal[i];
-		}
-		norm = sqrtf(norm);
-		for (unsigned char i = 0; i < n; i++)
-		{
-			normal[i] /= norm;
-		}
+            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 (unsigned char i = 0; i < n - 1; i++)
-		{
-			free(u[i]);
-		}
-		free(u);
-		return;
-#endif
-	}
+        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;  
+        }
+
+        free(v1);
+        free(v2);
+        free(v3);
+        free(u1);
+        free(u2);
+        free(u3);
+        return;
+    }
 }
 
+
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
@@ -265,4 +199,4 @@ float *generate_normals_surface(float *d, unsigned char m)
 
 	free(norm_vec);
 	return n;
-}
+}
\ No newline at end of file

From 1e009d5bdfe6ac2f11ee4358739d030bfa9a308c Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Thu, 28 Nov 2024 09:55:48 -0600
Subject: [PATCH 6/9] Fix gamma, add Glad, error if glad is compiled with
 emscripten

---
 Makefile           | 2 ++
 src/context.c      | 3 +--
 src/data/shaders.h | 7 ++++---
 src/main.c         | 8 +++++---
 src/main.h         | 8 +++++++-
 5 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/Makefile b/Makefile
index b2e71e1..28b3e45 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,7 @@
 BIN = manigraph
 
 OBJ = \
+	ext/glad/glad.o \
 	src/surface.o \
 	src/context.o \
 	src/texture.o \
@@ -14,6 +15,7 @@ OBJ = \
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
+	-I./ext/glad  \
 	-Wall -Wno-unused-function -std=c99 -D_GNU_SOURCE \
 
 WAYLAND-LIB = \
diff --git a/src/context.c b/src/context.c
index 4eb36bb..be286b5 100644
--- a/src/context.c
+++ b/src/context.c
@@ -4,8 +4,8 @@
 #include <GL/gl.h>
 #else
 #ifdef GLAD
-#include <GLFW/glfw3.h>
 #include <glad.h>
+#include <GLFW/glfw3.h>
 #else
 #include <GL/glew.h>
 #endif
@@ -14,7 +14,6 @@
 void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b)
 {
 	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_FRAMEBUFFER_SRGB); 
 	glClearColor((float)r / 0xff, (float)g / 0xff, (float)b / 0xff, 1.0);
 }
 
diff --git a/src/data/shaders.h b/src/data/shaders.h
index 48294f5..0e17dc0 100644
--- a/src/data/shaders.h
+++ b/src/data/shaders.h
@@ -67,7 +67,8 @@ const char * fs_plain =
 
 	"void main()"
 	"{"
-	"	FragColor = texture( palette, vec3( 0, 0, index ) ).rgba;"
+	"	vec4 color = texture( palette, vec3(0,0,index)).rgba;"
+	"	FragColor = vec4(pow(vec3(color),vec3(1.0/2.2)),color.a);"
 	"}";
 
 const char * fs =
@@ -102,6 +103,6 @@ const char * fs =
     "   float specular = pow(abs(dot(normalize(Normal), halfwayDir)), 32.0);\n"
     "   float diffuse = abs(dot(normalize(Normal), lightDir));\n"
 
-    "   vec3 result = (0.5 + 1.5*diffuse + 4*specular) * color.rgb;\n"
-    "   FragColor = vec4(result, color.a)*1/2.2;\n"
+    "   vec3 result = pow((0.5 + 0.5*diffuse + 1.5*specular) * color.rgb, vec3(1.0/2.2));\n"
+    "   FragColor = vec4(result, color.a);\n"
     "}";
diff --git a/src/main.c b/src/main.c
index fd7ae8d..7a84d89 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 = 3, .y=1, .z=2, .w=0 };
+struct projection projection = {.x = 0, .y=1, .z=2, .w=3 };
 
 const char *wname = "manigraph: manifold grapher";
 
@@ -65,6 +65,7 @@ void main_loop(void)
 
 			load_uint_to_shader( shader, "i", animate_index-1 );
 			load_uint_to_shader( shader_plain, "i", animate_index-1 );
+
 			load_float_to_shader( shader, "angle", angle);
 			load_float_to_shader( shader_plain, "angle", angle);
 		}
@@ -117,7 +118,7 @@ int main(void)
 			mlog("[CONTEXT] Error al inicializar...\n");
 			goto error_context;
 		}
-		set_clean_color_context(0xFB, 0xEA, 0xEB);
+		set_clean_color_context(0xFF, 0xFF, 0xFF);
 	}
 
 	mlog("[TEXTURE] Inicializando...\n");
@@ -184,7 +185,8 @@ int main(void)
 
 	mlog("[MAIN LOOP] Inicializando...\n");
 #ifdef EMSCRIPTEN
-	emscripten_set_main_loop(&main_loop, 0, 1);
+	emscripten_set_main_loop(&main_loop, 60, 1);
+	return 0;
 #else
 	while (is_open_window(window))
 		main_loop();
diff --git a/src/main.h b/src/main.h
index c003e36..9fb0637 100644
--- a/src/main.h
+++ b/src/main.h
@@ -5,7 +5,7 @@
 */
 
 /* #define DEBUG  */
-/* #define GLAD  */
+#define GLAD 
 
 typedef const void * window_t;
 typedef unsigned int id_t;
@@ -154,3 +154,9 @@ void destroy_texture(id_t texture);
 id_t create_palette_texture(const unsigned char colors[][4], unsigned char n );
 
 quat_t poll_input(window_t window);
+
+#ifdef EMSCRIPTEN 
+#ifdef GLAD
+#error undefine GLAD on src/main.h please
+#endif
+#endif

From 6c7c22ce509614c74bd9d5025aec8b8bcd18798d Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Thu, 28 Nov 2024 16:23:39 -0600
Subject: [PATCH 7/9] Fix: rotations on R4

---
 Makefile           |  3 ++-
 src/data/shaders.h |  4 ++--
 src/input.c        |  1 -
 src/main.c         | 30 ++++++++++++++++--------------
 src/main.h         |  2 +-
 5 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/Makefile b/Makefile
index 28b3e45..c4435ff 100644
--- a/Makefile
+++ b/Makefile
@@ -76,7 +76,8 @@ cocoa: $(OBJ)
 	$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
 
 wasm: $(OBJ)
-	$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o mani.html $(OBJ)
+	$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o $(BIN).js $(OBJ)
+	chmod -x $(BIN).wasm
 
 libglfw.so: 
 	$(CC) -fPIC -shared $(DFLAGS) -D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 
diff --git a/src/data/shaders.h b/src/data/shaders.h
index 0e17dc0..1c25efc 100644
--- a/src/data/shaders.h
+++ b/src/data/shaders.h
@@ -40,8 +40,8 @@ const char * vs =
 	"	vec3 aNormal = vec3(aNormal_x,aNormal_y,aNormal_z);"
 	"	vec3 aPos = vec3(aPos_x,aPos_y,aPos_z);"
 
-	"	aNormal[i] = (vec2(aNormal_w, aNormal[i]) * rotate2d(angle))[0];"
-	"	aPos[i] = (vec2(aPos_w, aPos[i]) * rotate2d(angle))[0];"
+	"	aNormal[i] = (vec2(aNormal[i], aNormal_w) * rotate2d(angle))[0];"
+	"	aPos[i] = (vec2(aPos[i], aPos_w) * rotate2d(angle))[0];"
 
 	"	Normal = mat3(transpose(inverse(rot*mdl))) * aNormal;"
 	"	gl_Position = fix * rot * mdl * vec4( aPos, 1.0 );\n"
diff --git a/src/input.c b/src/input.c
index 4e4280a..76d85fe 100644
--- a/src/input.c
+++ b/src/input.c
@@ -73,7 +73,6 @@ void __key_callback_input(
 	}
 
 
-	set_projection_mesh(projection);
 	return;
 }
 
diff --git a/src/main.c b/src/main.c
index 7a84d89..20da610 100644
--- a/src/main.c
+++ b/src/main.c
@@ -58,26 +58,29 @@ void main_loop(void)
 	{
 		static float angle = 0;
 
-
-		if( animate_index )
-		{
-			angle+=0.01;
-
-			load_uint_to_shader( shader, "i", animate_index-1 );
-			load_uint_to_shader( shader_plain, "i", animate_index-1 );
-
-			load_float_to_shader( shader, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
-		}
-
-		if( angle > M_PI/2 && angle )
+		if( angle > M_PI/2 )
 		{
 			animate_index=0;
 			angle = 0;
+
+			load_float_to_shader( shader, "angle", angle);
+			load_float_to_shader( shader_plain, "angle", angle);
+			set_projection_mesh( projection );
+		}
+
+		if( animate_index )
+		{
+			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);
 		}
 	}
 
 
+
 	clean_context();
 
 #ifndef DEBUG
@@ -166,7 +169,6 @@ int main(void)
 
 		projection.m = m;
 		projection.mesh = m_surface;
-
 		set_projection_mesh( projection );
 
 
diff --git a/src/main.h b/src/main.h
index 9fb0637..b939d5b 100644
--- a/src/main.h
+++ b/src/main.h
@@ -5,7 +5,7 @@
 */
 
 /* #define DEBUG  */
-#define GLAD 
+/* #define GLAD  */
 
 typedef const void * window_t;
 typedef unsigned int id_t;

From 590fa226580557f0de0e626a31d360745d037169 Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Thu, 28 Nov 2024 18:52:53 -0600
Subject: [PATCH 8/9] Better use of viewport

---
 src/matrix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/matrix.c b/src/matrix.c
index b5c48f9..5108268 100644
--- a/src/matrix.c
+++ b/src/matrix.c
@@ -30,7 +30,7 @@ void load_fix_matrix(id_t shader, float ratio)
 	const int d = 7;
 
 	glm_lookat((vec3){0, 0, -d}, (vec3){0, 0, 0}, (vec3){0, 1, 0}, m);
-	glm_perspective(CGLM_PI / 4, ratio, d - 3, d + 3, n);
+	glm_perspective(CGLM_PI / 6, ratio, d - 3, d + 3, n);
 	glm_mat4_mul(n, m, m);
 
 	load_mat4_to_shader(shader, "fix", (mat4_t)m);

From df5ae70aa2304939abe75966eb386d018018294a Mon Sep 17 00:00:00 2001
From: PedroEdiaz <ppedroediaz@gmail.com>
Date: Sat, 30 Nov 2024 22:27:57 -0600
Subject: [PATCH 9/9] Use G-S on all dimentions

---
 src/surface.c | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/src/surface.c b/src/surface.c
index c87daa5..3e4aaa3 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -165,17 +165,10 @@ static void __calculate_normal(
     u2 = malloc(n * sizeof(float));
     u3 = malloc(n * sizeof(float));
 
-    switch (n)
+    /* 
+    	Calculate a normal vector of a plain using Gram-Schmidt process
+    */
     {
-    case 3:
-        glm_vec3_sub(p2, p1, v1);
-        glm_vec3_sub(p3, p1, v2);
-
-        glm_vec3_cross(v1, v2, normal);
-        glm_vec3_normalize(normal);
-        return;
-
-    default:
         for (i = 0; i < n; ++i) {
             v1[i] = p2[i] - p1[i];  
             v2[i] = p3[i] - p1[i]; 
@@ -267,4 +260,4 @@ float *generate_normals_surface(float *d, unsigned char m)
 
 	free(norm_vec);
 	return n;
-}
\ No newline at end of file
+}