Merge main, change compile.bat, add struct gui

2025-02-04 10:16:09 -06:00
parent bc537cf9f2 52aa9d4ac2
commit b83f0f07e3
36 changed files with 6399 additions and 935 deletions
--- a/88
+++ b/88
@@ -1,77 +1,81 @@
 BIN = manigraph

 OBJ = \
-	src/surface.o \
+	ext/glad/glad.o \
 	src/context.o \
-	src/texture.o \
 	src/window.o \
-	src/matrix.o \
 	src/shader.o \
+	src/klein.o \
 	src/input.o \
+	src/load.o \
 	src/mesh.o \
+	src/gui.o \
 	src/main.o 

+EXAMPLES = \
+	example/basic \
+	example/riemman \
+	example/n-cube \
+	example/n-hilbert-cube \
+	example/lens
+
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
-	-Wall -Wno-unused-function -std=c99 -D_POSIX_C_SOURCE \
-
-WAYLAND-LIB = \
-	xdg-shell \
-	relative-pointer-unstable-v1 \
-	xdg-decoration-unstable-v1 \
-	pointer-constraints-unstable-v1 \
-	viewporter \
-	idle-inhibit-unstable-v1  \
-	fractional-scale-v1 \
-	xdg-activation-v1 \
-	wayland
+	-I./ext/glad  \
+	-I./ext/nuklear  \
+	-I./include  \
+	-Wall -Wno-unused-function -std=c99 -D_GNU_SOURCE \

 help:
-	@echo "Para compilar el proyecto a tu sistema operativo"
-	@echo "porfavor usa uno de los siguientes comandos:"
+	@echo "Usage:"
 	@echo "	$(MAKE) windows"
-	@echo "	$(MAKE) linux"
+	@echo "	$(MAKE) linux-x11"
+	@echo "	$(MAKE) linux-wayland"
 	@echo "	$(MAKE) cocoa"
-	@echo "Para limpiar los archivos compilados se puede usar"
+	@echo "	$(MAKE) CC=emcc wasm"
+	@echo "Examples"
+	@echo "	$(MAKE) examples"
+	@echo "Clean"
 	@echo "	$(MAKE) clean"
-	@echo "Para ejecturar el programa sin instalarlos se puede usar:"
-	@echo "	$(MAKE) run-linux"

-src/main.o: src/data/axis.h src/data/shaders.h
+src/main.o: src/data/shaders.h

-# WINDOWS
-windows: $(OBJ) glfw.dll
-	$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 -lglew32 
+windows: $(OBJ) 
+	cd ext; $(MAKE) -f glfw.mk windows; cd -
+	$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 

 glfw.dll:
 	$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32 

 # LINUX
-linux: $(OBJ)
-	for i in $(WAYLAND-LIB); \
-	do  \
-		wayland-scanner client-header ext/glfw/deps/wayland/$$i.xml ext/glfw/deps/wayland/$$i-client-protocol.h; \
-		wayland-scanner private-code ext/glfw/deps/wayland/$$i.xml ext/glfw/deps/wayland/$$i-client-protocol-code.h; \
-	done
-	$(MAKE) DFLAGS="-D_GLFW_WAYLAND -D_GLFW_X11" libglfw.so
-	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm
+linux-wayland: $(OBJ)
+	cd ext; $(MAKE) -f glfw.mk linux-wayland; cd -
+	$(CC) -o $(BIN) $(OBJ) ext/libglfw.a -lm

-run-linux:
-	LD_LIBRARY_PATH=. ./$(BIN)
+linux-x11: $(OBJ)
+	cd ext; $(MAKE) -f glfw.mk linux-x11; cd -
+	$(CC) -o $(BIN) $(OBJ) ext/libglfw.a -lm 

-# COCOA
 cocoa: $(OBJ)
-	$(MAKE) DFLAGS="-D_GLFW_COCOA" libglfw.so
-	$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
+	cd ext; $(MAKE) -f glfw.mk cocoa; cd -
+	$(CC) -framework OpenGL -o $(BIN) $(OBJ) ext/glfw.a -lGL -lglfw 

-libglfw.so: 
-	$(CC) -fPIC -shared $(DFLAGS)-D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 
+wasm: $(OBJ)
+	$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o $(BIN).html $(OBJ)
+	chmod -x $(BIN).wasm

 clean:
-	rm $(OBJ) $(BIN) ext/glfw/deps/wayland/*.h
+	rm $(OBJ) $(BIN) $(EXAMPLES)
+	cd ext; $(MAKE) -f glfw.mk clean; cd -
+
+
+examples: $(EXAMPLES)

 .SUFFIXES: .c .o 

 .c.o:
-	$(CC) $(CFLAGS) -c -o $@ $<
+	$(CC) -Wno-implicit-function-declaration $(CFLAGS) -c -o $@ $<
+
+.c:
+	$(CC) -I include  -o $@ $< -lm
--- a/README.md
+++ b/README.md
@@ -1,89 +1,62 @@
-# Manigraph: Graficadora de variedades
-Diaz Camacho Pedro Emilio
+# Manigraph
+Manigraph is a cutting-edge tool for multidimentional surface visualization,
+capable of handling over a hundred dimensions. It allows users to interactively
+explore each dimension in an intuitive and dynamic way. 
+Import your .klein files, which represents multidimentional surface.

-# Resumen
-manigraph es un graficador interactiva de variedades que lee archivos binarios, con la información de
-una variedad multidimensional y grafica esta variedad en una proyección tridimensional.
+# Building
+Manigraph is written in C99, and uses OpenGL 2.0 for the rendering. So you just
+need a C compiler to build this project.

-# Dependencias
-Para poder compilar el proyecto hace falta lo siguiente.
-## Programas
- `cc`: Cualquier compilador de C.
- `git`: Gestor de dependencias. (Opcional)
- `make`: Herramienta para compilar automáticamente. (Opcional) 
-
-## Librerías
- `openGL`: A cross-platform API for rendering 2D and 3D graphics. (no incluida)
- `glew`: The OpenGL Extension Wrangler Library (no incluida)
- `glfw`: A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input.
- `cglm`: Highly Optimized 2D / 3D Graphics Math (glm) for C.
-### Linux
-Para compilar `glfw` en linux hacen falta las siguientes librerías. (no incluidas)
- libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel libwayland-dev libxkbcommon-dev wayland-protocols
-
-# Descargas
- [git](https://git-scm.com/downloads/win)
- [MinGW](https://github.com/niXman/mingw-builds-binaries/releases)
- [glew](https://glew.sourceforge.net/)
-
-# Clonar el código fuente
+## Source code
 ```
-git clone https://gitea.adles.top/software/manigraph.git
+git clone https://gitea.axiolutions.top/software/manigraph.git
 cd manigraph
 git submodule update --init --recursive
 ```

-# Compilación
-Para compilar manualmente el proyecto se puede usar `make` o ejecutar los comandos manualmente
-en el código fuente de `manigraph`.
+##  Dependecies
+You may need system specific dependecies to build *Manigraph*. 
+[Reference](https://www.glfw.org/docs/3.3/compile.html#compile_deps)

-## Make
-Los siguientes comandos sirven para compilar `manigraph` deacuerdo al sistema operativo.
+### Linux
+- `x11`: libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel
+- `wayland`: libwayland-dev libxkbcommon-dev wayland-protocols
+
+## Commands
+A C compiler is needed for building *Manigraph*. and any of those commands

 ```
 make windows
-make linux
+./compile.bat
+make linux-x11
+make linux-wayland
 make cocoa
+make CC=emcc wasm
 ```

-## Manualmente
-se pueden compilar el proyecto  manualmente sin necesidad del programa `make`.
+# Flow of Manigraph
+![Flow of Manigraph](doc/flow.svg)

-### GLFW
-Si tienes problemas compilando `GLFW` puedes checar su página web oficial
-explicando el tema: [Compiling GLFW](https://www.glfw.org/docs/3.3/compile.html).
+# Design
+Manigraph is a program designed with sustainability in mind. It is built to be 
+portable, resource-efficient, and easy to maintain and scale. The program 
+follows a Data-Oriented Programming (DOP) paradigm, where each file is 
+responsible for a specific data type and manages its own dependencies. Each 
+function is named after the file it resides in, ensuring a clear organization
+and structure.

-#### Windows
-```
-cc -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o glfw.dll -lgdi32
-```
+The independence of data types allows for efficient scaling and maintenance. 
+The main file is a special case in this design: it is responsible for combining
+all the data types in a comprehensive manner, actng as the workflow of the program.

-#### Linux
-```
-cc -fPIC -shared -D_GLFW_X11 -D_GLFW_WAYLAND -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o libglfw.so
-```
+# Contributing
+Before commiting use `clang-format`, for coding style consistency. Your 
+contribution must be whitin the design principles and the concept of Manigraph.

-#### Mac
-```
-cc -fPIC -shared -D_GLFW_COCOA -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o libglfw.so
-```
+The following diagram illustrates the relationships between files, showing how 
+they are connected through dependencies. It also highlights the scenarios where
+files are not independent of one another,

-### Manigraph
-#### Windows
-```
-cc -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lopengl32 -lglew32
-```
-#### Linux
-```
-cc -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lGL -lGLEW
-```
-#### Mac
-```
-cc -framework GL -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lGLEW
-```
+![File layout](doc/file_layout.svg)

-# Ejecutar
-En linux se puede ejecutar el programa sin instalar la libreria de glfw usando:
-```
-LD_LIBRARY_PATH=. ./manigraph
-```
--- a/compile.bat
+++ b/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/cglm/include -I ext/nuklear -I ext/glfw/include src/*.c -o manigraph -L . -lglfw -lopengl32 -lglew32
+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
--- a/doc/es/dev/estructura-archivos.md
+++ b/doc/es/dev/estructura-archivos.md
@@ -1,80 +0,0 @@
-# Estructura de archivos
-Díaz Camacho Pedro Emilio
-
-# Headers
-## main.h
-Este archivo incluye los prototipos internos, que va a usar el programa
-funge como api interna para los desarrolladores y debe estar bien documentada.
-
-# codigo fuente
-
-## main.c
-Este archivo debe configurar el programa antes de iniciarse, avisar de los problemas
-que eviten que el programa se ejecute correctamente, iniciar y terminar los objetos que use el
-programa, así como ejecutar la función principal
-### Depende de
- <GL/gl.h>
-
-## context.c
-En este archivo se escoge un color para limpiar la pantalla y tiene una función para limpiar
-tanto lo dibujado en pantalla, como distintos buffers gráficos.
-### Depende de
- <GL/gl.h>
-
-## input.c
-Incluye la función `poll_input`, que se ejecuta en cada ciclo del programa y devuelve un
-cuaternion de tipo `float *` que representa la rotación total del cubo, después de interactuar 
-con el programa.
-### Depende de
- <GLFW/glfw3.h>
- <cglm/quat.h>
-
-## matrix.c
-Incluye las funciónes para configurar y cargar en la GPU las 3 matrices principales.
- `fix_matrix` esta matriz no cambia y se usa para configurar la perspectiva y la vista que
-va a usar el programa en todo momento.
- `mdl_matrix` esta matriz depende de cada mesh y describe la rotación única de cada objeto,
-se usa para rotar los ejes ortogonamente con un indice.
- `rot_matrix` esta matriz describe la rotación total de todos los objetos y se configura con
-un cuaternio
-### Depende de
- <cglm/mat4.h>
- <cglm/cam.h>
- <cglm/quat.h>
-
-## mesh.c
-Este archivo se usa para crear, destruir y dibujar objetos de tipo `mesh`, un `mesh` es una
-colección de triángulos que describen un objeto multidimensional.
-### Depende de
- <GL/gl.h>
- <stdlib.h>
-
-## shader.c
-Debe crear, destruir y usar los shaders, estos shaders son programas para la gpu escritos en glsl para
-además aquí se carga memoria en gpu con las funciónes `gload_`
-### Depende de
- <GL/gl.h>
-
-## texture.c
-Debe cargar, usar y destruir las texturas, que va a usar la gpu,  también crea una textura 
-para una paleta de colores definida, esto para manipular fácilmente los colores que usará el programa.
-### Depende de
- <GL/gl.h>
-
-## window.c
-Crea, usa, limpie y cierra una ventana, una ventana tiene un contexto de OpenGL asociado para poder
-dibujar objetos en ella, tiene una función especial para avisar si la ventana está abierta para
-dibujar.
-### Depende de
- <GLFW/glfw3.h>
-
-# Datos
-## data/cube.h
-Aquí esta la información del mesh de un cubo, este se va a borrar cuando podamos
-importar meshes para graficarlos.
-
-## data/axis.h
-Aquí está el mesh de un solo eje, este se va a rotar para hacer los otros 2 ejes.
-
-## data/shaders.h
-Aquí estan los shaders en glsl para dibujar en pantalla
--- a/doc/es/dev/tipos.md
+++ b/doc/es/dev/tipos.md
@@ -1,43 +0,0 @@
-# Tipos de datos del proyecto
-Díaz Camacho Pedro Emilio
-
-# Introducción
-En este archivo vamos a detallar los tipos de datos únicos del programa, estos
-tipos de datos son estructuras que representan objetos computacionales y son
-necesarios para integrar las distintas partes del programa.
-
-## window_t
-En `window.c` tenemos una estructura que es la ventana y esta se representa por `window_t`,
-este tipo de dato es un pointer que es manejado por `glfw`.
-
-## id_t
-`id_t` es un tipo de dato que representa objetos de `OpenGL`, estos datos
-normalmente vienen enumerados, y en `manigraph` se usan para representar `shaders`, 
-`programs` y `texture`.
-
-## mesh_t
-Este es un tipo de dato usado para interactuar con `mesh.c`, este representa la triangulación de un
-objeto gráfico y funciona ocultando las variables que `OpenGL` necesita en un `void *`.
-
-## mat4_t
-`mat4_t` se usará para representar las matrices, se usará este tipo de dato exclusivamente
-en `matrix.c` y funcionará con el tipo de dato `mat4` de `cglm`.
-
-## quat_t
-Este tipo de dato sirve para representar un quaternio, este quaternio representa la rotación
-del objeto gráficado en la proyección tridimensional, y se usará para crear una matriz que
-pueda entender `glsl`.
-
-## narray
-`narray` es un tipo de dato que funciona como un `array` enumerado, esto significa que el primer
-elemento del `array` dice cuantos elementos tiene este, sin contar el primer elemento, y los demas elementos 
-funcionan como un `array` normal. 
-
-esta estructura nos ayuda a trabajar con arrays de tamaños arbitrario de forma óptima y sin tener que marcar el
-último elemento de forma especial.
-
-### narray_u8_t
-es un `narray` para `char` y `unsigned char`.
-### narray_float_t
-es un `narray` para `float`.
-
--- a/doc/es/tech/diseno.md
+++ b/doc/es/tech/diseno.md
@@ -1,59 +0,0 @@
-# Manual de Diseño
-Diaz Camacho Pedro Emilio
-
-# Objetivos
-## Prioridad alta
- [ ] El programa debe actualizarse cuando interactuan con el.
- [ ] El usuario quiere:
-	- [X] Ver 3 ejes en todo momento.
-	- [ ] Ver que ejes esta viendo.
-	- [ ] Ver cuantos ejes hay.
- [X] El usuario quiere:
-	- [X] Rotar estos ejes,
-	- [X] Ver donde quedan los ejes despues de la rotados.
- [ ] El usuario experimentado quiere ejecutar el programa y pasar la variedad:
-	- [ ] Como argumento del programa.
-	- [ ] Desde la entrada estandar del programa.
-
-## Prioridad media
-
- [ ] El usuario quiere:
-	- [ ] Cambiar los ejes que se ven por pares.
-	- [ ] Cambiar los ejes donde esta la informacion de los ejes.
- [ ] El usuario quiere interactuar con el programa:
-	- [ ] Usando solo el mouse.
-	- [ ] Usando solo el teclado.
-
-## Prioridad baja
- [ ] El usuario quiere guardar las transformaciones como un archivo GIF.
-
-# Camino
-
-0. Graficadora de un cubo.
-	1. Se hace un programa que muestre un cubo.
-	1. Se muestran los 3 ejes del cubo
-	1. Se rota el cubo en sus 3 ejes usando el teclado.
-	1. Se rota el cubo en sus 3 ejes usando el mouse.
-	1. Se muestran la etiqueta de los ejes.
-	1. Se hace el formato de objetos multidimensionales.
-0. Programa ejemplo
-	1. Se hace un programa que divida un cuadrado en triangulos.
-	1. Se mapea cada vertice del triangulo en un punto de la cinta de 
-	mobius usando una parametrizacion
-	1. Se mapea cada vertice del triangulo en un punto de la botella de
-		klein usando una parametrizacion
-	1. Se divide cada lado de un cubo de n dimensiones, en triangulos.
-
-0. Graficadora de variedades
-	1. Se generaliza el programa para usar este formato.
-	1. Se muestran la informacion de los ejes mostrados y cuantos hay.
-	1. Se pueden cambiar los ejes por pares
-		1. Usando el mouse.
-		1. Usando el teclado.
-0. Detalles.
-	1. Se anima el cambio de eje.
-	1. Se hace el generador de GIF.
-	1. Se puede cambiar el shader 
-	1. Documentacion
-
-
--- a/doc/es/tech/problemas.md
+++ b/doc/es/tech/problemas.md
@@ -1,22 +0,0 @@
-# Problemas esperados al desarrollar
-Diaz Camacho Pedro Emilio
-
-## OpenGL esperan objetos tridimensionales, no de n dimensiones.
-
-Usando glVertexAttribPointer podemos pasar las coordenadas que 
-queramos de los puntos de las variedades, y con ello usar objetos 3D en
-el shader.
-
-## Rotar ejes por pares en una animacion continua.
- Con glVertexAttribPointer podemos pasar las coordenadas del eje 
-seleccionado, al shader.
- Con la funcion mix del shader y bloqueando el input, podemos hacer 
-una animacion pasando una variable con la cpu.
- Cuando la animacion termine intercambiar los indices del layout, 
-usando glVertexAttribPointer otra vez.
-
-## Volumen de la variedad.
-Dado que la funcion parametrizadora es continua, mandamos la frontera
-de un n-cubo a la frontera de una variedad, por lo que solo basta 
-graficar la frontera de la variedad.
-
--- a/doc/es/user.md
+++ b/doc/es/user.md
@@ -1,19 +0,0 @@
-# Manual de usario para Manigraph
-Manigraph es un graficador interactivo de variedades que lee archivos
-binarios de una variedad multidimensional y los proyecta a 3 dimensiones.
-
-# Glosario
-Llamaremos a los 3 ejes de la proyección tridimensional `X`, `Y` y `Z`,
-este sistema de coordenadas es derecho con el eje `Z` apuntando afuera de la pantalla
-
-# Controles
-## Teclado
- `Q` Rota el eje `X` de forma horaria.
- `W` Rota el eje `X` de forma antihoraria.
- `A` Rota el eje `Y` de forma horaria.
- `S` Rota el eje `Y` de forma antihoraria.
- `Z` Rota el eje `Z` de forma horaria.
- `X` Rota el eje `Z` de forma antihoraria.
-## Mouse
- Hacer `click` en un eje lo selecciona.
- El `scroll` del mouse hace girar al eje seleccionado.
--- a/doc/file_layout.svg
+++ b/doc/file_layout.svg
--- a/doc/flow.svg
+++ b/doc/flow.svg
--- a/example/basic.c
+++ b/example/basic.c
@@ -0,0 +1,92 @@
+#include <math.h>
+#include <stdio.h>
+
+#define KLEIN_IMPLEMENT
+#include <klein/klein.h>
+#include <klein/norm.h>
+#include <klein/parm.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+void cube(float *d_surface, int *coord, unsigned char *grid)
+{
+	int i;
+
+	for (i = 0; i < 4; i++)
+		d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
+
+	if (4 == 2)
+		d_surface[2] = 0;
+}
+
+void mobius(float *d_surface, int *coord, unsigned char *grid)
+{
+	const float width = 0.5;
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
+	float v = (2 * width) * ((float)coord[1] / grid[1]) - width;
+
+	d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
+	d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
+	d_surface[2] = v * sin(u / 2);
+}
+
+void torus(float *d_surface, int *coord, unsigned char *grid)
+{
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
+	float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
+
+	d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
+	d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
+	d_surface[2] = 0.5 * sin(v);
+}
+
+void klein(float *d_surface, int *coord, unsigned char *grid)
+{
+	float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
+	float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
+
+	d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
+	d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
+	d_surface[2] = sin(v) * cos(u / 2);
+	d_surface[3] = sin(v) * sin(u / 2);
+}
+
+int main(void)
+{
+	unsigned char i = 0;
+	const char *file_name[] = {"mobius.klein", "torus.klein", "klein.klein"};
+	struct parm parametrization[] = {{
+										 .grid = (unsigned char[]){16, 4},
+										 .m = 2,
+										 .n = 3,
+										 .f = mobius,
+									 },
+		{
+			.grid = (unsigned char[]){16, 8},
+			.m = 2,
+			.n = 3,
+			.f = torus,
+		},
+		{
+			.grid = (unsigned char[]){16, 16},
+			.m = 2,
+			.n = 4,
+			.f = klein,
+		}};
+
+	for (i = 0; i < 3; ++i)
+	{
+		struct klein klein;
+		printf("writing %s\n", file_name[i]);
+
+		klein_parametrize(&klein, parametrization[i]);
+		klein_normalize(&klein);
+		klein_export_file(klein, file_name[i]);
+
+		free(klein.vertex);
+		free(klein.normals);
+	}
+	return 0;
+}
--- a/example/lens.c
+++ b/example/lens.c
@@ -0,0 +1,54 @@
+#include <math.h>
+#include <stdio.h>
+
+#define KLEIN_IMPLEMENT
+#include <klein/klein.h>
+#include <klein/norm.h>
+#include <klein/parm.h>
+
+int p = 37;
+int q = 7;
+
+void lens(float *d_surface, int *coord, unsigned char * grid)
+{
+
+	float norm = 0;
+	float sphere[4];
+
+	for (int i = 0; i < 4; i++)
+		sphere[i] = ((float)coord[i] / grid[i]) - 0.5;
+
+	for(int i = 0; i < 4; i++)
+		norm += sphere[i] * sphere[i];
+
+	for (int i = 0; i < 4; i++)
+		sphere[i] = sphere[i] / sqrt(norm);
+	
+	d_surface[0] = (sphere[0] * cos(2 * M_PI / p)) - (sphere[1] * sin(2 * M_PI / p));
+	d_surface[1] = (sphere[0] * sin(2 * M_PI / p)) + (sphere[1] * cos(2 * M_PI / p));
+	d_surface[2] = (sphere[2] * cos(2 * M_PI * q / p)) - (sphere[3] * sin(2 * M_PI * q / p));
+	d_surface[3] = (sphere[2] * sin(2 * M_PI * q / p)) + (sphere[3] * cos(2 * M_PI * q / p));
+}
+
+int main(void)
+{
+	char file_name[0xff];
+	struct klein klein;
+	struct parm parametrization = {
+		.grid = (unsigned char[]){8, 8,8,8},
+		.m = 4,
+		.n = 4,
+		.f = lens,
+	};
+
+	snprintf(file_name, 0xff, "lens-%03d-%03d.klein", p, q);
+	printf("writing %s\n", file_name);
+
+	klein_parametrize(&klein, parametrization);
+	klein_normalize(&klein);
+	klein_export_file(klein, file_name);
+
+	free(klein.vertex);
+	free(klein.normals);
+	return 0;
+}
--- a/example/n-cube.c
+++ b/example/n-cube.c
@@ -0,0 +1,50 @@
+#include <math.h>
+#include <stdio.h>
+
+#define KLEIN_IMPLEMENT
+#include <klein/klein.h>
+#include <klein/norm.h>
+#include <klein/parm.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+unsigned char dim = 10;
+
+void cube(float *d_surface, int *coord, unsigned char *grid)
+{
+	int i;
+
+	for (i = 0; i < dim; i++)
+		d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
+
+	if (dim == 2)
+		d_surface[2] = 0;
+}
+
+int main(void)
+{
+	unsigned char i;
+	char file_name[0xff];
+	struct klein klein;
+	struct parm parametrization = {
+		.m = dim,
+		.n = dim,
+		.f = cube,
+	};
+
+	parametrization.grid = malloc(dim);
+	
+	for (i = 0; i < dim; ++i)
+		parametrization.grid[i] = 1 + i;
+
+	snprintf(file_name, 0xff, "cube-%03d.klein", dim);
+	printf("writing %s\n", file_name);
+
+	klein_parametrize(&klein, parametrization);
+	klein_normalize(&klein);
+	klein_export_file(klein, file_name);
+
+	return 0;
+}
--- a/example/riemman.c
+++ b/example/riemman.c
@@ -0,0 +1,50 @@
+#include <complex.h>
+#include <math.h>
+#include <stdio.h>
+
+#define KLEIN_IMPLEMENT
+#include <klein/klein.h>
+#include <klein/norm.h>
+#include <klein/parm.h>
+
+#ifndef CMPLX
+#define CMPLX(a, b) (a + I * b)
+#endif
+
+complex float f(complex float z) { return csqrt(z); }
+
+void riemman(float *d_surface, int *coords, unsigned char *grid)
+{
+	complex float eq;
+	float u = 2 * ((float)coords[0] / grid[0]) - 1;
+	float v = 2 * ((float)coords[1] / grid[1]) - 1;
+
+	eq = f(CMPLX(u, v));
+
+	d_surface[0] = u;
+	d_surface[1] = v;
+	d_surface[2] = creal(eq);
+	d_surface[3] = cimag(eq);
+}
+
+int main(void)
+{
+	const char *file_name = "riemman.klein";
+	struct klein klein;
+	struct parm parametrization = {
+		.grid = (unsigned char[]){16, 4},
+		.m = 2,
+		.n = 4,
+		.f = riemman,
+	};
+
+	printf("writing %s\n", file_name);
+
+	klein_parametrize(&klein, parametrization);
+	klein_normalize(&klein);
+	klein_export_file(klein, file_name);
+
+	free(klein.vertex);
+	free(klein.normals);
+	return 0;
+}
--- a/ext/glad/glad.c
+++ b/ext/glad/glad.c
--- a/ext/glad/glad.h
+++ b/ext/glad/glad.h
--- a/ext/glad/khrplatform.h
+++ b/ext/glad/khrplatform.h
@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
--- a/ext/glfw.mk
+++ b/ext/glfw.mk
@@ -0,0 +1,71 @@
+BIN = libglfw.a
+OBJ = \
+	glfw/src/context.o \
+	glfw/src/egl_context.o \
+	glfw/src/glx_context.o \
+	glfw/src/init.o \
+	glfw/src/input.o \
+	glfw/src/linux_joystick.o \
+	glfw/src/monitor.o \
+	glfw/src/null_init.o \
+	glfw/src/null_joystick.o \
+	glfw/src/null_monitor.o \
+	glfw/src/null_window.o \
+	glfw/src/osmesa_context.o \
+	glfw/src/platform.o \
+	glfw/src/posix_module.o \
+	glfw/src/posix_poll.o \
+	glfw/src/posix_thread.o \
+	glfw/src/posix_time.o \
+	glfw/src/vulkan.o \
+	glfw/src/wgl_context.o \
+	glfw/src/win32_init.o \
+	glfw/src/win32_joystick.o \
+	glfw/src/win32_module.o \
+	glfw/src/win32_monitor.o \
+	glfw/src/win32_thread.o \
+	glfw/src/win32_time.o \
+	glfw/src/win32_window.o \
+	glfw/src/window.o \
+	glfw/src/wl_init.o \
+	glfw/src/wl_monitor.o \
+	glfw/src/wl_window.o \
+	glfw/src/x11_init.o \
+	glfw/src/x11_monitor.o \
+	glfw/src/x11_window.o \
+	glfw/src/xkb_unicode.o 
+
+WAYLAND-LIB = \
+	xdg-shell \
+	relative-pointer-unstable-v1 \
+	xdg-decoration-unstable-v1 \
+	pointer-constraints-unstable-v1 \
+	viewporter \
+	idle-inhibit-unstable-v1  \
+	fractional-scale-v1 \
+	xdg-activation-v1 \
+	wayland
+
+windows: 
+	$(MAKE) $(OBJ) CFLAGS="-D_GLFW_WIN32 -Iglfw/deps/wayland"
+	$(AR) rsc $(BIN) $(OBJ)
+
+linux-x11: 
+	$(MAKE) $(OBJ) CFLAGS="-D_GLFW_X11 -Iglfw/deps/wayland"
+	$(AR) rsc $(BIN) $(OBJ)
+
+
+linux-wayland: 
+	for i in $(WAYLAND-LIB); \
+	do  \
+		wayland-scanner client-header glfw/deps/wayland/$$i.xml glfw/deps/wayland/$$i-client-protocol.h; \
+		wayland-scanner private-code glfw/deps/wayland/$$i.xml glfw/deps/wayland/$$i-client-protocol-code.h; \
+	done
+	$(MAKE) $(OBJ) CFLAGS="-D_GLFW_WAYLAND -fPIC -Iglfw/deps/wayland"
+	$(AR) rsc $(BIN) $(OBJ)
+
+
+
+clean:
+	rm $(OBJ) $(BIN)
+	rm glfw/deps/wayland/*.h
--- a/include/klein/klein.h
+++ b/include/klein/klein.h
@@ -0,0 +1,48 @@
+#ifdef KLEIN_H
+#error file included twice
+#endif
+#define KLEIN_H
+
+#ifdef KLEIN_IMPLEMENT
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+struct klein
+{
+	unsigned long vertex_size;
+	float *vertex, *normals;
+	unsigned char dim;
+};
+
+/*
+	The klein format must have:
+		5 bytes with klein.
+		1 byte empty for expantions
+		1 byte with the dimention of the surface
+
+*/
+
+static inline
+int klein_export_file(struct klein klein, const char * filename);
+
+
+#ifdef KLEIN_IMPLEMENT
+static inline
+int klein_export_file(struct klein klein, const char * filename)
+{
+	FILE *file = fopen(filename, "wb");
+	if (!file)
+		return 1;
+
+	fwrite("KLEIN", 1, 5, file);
+	fwrite("\0", 1, 1, file);
+	fwrite(&klein.dim, 1, 1, file);
+	fwrite(&klein.vertex_size, 8, 1, file);
+	fwrite(klein.vertex, 4, klein.vertex_size * klein.dim, file);
+	fwrite(klein.normals, 4, klein.vertex_size * klein.dim, file);
+
+	fclose(file);
+	return 0;
+}
+#endif
--- a/include/klein/norm.h
+++ b/include/klein/norm.h
@@ -0,0 +1,132 @@
+#ifdef KLEIN_NORM_H
+#error file included twice
+#endif
+#define KLEIN_NORM_H
+
+
+#ifndef KLEIN_H
+#warning Please include klein/klein.h
+#endif
+
+void klein_normalize(struct klein * klein);
+
+#ifdef KLEIN_IMPLEMENT
+static inline
+void __calculate_normal( float *p1, float *p2, float *p3, float *normal, unsigned char n)
+{ unsigned char i;
+	float alpha;
+	float *v1, *v2, *v3;
+	float *u1, *u2, *u3;
+
+	v1 = malloc(n * sizeof(float));
+	v2 = malloc(n * sizeof(float));
+	v3 = malloc(n * sizeof(float));
+	u1 = malloc(n * sizeof(float));
+	u2 = malloc(n * sizeof(float));
+	u3 = malloc(n * sizeof(float));
+
+	/*
+		Calculate a normal vector of a plain using Gram-Schmidt process
+	*/
+	{
+		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)
+		{
+			u1[i] = v1[i];
+		}
+
+		{
+			float proj[n];
+			float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
+			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)
+			{
+				proj[i] = u1[i] * alpha;
+				u2[i] = v2[i] - proj[i];
+			}
+		}
+
+		{
+			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;
+
+			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);
+			}
+
+			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)
+			{
+				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)
+		{
+			magnitude += u3[i] * u3[i];
+		}
+		magnitude = sqrtf(magnitude);
+
+		for (i = 0; i < n; ++i)
+		{
+			normal[i] = u3[i] / magnitude;
+		}
+
+		free(v1);
+		free(v2);
+		free(v3);
+		free(u1);
+		free(u2);
+		free(u3);
+		return;
+	}
+}
+
+void klein_normalize(struct klein * klein)
+{
+	unsigned long i;
+	unsigned char j;
+	float *norm_vec;
+
+	klein->normals = malloc((klein->dim * klein->vertex_size) * sizeof(float));
+	norm_vec = malloc(klein->dim * sizeof(float));
+
+	for (i = 0; i < klein->vertex_size; i += 3 * klein->dim)
+	{
+		__calculate_normal(klein->vertex + i, klein->vertex + i + klein->dim, klein->vertex + i + 2 * klein->dim, norm_vec, klein->dim);
+		for (j = 0; j < klein->dim; ++j )
+		{
+			(klein->normals + i)[j]=norm_vec[j];
+			(klein->normals + i + klein->dim)[j]=norm_vec[j];
+			(klein->normals + i + 2*klein->dim)[j]=norm_vec[j];
+		}
+	}
+
+	free(norm_vec);
+}
+#endif
--- a/include/klein/parm.h
+++ b/include/klein/parm.h
@@ -0,0 +1,134 @@
+#ifndef KLEIN_H
+#warning Please include klein/klein.h before klein/parm.h
+#endif
+
+#ifdef KLEIN_PARM_H
+#error file included twice
+#endif
+#define KLEIN_PARM_H
+
+
+typedef void (*function_t)(float *, int *, unsigned char *);
+
+struct parm
+{
+	unsigned char *grid;
+	unsigned char m, n;
+	function_t f;
+};
+
+
+void klein_parametrize( struct klein * klein, struct parm parm );
+
+#ifdef KLEIN_IMPLEMENT
+#ifdef TEST
+#include <assert.h>
+#endif
+
+static inline int __factorial(int n)
+{
+	if (n == 1)
+		return 1;
+
+	return n * __factorial(n - 1);
+}
+
+static inline int __face(int n)
+{
+	if (n == 2)
+		return 1;
+
+	return (1 << (n - 3)) * __factorial(n) / __factorial(n - 2);
+}
+
+void klein_parametrize( struct klein * klein, struct parm parm)
+{
+	unsigned int i, j, k, o, p, n;
+	unsigned long size, q = 0;
+	int *face;
+
+#ifdef TEST
+	assert(__face(2) == 1);
+	assert(__face(3) == 6);
+	assert(__face(4) == 24);
+#endif
+
+	klein->dim = parm.n;
+	klein->vertex_size = 0;
+	{
+		unsigned char 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);
+			}
+		}
+		klein->vertex_size /= test;
+	}
+
+	size = (klein->dim) * (klein->vertex_size);
+	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++)
+			{
+				unsigned char skip = 0;
+				for (n = 0; n < parm.m; n++)
+				{
+					if (n == o || n == p)
+						skip++;
+
+					face[n] = (k & (1 << (n - skip))) ? parm.grid[n] : 0;
+				}
+
+				for (i = 0; i < parm.grid[p]; i++)
+				{
+					for (j = 0; j < parm.grid[o]; j++)
+					{
+						face[p] = i;
+						face[o] = j;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+
+						face[p] = i + 1;
+						face[o] = j;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+
+						face[p] = i + 1;
+						face[o] = j + 1;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+
+						face[p] = i;
+						face[o] = j;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+
+						face[p] = i;
+						face[o] = j + 1;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+
+						face[p] = i + 1;
+						face[o] = j + 1;
+						parm.f(&klein->vertex[q], face, parm.grid);
+						q += parm.n;
+					}
+				}
+			}
+		}
+	}
+
+#ifdef TEST
+	assert(q == size);
+#endif
+}
+#endif
--- a/src/context.c
+++ b/src/context.c
@@ -1,17 +1,31 @@
 #include "main.h"
-#include <GL/glew.h>
+
+#ifdef EMSCRIPTEN
+#include <GL/gl.h>
+#else
+#include <glad.h>
+#include <GLFW/glfw3.h>
+#endif

 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);
 }

-int init_context(void) { return glewInit(); }
+int init_context(void)
+{
+#ifdef EMSCRIPTEN
+	return 1;
+#else
+	return gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
+#endif
+}

 void clean_context(void)
 {
 	/* This is important cos, Nuklear Disable DEPTH TEST */
+	glEnable(GL_BLEND);
 	glEnable(GL_DEPTH_TEST);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT );
 }
--- a/src/data/axis.h
+++ b/src/data/axis.h
@@ -1,40 +0,0 @@
-#undef A
-#undef B 
-#undef C 
-#undef D
-#undef E
-#undef F
-#undef G 
-#undef H
-
-#define A -2.0,-0.05,-0.05,
-#define B -2.0,-0.05, 0.05,
-#define C -2.0, 0.05,-0.05,
-#define D -2.0, 0.05, 0.05,
-#define E  2.0,-0.05,-0.05,
-#define F  2.0,-0.05, 0.05,
-#define G  2.0, 0.05,-0.05,
-#define H  2.0, 0.05, 0.05,
-
-float d_axis[] =
-{
-	3*3*2*6,
-
-	A C E
-	G E C
-
-	E G F
-	H F G
-
-	F H B
-	D B H
-
-	B D A
-	C A D 
-
-	C D G
-	H G D
-
-	E B A
-	B E F
-};
--- a/src/data/shaders.h
+++ b/src/data/shaders.h
@@ -1,6 +1,10 @@
-const char * vs =
+const char *vs =
+#ifdef EMSCRIPTEN
+	"#version 300 es\n"
+	"precision highp float;"
+#else
 	"#version 330 core\n"
-
+#endif
 	"layout (location = 0) in float aPos_x;"
 	"layout (location = 1) in float aPos_y;"
 	"layout (location = 2) in float aPos_z;"
@@ -11,62 +15,84 @@ const char * vs =
 	"layout (location = 6) in float aNormal_z;"
 	"layout (location = 7) in float aNormal_w;"

-	"uniform float idx;"
+	"uniform float angle;"
+	"uniform float i;"
+	"uniform vec4 color;"
+
 	"uniform mat4 fix;"
 	"uniform mat4 rot;"
-	"uniform mat4 mdl;"

-	"out float index;"
 	"out vec3 Normal;"
 	"out vec3 FragPos;"
+	"out vec4 Color;"
+
+	"mat2 rotate2d( float angle )"
+	"{"
+	"return mat2( cos(angle), sin(angle), -sin(angle), cos(angle) );"
+	"}"

 	"void main()"
 	"{"
-	"	index=idx;"
+	"	Color=color;"
+
 	"	vec3 aNormal = vec3(aNormal_x,aNormal_y,aNormal_z);"
 	"	vec3 aPos = vec3(aPos_x,aPos_y,aPos_z);"
-	"	Normal = mat3(transpose(inverse(rot*mdl))) * aNormal;"
-	"	gl_Position = fix * rot * mdl * vec4( aPos, 1.0 );\n"
-	"	FragPos = vec3( rot * mdl * vec4(aPos, 1.0));"
+
+	"	aNormal[int(i)] = (vec2(aNormal[int(i)], aNormal_w) * "
+	"rotate2d(angle))[0];"
+	"	aPos[int(i)] = (vec2(aPos[int(i)], aPos_w) * rotate2d(angle))[0];"
+
+	"	Normal = mat3(transpose(inverse(rot))) * aNormal;"
+	"	gl_Position = fix * rot * vec4( aPos, 1.0 );\n"
+	"	FragPos = vec3( rot * vec4(aPos, 1.0));"
 	"}";

-	
-const char * fs_plain =
+const char *fs_plain =
+#ifdef EMSCRIPTEN
+	"#version 300 es\n"
+	"precision highp float;"
+#else
 	"#version 330 core\n"
-
-	"uniform sampler2DArray palette;"
-
-	"in float index;"
+#endif
 	"out vec4 FragColor;"
 	"in vec3 Normal;"
 	"in vec3 FragPos;"
+	"in vec4 Color;"

 	"void main()"
 	"{"
-	"	FragColor = texture( palette, vec3( 0, 0, index ) ).rgba;"
+	"	FragColor = vec4(pow(vec3(Color),vec3(1.0/1.0)),Color.a);"
 	"}";

-	
-const char * fs =
+const char *fs =
+#ifdef EMSCRIPTEN
+	"#version 300 es\n"
+	"precision highp float;"
+#else
 	"#version 330 core\n"
+#endif

-	"uniform sampler2DArray palette;"
-
-	"in float index;"
-	"out vec4 FragColor;"
 	"in vec3 Normal;"
 	"in vec3 FragPos;"
+	"in vec4 Color;"
+
+	"out vec4 FragColor;"

 	"void main()"
 	"{"

-	"	vec4 color = texture( palette, vec3( 0, 0, index ) ).rgba;"
-	"	vec3 lightPos = vec3(0,0,-15);"
-	"	vec3 lightDir = normalize(lightPos - FragPos);"
+	"   vec3 viewPos = vec3(0, 0, -15);\n"
+	"   vec3 viewDir = normalize(viewPos - FragPos);\n"

-	"	float diffuse = abs(dot(Normal, lightDir)); "
+	"   vec3 lightPos = viewPos;\n"
+	"   vec3 lightDir = normalize(lightPos - FragPos);\n"

-	"	FragColor = (0.5 + 0.5*diffuse)*color;"
+	"   vec3 halfwayDir = normalize(lightDir + viewDir);\n"
+
+	"   float specular = pow(abs(dot(normalize(Normal), halfwayDir)), 32.0);\n"
+	"   float diffuse = abs(dot(normalize(Normal), lightDir));\n"
+
+	"   vec3 result = pow((0.5 + 0.5*diffuse + 1*specular) * Color.rgb, "
+	"vec3(1.0/2.2));\n"
+	"   FragColor = vec4(result, Color.a);\n"
 	"}";
-
-	
--- a/src/gui.c
+++ b/src/gui.c
@@ -0,0 +1,83 @@
+#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);
+	}
+}
--- a/src/input.c
+++ b/src/input.c
@@ -1,13 +1,18 @@
 #include "main.h"
+#include <glad.h>
 #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;
-int window_height;
+int window_width = 512;
+int window_height = 512;
+
+unsigned char animate_index = 0;
+extern struct gui gui;

 versor q = GLM_QUAT_IDENTITY_INIT;

@@ -17,7 +22,13 @@ vec3 axis[3] = {
 	{0, 0, 1},
 };

-extern struct projection projection;
+
+void __error_callback_input(int x, const char * msg )
+{
+	mlog("[GLFW] ");
+	mlog(msg);
+	mlog("\n");
+}

 void __key_callback_input(
 	GLFWwindow *window, int key, int scancode, int action, int mods)
@@ -31,43 +42,45 @@ void __key_callback_input(

 		selected_coord = key - GLFW_KEY_0 - 1;

-		if (selected_coord >= projection.m)
+		if (selected_coord >= gui.projection.m)
 			return;
-		if (selected_coord == projection.x)
+		if (selected_coord == gui.projection.x)
 			return;
-		if (selected_coord == projection.y)
+		if (selected_coord == gui.projection.y)
 			return;
-		if (selected_coord == projection.z)
+		if (selected_coord == gui.projection.z)
 			return;

-		selected_coord = projection.w;
+		selected_coord = gui.projection.w;
 	}

-	if (projection.w >= projection.m)
+	if (gui.projection.w >= gui.projection.m)
 		return;

 	switch (key)
 	{
 		unsigned char tmp;
+	case GLFW_KEY_I:
+		tmp = gui.projection.w;
+		gui.projection.w = gui.projection.x;
+		gui.projection.x = tmp;

-	case GLFW_KEY_P:
-		tmp = projection.w;
-		projection.w = projection.x;
-		projection.x = tmp;
+		animate_index = 1;
 		break;
 	case GLFW_KEY_O:
-		tmp = projection.w;
-		projection.w = projection.y;
-		projection.y = tmp;
+		tmp = gui.projection.w;
+		gui.projection.w = gui.projection.y;
+		gui.projection.y = tmp;
+		animate_index = 2;
 		break;
-	case GLFW_KEY_I:
-		tmp = projection.w;
-		projection.w = projection.z;
-		projection.z = tmp;
+	case GLFW_KEY_P:
+		tmp = gui.projection.w;
+		gui.projection.w = gui.projection.z;
+		gui.projection.z = tmp;
+		animate_index = 3;
 		break;
 	}

-	set_projection_mesh(projection);
 	return;
 }

@@ -107,13 +120,40 @@ 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]);
+}
+
+void __drop_callback_input(GLFWwindow *window, int count, unsigned char **path)
+{
+	struct surface surface;
+
+	if (create_surface_klein(*path, &surface))
+		return;
+
+	if (!(gui.projection.mesh = create_mesh(surface)))
+		return;
+
+	strcpy(gui.file_name, *path);
+
+	gui.projection.m = surface.dim;
+	set_projection_mesh(gui.projection);
+
+	free(surface.norm);
+	free(surface.data);
 }

 quat_t poll_input(window_t window)
@@ -157,5 +197,6 @@ end:
 	glm_quat_rotatev(p, axis[1], axis[1]);
 	glm_quat_rotatev(p, axis[2], axis[2]);
 	glm_quat_normalize(q);
+
 	return q;
 }
--- a/src/klein.c
+++ b/src/klein.c
@@ -0,0 +1,44 @@
+#include "main.h"
+
+#include <stdio.h>
+
+/*
+	KLEIN Format:
+		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
+		n bytes with the vertex data of the surface
+		n bytes with the normal data of the surface
+
+	where n is the size of the vertex and normal data that could be 
+	calculated as the dimention of the surface  time the number of vertes 
+	time the size of a 16 bytes float.
+*/
+
+int create_surface_klein(unsigned char *path, struct surface *surface)
+{
+	unsigned long size;
+	char buffer[5];
+	FILE *file = fopen(path, "rb");
+	if (!file)
+		return 1;
+
+	fread(buffer, 1, 5, file);
+
+	if (strncmp(buffer, "KLEIN", 5))
+		return 1;
+
+	fread(buffer, 1, 1, file);
+	fread(&surface->dim, 1, 1, file);
+	fread(&surface->vertex, 8, 1, file);
+
+	size = surface->dim * surface->vertex;
+
+	surface->data = malloc(4 * size);
+	fread(surface->data, 4, size, file);
+
+	surface->norm = malloc(4 * size);
+	fread(surface->norm, 4, size, file);
+	return 0;
+}
--- a/src/load.c
+++ b/src/load.c
@@ -0,0 +1,28 @@
+#include "main.h"
+#include <cglm/cam.h>
+#include <cglm/mat4.h>
+#include <cglm/quat.h>
+
+void fix_matrix_load(id_t shader, float ratio)
+{
+	mat4 m, n;
+	const int d = 7;
+
+	glm_lookat((vec3){0, 0, -d}, (vec3){0, 0, 0}, (vec3){0, 1, 0}, m);
+	glm_perspective(CGLM_PI / 6, ratio, d - 3, d + 3, n);
+	glm_mat4_mul(n, m, m);
+
+	load_mat4_to_shader(shader, "fix", (mat4_t)m);
+}
+
+void rot_matrix_load(id_t shader, quat_t q)
+{
+	mat4 m;
+	glm_quat_mat4(q, m);
+	load_mat4_to_shader(shader, "rot", (mat4_t)m);
+}
+
+void color_load(id_t shader, float res[4])
+{
+	load_float4_to_shader(shader, "color", res);
+}
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,4 @@
 #include "main.h"
-#include "data/axis.h"
 #include "data/shaders.h"

 #include <stdio.h>
@@ -8,41 +7,26 @@
 #define WIDTH 512
 #define HEIGHT 512

-#ifdef GLAD
 #include <glad.h>
-#else
-#include <GL/glew.h>
-#endif
-#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>

 float *generate_data_surface(unsigned int, unsigned char *);
 float *generate_normals_surface(float *, unsigned char);

-float graph_color[3] = {1.0f, 1.0f, 1.0f}; // Inicialización al blanco
+#ifdef EMSCRIPTEN
+#include <emscripten.h>
+#endif

+#ifndef M_PI
+#define M_PI 3.14159
+#endif
+
+window_t window;
+id_t shader, shader_plain;

 const char *wname = "manigraph: manifold grapher";

-struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3};
-
-unsigned char palette[][4] = {
-	{0xEB, 0xD3, 0xF8, 0xff},
-	{0xEB, 0xD4, 0xF8, 0xff},
-	{0xEB, 0xD5, 0xF8, 0xff},
-	{0x7A, 0x1C, 0xAC, 0xff},
-};
+extern volatile unsigned char animate_index;
+extern struct gui gui;

 void mlog(char *msg)
 {
@@ -51,15 +35,66 @@ void mlog(char *msg)
 #endif
 }

+#ifndef EMSCRIPTEN
+static inline
+#endif
+
+	void
+	main_loop(void)
+{
+	quat_t q;
+
+	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_plain, gui.picked_color);
+
+	{
+		static float angle = 0;
+
+		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(gui.projection);
+		}
+
+		if (animate_index)
+		{
+			load_float_to_shader(shader, "i", animate_index - 1);
+			load_float_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);
+		}
+	}
+	clean_context();
+
+
+	if (gui.projection.mesh)
+	{
+		draw_mesh(shader, gui.projection.mesh);
+		draw_mesh_lines(shader_plain, gui.projection.mesh);
+	}
+
+	draw_gui();
+	
+}
+
 int main(void)
 {
-	struct nk_context* context;
-	struct nk_glfw glfw = {0};
-	id_t shader, texture, shader_plain;
-	mesh_t m_surface, m_axis;
-	window_t window;
-	
-
 	mlog("[VENTANA] Inicializando...\n");
 	{
 		if (!(window = init_window(WIDTH, HEIGHT, wname)))
@@ -73,15 +108,12 @@ int main(void)

 	mlog("[CONTEXT] Inicializando...\n");
 	{
-		init_context();
-	
-		set_clean_color_context(0x2E, 0x07, 0x3F);
-	}
-
-	mlog("[TEXTURE] Inicializando...\n");
-	{
-		texture = create_palette_texture(palette, 4);
-		use_texture(texture);
+		if (!(init_context()))
+		{
+			mlog("[CONTEXT] Error al inicializar...\n");
+			goto error_context;
+		}
+		set_clean_color_context(0xFF, 0xFF, 0xFF);
 	}

 	mlog("[SHADER] Inicializando...\n");
@@ -93,7 +125,7 @@ int main(void)
 		}
 		load_program_to_shader(shader, vs, VERTEX);
 		load_program_to_shader(shader, fs, FRAGMENT);
-		load_fix_matrix(shader, (float)WIDTH / HEIGHT);
+		fix_matrix_load(shader, (float)WIDTH / HEIGHT);
 	}

 	mlog("[SHADER] Inicializando...\n");
@@ -105,165 +137,42 @@ int main(void)
 		}
 		load_program_to_shader(shader_plain, vs, VERTEX);
 		load_program_to_shader(shader_plain, fs_plain, FRAGMENT);
-		load_fix_matrix(shader_plain, (float)WIDTH / HEIGHT);
-	}
-
-	mlog("[MESH] Inicializando...\n");
-	{
-		unsigned char m;
-		float *n_surface, *d_surface;
-		d_surface = generate_data_surface(16, &m);
-		n_surface = generate_normals_surface(d_surface, m);
-
-		projection.m = m;
-
-		if (!(m_surface = create_mesh(d_surface, n_surface, m)))
-		{
-			mlog("[MESH] Error al inicializar...\n");
-			goto error_mesh_surface;
-		}
-
-		projection.mesh = m_surface;
-
-		free(n_surface);
-		free(d_surface);
-	}
-
-	mlog("[MESH] Inicializando...\n");
-	{
-		if (!(m_axis = create_mesh(d_axis, NULL, 3)))
-		{
-			mlog("[MESH] Error al inicializar...\n");
-			goto error_mesh_axis;
-		}
+		fix_matrix_load(shader_plain, (float)WIDTH / HEIGHT);
 	}

 	mlog("[GUI] Inicializando...\n");
 	{
-		struct nk_font_atlas* atlas;
-		context = nk_glfw3_init(&glfw,(GLFWwindow*) window, NK_GLFW3_DEFAULT );
-		nk_glfw3_font_stash_begin(&glfw, &atlas);
-		nk_glfw3_font_stash_end(&glfw);
+		init_gui(window);
 	}

-	/* Variable para el color */
-	static struct nk_colorf picked_color = {1.0f, 1.0f, 1.0f, 1.0f}; // Blanco en formato flotante
-
-
 	mlog("[MAIN LOOP] Inicializando...\n");
-	while (is_open_window(window))
-	{
-		quat_t q;
-
-		q = poll_input(window);
-		load_rot_matrix(shader, q);
-		load_rot_matrix(shader_plain, q);
-
-		clean_context();
-
-#ifndef DEBUG
-		load_mdl_matrix(shader_plain, 0, 0);
-		draw_mesh(m_axis);
-		load_mdl_matrix(shader_plain, 1, 1);
-		draw_mesh(m_axis);
-		load_mdl_matrix(shader_plain, 2, 2);
-		draw_mesh(m_axis);
-		load_mdl_matrix(shader, 0, 3);
+#ifdef EMSCRIPTEN
+	emscripten_set_main_loop(&main_loop, 60, 1);
+	return 0;
 #else
-		load_mdl_matrix(shader_plain, 0, 3);
+	while (is_open_window(window))
+		main_loop();
 #endif
-		draw_mesh(m_surface);
-
-		/* Dibujando interfaz gráfica */
-		{
-			/* Mejorar el diseño del UI */
-			nk_glfw3_new_frame(&glfw);
-
-			if (nk_begin(context, "MANIGRAPH", nk_rect(10, 10, 480, 480),
-						NK_WINDOW_BORDER | NK_WINDOW_TITLE | NK_WINDOW_SCALABLE | NK_WINDOW_MOVABLE | NK_WINDOW_MINIMIZABLE)) {
-
-				/* Encabezado del UI */
-				nk_layout_row_dynamic(context, 30, 1);
-				nk_label_colored(context, "MANIGRAPH", NK_TEXT_ALIGN_CENTERED, nk_rgb(255, 255, 0)); // Título en amarillo
-
-				/* Información sobre la gráfica */
-				nk_layout_row_dynamic(context, 20, 1);
-				nk_label(context, "Información de la gráfica:", NK_TEXT_ALIGN_LEFT);
-
-				/* Mostrar la función de la gráfica */
-				nk_label_colored(context, "Función actual: z = x^2 + y^2", NK_TEXT_ALIGN_LEFT, nk_rgb(0, 255, 0)); // Texto verde
-
-				/* Color picker para personalización */
-				nk_layout_row_dynamic(context, 120, 1); // Área para selector de color
-				picked_color = nk_color_picker(context, picked_color, NK_RGBA);
-
-				/* Aplicar color a la gráfica */
-				graph_color[0] = picked_color.r;
-				graph_color[1] = picked_color.g;
-				graph_color[2] = picked_color.b;
-
-				glUseProgram(shader);
-				glUniform3fv(glGetUniformLocation(shader, "uColor"), 1, graph_color);
-
-				/* Opciones de configuración */
-				nk_layout_row_dynamic(context, 30, 2); // Filas divididas en dos columnas
-				if (nk_button_label(context, "Restablecer")) {
-					printf("Color restablecido\n");
-					picked_color.r = 1.0f;
-					picked_color.g = 1.0f;
-					picked_color.b = 1.0f;
-				}
-
-				if (nk_button_label(context, "Exportar")) {
-					printf("Exportar gráfica\n");
-					// Lógica de exportación aquí
-				}
-
-				/* Sección de ayuda */
-				nk_layout_row_dynamic(context, 20, 1);
-				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);
-
-				/* Espacio para interacción adicional */
-				nk_layout_row_dynamic(context, 30, 1);
-				if (nk_button_label(context, "Salir")) {
-					printf("Cerrando aplicación\n");
-					break; // Salir del bucle principal
-				}
-			}
-
-			nk_end(context);
-			nk_glfw3_render(&glfw, NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
-
-		}
-	}
 	mlog("[MAIN LOOP] Terminando...\n");

 	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_axis);
-	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_surface);
+	destroy_mesh(gui.projection.mesh);
 	mlog("[SHADER] Destruyendo...\n");
 	destroy_shader(shader_plain);
 	mlog("[SHADER] Destruyendo...\n");
 	destroy_shader(shader);
-	mlog("[TEXTURE] Destruyendo...\n");
-	destroy_texture(texture);
 	mlog("[WINDOW] Destruyendo...\n");
 	close_window(window);
 	return 0;

-error_mesh_axis:
-	destroy_mesh(m_surface);
-error_mesh_surface:
-	destroy_shader(shader_plain);
-error_shader_plain:
+error_context:
+	mlog("[SHADER] Destruyendo...\n");
 	destroy_shader(shader);
 error_shader:
-	destroy_texture(texture);
-error_context:
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader_plain);
+error_shader_plain:
+	mlog("[WINDOW] Destruyendo...\n");
 	close_window(window);
 error_window:
 	return 1;
--- a/src/main.h
+++ b/src/main.h
@@ -4,15 +4,16 @@
 	error of the shaders.
 */

-/* #define DEBUG  */
+#define DEBUG
+#define GLFW_INCLUDE_NONE

-typedef const void * window_t;
+typedef const void *window_t;
 typedef unsigned int id_t;
-typedef void * mesh_t;
-typedef float * quat_t;
-typedef float * mat4_t;
+typedef void *mesh_t;
+typedef float *quat_t;
+typedef float *mat4_t;

-/* 
+/*
 	This struct represent the proyection, where:
 		mesh: data of surface.
 		m: the dimention of the surface.
@@ -22,20 +23,45 @@ typedef float * mat4_t;
 		w: the coordanate of the w axis.
 */

-struct projection
+struct gui
 {
-	mesh_t mesh;
-	unsigned char m, x, y, z, w;
+	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:
+		data: the buffer with the vertex coords
+		norm: the buffer with the norm coords
+		vertex: the number of vertex
+		dim: the dimentions of the surface
+*/
+
+struct surface
+{
+	float *data, *norm;
+	unsigned long vertex;
+	unsigned char dim;
+};
+
+/*
 	Init window:
 		w: default width;
 		h: default height;
 		name: Name of the window.
 */

-window_t init_window(unsigned int w, unsigned int h, const char * name);
+int create_surface_klein( unsigned char *, struct surface *  );
+
+window_t init_window(unsigned int w, unsigned int h, const char *name);

 void use_window(window_t window);

@@ -43,20 +69,22 @@ int is_open_window(window_t window);

 void close_window(window_t window);

-/* 
+/*
 	Create mesh:
 		d: array of floats with the vertex data.
 		n: array of floats with the normal data.
 		m: Dimention of mesh
 */

-mesh_t create_mesh( float * d, float * n, unsigned char m );
+mesh_t create_mesh(struct surface);

-void set_projection_mesh( struct projection );
+void set_projection_mesh(struct projection);

 void destroy_mesh(mesh_t p);

-void draw_mesh(mesh_t p);
+void draw_mesh(id_t, mesh_t p);
+
+void draw_mesh_lines(id_t, mesh_t p);

 /*
 	Set background color:
@@ -69,7 +97,7 @@ void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b);

 void clean_context(void);

-int init_context( void );
+int init_context(void);

 void destroy_shader(id_t shader);

@@ -79,7 +107,8 @@ void use_shader(id_t shader);

 enum
 {
-	VERTEX, FRAGMENT
+	VERTEX,
+	FRAGMENT
 };

 /*
@@ -88,7 +117,8 @@ enum
 		type: VERTEX or FRAGMENT
 */

-unsigned char load_program_to_shader(id_t shader, const char * src, unsigned int type);
+unsigned char load_program_to_shader(
+	id_t shader, const char *src, unsigned int type);

 /*
 	load float to shader:
@@ -96,7 +126,23 @@ unsigned char load_program_to_shader(id_t shader, const char * src, unsigned int
 		f: float to load
 */

-void load_float_to_shader(id_t shader, char * var, float f);
+void load_float_to_shader(id_t shader, char *var, float f);
+
+/*
+	load unsigned int to shader:
+		var: name of glsl variable.
+		u: unsigned int to load
+*/
+
+void load_uint_to_shader(id_t shader, char *var, unsigned int u);
+
+/*
+	load float[4] to shader:
+		var: name of glsl variable.
+		f: float[4] to load
+*/
+
+void load_float4_to_shader(id_t shader, char *var, float f[4]);

 /*
 	load matrix 4 to shader:
@@ -104,32 +150,28 @@ void load_float_to_shader(id_t shader, char * var, float f);
 		m: Matrix to load
 */

-void load_mat4_to_shader(id_t shader, char * var, mat4_t m);
+void load_mat4_to_shader(id_t shader, char *var, mat4_t m);

 /*
 	Generate and load fix matrix, this matrix
 	has the information of the perspective and
 	camera information.
-		
+
 		ratio: default ratio of window.
 */
-void load_fix_matrix(id_t shader, float ratio);
-
-/*
-	Generate and load model matrix, it also sets the color
-	to draw.
-		i: From {0,1,2} select one of 3 ortogonal rotations,
-		   One for each axis.	
-		c: Color index of the pallete.
-*/
-void load_mdl_matrix(id_t shader, unsigned char i, unsigned char c);
+void fix_matrix_load(id_t shader, float ratio);

 /*
 	Generate and load rotation matrix.
 		q: quaterinon describing the rotation.
 */

-void load_rot_matrix(id_t shader, quat_t q);
+void rot_matrix_load(id_t shader, quat_t q);
+
+/*
+ */
+
+void color_load(id_t shader, float* color);

 id_t config_texture(unsigned short type);

@@ -142,6 +184,9 @@ void destroy_texture(id_t texture);
 		colors: array of color values (rgba in hex ).
 		n: number of color on colors.
 */
-id_t create_palette_texture(const unsigned char colors[][4], unsigned char n );
+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 );
--- a/src/matrix.c
+++ b/src/matrix.c
@@ -1,50 +0,0 @@
-#include "main.h"
-#include <cglm/cam.h>
-#include <cglm/mat4.h>
-#include <cglm/quat.h>
-
-mat4 ortho[] = {
-	{
-		{1, 0, 0, 0},
-		{0, 1, 0, 0},
-		{0, 0, 1, 0},
-		{0, 0, 0, 1},
-	},
-	{
-		{0, 1, 0, 0},
-		{-1, 0, 0, 0},
-		{0, 0, 1, 0},
-		{0, 0, 0, 1},
-	},
-	{
-		{0, 0, 1, 0},
-		{0, 1, 0, 0},
-		{-1, 0, 0, 0},
-		{0, 0, 0, 1},
-	},
-};
-
-void load_fix_matrix(id_t shader, float ratio)
-{
-	mat4 m, n;
-	const int d = 7;
-
-	glm_lookat((vec3){0, 0, -d}, (vec3){0, 0, 0}, (vec3){0, 1, 0}, m);
-	glm_perspective(CGLM_PI / 4, ratio, d - 3, d + 3, n);
-	glm_mat4_mul(n, m, m);
-
-	load_mat4_to_shader(shader, "fix", (mat4_t)m);
-}
-
-void load_mdl_matrix(id_t shader, unsigned char i, unsigned char c)
-{
-	load_float_to_shader(shader, "idx", c);
-	load_mat4_to_shader(shader, "mdl", (mat4_t)ortho[i]);
-}
-
-void load_rot_matrix(id_t shader, quat_t q)
-{
-	mat4 m;
-	glm_quat_mat4(q, m);
-	load_mat4_to_shader(shader, "rot", (mat4_t)m);
-}
--- a/src/mesh.c
+++ b/src/mesh.c
@@ -1,5 +1,11 @@
 #include "main.h"
-#include <GL/glew.h>
+
+#ifdef EMSCRIPTEN
+#include <GL/gl.h>
+#else
+#include <glad.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>

@@ -25,7 +31,7 @@ void set_projection_mesh(struct projection projection)
 	glVertexAttribPointer(3, 1, GL_FLOAT, 0, projection.m * sizeof(float),
 		(float *)(projection.w * sizeof(float)));

-	glBindBuffer(GL_UNIFORM_BUFFER, p->n_vbo);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, p->n_vbo);
 	glVertexAttribPointer(4, 1, GL_FLOAT, 0, projection.m * sizeof(float),
 		(float *)(projection.x * sizeof(float)));
 	glVertexAttribPointer(5, 1, GL_FLOAT, 0, projection.m * sizeof(float),
@@ -37,55 +43,40 @@ void set_projection_mesh(struct projection projection)
 }

 /*
-	In this function we load all the vertex and normal datas on two
+	In this function we load all the vertex and ELEMENT_ARRAY datas on two
 	diferents buffers, so we can access the coordanates that we want
 	to display using the layout location in GLSL.
 	This trick can be done with glVertexAttribPointer.
 */

-mesh_t create_mesh(float *d, float *n, unsigned char m)
+mesh_t create_mesh(struct surface surface)
 {
 	unsigned char i;
 	struct obj *p;

 	p = malloc(sizeof(struct obj));

-	p->vertex = (*d) / m;
+	p->vertex = surface.vertex;

 	glGenVertexArrays(1, &p->vao);
 	glBindVertexArray(p->vao);

 	glGenBuffers(1, &p->d_vbo);
 	glBindBuffer(GL_ARRAY_BUFFER, p->d_vbo);
-	glBufferData(
-		GL_ARRAY_BUFFER, p->vertex * m * sizeof(float), d + 1, GL_STATIC_DRAW);
+	glBufferData(GL_ARRAY_BUFFER, p->vertex * surface.dim * sizeof(float),
+		surface.data, GL_STATIC_DRAW);

-	if (n)
+	if (surface.norm)
 	{
 		glGenBuffers(1, &p->n_vbo);
-		glBindBuffer(GL_UNIFORM_BUFFER, p->n_vbo);
-		glBufferData(GL_UNIFORM_BUFFER, p->vertex * m * sizeof(float), n + 1,
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, p->n_vbo);
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+			p->vertex * surface.dim * sizeof(float), surface.norm,
 			GL_STATIC_DRAW);
 	}

-	for (i = 0; i < 4; ++i)
-	{
+	for (i = 0; i < 8; ++i)
 		glEnableVertexAttribArray(i);
-		glEnableVertexAttribArray(i + 4);
-	}
-
-	{
-		struct projection projection = {
-			.x = 0,
-			.y = 1,
-			.z = 2,
-			.w = 3,
-		};
-
-		projection.m = m;
-		projection.mesh = p;
-		set_projection_mesh(projection);
-	}

 	return p;
 }
@@ -100,18 +91,28 @@ void destroy_mesh(mesh_t p)
 	free(p);
 }

-void draw_mesh(mesh_t p)
+void draw_mesh(id_t shader, mesh_t p)
 {
 	struct obj *obj = p;

+	glUseProgram(shader);
 	glBindVertexArray(obj->vao);
-#ifdef DEBUG
-	{
-		int i;
-		for (i = 0; i < obj->vertex; i += 3)
-			glDrawArrays(GL_LINE_LOOP, i, 3);
-	}
-#else
+#ifndef EMSCRIPTEN
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
 	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
+}
+void draw_mesh_lines(id_t shader, mesh_t p)
+{
+	struct obj *obj = p;
+
+	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
 }
--- a/src/shader.c
+++ b/src/shader.c
@@ -1,15 +1,20 @@
 #include "main.h"
-#include <GL/glew.h>
+
+#ifndef EMSCRIPTEN
+#include <glad.h>
+#else
+#include <GL/gl.h>
+#endif

 #ifdef DEBUG
 #include <stdio.h>
 #endif

-void destroy_shader(unsigned int shader) { return glDeleteProgram(shader); }
+void destroy_shader(unsigned int shader) { glDeleteProgram(shader); }

 unsigned int create_shader(void) { return glCreateProgram(); }

-void use_shader(unsigned int program) { return glUseProgram(program); }
+void use_shader(unsigned int program) { glUseProgram(program); }

 unsigned char load_program_to_shader(
 	unsigned int program, const char *src, unsigned int i)
@@ -54,3 +59,10 @@ void load_mat4_to_shader(unsigned int program, char *var, float *mat)
 	glUseProgram(program);
 	glUniformMatrix4fv(glGetUniformLocation(program, var), 1, 0, mat);
 }
+
+void load_float4_to_shader(unsigned int program, char *var, float float4[4])
+{
+	glUseProgram(program);
+	glUniform4f(glGetUniformLocation(program, var), float4[0], float4[1],
+		float4[2], float4[3]);
+}
--- a/src/surface.c
+++ b/src/surface.c
@@ -1,166 +0,0 @@
-#include <math.h>
-#include <stdlib.h>
-
-#define CGLM_ALL_UNALIGNED
-#include <cglm/vec3.h>
-#include <cglm/vec4.h>
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-void mobius(float *d_surface, int i, int j, int grid_size)
-{
-	const float width = 0.5;
-	float u = (2 * M_PI) * ((float)i / grid_size);
-	float v = (2 * width) * ((float)j / grid_size) - width;
-
-	d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
-	d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
-	d_surface[2] = v * sin(u / 2);
-}
-
-void torus(float *d_surface, int i, int j, int grid_size)
-{
-	float u = (2 * M_PI) * ((float)i / grid_size);
-	float v = (2 * M_PI) * ((float)j / grid_size);
-
-	d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
-	d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
-	d_surface[2] = 0.5 * sin(v);
-}
-
-void klein(float *d_surface, int i, int j, int grid_size)
-{
-	float u = (2 * M_PI) * ((float)i / grid_size);
-	float v = (2 * M_PI) * ((float)j / grid_size);
-
-	d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
-	d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
-	d_surface[2] = sin(v) * cos(u / 2);
-	d_surface[3] = sin(v) * sin(u / 2);
-}
-
-typedef void (*function_t)(float *, int, int, int);
-
-float *generate_data_surface(int grid_size, unsigned char *m)
-{
-	unsigned int i, j, k = 0;
-	long size;
-	function_t f;
-	float *d_surface;
-
-	f = klein;
-	*m = 4;
-	size = grid_size * grid_size * 6 * (*m);
-	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++)
-		{
-			// triangle 1, Front
-			f(&d_surface[k + 1], i, j, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], i + 1, j, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
-			k += *m;
-
-			// triangle 2, Back
-			f(&d_surface[k + 1], i, j, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], i, j + 1, grid_size);
-			k += *m;
-			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
-			k += *m;
-		}
-	}
-
-	return d_surface;
-}
-
-static void __calculate_normal(
-	float *p1, float *p2, float *p3, float *normal, unsigned char n)
-{
-	float alpha;
-	vec4 v1, v2, v3;
-	vec4 u1, u2, u3;
-
-	switch (n)
-	{
-	case 3:
-
-		glm_vec3_sub(p2, p1, v1);
-		glm_vec3_sub(p3, p1, v2);
-
-		glm_vec3_cross(v1, v2, normal);
-		glm_vec3_normalize(normal);
-		return;
-
-	case 4:
-
-		/*
-			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.
-		*/
-		glm_vec4_sub(p2, p1, v1);
-		glm_vec4_sub(p3, p1, v2);
-		glm_vec4_copy(p1, v3);
-
-		/* Setup U1 */
-		{
-			glm_vec4_copy(v1, u1);
-		}
-
-		/* Setup U2 */
-		{
-			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);
-		}
-
-		/* Setup U3 */
-		{
-			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);
-		return;
-	}
-}
-
-float *generate_normals_surface(float *d, unsigned char m)
-{
-	float *n;
-	n = malloc((*d + 1) * sizeof(float));
-	*n = *d;
-	for (int i = 0; i < *d; i += 3 * m)
-	{
-
-		vec4 norm_vec;
-
-		__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);
-		glm_vec3_copy(norm_vec, (n + 1) + i + m);
-		glm_vec3_copy(norm_vec, (n + 1) + i + 2 * m);
-	}
-	return n;
-}
--- a/src/texture.c
+++ b/src/texture.c
@@ -1,34 +0,0 @@
-#include "main.h"
-#include <GL/glew.h>
-
-#define TYPE GL_TEXTURE_2D_ARRAY
-
-static id_t __config_texture(unsigned short type)
-{
-	id_t texture;
-
-	glGenTextures(1, &texture);
-	glBindTexture(TYPE, texture);
-
-	{
-		glTexParameteri(TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		glTexParameteri(TYPE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	}
-
-	return texture;
-}
-
-void use_texture(id_t texture) { return glBindTexture(TYPE, texture); }
-
-void destroy_texture(unsigned int texture)
-{
-	return glDeleteTextures(1, &texture);
-}
-
-id_t create_palette_texture(const unsigned char colors[][4], unsigned char n)
-{
-	id_t texture = __config_texture(TYPE);
-	glTexImage3D(
-		TYPE, 0, GL_RGBA, 1, 1, n, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors);
-	return texture;
-}
--- a/src/window.c
+++ b/src/window.c
@@ -7,6 +7,8 @@ void __window_callback_input(GLFWwindow *, int, int);
 void __mouse_callback_input(GLFWwindow *, int, int, int);
 void __scroll_callback_input(GLFWwindow *, double, double);
 void __key_callback_input(GLFWwindow *, int, int, int, int);
+void __drop_callback_input(GLFWwindow *, int, const char **);
+void __error_callback_input(int, const char *);

 window_t init_window(unsigned int w, unsigned int h, const char *name);

@@ -43,6 +45,7 @@ static void __limit_fps_window(int max_fps)
 window_t init_window(unsigned int width, unsigned int height, const char *title)
 {
 	window_t window;
+	glfwSetErrorCallback(__error_callback_input);

 	if (!glfwInit())
 		return NULL;
@@ -50,6 +53,7 @@ window_t init_window(unsigned int width, unsigned int height, const char *title)
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+	glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1); 

 	window = (window_t)glfwCreateWindow(width, height, title, NULL, NULL);
 	if (!(window))
@@ -64,8 +68,7 @@ window_t init_window(unsigned int width, unsigned int height, const char *title)
 	glfwSetMouseButtonCallback((GLFWwindow *)window, __mouse_callback_input);
 	glfwSetScrollCallback((GLFWwindow *)window, __scroll_callback_input);
 	glfwSetKeyCallback((GLFWwindow *)window, __key_callback_input);
-
-	__window_callback_input((GLFWwindow *)window, width, height);
+	glfwSetDropCallback((GLFWwindow *)window, __drop_callback_input);

 	return window;
 }