Clean code for MVP Release

src/context.c

@@ -5,6 +5,7 @@ void set_clean_color_context( unsigned char r, unsigned char g, unsigned char b
 {
 	glEnable( GL_DEPTH_TEST );
 	glEnable( GL_CULL_FACE );
+
 	glCullFace( GL_BACK );
 
 	glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );

src/data/shaders.h

@@ -65,8 +65,7 @@ const char * fs =
 
 	"	float diffuse = max(dot(Normal, lightDir),0.0); "
 
-	"	float ambient = 0.5;"
+	"	FragColor = (0.5 + 0.5*diffuse)*color;"
-	"	FragColor = (ambient + diffuse)*color;"
 	"}";
 
 	

src/main.c

@@ -5,15 +5,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-#define CGLM_ALL_UNALIGNED
-#include <cglm/vec3.h>
-#include <cglm/vec4.h>
 
 #define WIDTH 512
 #define HEIGHT 512
 
-unsigned char coordanate[4] = {0,1,2,3};
-
 unsigned char palette[] =
 {
 	0xEB,0xD3,0xF8,0xff,
@@ -22,88 +17,12 @@ unsigned char palette[] =
 	0x7A,0x1C,0xAC,0xff,
 };
 
-void calc_normal(float* p1, float* p2, float* p3,float* normal, unsigned char n)
+unsigned char coordanate[4] = {0,1,2,3};
-{
+const char * wname = "manigraph: manifold grapher";
-	float alpha;
-	vec4 v1, v2, v3;
-	vec4 u1, u2, u3; 
 
-	switch (n)
+float * generate_data_surface(unsigned int, unsigned char *);
-	{
+float * generate_normals_surface(float *, unsigned char);
-	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;
-
-	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); 
-		
-		/* Setup U1 */
-		{
-			glm_vec4_copy(v1, u1);
-		}
-
-		/* Setup U2 */
-		{
-			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 U3 */
-		{
-			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);
-		return;
-	}	
-}
-
-float * fill_normal( float * d, unsigned char m )
-{
-	float * n;
-	n = malloc( (*d+1)*sizeof(float));
-	*n = *d;
-	for (int i = 0; i < *d; i += 3*m)
-	{
-
-		vec4 norm_vec;
-
-		calc_normal((d+1)+i, (d+1)+i+m, (d+1)+i+2*m, norm_vec, m);
-		glm_vec3_copy( norm_vec, (n+1)+i );
-		glm_vec3_copy( norm_vec, (n+1)+i+m );
-		glm_vec3_copy( norm_vec, (n+1)+i+2*m );
-	}
-	return n;
-}
 
 void mlog( char * msg )
 {
@@ -112,9 +31,6 @@ void mlog( char * msg )
 #endif
 }
 
-const char * wname = "manigraph: manifold grapher";
-float * generate_surface();
-
 int main( void )
 {
 	id_t shader, texture, shader_plain;
@@ -176,8 +92,8 @@ int main( void )
 	{
 		unsigned char m;
 		float * n_surface, *d_surface;
-		d_surface = generate_surface(16,&m);
+		d_surface = generate_data_surface(16,&m);
-		n_surface = fill_normal(d_surface, m);
+		n_surface = generate_normals_surface(d_surface, m);
 		if( !(m_surface = create_mesh(d_surface, n_surface, coordanate, m)))
 		{
 			mlog("[MESH] Error al inicializar...\n");
@@ -189,14 +105,11 @@ int main( void )
 
 	mlog("[MESH] Inicializando...\n");
 	{
-		float * n_axis;
+		if(!(m_axis = create_mesh(d_axis, NULL, coordanate, 3)))
-		n_axis = fill_normal(d_axis, 3);
-		if(!(m_axis = create_mesh(d_axis, n_axis, coordanate, 3)))
 		{
 			mlog("[MESH] Error al inicializar...\n");
 			goto error_mesh_axis; 
 		}
-		free(n_axis);
 	}
 
 	mlog("[MAIN LOOP] Inicializando...\n");

src/mesh.c

@@ -37,6 +37,9 @@ mesh_t create_mesh( float * d, float * n, unsigned char * coordanate, unsigned c
 		glEnableVertexAttribArray(i);
 	}
 
+	if( !n )
+		return p;
+
 	glGenBuffers( 1, &p->n_vbo );
 	glBindBuffer( GL_ARRAY_BUFFER, p->n_vbo );
 	glBufferData( GL_ARRAY_BUFFER, p->vertex*m*sizeof(float), n+1, 

src/surface.c

@@ -1,12 +1,14 @@
-#include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 
+#define CGLM_ALL_UNALIGNED
+#include <cglm/vec3.h>
+#include <cglm/vec4.h>
+
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
-typedef void(*function_t)(float*,int, int, int);
 
 void mobius(float *d_surface, int i, int j, int grid_size)
 {
@@ -40,7 +42,9 @@ void klein(float *d_surface, int i, int j, int grid_size)
 	d_surface[3] = sin(v)*sin(u/2);
 }
 
-float * generate_surface(int grid_size, unsigned char *m )
+typedef void(*function_t)(float*,int, int, int);
+
+float * generate_data_surface(int grid_size, unsigned char *m )
 {
 	unsigned int i,j,k=0;
 	long size;
@@ -94,3 +98,88 @@ float * generate_surface(int grid_size, unsigned char *m )
 
 	return d_surface;
 }
+
+static
+void __calculate_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:
+
+		glm_vec3_sub(p2, p1, v1); 
+		glm_vec3_sub(p3, p1, v2); 
+
+		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); 
+		
+		/* Setup U1 */
+		{
+			glm_vec4_copy(v1, u1);
+		}
+
+		/* Setup U2 */
+		{
+			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 U3 */
+		{
+			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);
+		return;
+	}	
+}
+
+float * generate_normals_surface( float * d, unsigned char m )
+{
+	float * n;
+	n = malloc( (*d+1)*sizeof(float));
+	*n = *d;
+	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);
+		glm_vec3_copy( norm_vec, (n+1)+i );
+		glm_vec3_copy( norm_vec, (n+1)+i+m );
+		glm_vec3_copy( norm_vec, (n+1)+i+2*m );
+	}
+	return n;
+}
+

src/window.c

@@ -13,7 +13,7 @@ window_t init_window(unsigned int w, unsigned int h, const char * name);
 /*
 	Limitamos los FPS, contando el tiempo en el que
 	se ejecuta el main loop, y esperando el tiempo restante
-	para lograr los fps deciados.
+	para lograr los fps deseados.
 */
 
 static
@@ -37,6 +37,7 @@ void __limit_fps_window(int max_fps)
 
 		current_time = glfwGetTime();
 	}
+
 	previous_time = current_time;
 }