Fix: cube, add test for cube generation

src/main.c

@@ -16,10 +16,10 @@
 #define M_PI 3.14159
 #endif
 
-float *generate_data_surface(unsigned int, unsigned char *);
+float *generate_data_surface(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";
 
@@ -40,13 +40,15 @@ void mlog(char *msg)
 window_t window;
 mesh_t m_surface, m_axis;
 id_t shader, shader_plain;
+unsigned char m;
 
 extern volatile unsigned char animate_index;
 
 #ifndef EMSCRIPTEN
 static inline
 #endif
-void main_loop(void)
+	void
+	main_loop(void)
 {
 	quat_t q;
 
@@ -58,25 +60,23 @@ void main_loop(void)
 	{
 		static float angle = 0;
 
-
+		if (animate_index && m)
-		if( animate_index )
 		{
-			angle+=0.01;
+			angle += 0.01;
 
-			load_uint_to_shader( shader, "i", animate_index-1 );
+			load_uint_to_shader(shader, "i", animate_index - 1);
-			load_uint_to_shader( shader_plain, "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, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
 		}
 
-		if( angle > M_PI/2 && angle )
+		if (angle > M_PI / 2 && angle)
 		{
-			animate_index=0;
+			animate_index = 0;
 			angle = 0;
 		}
 	}
 
-
 	clean_context();
 
 #ifndef DEBUG
@@ -88,11 +88,10 @@ void main_loop(void)
 	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)
@@ -152,9 +151,8 @@ int main(void)
 
 	mlog("[MESH] Inicializando...\n");
 	{
-		unsigned char m;
 		float *n_surface, *d_surface;
-		d_surface = generate_data_surface(16, &m);
+		d_surface = generate_data_surface(&m);
 		n_surface = generate_normals_surface(d_surface, m);
 
 		if (!(m_surface = create_mesh(d_surface, n_surface, m)))
@@ -166,8 +164,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);

src/surface.c

@@ -2,6 +2,8 @@
 #include <math.h>
 #include <stdlib.h>
 
+#define TEST
+
 #define CGLM_ALL_UNALIGNED
 #include <cglm/vec3.h>
 #include <cglm/vec4.h>
@@ -11,14 +13,25 @@
 #endif
 
 #ifndef CMPLX
-#define CMPLX(a,b) (a+I*b)
+#define CMPLX(a, b) (a + I * b)
 #endif
 
-const int dim = 6;
+#ifdef TEST
+#include <assert.h>
+#endif
+
+typedef void (*function_t)(float *, int *, int);
+
+struct parm
+{
+	function_t f;
+	unsigned char m, n;
+	unsigned int grid;
+} parm;
 
 int factorial(int n)
 {
-	if(n == 1)
+	if (n == 1)
 		return 1;
 
 	return n * factorial(n - 1);
@@ -26,19 +39,19 @@ int factorial(int n)
 
 int numero_caras(int n)
 {
-	if(n == 2)
+	if (n == 2)
 		return 1;
 
 	return (1 << (n - 3)) * factorial(n) / factorial(n - 2);
 }
 
-void riemman(float *d_surface, int * coords, int grid_size)
+void riemman(float *d_surface, int *coords, int grid)
 {
 	complex double eq;
-	float u = 2 * ((float)coords[0] / grid_size) - 1;
+	float u = 2 * ((float)coords[0] / grid) - 1;
-	float v = 2 * ((float)coords[1] / grid_size) - 1;
+	float v = 2 * ((float)coords[1] / grid) - 1;
 
-	eq = csqrt(CMPLX(u,v));
+	eq = csqrt(CMPLX(u, v));
 
 	d_surface[0] = u;
 	d_surface[1] = v;
@@ -46,38 +59,37 @@ void riemman(float *d_surface, int * coords, int grid_size)
 	d_surface[3] = cimag(eq);
 }
 
-
+void cube(float *d_surface, int *coord, int grid)
-void cube( float *d_surface, int * coord, int grid_size )
 {
-	for(int i = 0; i < dim; i++ )
+	for (int i = 0; i < parm.m; i++)
-		d_surface[i] = ((float)coord[i]/grid_size) - 0.5;
+		d_surface[i] = ((float)coord[i] / grid) - 0.5;
 }
 
-void mobius(float *d_surface, int * coord, int grid_size)
+void mobius(float *d_surface, int *coord, int grid)
 {
 	const float width = 0.5;
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float u = (2 * M_PI) * ((float)coord[0] / grid);
-	float v = (2 * width) * ((float)coord[1] / grid_size) - width;
+	float v = (2 * width) * ((float)coord[1] / grid) - width;
 
 	d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
 	d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
 	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)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float u = (2 * M_PI) * ((float)coord[0] / grid);
-	float v = (2 * M_PI) * ((float)coord[1] / grid_size);
+	float v = (2 * M_PI) * ((float)coord[1] / grid);
 
 	d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
 	d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
 	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)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float u = (2 * M_PI) * ((float)coord[0] / grid);
-	float v = (2 * M_PI) * ((float)coord[1]/ grid_size);
+	float v = (2 * M_PI) * ((float)coord[1] / grid);
 
 	d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
 	d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
@@ -85,83 +97,91 @@ void klein(float *d_surface, int * coord, int grid_size)
 	d_surface[3] = sin(v) * sin(u / 2);
 }
 
-typedef void (*function_t)(float *, int *, int);
+float *generate_data_surface(unsigned char *s)
-
-float *generate_data_surface(int grid_size, unsigned char *s)
 {
 	unsigned int i, j, k, o, p, n;
 	long size, q = 0;
-	function_t f;
 	float *d_surface;
 
-	int cara[dim];
+	int *cara;
 
-	f =cube ;
+	parm.f = cube;
-	*s = 6;
+	parm.m = 5;
+	parm.n = parm.m;
+	parm.grid = 1;
 
-	size = grid_size * grid_size * 6 * (*s) * numero_caras(dim);
+#ifdef TEST
+	assert(numero_caras(2) == 1);
+	assert(numero_caras(3) == 6);
+	assert(numero_caras(4) == 24);
+#endif
+
+	cara = malloc(parm.m * sizeof(int));
+	*s = parm.m;
+
+	size = parm.grid * parm.grid * 6 * (parm.n) * numero_caras(parm.m);
 	d_surface = malloc((size + 1) * sizeof(float));
 	d_surface[0] = size;
 
-	for(o = 0; o < dim; o ++)
+	for (o = 0; o < parm.m; o++)
 	{
 		for (p = 0; p < o; p++)
 		{
-			for (k = 0; k < (1 << (dim-2)); k++)
+			for (k = 0; k < (1 << (parm.m - 2)); k++)
 			{
-				unsigned char skip=0;
+				unsigned char skip = 0;
-				for(n = 0; n < dim-2; n++)
+				for (n = 0; n < parm.m; n++)
 				{
-					if( n==(o-1) || n==p )
+					if (n == o || n == p)
 						skip++;
 
-					cara[n+skip] = (k & (1<<n))?grid_size:0;
+					cara[n] = (k & (1 << (n - skip))) ? parm.grid : 0;
 				}
 
-				for(i = 0; i < grid_size; i++)
+				for (i = 0; i < parm.grid; i++)
 				{
-					for (j = 0; j < grid_size; j++)
+					for (j = 0; j < parm.grid; j++)
 					{
 						cara[o] = i;
 						cara[p] = j;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 
 						cara[o] = i + 1;
-						//cara[p] = j;
+						// cara[p] = j;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 
-						//cara[o] = i + 1;
+						// cara[o] = i + 1;
-						cara [p] = j + 1;
+						cara[p] = j + 1;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 
 						cara[o] = i;
-						cara [p] = j; 
+						cara[p] = j;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 
-						//cara[o] = i;
+						// cara[o] = i;
-						cara [p] = j + 1;
+						cara[p] = j + 1;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 
 						cara[o] = i + 1;
-						//cara [p] = j + 1;
+						// cara [p] = j + 1;
-						f(&d_surface[q + 1], cara, grid_size);
+						parm.f(&d_surface[q + 1], cara, parm.grid);
-						q += *s;
+						q += parm.n;
 					}
 				}
 			}
 		}
 	}
-
+#ifdef TEST
+	assert(q == size);
+#endif
 	return d_surface;
 }
 
-
-
 static void __calculate_normal(
 	float *p1, float *p2, float *p3, float *normal, unsigned char n)
 {