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;
-}