Set up struct surface, and use variable grid

src/main.c

@@ -1,5 +1,4 @@
 #include "main.h"
-#include "data/axis.h"
 #include "data/shaders.h"
 
 #include <stdio.h>
@@ -16,8 +15,8 @@
 #define M_PI 3.14159
 #endif
 
-float *generate_data_surface(unsigned char *);
+float *generate_data_surface(unsigned char *, unsigned long *);
-float *generate_normals_surface(float *, unsigned char);
+float *generate_normals_surface(float *, unsigned char, unsigned long);
 
 struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3};
 
@@ -38,9 +37,8 @@ void mlog(char *msg)
 }
 
 window_t window;
-mesh_t m_surface, m_axis;
+mesh_t m_surface;
 id_t shader, shader_plain;
-unsigned char m;
 
 extern volatile unsigned char animate_index;
 
@@ -83,14 +81,6 @@ static inline
 	}
 	clean_context();
 
-#ifndef DEBUG
-	load_mdl_matrix(shader_plain, 0, 0);
-	draw_mesh(m_axis);
-	load_mdl_matrix(shader_plain, 1, 1);
-	draw_mesh(m_axis);
-	load_mdl_matrix(shader_plain, 2, 2);
-	draw_mesh(m_axis);
-#endif
 	load_mdl_matrix(shader, 0, 3);
 	draw_mesh(m_surface);
 
@@ -155,32 +145,25 @@ int main(void)
 
 	mlog("[MESH] Inicializando...\n");
 	{
-		float *n_surface, *d_surface;
+		struct surface surface;
-		d_surface = generate_data_surface(&m);
-		n_surface = generate_normals_surface(d_surface, m);
 
-		if (!(m_surface = create_mesh(d_surface, n_surface, m)))
+		surface.data = generate_data_surface(&surface.dim, &surface.vertex);
+		surface.norm =
+			generate_normals_surface(surface.data, surface.dim, surface.vertex);
+
+		if (!(m_surface = create_mesh(surface)))
 		{
 			mlog("[MESH] Error al inicializar...\n");
 			goto error_mesh_surface;
 		}
 
-		projection.m = m;
+		projection.m = surface.dim;
 		projection.mesh = m_surface;
 
 		set_projection_mesh(projection);
 
-		free(n_surface);
+		free(surface.norm);
-		free(d_surface);
+		free(surface.data);
-	}
-
-	mlog("[MESH] Inicializando...\n");
-	{
-		if (!(m_axis = create_mesh(d_axis, NULL, 3)))
-		{
-			mlog("[MESH] Error al inicializar...\n");
-			goto error_mesh_axis;
-		}
 	}
 
 	mlog("[MAIN LOOP] Inicializando...\n");
@@ -193,8 +176,6 @@ int main(void)
 #endif
 	mlog("[MAIN LOOP] Terminando...\n");
 
-	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_axis);
 	mlog("[MESH] Destruyendo...\n");
 	destroy_mesh(m_surface);
 	mlog("[SHADER] Destruyendo...\n");
@@ -207,8 +188,6 @@ int main(void)
 	close_window(window);
 	return 0;
 
-	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_axis);
 error_mesh_axis:
 	mlog("[MESH] Destruyendo...\n");
 	destroy_mesh(m_surface);

src/mesh.c

@@ -47,36 +47,34 @@ void set_projection_mesh(struct projection projection)
 	This trick can be done with glVertexAttribPointer.
 */
 
-mesh_t create_mesh(float *d, float *n, unsigned char m)
+mesh_t create_mesh(struct surface surface)
 {
 	unsigned char i;
 	struct obj *p;
 
 	p = malloc(sizeof(struct obj));
 
-	p->vertex = (*d) / m;
+	p->vertex = surface.vertex;
 
 	glGenVertexArrays(1, &p->vao);
 	glBindVertexArray(p->vao);
 
 	glGenBuffers(1, &p->d_vbo);
 	glBindBuffer(GL_ARRAY_BUFFER, p->d_vbo);
-	glBufferData(
+	glBufferData(GL_ARRAY_BUFFER, p->vertex * surface.dim * sizeof(float),
-		GL_ARRAY_BUFFER, p->vertex * m * sizeof(float), d + 1, GL_STATIC_DRAW);
+		surface.data, GL_STATIC_DRAW);
 
-	if (n)
+	if (surface.norm)
 	{
 		glGenBuffers(1, &p->n_vbo);
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, p->n_vbo);
-		glBufferData(GL_ELEMENT_ARRAY_BUFFER, p->vertex * m * sizeof(float),
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER,
-			n + 1, GL_STATIC_DRAW);
+			p->vertex * surface.dim * sizeof(float), surface.norm,
+			GL_STATIC_DRAW);
 	}
 
-	for (i = 0; i < 4; ++i)
+	for (i = 0; i < 8; ++i)
-	{
 		glEnableVertexAttribArray(i);
-		glEnableVertexAttribArray(i + 4);
-	}
 
 	return p;
 }

src/surface.c

@@ -22,13 +22,13 @@
 #endif
 #include <stdio.h>
 
-typedef void (*function_t)(float *, int *, int);
+typedef void (*function_t)(float *, int *, unsigned char *);
 
 struct parm
 {
-	function_t f;
+	unsigned char *grid;
 	unsigned char m, n;
-	unsigned int grid;
+	function_t f;
 } parm;
 
 int factorial(int n)
@@ -47,11 +47,11 @@ int numero_caras(int n)
 	return (1 << (n - 3)) * factorial(n) / factorial(n - 2);
 }
 
-void riemman(float *d_surface, int *coords, int grid)
+void riemman(float *d_surface, int *coords, unsigned char *grid)
 {
 	complex double eq;
-	float u = 2 * ((float)coords[0] / grid) - 1;
+	float u = 2 * ((float)coords[0] / grid[0]) - 1;
-	float v = 2 * ((float)coords[1] / grid) - 1;
+	float v = 2 * ((float)coords[1] / grid[1]) - 1;
 
 	eq = csqrt(CMPLX(u, v));
 
@@ -61,42 +61,42 @@ void riemman(float *d_surface, int *coords, int grid)
 	d_surface[3] = cimag(eq);
 }
 
-void cube(float *d_surface, int *coord, int grid)
+void cube(float *d_surface, int *coord, unsigned char *grid)
 {
 	int i;
 
 	for (i = 0; i < parm.m; i++)
-		d_surface[i] = (2 * (float)coord[i] / grid) - 1;
+		d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
 
 	if (parm.m == 2)
 		d_surface[2] = 0;
 }
 
-void mobius(float *d_surface, int *coord, int grid)
+void mobius(float *d_surface, int *coord, unsigned char *grid)
 {
 	const float width = 0.5;
-	float u = (2 * M_PI) * ((float)coord[0] / grid);
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
-	float v = (2 * width) * ((float)coord[1] / grid) - width;
+	float v = (2 * width) * ((float)coord[1] / grid[1]) - 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)
+void torus(float *d_surface, int *coord, unsigned char *grid)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid);
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
-	float v = (2 * M_PI) * ((float)coord[1] / grid);
+	float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
 
 	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)
+void klein(float *d_surface, int *coord, unsigned char *grid)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid);
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
-	float v = (2 * M_PI) * ((float)coord[1] / grid);
+	float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
 
 	d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
 	d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
@@ -104,17 +104,17 @@ void klein(float *d_surface, int *coord, int grid)
 	d_surface[3] = sin(v) * sin(u / 2);
 }
 
-float *generate_data_surface(unsigned char *s)
+float *generate_data_surface(unsigned char *dim, unsigned long *vertex)
 {
 	unsigned int i, j, k, o, p, n;
 	long size, q = 0;
 	float *d_surface;
 	int *cara;
 
-	parm.f = klein;
+	parm.f = mobius;
 	parm.m = 2;
-	parm.n = 4;
+	parm.n = 3;
-	parm.grid = 16;
+	parm.grid = (char[2]){16, 2};
 
 #ifdef TEST
 	assert(numero_caras(2) == 1);
@@ -122,12 +122,16 @@ float *generate_data_surface(unsigned char *s)
 	assert(numero_caras(4) == 24);
 #endif
 
-	*s = parm.n;
+	*dim = parm.n;
+	*vertex = 0;
+
+	for (o = 0; o < parm.m; o++)
+		for (p = 0; p < o; p++)
+			*vertex += parm.grid[p] * parm.grid[o] * 6;
 
 	cara = malloc(parm.m * sizeof(int));
-	size = parm.grid * parm.grid * 6 * (parm.n) * numero_caras(parm.m);
+	size = (*dim) * (*vertex);
-	d_surface = malloc((size + 1) * sizeof(float));
+	d_surface = malloc(size * sizeof(float));
-	d_surface[0] = size;
 
 	for (o = 0; o < parm.m; o++)
 	{
@@ -141,41 +145,41 @@ float *generate_data_surface(unsigned char *s)
 					if (n == o || n == p)
 						skip++;
 
-					cara[n] = (k & (1 << (n - skip))) ? parm.grid : 0;
+					cara[n] = (k & (1 << (n - skip))) ? parm.grid[n] : 0;
 				}
 
-				for (i = 0; i < parm.grid; i++)
+				for (i = 0; i < parm.grid[p]; i++)
 				{
-					for (j = 0; j < parm.grid; j++)
+					for (j = 0; j < parm.grid[o]; j++)
 					{
 						cara[p] = i;
 						cara[o] = j;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 
 						cara[p] = i + 1;
 						cara[o] = j;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 
 						cara[p] = i + 1;
 						cara[o] = j + 1;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 
 						cara[p] = i;
 						cara[o] = j;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 
 						cara[p] = i;
 						cara[o] = j + 1;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 
 						cara[p] = i + 1;
 						cara[o] = j + 1;
-						parm.f(&d_surface[q + 1], cara, parm.grid);
+						parm.f(&d_surface[q], cara, parm.grid);
 						q += parm.n;
 					}
 				}
@@ -285,23 +289,22 @@ static void __calculate_normal(
 	}
 }
 
-float *generate_normals_surface(float *d, unsigned char m)
+float *generate_normals_surface(float *d, unsigned char m, unsigned long vertex)
 {
 	float *n;
-	n = malloc((*d + 1) * sizeof(float));
-	*n = *d;
-
 	float *norm_vec;
+
+	n = malloc((m * vertex) * sizeof(float));
+
 	norm_vec = malloc(m * sizeof(float));
 
 	for (int i = 0; i < *d; i += 3 * m)
 	{
 
-		__calculate_normal(
+		__calculate_normal(d + i, d + i + m, d + i + 2 * m, norm_vec, m);
-			(d + 1) + i, (d + 1) + i + m, (d + 1) + i + 2 * m, norm_vec, m);
+		glm_vec3_copy(norm_vec, n + i);
-		glm_vec3_copy(norm_vec, (n + 1) + i);
+		glm_vec3_copy(norm_vec, n + i + m);
-		glm_vec3_copy(norm_vec, (n + 1) + i + m);
+		glm_vec3_copy(norm_vec, n + i + 2 * m);
-		glm_vec3_copy(norm_vec, (n + 1) + i + 2 * m);
 	}
 
 	free(norm_vec);