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

src/main.c

@@ -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, "angle", angle);
-			load_float_to_shader( shader_plain, "angle", angle);
+			load_float_to_shader(shader_plain, "angle", angle);
-			set_projection_mesh( projection );
+			set_projection_mesh(projection);
 		}
 
-		if( animate_index )
+		if (animate_index)
 		{
-			load_uint_to_shader( shader, "i", animate_index-1 );
+			load_uint_to_shader(shader, "i", animate_index - 1);
-			load_uint_to_shader( shader_plain, "i", animate_index-1 );
+			load_uint_to_shader(shader_plain, "i", animate_index - 1);
 
-			angle+=0.01;
+			angle += 0.01;
-			load_float_to_shader( shader, "angle", angle);
+			load_float_to_shader(shader, "angle", angle);
-			load_float_to_shader( shader_plain, "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)

src/main.h

@@ -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:

src/mesh.c

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

src/surface.c

@@ -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++)
+	int i;
-		d_surface[i] = ((float)coord[i] / grid) - 0.5;
+
+	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] = i;
-						cara[p] = j;
+						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] = i + 1;
-						cara[p] = j;
+						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;
 					}
@@ -219,106 +255,114 @@ float *generate_data_surface(unsigned char *s)
 }
 
 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));
 
-    /* 
+	/*
-    	Calculate a normal vector of a plain using Gram-Schmidt process
+		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]; 
+			v1[i] = p2[i] - p1[i];
-            v3[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]; 
+		{
-        }
+			u1[i] = v1[i];
+		}
 
-        {
+		{
-            float proj[n];
+			float proj[n];
-            float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
+			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];
+				dot_v2_u1 += v2[i] * u1[i];
-            }
+				dot_u1_u1 += u1[i] * u1[i];
-            alpha = dot_v2_u1 / dot_u1_u1;
+			}
+			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]; 
+				proj[i] = u1[i] * alpha;
-            }
+				u2[i] = v2[i] - proj[i];
-        }
+			}
+		}
 
-        {
+		{
-            float proj1[n], proj2[n];
+			float proj1[n], proj2[n];
-            float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
+			float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
-            float dot_v3_u2 = 0.0f, dot_u2_u2 = 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];
+				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);
+			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];
+				dot_v3_u2 += v3[i] * u2[i];
-            }
+				dot_u2_u2 += u2[i] * u2[i];
-            for (i = 0; i < n; ++i) {
+			}
-                proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
+			for (i = 0; i < n; ++i)
-                u3[i] = v3[i] - proj1[i] - proj2[i]; 
+			{
-            }
+				proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
-        }
+				u3[i] = v3[i] - proj1[i] - proj2[i];
+			}
+		}
 
-        float magnitude = 0.0f;
+		float magnitude = 0.0f;
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
-            magnitude += u3[i] * u3[i];
+		{
-        }
+			magnitude += u3[i] * u3[i];
-        magnitude = sqrtf(magnitude);
+		}
+		magnitude = sqrtf(magnitude);
 
-        for (i = 0; i < n; ++i) {
+		for (i = 0; i < n; ++i)
-            normal[i] = u3[i] / magnitude;  
+		{
-        }
+			normal[i] = u3[i] / magnitude;
+		}
 
-        free(v1);
+		free(v1);
-        free(v2);
+		free(v2);
-        free(v3);
+		free(v3);
-        free(u1);
+		free(u1);
-        free(u2);
+		free(u2);
-        free(u3);
+		free(u3);
-        return;
+		return;
-    }
+	}
 }
 
-
 float *generate_normals_surface(float *d, unsigned char m)
 {
 	float *n;
 	n = malloc((*d + 1) * sizeof(float));
 	*n = *d;
 
-	float * norm_vec;
+	float *norm_vec;
-	norm_vec=malloc(m*sizeof(float));
+	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);