ya son puros for loops xd

src/surface.c

@@ -82,38 +82,6 @@ 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)
 {
@@ -122,12 +90,12 @@ static void __calculate_normal(
     float *v1, *v2, *v3;
     float *u1, *u2, *u3;
 
-	v1=malloc(n*sizeof(float));
+    v1 = malloc(n * sizeof(float));
-	v2=malloc(n*sizeof(float));
+    v2 = malloc(n * sizeof(float));
-	v3=malloc(n*sizeof(float));
+    v3 = malloc(n * sizeof(float));
-	u1=malloc(n*sizeof(float));
+    u1 = malloc(n * sizeof(float));
-	u2=malloc(n*sizeof(float));
+    u2 = malloc(n * sizeof(float));
-	u3=malloc(n*sizeof(float));
+    u3 = malloc(n * sizeof(float));
 
     switch (n)
     {
@@ -138,44 +106,65 @@ static void __calculate_normal(
         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 )
+        for (i = 0; i < n; ++i) {
-    	{
+            v1[i] = p2[i] - p1[i];  
-    		v1[i]=p2[i]-p1[i]; //cglm_vec4_sub( p2, p1, v1 );
+            v2[i] = p3[i] - p1[i]; 
-    		v2[i]=p3[i]-p1[i]; //cglm_vec4_sub( p3, p1, v2 );
+            v3[i] = p1[i];          
-    		v3[i]=p1[i];   //cglm_vec4_copy( p1, v3 );
         }
 
-    	for( i=0; i<n; ++i )
+        for (i = 0; i < n; ++i) {
-    		u1[i]=v1[i];   //cglm_vec4_copy( v1, u1 );
+            u1[i] = v1[i]; 
-
-        {
-            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;
+            float proj[n];
-            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
+            float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
-            glm_vec4_scale(u1, alpha, proj1);
+            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;
 
-            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
+            for (i = 0; i < n; ++i) {
-            glm_vec4_scale(u2, alpha, proj2);
+                proj[i] = u1[i] * alpha;
-
+                u2[i] = v2[i] - proj[i]; 
-            glm_vec4_sub(v3, proj1, u3);
+            }
-            glm_vec4_sub(u3, proj2, u3);
         }
 
-        glm_vec4_copy(u3, normal);
+        {
-        glm_vec4_normalize(normal);
+            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_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);
+
+        for (i = 0; i < n; ++i) {
+            normal[i] = u3[i] / magnitude;  
+        }
 
         free(v1);
         free(v2);
@@ -184,65 +173,10 @@ static void __calculate_normal(
         free(u2);
         free(u3);
         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];
-			}
-
-			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;
-#endif
     }
 }
 
+
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;