ax/manigraph
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Set up struct surface, and use variable grid

Browse Source
This commit is contained in:
PedroEdiaz
2024-12-01 13:23:29 -06:00
parent b19100424d
commit 0729388291
3 changed files with 67 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/main.c
View File

@@ -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_normals_surface(float *, unsigned char);
float *generate_data_surface(unsigned char *, unsigned long *);
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;
d_surface = generate_data_surface(&m);
n_surface = generate_normals_surface(d_surface, m);
struct surface surface;
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(d_surface);
}
mlog("[MESH] Inicializando...\n");
{
if (!(m_axis = create_mesh(d_axis, NULL, 3)))
{
mlog("[MESH] Error al inicializar...\n");
goto error_mesh_axis;
}
free(surface.norm);
free(surface.data);
}
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);

20
src/mesh.c
View File

@@ -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(
GL_ARRAY_BUFFER, p->vertex * m * sizeof(float), d + 1, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, p->vertex * surface.dim * sizeof(float),
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),
n + 1, GL_STATIC_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
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;
}

89
src/surface.c
View File

@@ -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 v = 2 * ((float)coords[1] / grid) - 1;
float u = 2 * ((float)coords[0] / grid[0]) - 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 v = (2 * width) * ((float)coord[1] / grid) - width;
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
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 v = (2 * M_PI) * ((float)coord[1] / grid);
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
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 v = (2 * M_PI) * ((float)coord[1] / grid);
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
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.grid = 16;
parm.n = 3;
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);
d_surface = malloc((size + 1) * sizeof(float));
d_surface[0] = size;
size = (*dim) * (*vertex);
d_surface = malloc(size * sizeof(float));
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(
(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);
__calculate_normal(d + i, d + i + m, d + i + 2 * m, norm_vec, m);
glm_vec3_copy(norm_vec, n + i);
glm_vec3_copy(norm_vec, n + i + m);
glm_vec3_copy(norm_vec, n + i + 2 * m);
}
free(norm_vec);