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

Merge branch 'main' into roberto

Browse Source
This commit is contained in:
PedroEdiaz
2024-11-30 22:22:48 -06:00
parent 814f0c94a4 465d7acb3a
commit 565afe2f7d
11 changed files with 322 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
src/surface.c
View File

@@ -1,3 +1,4 @@
#include <complex.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
@@ -10,31 +11,58 @@
#define M_PI 3.14159265358979323846
#endif
void mobius(float *d_surface, int i, int j, int grid_size)
#ifndef CMPLX
#define CMPLX(a,b) (a+I*b)
#endif
void riemman(float *d_surface, int * coords, int grid_size)
{
complex double eq;
float u = 2 * ((float)coords[0] / grid_size) - 1;
float v = 2 * ((float)coords[1] / grid_size) - 1;
eq = csqrt(CMPLX(u,v));
d_surface[0] = u;
d_surface[1] = v;
d_surface[2] = creal(eq);
d_surface[3] = cimag(eq);
}
void cube( float *d_surface, int * coord, int grid_size )
{
unsigned char i;
for(int i=0; i<4; i++ )
d_surface[i]=(float)coord[i]/grid_size;
}
void mobius(float *d_surface, int * coord, int grid_size)
{
const float width = 0.5;
float u = (2 * M_PI) * ((float)i / grid_size);
float v = (2 * width) * ((float)j / grid_size) - width;
float u = (2 * M_PI) * ((float)coord[0] / grid_size);
float v = (2 * width) * ((float)coord[1] / grid_size) - 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 i, int j, int grid_size)
void torus(float *d_surface, int * coord, int grid_size)
{
float u = (2 * M_PI) * ((float)i / grid_size);
float v = (2 * M_PI) * ((float)j / grid_size);
float u = (2 * M_PI) * ((float)coord[0] / grid_size);
float v = (2 * M_PI) * ((float)coord[1] / grid_size);
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 i, int j, int grid_size)
void klein(float *d_surface, int * coord, int grid_size)
{
float u = (2 * M_PI) * ((float)i / grid_size);
float v = (2 * M_PI) * ((float)j / grid_size);
float u = (2 * M_PI) * ((float)coord[0] / grid_size);
float v = (2 * M_PI) * ((float)coord[1]/ grid_size);
d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
@@ -42,46 +70,86 @@ void klein(float *d_surface, int i, int j, int grid_size)
d_surface[3] = sin(v) * sin(u / 2);
}
typedef void (*function_t)(float *, int, int, int);
typedef void (*function_t)(float *, int *, int);
float *generate_data_surface(int grid_size, unsigned char *m)
float *generate_data_surface(int grid_size, unsigned char *s)
{
unsigned int i, j, k = 0;
long size;
unsigned int i, j, k, o, p, l, n, m;
long size, q=0;
function_t f;
float *d_surface;
f = klein;
*m = 4;
size = grid_size * grid_size * 6 * (*m);
const int dim =2;
int cara[dim];
char bits[dim+1];
bits[dim]=0;
f =klein ;
*s = 4;
size = grid_size * grid_size * 6 * (*s) * 24;
d_surface = malloc((size + 1) * sizeof(float));
d_surface[0] = size;
for (i = 0; i < grid_size; i++)
{
for (j = 0; j < grid_size; j++)
for(o = 0; o < dim; o ++)
{
for (p = 0; p < o; p++)
{
// triangle 1, Front
f(&d_surface[k + 1], i, j, grid_size);
k += *m;
f(&d_surface[k + 1], i + 1, j, grid_size);
k += *m;
f(&d_surface[k + 1], i + 1, j + 1, grid_size);
k += *m;
for (k = 0; k < (1 << (dim-2)); k++)
{
unsigned char skip=0;
for(n = 0; n < dim-2; n++)
{
if( n==(o-1) || n==p )
skip++;
// triangle 2, Back
f(&d_surface[k + 1], i, j, grid_size);
k += *m;
f(&d_surface[k + 1], i, j + 1, grid_size);
k += *m;
f(&d_surface[k + 1], i + 1, j + 1, grid_size);
k += *m;
cara[n+skip] = (k & (1<<n))?grid_size:0;
}
for(i = 0; i < grid_size; i++)
{
for (j = 0; j < grid_size; j++)
{
cara[o] = i;
cara[p] = j;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[o] = i + 1;
cara[p] = j;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[o] = i + 1;
cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[o] = i;
cara [p] = j;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[o] = i;
cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
cara[o] = i + 1;
cara [p] = j + 1;
f(&d_surface[q + 1], cara, grid_size);
q += *s;
}
}
}
}
}
return d_surface;
}
static void __calculate_normal(
float *p1, float *p2, float *p3, float *normal, unsigned char n)
{