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

Merge branch 'experimental' of https://gitea.axiolutions.com/software/manigraph into experimental

Browse Source
This commit is contained in:
alan
2024-12-01 15:00:42 -06:00
parent f33b8f67b5 b19100424d
commit 3e3c6e676e
5 changed files with 158 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/main.c
View File

@@ -48,7 +48,8 @@ extern volatile unsigned char animate_index;
static inline
#endif
void main_loop(void)
void
main_loop(void)
{
quat_t q;
@@ -60,41 +61,41 @@ void main_loop(void)
{
static float angle = 0;
if( angle > M_PI/2 )
if (angle > M_PI / 2)
{
animate_index = 0;
angle = 0;
load_float_to_shader( shader, "angle", angle);
load_float_to_shader( shader_plain, "angle", angle);
set_projection_mesh( projection );
load_float_to_shader(shader, "angle", angle);
load_float_to_shader(shader_plain, "angle", angle);
set_projection_mesh(projection);
}
if( animate_index )
if (animate_index)
{
load_uint_to_shader( shader, "i", animate_index-1 );
load_uint_to_shader( shader_plain, "i", animate_index-1 );
load_uint_to_shader(shader, "i", animate_index - 1);
load_uint_to_shader(shader_plain, "i", animate_index - 1);
angle+=0.01;
load_float_to_shader( shader, "angle", angle);
load_float_to_shader( shader_plain, "angle", angle);
angle += 0.01;
load_float_to_shader(shader, "angle", angle);
load_float_to_shader(shader_plain, "angle", angle);
}
}
clean_context();
#ifndef DEBUG
load_mdl_matrix(shader_plain, 0, 0);
draw_mesh(m_axis, 1);
draw_mesh(m_axis);
load_mdl_matrix(shader_plain, 1, 1);
draw_mesh(m_axis, 1);
draw_mesh(m_axis);
load_mdl_matrix(shader_plain, 2, 2);
draw_mesh(m_axis, 1);
draw_mesh(m_axis);
#endif
load_mdl_matrix(shader, 0, 3);
draw_mesh(m_surface, 0);
draw_mesh(m_surface);
load_mdl_matrix(shader_plain, 0, 3);
draw_mesh(m_surface, 1);
draw_mesh_lines(m_surface);
}
int main(void)

4
src/main.h
View File

@@ -57,7 +57,9 @@ void set_projection_mesh( struct projection );
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:

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);
}
void draw_mesh(mesh_t p, char lines )
void draw_mesh(mesh_t p)
{
struct obj *obj = p;
glBindVertexArray(obj->vao);
if( lines )
{
int i;
for (i = 0; i < obj->vertex; i += 3)
glDrawArrays(GL_LINE_LOOP, i, 3);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
}
void draw_mesh_lines(mesh_t p)
{
struct obj *obj = p;
glBindVertexArray(obj->vao);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
}
}

86
src/surface.c
View File

@@ -20,6 +20,7 @@
#ifdef TEST
#include <assert.h>
#endif
#include <stdio.h>
typedef void (*function_t)(float *, int *, int);
@@ -62,8 +63,13 @@ void riemman(float *d_surface, int *coords, int grid)
void cube(float *d_surface, int *coord, int grid)
{
for (int i = 0; i < parm.m; i++)
d_surface[i] = ((float)coord[i] / grid) - 0.5;
int i;
for (i = 0; i < parm.m; i++)
d_surface[i] = (2 * (float)coord[i] / grid) - 1;
if (parm.m == 2)
d_surface[2] = 0;
}
void sphere(float *d_surface, int *coord, int grid)
@@ -138,13 +144,19 @@ float *generate_data_surface(unsigned char *s)
unsigned int i, j, k, o, p, n;
long size, q = 0;
float *d_surface;
int *cara;
<<<<<<< HEAD
parm.f = lens;
parm.m = 4;
parm.n = 4;
parm.grid = 5;
=======
parm.f = klein;
parm.m = 2;
parm.n = 4;
parm.grid = 16;
>>>>>>> b19100424dbeaf4a4ecc88ddfc633b0c34fd0010
#ifdef TEST
assert(numero_caras(2) == 1);
@@ -152,9 +164,13 @@ float *generate_data_surface(unsigned char *s)
assert(numero_caras(4) == 24);
#endif
<<<<<<< HEAD
cara = malloc(parm.m * sizeof(int));
=======
>>>>>>> b19100424dbeaf4a4ecc88ddfc633b0c34fd0010
*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[0] = size;
@@ -178,11 +194,12 @@ float *generate_data_surface(unsigned char *s)
{
for (j = 0; j < parm.grid; j++)
{
cara[o] = i;
cara[p] = j;
cara[p] = i;
cara[o] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
<<<<<<< HEAD
cara[o] = i + 1;
cara[p] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
@@ -190,14 +207,24 @@ float *generate_data_surface(unsigned char *s)
cara[o] = i + 1;
cara[p] = j + 1;
=======
cara[p] = i + 1;
cara[o] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[o] = i;
cara[p] = j;
cara[p] = i + 1;
cara[o] = j + 1;
>>>>>>> b19100424dbeaf4a4ecc88ddfc633b0c34fd0010
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[p] = i;
cara[o] = j;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
<<<<<<< HEAD
cara[o] = i;
cara[p] = j + 1;
parm.f(&d_surface[q + 1], cara, parm.grid);
@@ -205,6 +232,15 @@ float *generate_data_surface(unsigned char *s)
cara[o] = i + 1;
cara [p] = j + 1;
=======
cara[p] = i;
cara[o] = j + 1;
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
cara[p] = i + 1;
cara[o] = j + 1;
>>>>>>> b19100424dbeaf4a4ecc88ddfc633b0c34fd0010
parm.f(&d_surface[q + 1], cara, parm.grid);
q += parm.n;
}
@@ -237,26 +273,30 @@ static void __calculate_normal(
Calculate a normal vector of a plain using Gram-Schmidt process
*/
{
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
v1[i] = p2[i] - p1[i];
v2[i] = p3[i] - p1[i];
v3[i] = p1[i];
}
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
u1[i] = v1[i];
}
{
float proj[n];
float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
dot_v2_u1 += v2[i] * u1[i];
dot_u1_u1 += u1[i] * u1[i];
}
alpha = dot_v2_u1 / dot_u1_u1;
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
proj[i] = u1[i] * alpha;
u2[i] = v2[i] - proj[i];
}
@@ -267,31 +307,37 @@ static void __calculate_normal(
float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
dot_v3_u1 += v3[i] * u1[i];
dot_u1_u1 += u1[i] * u1[i];
}
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
}
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
dot_v3_u2 += v3[i] * u2[i];
dot_u2_u2 += u2[i] * u2[i];
}
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
u3[i] = v3[i] - proj1[i] - proj2[i];
}
}
float magnitude = 0.0f;
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
magnitude += u3[i] * u3[i];
}
magnitude = sqrtf(magnitude);
for (i = 0; i < n; ++i) {
for (i = 0; i < n; ++i)
{
normal[i] = u3[i] / magnitude;
}
@@ -305,20 +351,18 @@ static void __calculate_normal(
}
}
float *generate_normals_surface(float *d, unsigned char m)
{
float *n;
n = malloc((*d + 1) * sizeof(float));
*n = *d;
float * norm_vec;
norm_vec=malloc(m*sizeof(float));
float *norm_vec;
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);