Merge branch 'experimental'

src/main.c

@@ -16,7 +16,7 @@
 #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 = 0, .y = 1, .z = 2, .w = 3};
@@ -40,12 +40,14 @@ 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)
 {
@@ -79,22 +81,21 @@ static inline
 			load_float_to_shader(shader_plain, "angle", angle);
 		}
 	}
-
 	clean_context();
 
 #ifndef DEBUG
 	load_mdl_matrix(shader_plain, 0, 0);
-	draw_mesh(m_axis, 1);
+	draw_mesh(m_axis);
 	load_mdl_matrix(shader_plain, 1, 1);
-	draw_mesh(m_axis, 1);
+	draw_mesh(m_axis);
 	load_mdl_matrix(shader_plain, 2, 2);
-	draw_mesh(m_axis, 1);
+	draw_mesh(m_axis);
 #endif
 	load_mdl_matrix(shader, 0, 3);
-	draw_mesh(m_surface, 0);
+	draw_mesh(m_surface);
 
 	load_mdl_matrix(shader_plain, 0, 3);
-	draw_mesh(m_surface, 1);
+	draw_mesh_lines(m_surface);
 }
 
 int main(void)
@@ -154,9 +155,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)))

src/main.h

@@ -57,7 +57,9 @@ void set_projection_mesh( struct projection );
 
 void destroy_mesh(mesh_t p);
 
-void draw_mesh(mesh_t p, char lines);
+void draw_mesh(mesh_t p);
+
+void draw_mesh_lines(mesh_t p);
 
 /*
 	Set background color:

src/mesh.c

@@ -91,19 +91,19 @@ void destroy_mesh(mesh_t p)
 	free(p);
 }
 
-void draw_mesh(mesh_t p, char lines)
+void draw_mesh(mesh_t p)
 {
 	struct obj *obj = p;
 
 	glBindVertexArray(obj->vao);
-	if (lines)
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-	{
-		int i;
-		for (i = 0; i < obj->vertex; i += 3)
-			glDrawArrays(GL_LINE_LOOP, i, 3);
-	}
-	else
-	{
 	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
 }
+void draw_mesh_lines(mesh_t p)
+{
+	struct obj *obj = p;
+
+	glBindVertexArray(obj->vao);
+	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
 }

src/surface.c

@@ -3,6 +3,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define TEST
+
 #define CGLM_ALL_UNALIGNED
 #include <cglm/vec3.h>
 #include <cglm/vec4.h>
@@ -15,11 +17,41 @@
 #define CMPLX(a, b) (a + I * b)
 #endif
 
-void riemman(float *d_surface, int *coords, int grid_size)
+#ifdef TEST
+#include <assert.h>
+#endif
+#include <stdio.h>
+
+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)
+		return 1;
+
+	return n * factorial(n - 1);
+}
+
+int numero_caras(int n)
+{
+	if (n == 2)
+		return 1;
+
+	return (1 << (n - 3)) * factorial(n) / factorial(n - 2);
+}
+
+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));
 
@@ -29,39 +61,42 @@ void riemman(float *d_surface, int *coords, int grid_size)
 	d_surface[3] = cimag(eq);
 }
 
-void cube(float *d_surface, int *coord, int grid_size)
+void cube(float *d_surface, int *coord, int grid)
 {
-	unsigned char i;
+	int i;
 
-	for (int i = 0; i < 4; i++)
+	for (i = 0; i < parm.m; i++)
-		d_surface[i] = (float)coord[i] / grid_size;
+		d_surface[i] = (2 * (float)coord[i] / grid) - 1;
+
+	if (parm.m == 2)
+		d_surface[2] = 0;
 }
 
-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);
@@ -69,81 +104,87 @@ 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, l, n, m;
+	unsigned int i, j, k, o, p, n;
 	long size, q = 0;
-	function_t f;
 	float *d_surface;
+	int *cara;
 
-	const int dim = 2;
+	parm.f = klein;
-	int cara[dim];
+	parm.m = 2;
-	char bits[dim + 1];
+	parm.n = 4;
-	bits[dim] = 0;
+	parm.grid = 16;
 
-	f = klein;
+#ifdef TEST
-	*s = 4;
+	assert(numero_caras(2) == 1);
+	assert(numero_caras(3) == 6);
+	assert(numero_caras(4) == 24);
+#endif
 
-	size = grid_size * grid_size * 6 * (*s) * 24;
+	*s = parm.n;
+
+	cara = malloc(parm.m * sizeof(int));
+	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;
-				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] = i;
-						cara[p] = j;
+						cara[o] = 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] = i + 1;
-						cara[p] = j;
+						cara[o] = 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] = i + 1;
-						cara[p] = j + 1;
+						cara[o] = 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] = i;
-						cara[p] = j;
+						cara[o] = 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[p] = i;
-						cara[p] = j + 1;
+						cara[o] = 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] = i + 1;
-						cara[p] = j + 1;
+						cara[o] = 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;
 }