feat(main.c, input.c): Print important information to stdout

Makefile

@@ -9,7 +9,6 @@ OBJ = \
 	src/input.o \
 	src/load.o \
 	src/mesh.o \
-	src/gui.o \
 	src/main.o 
 
 EXAMPLES = \
@@ -17,13 +16,13 @@ EXAMPLES = \
 	example/riemman \
 	example/n-cube \
 	example/n-hilbert-cube \
+	example/light-cone \
 	example/lens
 
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
 	-I./ext/glad  \
-	-I./ext/nuklear  \
 	-I./include  \
 	-Wall -Wno-unused-function -std=c99 -D_GNU_SOURCE \
 
@@ -42,8 +41,8 @@ help:
 src/main.o: src/data/shaders.h
 
 windows: $(OBJ) 
-	cd ext; $(MAKE) -f glfw.mk windows; cd -
+	#cd ext; $(MAKE) -f glfw.mk windows; cd -
-	$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 
+	$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32  -lgdi32
 
 glfw.dll:
 	$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32 

compile.bat

@@ -1,3 +1,3 @@
 :: git submodule update --init --recursive
 :: gcc -fPIC -shared -Iext/glfw/deps/MinGW -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o  glfw.dll -lgdi32
-gcc -I ext/glad -I ext/cglm/include -I ext/nuklear -I ext/glfw/include src/*.c ext/glad/glad.c -o manigraph -L . -lglfw -lopengl32
+gcc -I ext/cglm/include -I ext/glfw/include src/*.c -o manigraph -L . -lglfw -lopengl32 -lglew32

example/basic.c

@@ -34,7 +34,7 @@ void mobius(float *d_surface, int *coord, unsigned char *grid)
 
 void torus(float *d_surface, int *coord, unsigned char *grid)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
+	float u = (M_PI) * ((float)coord[0] / grid[0]) + M_PI;
 	float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
 
 	d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
@@ -57,8 +57,10 @@ int main(void)
 {
 	unsigned char i = 0;
 	const char *file_name[] = {"mobius.klein", "torus.klein", "klein.klein"};
-	struct parm parametrization[] = {{
+	struct parm parametrization[] = {
+		{
 			 .grid = (unsigned char[]){16, 4},
+
 			 .m = 2,
 			 .n = 3,
 			 .f = mobius,
@@ -74,9 +76,10 @@ int main(void)
 			.m = 2,
 			.n = 4,
 			.f = klein,
-		}};
+		},
+	};
 
-	for (i = 0; i < 3; ++i)
+	for (i = 0; i < 4; ++i)
 	{
 		struct klein klein;
 		printf("writing %s\n", file_name[i]);

example/n-cube.c

@@ -10,7 +10,7 @@
 #define M_PI 3.14159265358979323846
 #endif
 
-unsigned char dim = 10;
+unsigned char dim = 17;
 
 void cube(float *d_surface, int *coord, unsigned char *grid)
 {

include/klein/klein.h

@@ -3,6 +3,8 @@
 #endif
 #define KLEIN_H
 
+#include <stdint.h>
+
 #ifdef KLEIN_IMPLEMENT
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,9 +12,9 @@
 
 struct klein
 {
-	unsigned long vertex_size;
 	float *vertex, *normals;
-	unsigned char dim;
+	uint64_t vertex_size;
+	uint8_t dim;
 };
 
 /*

include/klein/parm.h

@@ -25,7 +25,7 @@ void klein_parametrize( struct klein * klein, struct parm parm );
 #include <assert.h>
 #endif
 
-static inline int __factorial(int n)
+static inline uint64_t __factorial(uint64_t n)
 {
 	if (n == 1)
 		return 1;
@@ -33,7 +33,7 @@ static inline int __factorial(int n)
 	return n * __factorial(n - 1);
 }
 
-static inline int __face(int n)
+static inline uint64_t __face(int n)
 {
 	if (n == 2)
 		return 1;
@@ -43,8 +43,8 @@ static inline int __face(int n)
 
 void klein_parametrize( struct klein * klein, struct parm parm)
 {
-	unsigned int i, j, k, o, p, n;
+	unsigned long i, j,  o, p, n;
-	unsigned long size, q = 0;
+	uint64_t k, size, q = 0;
 	int *face;
 
 #ifdef TEST
@@ -56,28 +56,30 @@ void klein_parametrize( struct klein * klein, struct parm parm)
 	klein->dim = parm.n;
 	klein->vertex_size = 0;
 	{
-		unsigned char test = 0;
+		uint64_t test = 0;
+
 		for (o = 0; o < parm.m; o++)
-		{
 			for (p = 0; p < o; p++)
-			{
 				test += 1;
-				klein->vertex_size += parm.grid[p] * parm.grid[o] * 6 * __face(parm.m);
+
-			}
+
-		}
+		for (o = 0; o < parm.m; o++)
-		klein->vertex_size /= test;
+			for (p = 0; p < o; p++)
+				klein->vertex_size += (uint64_t)parm.grid[p] * parm.grid[o] * 6 * __face(parm.m)/test;
+
 	}
 
-	size = (klein->dim) * (klein->vertex_size);
+	size = klein->vertex_size*klein->dim;
+
 	klein->vertex = malloc(size * sizeof(float));
-
 	face = malloc(parm.m * sizeof(int));
 
+
 	for (o = 0; o < parm.m; o++)
 	{
 		for (p = 0; p < o; p++)
 		{
-			for (k = 0; k < (1 << (parm.m - 2)); k++)
+			for (k = 0; k < ((uint64_t)1 << (parm.m - 2)); k++)
 			{
 				unsigned char skip = 0;
 				for (n = 0; n < parm.m; n++)
@@ -85,7 +87,7 @@ void klein_parametrize( struct klein * klein, struct parm parm)
 					if (n == o || n == p)
 						skip++;
 
-					face[n] = (k & (1 << (n - skip))) ? parm.grid[n] : 0;
+					face[n] = (k & ((uint64_t)1 << (n - skip))) ? parm.grid[n] : 0;
 				}
 
 				for (i = 0; i < parm.grid[p]; i++)

src/context.c

@@ -9,6 +9,7 @@
 
 void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b)
 {
+	glEnable(GL_DEPTH_TEST);
 	glClearColor((float)r / 0xff, (float)g / 0xff, (float)b / 0xff, 1.0);
 }
 
@@ -21,11 +22,4 @@ int init_context(void)
 #endif
 }
 
-void clean_context(void)
+void clean_context(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
-{
-	/* This is important cos, Nuklear Disable DEPTH TEST */
-	glEnable(GL_BLEND);
-	glEnable(GL_DEPTH_TEST);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT );
-}

src/data/cube.h

@@ -1,32 +0,0 @@
-#define A -1,-1,-1,
-#define B -1,-1, 1,
-#define C -1, 1,-1,
-#define D -1, 1, 1,
-#define E  1,-1,-1,
-#define F  1,-1, 1,
-#define G  1, 1,-1,
-#define H  1, 1, 1,
-
-narray_float_t d_cube =
-{
-	3*3*2*6,
-
-	A C E
-	C E G
-
-	E G F
-	G F H
-
-	F H B
-	H B D
-
-	B D A
-	D A C
-
-	C D G
-	D G H
-
-	A B E 
-	B E F
-
-};

src/gui.c

@@ -1,83 +0,0 @@
-#include <glad.h>
-#include "main.h"
-#define MAX_VERTEX_BUFFER 512 * 1024
-#define MAX_ELEMENT_BUFFER 128 * 1024
-#define NK_INCLUDE_FIXED_TYPES
-#define NK_INCLUDE_STANDARD_IO
-#define NK_INCLUDE_STANDARD_VARARGS
-#define NK_INCLUDE_DEFAULT_ALLOCATOR
-#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
-#define NK_INCLUDE_FONT_BAKING
-#define NK_INCLUDE_DEFAULT_FONT
-#define NK_IMPLEMENTATION
-#define NK_GLFW_GL3_IMPLEMENTATION
-#include <nuklear.h>
-#include <demo/glfw_opengl3/nuklear_glfw_gl3.h>
-
-struct gui gui =
-{
-	.file_name = {0},
-	.projection = (struct projection){ .mesh=NULL, .x =0, .y=1, .z=2 },
-};
-
-float surface_color[4] = {(float)0x2F/0xFF, (float)0x3C/0xFF, (float)0x7E/0xFF, (float)0xff/0xFF};
-
-
-static inline
-void restore_surface_color( void )
-{
-	gui.picked_color[0] = surface_color[0];
-	gui.picked_color[1] = surface_color[1];
-	gui.picked_color[2] = surface_color[2];
-	gui.picked_color[3] = surface_color[3];
-}
-
-struct nk_glfw glfw ={0};
-struct nk_context * context;
-
-void draw_gui( void )
-{
-	nk_glfw3_new_frame(&glfw);
-
-	if (nk_begin(context, "MANIGRAPH", nk_rect(10, 10, 256, 256),
-			NK_WINDOW_BORDER |NK_WINDOW_SCALABLE | NK_WINDOW_MOVABLE | NK_WINDOW_MINIMIZABLE) )
-	{
-
-		/* Color picker para personalización */
-		{
-			struct nk_colorf * p = (void*)&gui.picked_color;
-			nk_layout_row_dynamic(context, 120, 1);
-			*p = nk_color_picker(context, *p, NK_RGBA);
-		}
-
-		nk_layout_row_dynamic(context, 20, 1);
-		if (nk_button_label(context, "Restablecer"))
-			restore_surface_color();
-
-
-		nk_layout_row_dynamic(context, 12, 1);
-		nk_label(context, (char*)gui.file_name, NK_TEXT_ALIGN_LEFT);
-
-		nk_label_colored(context, "Atajos de teclado:", NK_TEXT_ALIGN_LEFT, nk_rgb(255, 255, 255)); // Encabezado
-		nk_label(context, "  - W/S: Rotar eje X", NK_TEXT_ALIGN_LEFT);
-		nk_label(context, "  - A/D: Rotar eje Y", NK_TEXT_ALIGN_LEFT);
-		nk_label(context, "  - Z/X: Rotar eje Z", NK_TEXT_ALIGN_LEFT);
-	}
-
-	nk_end(context);
-	nk_glfw3_render(&glfw, NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
-}
-
-
-void init_gui( window_t window )
-{
-	struct nk_font_atlas * atlas;
-
-	restore_surface_color();
-
-	{
-		context = nk_glfw3_init(&glfw,(GLFWwindow*) window, NK_GLFW3_DEFAULT );
-		nk_glfw3_font_stash_begin(&glfw, &atlas);
-		nk_glfw3_font_stash_end(&glfw);
-	}
-}

src/input.c

@@ -3,18 +3,16 @@
 #include <GLFW/glfw3.h>
 #include <cglm/quat.h>
 #include <stdio.h>
-#include <string.h>
 
 #define ANGLE ((float)0x01 / 0xff * 2 * GLM_PI)
 
 unsigned char selected_axis = 0;
-int window_width = 512;
+int window_width;
-int window_height = 512;
+int window_height;
 
+static versor q = GLM_QUAT_IDENTITY_INIT;
 unsigned char animate_index = 0;
-extern struct gui gui;
 
-versor q = GLM_QUAT_IDENTITY_INIT;
 
 vec3 axis[3] = {
 	{1, 0, 0},
@@ -22,6 +20,17 @@ vec3 axis[3] = {
 	{0, 0, 1},
 };
 
+extern struct projection projection;
+
+static inline
+void __input_update_q(versor p)
+{
+	glm_quat_mul(p, 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_normalize(q);
+}
 
 void __error_callback_input(int x, const char * msg )
 {
@@ -42,45 +51,48 @@ void __key_callback_input(
 
 		selected_coord = key - GLFW_KEY_0 - 1;
 
-		if (selected_coord >= gui.projection.m)
+		if (selected_coord >= projection.m)
 			return;
-		if (selected_coord == gui.projection.x)
+		if (selected_coord == projection.x)
 			return;
-		if (selected_coord == gui.projection.y)
+		if (selected_coord == projection.y)
 			return;
-		if (selected_coord == gui.projection.z)
+		if (selected_coord == projection.z)
 			return;
 
-		selected_coord = gui.projection.w;
+		projection.w = selected_coord;
 	}
 
-	if (gui.projection.w >= gui.projection.m)
+	if (projection.w >= projection.m)
 		return;
 
 	switch (key)
 	{
 		unsigned char tmp;
-	case GLFW_KEY_I:
+	case GLFW_KEY_Z:
-		tmp = gui.projection.w;
+		tmp = projection.w;
-		gui.projection.w = gui.projection.x;
+		projection.w = projection.x;
-		gui.projection.x = tmp;
+		projection.x = tmp;
 
 		animate_index = 1;
 		break;
-	case GLFW_KEY_O:
+	case GLFW_KEY_X:
-		tmp = gui.projection.w;
+		tmp = projection.w;
-		gui.projection.w = gui.projection.y;
+		projection.w = projection.y;
-		gui.projection.y = tmp;
+		projection.y = tmp;
 		animate_index = 2;
 		break;
-	case GLFW_KEY_P:
+	case GLFW_KEY_C:
-		tmp = gui.projection.w;
+		tmp = projection.w;
-		gui.projection.w = gui.projection.z;
+		projection.w = projection.z;
-		gui.projection.z = tmp;
+		projection.z = tmp;
 		animate_index = 3;
 		break;
+	default:
+		return;
 	}
 
+	printf("[AXIS] (X,Y,Z,W) = (%d,%d,%d,%d)\n", projection.x, projection.y, projection.z, projection.w);
 	return;
 }
 
@@ -95,26 +107,32 @@ void __window_callback_input(GLFWwindow *window, int w, int h)
 	glViewport((w - m) / 2, (h - m) / 2, m, m);
 }
 
-void __mouse_callback_input(
+static double xpos_s, ypos_s;
-	GLFWwindow *window, int button, int action, int mods)
+static char lbutton_down = 0;
+
+void __mouse_callback_input(GLFWwindow* window, int button, int action, int mods)
 {
-	unsigned char green_value;
+	if( button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
-	double xpos, ypos;
+		lbutton_down = 1;
 
-	if (button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS)
+	if( button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE)
-		return;
-
-	glfwGetCursorPos(window, &xpos, &ypos);
-	glReadPixels((int)xpos, (int)(window_height - ypos), 1, 1, GL_GREEN,
-		GL_UNSIGNED_BYTE, &green_value);
-
-	switch (green_value)
 	{
-	case 0xD3:
+		glfwGetCursorPos(window, &xpos_s, &ypos_s);
-	case 0xD4:
+		lbutton_down = 0;
-	case 0xD5:
-		selected_axis = green_value - 0xD3;
 	}
+
+}
+
+void __cursor_callback_input(
+	GLFWwindow *window, double xpos, double ypos)
+{
+	if( lbutton_down )
+	{
+		versor p = GLM_QUAT_IDENTITY_INIT;
+		glm_quatv(p, ANGLE, (vec3){-1*(ypos-ypos_s),(xpos-xpos_s),0});
+		__input_update_q(p);
+	}
+
 }
 
 void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
@@ -137,20 +155,18 @@ void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
 	glm_quat_rotatev(r, axis[2], axis[2]);
 }
 
-void __drop_callback_input(GLFWwindow *window, int count, unsigned char **path)
+void __drop_callback_input(GLFWwindow *window, int count, char **path)
 {
 	struct surface surface;
 
 	if (create_surface_klein(*path, &surface))
 		return;
 
-	if (!(gui.projection.mesh = create_mesh(surface)))
+	if (!(projection.mesh = create_mesh(surface)))
 		return;
 
-	strcpy(gui.file_name, *path);
+	projection.m = surface.dim;
-
+	set_projection_mesh(projection);
-	gui.projection.m = surface.dim;
-	set_projection_mesh(gui.projection);
 
 	free(surface.norm);
 	free(surface.data);
@@ -160,43 +176,69 @@ quat_t poll_input(window_t window)
 {
 	versor p = GLM_QUAT_IDENTITY_INIT;
 
-	if (glfwGetKey((GLFWwindow *)window, 'Q') == GLFW_PRESS)
+	if (glfwGetKey((GLFWwindow *)window, 'W') == GLFW_PRESS)
 	{
 		glm_quatv(p, ANGLE, axis[0]);
 		goto end;
 	}
-	if (glfwGetKey((GLFWwindow *)window, 'W') == GLFW_PRESS)
+	if (glfwGetKey((GLFWwindow *)window, 'S') == GLFW_PRESS)
 	{
 		glm_quatv(p, -ANGLE, axis[0]);
 		goto end;
 	}
 	if (glfwGetKey((GLFWwindow *)window, 'A') == GLFW_PRESS)
-	{
-		glm_quatv(p, ANGLE, axis[1]);
-		goto end;
-	}
-	if (glfwGetKey((GLFWwindow *)window, 'S') == GLFW_PRESS)
 	{
 		glm_quatv(p, -ANGLE, axis[1]);
 		goto end;
 	}
-	if (glfwGetKey((GLFWwindow *)window, 'Z') == GLFW_PRESS)
+	if (glfwGetKey((GLFWwindow *)window, 'D') == GLFW_PRESS)
+	{
+		glm_quatv(p, ANGLE, axis[1]);
+		goto end;
+	}
+	if (glfwGetKey((GLFWwindow *)window, 'Q') == GLFW_PRESS)
 	{
 		glm_quatv(p, ANGLE, axis[2]);
 		goto end;
 	}
-	if (glfwGetKey((GLFWwindow *)window, 'X') == GLFW_PRESS)
+	if (glfwGetKey((GLFWwindow *)window, 'E') == GLFW_PRESS)
 	{
 		glm_quatv(p, -ANGLE, axis[2]);
 		goto end;
 	}
 
-end:
+	if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_UP) == GLFW_PRESS)
-	glm_quat_mul(p, q, q);
+	{
-	glm_quat_rotatev(p, axis[0], axis[0]);
+		glm_quatv(p, ANGLE, (vec3){1,0,0});
-	glm_quat_rotatev(p, axis[1], axis[1]);
+		goto end;
-	glm_quat_rotatev(p, axis[2], axis[2]);
+	}
-	glm_quat_normalize(q);
+	if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_DOWN) == GLFW_PRESS)
+	{
+		glm_quatv(p, -ANGLE, (vec3){1,0,0});
+		goto end;
+	}
+	if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_RIGHT) == GLFW_PRESS)
+	{
+		glm_quatv(p, ANGLE, (vec3){0,1,0});
+		goto end;
+	}
+	if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_LEFT) == GLFW_PRESS)
+	{
 
+		glm_quatv(p, -ANGLE, (vec3){0,1,0});
+		goto end;
+	}
+
+end:
+/*
+	// LOG INFO
+	if (0)
+	{
+		printf("QUAT: %2.5f %2.5f %2.5f %2.5f\n", q[0], q[1], q[2], q[3]);
+		printf("\n");
+	}
+*/
+
+	__input_update_q(p);
 	return q;
 }

src/klein.c

@@ -1,5 +1,6 @@
 #include "main.h"
 
+#include <stdlib.h>
 #include <stdio.h>
 
 /*
@@ -7,7 +8,7 @@
 		5 bytes with KLEIN
 		1 byte empty for scaling
 		1 byte with the dimention of the surface
-		8 bytes interprated as a long with the number of vertex
+		8 bytes interprated as an int  with the number of vertex
 		n bytes with the vertex data of the surface
 		n bytes with the normal data of the surface
 

src/load.c

@@ -22,7 +22,13 @@ void rot_matrix_load(id_t shader, quat_t q)
 	load_mat4_to_shader(shader, "rot", (mat4_t)m);
 }
 
-void color_load(id_t shader, float res[4])
+void color_load(id_t shader, unsigned char color[4])
 {
+	float res[4];
+
+	res[0] = (float)color[0] / 0xff;
+	res[1] = (float)color[1] / 0xff;
+	res[2] = (float)color[2] / 0xff;
+	res[3] = (float)color[3] / 0xff;
 	load_float4_to_shader(shader, "color", res);
 }

src/main.c

@@ -7,11 +7,6 @@
 #define WIDTH 512
 #define HEIGHT 512
 
-#include <glad.h>
-
-float *generate_data_surface(unsigned int, unsigned char *);
-float *generate_normals_surface(float *, unsigned char);
-
 #ifdef EMSCRIPTEN
 #include <emscripten.h>
 #endif
@@ -20,13 +15,29 @@ float *generate_normals_surface(float *, unsigned char);
 #define M_PI 3.14159
 #endif
 
-window_t window;
+struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3, .mesh = NULL};
-id_t shader, shader_plain;
 
 const char *wname = "manigraph: manifold grapher";
+const char *input_map = 
+	"\n"
+	"DRAG AND DROP: Graph a klein file from the file system\n"
+	"LEFT-CLICK:    Rotate surface on DRAG direction\n"
+	"SCROLL:        Rotate surface on SCROLL direction\n"
+	"\n"
+	"W,S:        Rotate sufrace on X axis\n"
+	"A,D:        Rotate sufrace on Y axis\n"
+	"Q,E:        Rotate sufrace on Z axis\n"
+	"LEFT-RIGHT: Rotate sufrace Horizontally\n"
+	"UP-DOWN:    Rotate sufrace Vetrically\n"
+	"\n"
+	"Z:       Rotate W axis to X axis\n"
+	"X:       Rotate W axis to Y axis\n"
+	"C:       Rotate W axis to Z axis\n"
+	"1-9:     Rotate n axis to W axis\n"
+	"\n"
+;
 
-extern volatile unsigned char animate_index;
+unsigned char color[4] = {0x2F, 0x3C, 0x7E, 0xff};
-extern struct gui gui;
 
 void mlog(char *msg)
 {
@@ -35,6 +46,11 @@ void mlog(char *msg)
 #endif
 }
 
+window_t window;
+id_t shader, shader_plain;
+
+extern volatile unsigned char animate_index;
+
 #ifndef EMSCRIPTEN
 static inline
 #endif
@@ -46,16 +62,10 @@ static inline
 
 	q = poll_input(window);
 
-	gui.quat[0] = q[0];
-	gui.quat[1] = q[1];
-	gui.quat[2] = q[2];
-	gui.quat[3] = q[3];
-
-
 	rot_matrix_load(shader, q);
 	rot_matrix_load(shader_plain, q);
-	color_load(shader, gui.picked_color);
+	color_load(shader, color);
-	color_load(shader_plain, gui.picked_color);
+	color_load(shader_plain, color);
 
 	{
 		static float angle = 0;
@@ -67,7 +77,7 @@ static inline
 
 			load_float_to_shader(shader, "angle", angle);
 			load_float_to_shader(shader_plain, "angle", angle);
-			set_projection_mesh(gui.projection);
+			set_projection_mesh(projection);
 		}
 
 		if (animate_index)
@@ -82,19 +92,16 @@ static inline
 	}
 	clean_context();
 
+	if (!projection.mesh)
+		return;
 
-	if (gui.projection.mesh)
+	draw_mesh(shader, projection.mesh);
-	{
+	draw_mesh_lines(shader_plain, projection.mesh);
-		draw_mesh(shader, gui.projection.mesh);
-		draw_mesh_lines(shader_plain, gui.projection.mesh);
-	}
-
-	draw_gui();
-	
 }
 
 int main(void)
 {
+
 	mlog("[VENTANA] Inicializando...\n");
 	{
 		if (!(window = init_window(WIDTH, HEIGHT, wname)))
@@ -140,12 +147,11 @@ int main(void)
 		fix_matrix_load(shader_plain, (float)WIDTH / HEIGHT);
 	}
 
-	mlog("[GUI] Inicializando...\n");
+	mlog("[INPUTS] Imprimiendo...\n");
-	{
+	printf(input_map);
-		init_gui(window);
-	}
 
 	mlog("[MAIN LOOP] Inicializando...\n");
+
 #ifdef EMSCRIPTEN
 	emscripten_set_main_loop(&main_loop, 60, 1);
 	return 0;
@@ -156,7 +162,7 @@ int main(void)
 	mlog("[MAIN LOOP] Terminando...\n");
 
 	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(gui.projection.mesh);
+	destroy_mesh(projection.mesh);
 	mlog("[SHADER] Destruyendo...\n");
 	destroy_shader(shader_plain);
 	mlog("[SHADER] Destruyendo...\n");
@@ -166,12 +172,12 @@ int main(void)
 	return 0;
 
 error_context:
-	mlog("[SHADER] Destruyendo...\n");
-	destroy_shader(shader);
-error_shader:
 	mlog("[SHADER] Destruyendo...\n");
 	destroy_shader(shader_plain);
 error_shader_plain:
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader);
+error_shader:
 	mlog("[WINDOW] Destruyendo...\n");
 	close_window(window);
 error_window:

src/main.h

@@ -4,6 +4,7 @@
 	error of the shaders.
 */
 
+#include <stdint.h>
 #define DEBUG
 #define GLFW_INCLUDE_NONE
 
@@ -23,19 +24,12 @@ typedef float *mat4_t;
 		w: the coordanate of the w axis.
 */
 
-struct gui
+struct projection
 {
-	float quat[4];
-	float picked_color[4];
-	char file_name[0xff];
-	struct projection
-	{
 	mesh_t mesh;
 	unsigned char m, x, y, z, w;
-	} projection;
 };
 
-
 /*
 	this structure has all the information to generate
 	a mesh, where:
@@ -48,8 +42,8 @@ struct gui
 struct surface
 {
 	float *data, *norm;
-	unsigned long vertex;
+	uint64_t vertex;
-	unsigned char dim;
+	uint8_t dim;
 };
 
 /*
@@ -171,7 +165,7 @@ void rot_matrix_load(id_t shader, quat_t q);
 /*
  */
 
-void color_load(id_t shader, float* color);
+void color_load(id_t shader, unsigned char color[4]);
 
 id_t config_texture(unsigned short type);
 
@@ -187,6 +181,3 @@ void destroy_texture(id_t texture);
 id_t create_palette_texture(const unsigned char colors[][4], unsigned char n);
 
 quat_t poll_input(window_t window);
-
-void draw_gui( void );
-void init_gui(  window_t window );

src/mesh.c

@@ -106,12 +106,12 @@ void draw_mesh_lines(id_t shader, mesh_t p)
 {
 	struct obj *obj = p;
 
+	glLineWidth(4);
 	glUseProgram(shader);
 	glBindVertexArray(obj->vao);
 #ifndef EMSCRIPTEN
 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
-	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 #else
 	glDrawArrays(GL_LINES, 0, obj->vertex);
 #endif

src/window.c

@@ -4,6 +4,7 @@
 #include <time.h>
 
 void __window_callback_input(GLFWwindow *, int, int);
+void __cursor_callback_input(GLFWwindow *, double, double);
 void __mouse_callback_input(GLFWwindow *, int, int, int);
 void __scroll_callback_input(GLFWwindow *, double, double);
 void __key_callback_input(GLFWwindow *, int, int, int, int);
@@ -34,8 +35,12 @@ static void __limit_fps_window(int max_fps)
 		struct timespec sleep_time;
 		sleep_time.tv_sec = 0;
 		sleep_time.tv_nsec = (long)((frame_time - elapsed_time) * 1e9);
-		nanosleep(&sleep_time, NULL);
 
+#ifdef _WIN32
+		usleep(sleep_time.tv_nsec/1000);
+#else
+		nanosleep(&sleep_time, NULL);
+#endif
 		current_time = glfwGetTime();
 	}
 
@@ -65,6 +70,7 @@ window_t init_window(unsigned int width, unsigned int height, const char *title)
 	glfwMakeContextCurrent((GLFWwindow *)(window));
 
 	glfwSetWindowSizeCallback((GLFWwindow *)window, __window_callback_input);
+	glfwSetCursorPosCallback((GLFWwindow *)window, __cursor_callback_input);
 	glfwSetMouseButtonCallback((GLFWwindow *)window, __mouse_callback_input);
 	glfwSetScrollCallback((GLFWwindow *)window, __scroll_callback_input);
 	glfwSetKeyCallback((GLFWwindow *)window, __key_callback_input);
@@ -75,13 +81,8 @@ window_t init_window(unsigned int width, unsigned int height, const char *title)
 
 void use_window(window_t window) { glfwMakeContextCurrent((void *)window); }
 
-extern int window_width, window_height;
-
 int is_open_window(window_t window)
 {
-	/* Restore window proportions if Nuklear breaks it */
-	__window_callback_input((GLFWwindow *)window, window_width, window_height);
-
 	glfwSwapBuffers((void *)window);
 	glfwPollEvents();