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

ya son puros for loops xd

Browse Source
This commit is contained in:
roberto.mc
2024-11-27 23:22:31 -06:00
parent 2c8795bd9f
commit 814f0c94a4
1 changed files with 80 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
src/surface.c
View File

@@ -82,167 +82,101 @@ float *generate_data_surface(int grid_size, unsigned char *m)
return d_surface; return d_surface;
} }
/* pa' rearmar la funcion _calc_normal te entendi que creara las funciones de cglm artesanalmente, entonces ps eso hago xd */
void subtract(const float *v1, const float *v2, float *result, unsigned char n)
{
for (unsigned char i = 0; i < n; i++) {
result[i] = v1[i] - v2[i];
}
}
float dot_product(const float *a, const float *b, unsigned char n)
{
float result = 0.0f;
for (unsigned char i = 0; i < n; i++) {
result += a[i] * b[i];
}
return result;
}
void escalar_product(float a, const float *v1, float *result, unsigned char n)
{
for (unsigned char i = 0; i < n; i++) {
result[i] = a * v1[i];
}
}
void norm(const float *v1, float *result, unsigned char n)
{
float lenght = sqrtf(dot_product(v1, v1, n));
float inv_lenght = 1.0f / lenght;
escalar_product(inv_lenght, v1, result, n);
}
static void __calculate_normal( static void __calculate_normal(
float *p1, float *p2, float *p3, float *normal, unsigned char n) float *p1, float *p2, float *p3, float *normal, unsigned char n)
{ {
unsigned char i; unsigned char i;
float alpha; float alpha;
float *v1, *v2, *v3; float *v1, *v2, *v3;
float *u1, *u2, *u3; float *u1, *u2, *u3;
v1=malloc(n*sizeof(float)); v1 = malloc(n * sizeof(float));
v2=malloc(n*sizeof(float)); v2 = malloc(n * sizeof(float));
v3=malloc(n*sizeof(float)); v3 = malloc(n * sizeof(float));
u1=malloc(n*sizeof(float)); u1 = malloc(n * sizeof(float));
u2=malloc(n*sizeof(float)); u2 = malloc(n * sizeof(float));
u3=malloc(n*sizeof(float)); u3 = malloc(n * sizeof(float));
switch (n) switch (n)
{ {
case 3: case 3:
glm_vec3_sub(p2, p1, v1); glm_vec3_sub(p2, p1, v1);
glm_vec3_sub(p3, p1, v2); glm_vec3_sub(p3, p1, v2);
glm_vec3_cross(v1, v2, normal); glm_vec3_cross(v1, v2, normal);
glm_vec3_normalize(normal); glm_vec3_normalize(normal);
return;
/*
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.
*/
default:
for( i=0; i<n; ++i )
{
v1[i]=p2[i]-p1[i]; //cglm_vec4_sub( p2, p1, v1 );
v2[i]=p3[i]-p1[i]; //cglm_vec4_sub( p3, p1, v2 );
v3[i]=p1[i]; //cglm_vec4_copy( p1, v3 );
}
for( i=0; i<n; ++i )
u1[i]=v1[i]; //cglm_vec4_copy( v1, u1 );
{
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);
}
{
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);
free(v1);
free(v2);
free(v3);
free(u1);
free(u2);
free(u3);
return; return;
#if 0
default:
u = malloc((n - 1) * sizeof(float *));
for (unsigned char i = 0; i < n - 1; i++)
{
u[i] = malloc(n * sizeof(float));
}
for (unsigned char i = 0; i < n - 1; i++) default:
{ for (i = 0; i < n; ++i) {
float *vi = malloc(n * sizeof(float)); v1[i] = p2[i] - p1[i];
for (unsigned char j = 0; j < n; j++) v2[i] = p3[i] - p1[i];
{ v3[i] = p1[i];
vi[j] = p2[j] - p1[j]; }
}
for (unsigned char j = 0; j < i; j++) for (i = 0; i < n; ++i) {
{ u1[i] = v1[i];
float dot_vu = 0.0f, dot_uu = 0.0f; }
for (unsigned char k = 0; k < n; k++) {
{ float proj[n];
dot_vu += vi[k] * u[j][k]; float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
dot_uu += u[j][k] * u[j][k]; 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 (unsigned char k = 0; k < n; k++) for (i = 0; i < n; ++i) {
{ proj[i] = u1[i] * alpha;
vi[k] -= (dot_vu / dot_uu) * u[j][k]; u2[i] = v2[i] - proj[i];
} }
} }
memcpy(u[i], vi, n * sizeof(float)); {
free(vi); float proj1[n], proj2[n];
} float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
memcpy(normal, u[n - 2], n * sizeof(float)); 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) {
proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
}
float norm = 0.0f; for (i = 0; i < n; ++i) {
for (unsigned char i = 0; i < n; i++) dot_v3_u2 += v3[i] * u2[i];
{ dot_u2_u2 += u2[i] * u2[i];
norm += normal[i] * normal[i]; }
} for (i = 0; i < n; ++i) {
norm = sqrtf(norm); proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
for (unsigned char i = 0; i < n; i++) u3[i] = v3[i] - proj1[i] - proj2[i];
{ }
normal[i] /= norm; }
}
for (unsigned char i = 0; i < n - 1; i++) float magnitude = 0.0f;
{ for (i = 0; i < n; ++i) {
free(u[i]); magnitude += u3[i] * u3[i];
} }
free(u); magnitude = sqrtf(magnitude);
return;
#endif for (i = 0; i < n; ++i) {
} normal[i] = u3[i] / magnitude;
}
free(v1);
free(v2);
free(v3);
free(u1);
free(u2);
free(u3);
return;
}
} }
float *generate_normals_surface(float *d, unsigned char m) float *generate_normals_surface(float *d, unsigned char m)
{ {
float *n; float *n;
@@ -265,4 +199,4 @@ float *generate_normals_surface(float *d, unsigned char m)
free(norm_vec); free(norm_vec);
return n; return n;
} }