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

Clean code for MVP Release

Browse Source
This commit is contained in:
PedroEdiaz
2024-10-22 19:54:55 -06:00
parent 7787daa2da
commit 6727c5fa9a
6 changed files with 106 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/context.c
View File

@@ -5,6 +5,7 @@ void set_clean_color_context( unsigned char r, unsigned char g, unsigned char b
{
glEnable( GL_DEPTH_TEST );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );

3
src/data/shaders.h
View File

@@ -65,8 +65,7 @@ const char * fs =
" float diffuse = max(dot(Normal, lightDir),0.0); "
" float ambient = 0.5;"
" FragColor = (ambient + diffuse)*color;"
" FragColor = (0.5 + 0.5*diffuse)*color;"
"}";

101
src/main.c
View File

@@ -5,15 +5,10 @@
#include <stdlib.h>
#include <stdio.h>
#define CGLM_ALL_UNALIGNED
#include <cglm/vec3.h>
#include <cglm/vec4.h>
#define WIDTH 512
#define HEIGHT 512
unsigned char coordanate[4] = {0,1,2,3};
unsigned char palette[] =
{
0xEB,0xD3,0xF8,0xff,
@@ -22,88 +17,12 @@ unsigned char palette[] =
0x7A,0x1C,0xAC,0xff,
};
void calc_normal(float* p1, float* p2, float* p3,float* normal, unsigned char n)
{
float alpha;
vec4 v1, v2, v3;
vec4 u1, u2, u3;
switch (n)
{
case 3:
unsigned char coordanate[4] = {0,1,2,3};
const char * wname = "manigraph: manifold grapher";
glm_vec3_sub(p2, p1, v1);
glm_vec3_sub(p3, p1, v2);
float * generate_data_surface(unsigned int, unsigned char *);
float * generate_normals_surface(float *, unsigned char);
glm_vec3_cross(v1, v2, normal);
glm_vec3_normalize(normal);
return;
case 4:
/*
In Grant-Shmidth we need 3 linearly independian vector that forms a basis,
so we can have a ortonormal version of that basis, since, we must have
v1 = p3 - p1
v2 = p2 - p1
Then v3 = p1, will most certantly be linerly independiant to v1 and v2.
*/
glm_vec4_sub(p2, p1, v1);
glm_vec4_sub(p3, p1, v2);
glm_vec4_copy(p1, v3);
/* Setup U1 */
{
glm_vec4_copy(v1, u1);
}
/* Setup U2 */
{
vec4 proj;
alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
glm_vec4_scale(u1, alpha, proj);
glm_vec4_sub(v2, proj, u2);
}
/* Setup U3 */
{
vec4 proj1, proj2;
alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
glm_vec4_scale(u1, alpha, proj1);
alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
glm_vec4_scale(u2, alpha, proj2);
glm_vec4_sub(v3, proj1, u3);
glm_vec4_sub(u3, proj2, u3);
}
glm_vec4_copy(u3, normal);
glm_vec4_normalize(normal);
return;
}
}
float * fill_normal( float * d, unsigned char m )
{
float * n;
n = malloc( (*d+1)*sizeof(float));
*n = *d;
for (int i = 0; i < *d; i += 3*m)
{
vec4 norm_vec;
calc_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 );
}
return n;
}
void mlog( char * msg )
{
@@ -112,9 +31,6 @@ void mlog( char * msg )
#endif
}
const char * wname = "manigraph: manifold grapher";
float * generate_surface();
int main( void )
{
id_t shader, texture, shader_plain;
@@ -176,8 +92,8 @@ int main( void )
{
unsigned char m;
float * n_surface, *d_surface;
d_surface = generate_surface(16,&m);
n_surface = fill_normal(d_surface, m);
d_surface = generate_data_surface(16,&m);
n_surface = generate_normals_surface(d_surface, m);
if( !(m_surface = create_mesh(d_surface, n_surface, coordanate, m)))
{
mlog("[MESH] Error al inicializar...\n");
@@ -189,14 +105,11 @@ int main( void )
mlog("[MESH] Inicializando...\n");
{
float * n_axis;
n_axis = fill_normal(d_axis, 3);
if(!(m_axis = create_mesh(d_axis, n_axis, coordanate, 3)))
if(!(m_axis = create_mesh(d_axis, NULL, coordanate, 3)))
{
mlog("[MESH] Error al inicializar...\n");
goto error_mesh_axis;
}
free(n_axis);
}
mlog("[MAIN LOOP] Inicializando...\n");

3
src/mesh.c
View File

@@ -37,6 +37,9 @@ mesh_t create_mesh( float * d, float * n, unsigned char * coordanate, unsigned c
glEnableVertexAttribArray(i);
}
if( !n )
return p;
glGenBuffers( 1, &p->n_vbo );
glBindBuffer( GL_ARRAY_BUFFER, p->n_vbo );
glBufferData( GL_ARRAY_BUFFER, p->vertex*m*sizeof(float), n+1,

95
src/surface.c
View File

@@ -1,12 +1,14 @@
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define CGLM_ALL_UNALIGNED
#include <cglm/vec3.h>
#include <cglm/vec4.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
typedef void(*function_t)(float*,int, int, int);
void mobius(float *d_surface, int i, int j, int grid_size)
{
@@ -40,7 +42,9 @@ void klein(float *d_surface, int i, int j, int grid_size)
d_surface[3] = sin(v)*sin(u/2);
}
float * generate_surface(int grid_size, unsigned char *m )
typedef void(*function_t)(float*,int, int, int);
float * generate_data_surface(int grid_size, unsigned char *m )
{
unsigned int i,j,k=0;
long size;
@@ -94,3 +98,88 @@ float * generate_surface(int grid_size, unsigned char *m )
return d_surface;
}
static
void __calculate_normal(float* p1, float* p2, float* p3,float* normal, unsigned char n)
{
float alpha;
vec4 v1, v2, v3;
vec4 u1, u2, u3;
switch (n)
{
case 3:
glm_vec3_sub(p2, p1, v1);
glm_vec3_sub(p3, p1, v2);
glm_vec3_cross(v1, v2, normal);
glm_vec3_normalize(normal);
return;
case 4:
/*
In Grant-Shmidth we need 3 linearly independian vector that forms a basis,
so we can have a ortonormal version of that basis, since, we must have
v1 = p3 - p1
v2 = p2 - p1
Then v3 = p1, will most certantly be linerly independiant to v1 and v2.
*/
glm_vec4_sub(p2, p1, v1);
glm_vec4_sub(p3, p1, v2);
glm_vec4_copy(p1, v3);
/* Setup U1 */
{
glm_vec4_copy(v1, u1);
}
/* Setup U2 */
{
vec4 proj;
alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
glm_vec4_scale(u1, alpha, proj);
glm_vec4_sub(v2, proj, u2);
}
/* Setup U3 */
{
vec4 proj1, proj2;
alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
glm_vec4_scale(u1, alpha, proj1);
alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
glm_vec4_scale(u2, alpha, proj2);
glm_vec4_sub(v3, proj1, u3);
glm_vec4_sub(u3, proj2, u3);
}
glm_vec4_copy(u3, normal);
glm_vec4_normalize(normal);
return;
}
}
float * generate_normals_surface( float * d, unsigned char m )
{
float * n;
n = malloc( (*d+1)*sizeof(float));
*n = *d;
for (int i = 0; i < *d; i += 3*m)
{
vec4 norm_vec;
__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 );
}
return n;
}

3
src/window.c
View File

@@ -13,7 +13,7 @@ window_t init_window(unsigned int w, unsigned int h, const char * name);
/*
Limitamos los FPS, contando el tiempo en el que
se ejecuta el main loop, y esperando el tiempo restante
para lograr los fps deciados.
para lograr los fps deseados.
*/
static
@@ -37,6 +37,7 @@ void __limit_fps_window(int max_fps)
current_time = glfwGetTime();
}
previous_time = current_time;
}