Merge branch 'experimental'

src/input.c

@@ -112,13 +112,21 @@ void __mouse_callback_input(
 void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
 {
 	versor p = GLM_QUAT_IDENTITY_INIT;
+	versor r = GLM_QUAT_IDENTITY_INIT;
 
-	glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);
-
+	//glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);
+	glm_quatv(p, yoffset * ANGLE * 2, (vec3){-1,0,0});
+	glm_quatv(r, xoffset * ANGLE * 2, (vec3){0,1,0});
 	glm_quat_mul(p, q, q);
+	glm_quat_mul(r, q, q);
+
 	glm_quat_rotatev(p, axis[0], axis[0]);
 	glm_quat_rotatev(p, axis[1], axis[1]);
 	glm_quat_rotatev(p, axis[2], axis[2]);
+
+	glm_quat_rotatev(r, axis[0], axis[0]);
+	glm_quat_rotatev(r, axis[1], axis[1]);
+	glm_quat_rotatev(r, axis[2], axis[2]);
 }
 
 quat_t poll_input(window_t window)

src/main.h

@@ -4,8 +4,8 @@
 	error of the shaders.
 */
 
-/* #define DEBUG  */
-/* #define GLAD  */
+/* #define DEBUG */
+#define GLAD 
 
 typedef const void * window_t;
 typedef unsigned int id_t;

src/surface.c

@@ -29,6 +29,14 @@ void riemman(float *d_surface, int * coords, int grid_size)
 }
 
 
+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;
@@ -50,20 +58,6 @@ void torus(float *d_surface, int * coord, int grid_size)
 	d_surface[2] = 0.5 * sin(v);
 }
 
-void torus_5d(float *d_surface, int * coord, int grid_size)
-{
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
-	float v = (2 * M_PI) * ((float)coord[1] / grid_size);
-	float r1 = (float)coord[2] / grid_size;
-	float r2 = (float)coord[3] / grid_size;
-
-	d_surface[0] = (r1 + r2 * cos(v)) * cos(u);
-	d_surface[1] = (r1 + r2 * cos(v)) * sin(u);
-	d_surface[2] = r2 * sin(v);
-	d_surface[3] = r1;
-	d_surface[4] = r2;
-}
-
 void klein(float *d_surface, int * coord, int grid_size)
 {
 	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
@@ -77,45 +71,84 @@ void klein(float *d_surface, int * coord, int grid_size)
 
 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;
+	const int dim =2;
+	int cara[dim];
+	char bits[dim+1];
+	bits[dim]=0;
 
-	size = grid_size * grid_size * 6 * (*m);
+	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], (int[2]){i, j}, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], (int[2]){i + 1, j}, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], (int[2]){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], (int[2]){i, j}, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], (int[2]){i, j + 1}, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], (int[2]){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)
 {