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

Fix: cube, add test for cube generation

Browse Source
This commit is contained in:
PedroEdiaz
2024-12-01 00:13:26 -06:00
parent 468f9f951d
commit 1a0b804b57
2 changed files with 101 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/main.c
View File

@@ -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 )
if (animate_index && m)
{
angle+=0.01;
angle += 0.01;
load_uint_to_shader( shader, "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_plain, "angle", angle);
load_uint_to_shader(shader, "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_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);

138
src/surface.c
View File

@@ -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 v = 2 * ((float)coords[1] / grid_size) - 1;
float u = 2 * ((float)coords[0] / grid) - 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_size )
void cube(float *d_surface, int *coord, int grid)
{
for(int i = 0; i < dim; i++ )
d_surface[i] = ((float)coord[i]/grid_size) - 0.5;
for (int i = 0; i < parm.m; i++)
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 v = (2 * width) * ((float)coord[1] / grid_size) - width;
float u = (2 * M_PI) * ((float)coord[0] / grid);
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 v = (2 * M_PI) * ((float)coord[1] / grid_size);
float u = (2 * M_PI) * ((float)coord[0] / grid);
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 v = (2 * M_PI) * ((float)coord[1]/ grid_size);
float u = (2 * M_PI) * ((float)coord[0] / grid);
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(int grid_size, unsigned char *s)
float *generate_data_surface(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 ;
*s = 6;
parm.f = cube;
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;
for(n = 0; n < dim-2; n++)
unsigned char skip = 0;
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);
q += *s;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[o] = i + 1;
//cara[p] = j;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
// cara[p] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
//cara[o] = i + 1;
cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
// cara[o] = i + 1;
cara[p] = j + 1;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[o] = i;
cara [p] = j;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[p] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
//cara[o] = i;
cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
// cara[o] = i;
cara[p] = j + 1;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[o] = i + 1;
//cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
// cara [p] = j + 1;
parm.f(&d_surface[q + 1], cara, parm.grid);
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)
{