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

Merge branch 'experimental'

Browse Source
This commit is contained in:
PedroEdiaz
2024-12-01 12:28:39 -06:00
parent ee144f2286 b19100424d
commit eb59f5346a
5 changed files with 124 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/main.c
View File

@@ -16,7 +16,7 @@
#define M_PI 3.14159 #define M_PI 3.14159
#endif #endif
float *generate_data_surface(unsigned int, unsigned char *); float *generate_data_surface(unsigned char *);
float *generate_normals_surface(float *, unsigned char); float *generate_normals_surface(float *, unsigned char);
struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3}; struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3};
@@ -40,12 +40,14 @@ void mlog(char *msg)
window_t window; window_t window;
mesh_t m_surface, m_axis; mesh_t m_surface, m_axis;
id_t shader, shader_plain; id_t shader, shader_plain;
unsigned char m;
extern volatile unsigned char animate_index; extern volatile unsigned char animate_index;
#ifndef EMSCRIPTEN #ifndef EMSCRIPTEN
static inline static inline
#endif #endif
void void
main_loop(void) main_loop(void)
{ {
@@ -79,22 +81,21 @@ static inline
load_float_to_shader(shader_plain, "angle", angle); load_float_to_shader(shader_plain, "angle", angle);
} }
} }
clean_context(); clean_context();
#ifndef DEBUG #ifndef DEBUG
load_mdl_matrix(shader_plain, 0, 0); load_mdl_matrix(shader_plain, 0, 0);
draw_mesh(m_axis, 1); draw_mesh(m_axis);
load_mdl_matrix(shader_plain, 1, 1); load_mdl_matrix(shader_plain, 1, 1);
draw_mesh(m_axis, 1); draw_mesh(m_axis);
load_mdl_matrix(shader_plain, 2, 2); load_mdl_matrix(shader_plain, 2, 2);
draw_mesh(m_axis, 1); draw_mesh(m_axis);
#endif #endif
load_mdl_matrix(shader, 0, 3); load_mdl_matrix(shader, 0, 3);
draw_mesh(m_surface, 0); draw_mesh(m_surface);
load_mdl_matrix(shader_plain, 0, 3); load_mdl_matrix(shader_plain, 0, 3);
draw_mesh(m_surface, 1); draw_mesh_lines(m_surface);
} }
int main(void) int main(void)
@@ -154,9 +155,8 @@ int main(void)
mlog("[MESH] Inicializando...\n"); mlog("[MESH] Inicializando...\n");
{ {
unsigned char m;
float *n_surface, *d_surface; 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); n_surface = generate_normals_surface(d_surface, m);
if (!(m_surface = create_mesh(d_surface, n_surface, m))) if (!(m_surface = create_mesh(d_surface, n_surface, m)))

4
src/main.h
View File

@@ -57,7 +57,9 @@ void set_projection_mesh( struct projection );
void destroy_mesh(mesh_t p); 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: Set background color:

BIN
src/main.o
View File

Binary file not shown.

20
src/mesh.c
View File

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

161
src/surface.c
View File

@@ -3,6 +3,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#define TEST
#define CGLM_ALL_UNALIGNED #define CGLM_ALL_UNALIGNED
#include <cglm/vec3.h> #include <cglm/vec3.h>
#include <cglm/vec4.h> #include <cglm/vec4.h>
@@ -15,11 +17,41 @@
#define CMPLX(a, b) (a + I * b) #define CMPLX(a, b) (a + I * b)
#endif #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; 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));
@@ -29,39 +61,42 @@ void riemman(float *d_surface, int *coords, int grid_size)
d_surface[3] = cimag(eq); 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; 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[0] = cos(u) + v * cos(u / 2) * cos(u);
d_surface[1] = sin(u) + v * cos(u / 2) * sin(u); d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
d_surface[2] = v * sin(u / 2); 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[0] = (1 + 0.5 * cos(v)) * cos(u);
d_surface[1] = (1 + 0.5 * cos(v)) * sin(u); d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
d_surface[2] = 0.5 * sin(v); 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[0] = (0.5 * cos(v) + 0.5) * cos(u);
d_surface[1] = (0.5 * cos(v) + 0.5) * sin(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); 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; long size, q = 0;
function_t f;
float *d_surface; 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 = malloc((size + 1) * sizeof(float));
d_surface[0] = size; d_surface[0] = size;
for (o = 0; o < dim; o++) for (o = 0; o < parm.m; o++)
{ {
for (p = 0; p < o; p++) 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++; 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; return d_surface;
} }