Merge branch 'main' into roberto

2024-11-20 11:14:59 -06:00
parent d967550dd8 61b014a803
commit 6c5e2a9a29
24 changed files with 5956 additions and 616 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -0,0 +1,19 @@
+---
+PointerAlignment: Right
+AllowShortBlocksOnASingleLine: Never
+
+UseTab: Always
+IndentWidth: 4
+TabWidth: 4
+ColumnLimit: 80
+
+AlignAfterOpenBracket: false
+AlignOperands: AlignAfterOperator
+AlwaysBreakBeforeMultilineStrings: true
+
+BreakBeforeBraces: Allman
+BreakStringLiterals: true
+IndentCaseLabels: false
+IndentGotoLabels: false
+InsertBraces: false
+...
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,5 @@
+manigraph
+**.o
+**.so
+**.exe
+**.dll
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "ext/glfw"]
 	path = ext/glfw
 	url = https://github.com/glfw/glfw
+[submodule "ext/nuklear"]
+	path = ext/nuklear
+	url = https://github.com/Immediate-Mode-UI/Nuklear
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,28 +0,0 @@
-{
-    "tasks": [
-        {
-            "type": "cppbuild",
-            "label": "C/C++: gcc build active file",
-            "command": "/usr/bin/gcc",
-            "args": [
-                "-fdiagnostics-color=always",
-                "-g",
-                "${file}",
-                "-o",
-                "${fileDirname}/${fileBasenameNoExtension}"
-            ],
-            "options": {
-                "cwd": "${fileDirname}"
-            },
-            "problemMatcher": [
-                "$gcc"
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "detail": "Task generated by Debugger."
-        }
-    ],
-    "version": "2.0.0"
-}
--- a/34
+++ b/34
@@ -14,7 +14,7 @@ OBJ = \
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
-	-Wall -Wno-unused-function -std=c99 \
+	-Wall -Wno-unused-function -std=c99 -D_GNU_SOURCE \

 WAYLAND-LIB = \
 	xdg-shell \
@@ -34,12 +34,13 @@ help:
 	@echo "	$(MAKE) linux-x11"
 	@echo "	$(MAKE) linux-wayland"
 	@echo "	$(MAKE) cocoa"
+	@echo "	$(MAKE) CC=emcc wasm"
 	@echo "Para limpiar los archivos compilados se puede usar"
 	@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/cube.h src/data/shaders.h
+src/main.o: src/data/axis.h src/data/shaders.h

 # WINDOWS
 windows: $(OBJ) glfw.dll
@@ -48,15 +49,20 @@ windows: $(OBJ) glfw.dll
 glfw.dll:
 	$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32 

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

 # LINUX
-linux-x11: $(OBJ)
-	$(MAKE) BKN=_GLFW_X11 libglfw.so
+linux-wayland: $(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" libglfw.so
 	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm

-linux-wayland: $(OBJ)
-	$(MAKE) BKN=_GLFW_WAYLAND libglfw.so
+linux-x11: $(OBJ)
+	$(MAKE) DFLAGS="-D_GLFW_X11" libglfw.so
 	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm

 run-linux:
@@ -64,21 +70,19 @@ run-linux:

 # COCOA
 cocoa: $(OBJ)
-	$(MAKE) BKN=_GLFW_COCOA libglfw.so
+	$(MAKE) DFLAGS="-D_GLFW_COCOA" libglfw.so
 	$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 

+wasm: $(OBJ)
+	$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o mani.html $(OBJ)
+
 libglfw.so: 
-	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
-	$(CC) -fPIC -shared -D$(BKN) -D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 
+	$(CC) -fPIC -shared $(DFLAGS) -D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 

 clean:
 	rm $(OBJ) $(BIN) ext/glfw/deps/wayland/*.h

 .SUFFIXES: .c .o 

-.c.o:
+.c.o: src/main.h
 	$(CC) $(CFLAGS) -c -o $@ $<
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ Para poder compilar el proyecto hace falta lo siguiente.
 - `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 según el caso. (no incluidas)
+Para compilar `glfw` en linux hacen falta las siguientes librerías. (no incluidas)
 - `x11`: libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel
 - `wayland`: libwayland-dev libxkbcommon-dev wayland-protocols

--- a/compile.bat
+++ b/compile.bat
@@ -0,0 +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/glfw/include src/*.c -o manigraph -L . -lglfw -lopengl32 -lglew32
--- 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/nuklear
+++ b/ext/nuklear
--- a/src/context.c
+++ b/src/context.c
@@ -1,14 +1,35 @@
 #include "main.h"
+
+#ifdef EMSCRIPTEN
 #include <GL/gl.h>
+#else
+#ifdef GLAD
+#include <GLFW/glfw3.h>
+#include <glad.h>
+#else
+#include <GL/glew.h>
+#endif
+#endif

-void set_clean_color_context( unsigned char r, unsigned char g, unsigned char b )
+void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b)
 {
-	glEnable( GL_DEPTH_TEST );
+	glEnable(GL_DEPTH_TEST);

-	glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
+	glClearColor((float)r / 0xff, (float)g / 0xff, (float)b / 0xff, 1.0);
 }

-void clean_context( void )
+int init_context(void)
 {
-	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+#ifdef EMSCRIPTEN
+	return 1;
+#else
+#ifdef GLAD
+
+	return gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
+#else
+	return glewInit();
+#endif
+#endif
 }
+
+void clean_context(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
--- a/src/data/cube.h
+++ b/src/data/cube.h
@@ -1,31 +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,
-
-float d_cube[] =
-{
-	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 =
+#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;"
@@ -32,8 +36,14 @@ const char * vs =

 	
 const char * fs_plain =
-	"#version 330 core\n"
+#ifdef EMSCRIPTEN
+	"#version 300 es\n"

+	"precision highp float;"
+	"precision highp sampler2DArray;"
+#else
+	"#version 330 core\n"
+#endif
 	"uniform sampler2DArray palette;"

 	"in float index;"
@@ -47,7 +57,13 @@ const char * fs_plain =
 	"}";

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

    "uniform sampler2DArray palette;"

@@ -67,19 +83,9 @@ const char * fs =
    "   vec3 lightPos = viewPos;\n"
    "   vec3 lightDir = normalize(lightPos - FragPos);\n"

-    "   float specular = 0.0;\n"
-
-    "   if (true)"
-    "   {"
    "   vec3 halfwayDir = normalize(lightDir + viewDir);\n"
-    "       specular = pow(max(dot(normalize(Normal), halfwayDir), 0.0), 16.0);\n"
-    "   }"
-    "   else"
-    "   {"
-    "       vec3 reflectDir = reflect(-lightDir, normalize(Normal));\n"
-    "       specular = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);\n"
-    "   }"

+    "   float specular = pow(max(dot(normalize(Normal), halfwayDir), 0.0), 16.0);\n"
    "   float diffuse = max(dot(normalize(Normal), lightDir), 0.0);\n"

    "   vec3 result = (0.5 + 0.5 * diffuse + specular) * color.rgb;\n"
--- a/src/input.c
+++ b/src/input.c
@@ -1,9 +1,9 @@
 #include "main.h"
-#include <cglm/quat.h>
 #include <GLFW/glfw3.h>
+#include <cglm/quat.h>
 #include <stdio.h>

-#define ANGLE ((float)0x01/0xff*2*GLM_PI)
+#define ANGLE ((float)0x01 / 0xff * 2 * GLM_PI)

 unsigned char selected_axis = 0;
 int window_width;
@@ -11,25 +11,67 @@ int window_height;

 versor q = GLM_QUAT_IDENTITY_INIT;

-vec3 axis[3] =
-{
+vec3 axis[3] = {
 	{1, 0, 0},
 	{0, 1, 0},
 	{0, 0, 1},
 };

-void __key_callback(GLFWwindow * window, int key, int scancode, int action, int mods )
+extern struct projection projection;
+
+void __key_callback_input(
+	GLFWwindow *window, int key, int scancode, int action, int mods)
 {
-	if( action != GLFW_PRESS)
+	if (action != GLFW_PRESS)
 		return;

-	if( GLFW_KEY_0 <= key && key <= GLFW_KEY_9 )
+	if (GLFW_KEY_0 < key && key <= GLFW_KEY_9)
 	{
-		printf("%d\n", key-GLFW_KEY_0 );
+		unsigned char selected_coord;
+
+		selected_coord = key - GLFW_KEY_0 - 1;
+
+		if (selected_coord >= projection.m)
+			return;
+		if (selected_coord == projection.x)
+			return;
+		if (selected_coord == projection.y)
+			return;
+		if (selected_coord == projection.z)
+			return;
+
+		selected_coord = projection.w;
 	}
+
+	if (projection.w >= projection.m)
+		return;
+
+	switch (key)
+	{
+		unsigned char tmp;
+
+	case GLFW_KEY_P:
+		tmp = projection.w;
+		projection.w = projection.x;
+		projection.x = tmp;
+		break;
+	case GLFW_KEY_O:
+		tmp = projection.w;
+		projection.w = projection.y;
+		projection.y = tmp;
+		break;
+	case GLFW_KEY_I:
+		tmp = projection.w;
+		projection.w = projection.z;
+		projection.z = tmp;
+		break;
+	}
+
+	set_projection_mesh(projection);
+	return;
 }

-void __window_callback(GLFWwindow * window, int w, int h)
+void __window_callback_input(GLFWwindow *window, int w, int h)
 {
 	int m;

@@ -40,32 +82,33 @@ void __window_callback(GLFWwindow * window, int w, int h)
 	glViewport((w - m) / 2, (h - m) / 2, m, m);
 }

-void __mouse_callback(GLFWwindow* window, int button, int action, int mods)
+void __mouse_callback_input(
+	GLFWwindow *window, int button, int action, int mods)
 {
 	unsigned char green_value;
 	double xpos, ypos;

-	if( button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS )
+	if (button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS)
 		return;

 	glfwGetCursorPos(window, &xpos, &ypos);
 	glReadPixels((int)xpos, (int)(window_height - ypos), 1, 1, GL_GREEN,
 		GL_UNSIGNED_BYTE, &green_value);

-	switch(green_value)
+	switch (green_value)
 	{
 	case 0xD3:
 	case 0xD4:
 	case 0xD5:
-		selected_axis = green_value-0xD3;
+		selected_axis = green_value - 0xD3;
 	}
 }

-void __scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
+void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
 {
 	versor p = GLM_QUAT_IDENTITY_INIT;

-	glm_quatv(p, yoffset*ANGLE, axis[selected_axis]);
+	glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);

 	glm_quat_mul(p, q, q);
 	glm_quat_rotatev(p, axis[0], axis[0]);
@@ -77,43 +120,42 @@ quat_t poll_input(window_t window)
 {
 	versor p = GLM_QUAT_IDENTITY_INIT;

-	if( glfwGetKey((GLFWwindow*)window, 'Q') == GLFW_PRESS )
+	if (glfwGetKey((GLFWwindow *)window, 'Q') == GLFW_PRESS)
 	{
 		glm_quatv(p, ANGLE, axis[0]);
 		goto end;
 	}
-	if( glfwGetKey((GLFWwindow*)window, 'W') == GLFW_PRESS )
+	if (glfwGetKey((GLFWwindow *)window, 'W') == GLFW_PRESS)
 	{
 		glm_quatv(p, -ANGLE, axis[0]);
 		goto end;
 	}
-	if( glfwGetKey((GLFWwindow*)window, 'A') == GLFW_PRESS )
+	if (glfwGetKey((GLFWwindow *)window, 'A') == GLFW_PRESS)
 	{
 		glm_quatv(p, ANGLE, axis[1]);
 		goto end;
 	}
-	if( glfwGetKey((GLFWwindow*)window, 'S') == GLFW_PRESS )
+	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, 'Z') == GLFW_PRESS)
 	{
 		glm_quatv(p, ANGLE, axis[2]);
 		goto end;
 	}
-	if( glfwGetKey((GLFWwindow*)window, 'X') == GLFW_PRESS )
+	if (glfwGetKey((GLFWwindow *)window, 'X') == GLFW_PRESS)
 	{
 		glm_quatv(p, -ANGLE, axis[2]);
 		goto end;
 	}

 end:
-	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 );
+	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);
 	return q;
 }
-
--- a/src/main.c
+++ b/src/main.c
@@ -2,231 +2,194 @@
 #include "data/axis.h"
 #include "data/shaders.h"

+#include <stdio.h>
 #include <stdlib.h>
-#include <GL/glew.h>
-
-#define CGLM_ALL_UNALIGNED
-#include <cglm/vec3.h>
-#include <cglm/vec4.h>
-#include <string.h>

 #define WIDTH 512
 #define HEIGHT 512

-unsigned char coordanate[4] = {0,1,2,3};
+#ifdef EMSCRIPTEN
+#include <emscripten.h>
+#endif

-unsigned char palette[] =
-{
-	16,
-	0xEB,0xD3,0xF8,0xff,
-	0xEB,0xD4,0xF8,0xff,
-	0xEB,0xD5,0xF8,0xff,
-	0x7A,0x1C,0xAC,0xff,
+float *generate_data_surface(unsigned int, unsigned char *);
+float *generate_normals_surface(float *, unsigned char);
+
+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},
 };

-void calc_normal(float* p1, float* p2, float* p3, float* normal, unsigned char n) {
-    float **u;
-    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;
-#if 0
-    case 4:
-        glm_vec4_sub(p2, p1, v1);
-        glm_vec4_sub(p3, p1, v2);
-        glm_vec4_copy(p1, v3);
-        glm_vec4_copy(v1, u1);
-        {
-            vec4 proj;
-            alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj);
-            glm_vec4_sub(v2, proj, u2);
-        }
-		
-        {
-            vec4 proj1, proj2;
-            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
-            glm_vec4_scale(u1, alpha, proj1);
-
-            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
-            glm_vec4_scale(u2, alpha, proj2);
-
-            glm_vec4_sub(v3, proj1, u3);
-            glm_vec4_sub(u3, proj2, u3);
-        }
-
-        glm_vec4_copy(u3, normal);
-        glm_vec4_normalize(normal);
-        return;
+void mlog(char *msg)
+{
+#ifdef DEBUG
+	printf(msg);
 #endif
-    default:
-        u = malloc((n - 1) * sizeof(float*));
-        for (unsigned char i = 0; i < n - 1; i++) {
-            u[i] = malloc(n * sizeof(float));
-        }
-
-        for (unsigned char i = 0; i < n - 1; i++) {
-            float* vi = malloc(n * sizeof(float));
-            for (unsigned char j = 0; j < n; j++) {
-                vi[j] = p2[j] - p1[j]; 
-            }
-
-            for (unsigned char j = 0; j < i; j++) {
-                float dot_vu = 0.0f, dot_uu = 0.0f;
-
-                for (unsigned char k = 0; k < n; k++) {
-                    dot_vu += vi[k] * u[j][k];
-                    dot_uu += u[j][k] * u[j][k];
-                }
-
-                for (unsigned char k = 0; k < n; k++) {
-                    vi[k] -= (dot_vu / dot_uu) * u[j][k];
-                }
-            }
-
-            memcpy(u[i], vi, n * sizeof(float));
-            free(vi);
-        }
-
-        memcpy(normal, u[n - 2], n * sizeof(float));
-
-        float norm = 0.0f;
-        for (unsigned char i = 0; i < n; i++) {
-            norm += normal[i] * normal[i];
-        }
-        norm = sqrtf(norm);
-        for (unsigned char i = 0; i < n; i++) {
-            normal[i] /= norm;
-        }
-
-        for (unsigned char i = 0; i < n - 1; i++) {
-            free(u[i]);
-        }
-        free(u);
-        return;
-    }
 }

-float * fill_normal( float * d, unsigned char m )
+window_t window;
+mesh_t m_surface, m_axis;
+id_t shader, shader_plain;
+
+#ifndef EMSCRIPTEN
+static inline
+#endif
+	void
+	main_loop(void)
 {
-	float * n;
-	n = malloc( (*d+1)*sizeof(float));
-	*n = *d;
-	for (int i = 0; i < *d; i += 3*m)
-	{
-
-		vec4 norm_vec;
-
-		calc_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;
-}
-
-const char * wname = "manigraph: manifold grapher";
-float * generate_surface();
-
-int main( void )
-{
-	id_t shader, texture, shader_plain;
-	mesh_t m_cube, m_axis;
-	window_t window;
-
-	if( !( window = init_window( WIDTH, HEIGHT, wname ) ) )
-		goto error_window;
-
-	use_window( window );
-	set_clean_color_context( 0x2E, 0x07, 0x3F );
-
-	glewInit(); 
-
-	texture=create_palette_texture( palette );
-	use_texture( texture );
-
-	if( !( shader = create_shader() ) )
-		goto error_shader;
-	gload_program( shader, vs, VERTEX );
-	gload_program( shader, fs, FRAGMENT );
-
-	if( !( shader_plain = create_shader() ) )
-		goto error_shader_plain;
-	gload_program( shader_plain, vs, VERTEX );
-	gload_program( shader_plain, fs_plain, FRAGMENT );
-
-	load_fix_matrix( shader, (float)WIDTH/HEIGHT );
-	load_fix_matrix( shader_plain, (float)WIDTH/HEIGHT );
-
-	/* Fill m_cube */
-	{
-		float * n_cube, *d_cube;
-		d_cube = generate_surface(16);
-		n_cube = fill_normal( d_cube, 4 );
-		if( !( m_cube = create_mesh( d_cube, n_cube, coordanate, 4 ) ) )
-			goto error_mesh_cube; 
-		free( n_cube );
-		free( d_cube);
-	}
-
-	/* Fill m_axis */
-	{
-		float * n_axis;
-		n_axis = fill_normal( d_axis, 3 );
-		if( !( m_axis = create_mesh( d_axis, n_axis, coordanate, 3 ) ) )
-			goto error_mesh_axis; 
-		free( n_axis );
-	}
-
-	while( is_open_window( window ) )
-	{
 	quat_t q;

-		q=poll_input( window );
-		load_rot_matrix( shader, q );
-		load_rot_matrix( shader_plain, 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_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);
+#else
+	load_mdl_matrix(shader_plain, 0, 3);
 #endif
+	draw_mesh(m_surface);
+}

-		load_mdl_matrix( shader, 0, 3 );
-		draw_mesh( m_cube );
+int main(void)
+{
+	id_t texture;

+	mlog("[VENTANA] Inicializando...\n");
+	{
+		if (!(window = init_window(WIDTH, HEIGHT, wname)))
+		{
+			mlog("[VENTANA] Error al inicializar...\n");
+			goto error_window;
 		}

-	destroy_mesh( m_axis );
-	destroy_mesh( m_cube );
-	destroy_shader( shader_plain );
-	destroy_shader( shader );
-	destroy_texture( texture );
-	close_window( window );
+		use_window(window);
+	}
+
+	mlog("[CONTEXT] Inicializando...\n");
+	{
+		if (!(init_context()))
+		{
+			mlog("[CONTEXT] Error al inicializar...\n");
+			goto error_context;
+		}
+		set_clean_color_context(0x2E, 0x07, 0x3F);
+	}
+
+	mlog("[TEXTURE] Inicializando...\n");
+	{
+		texture = create_palette_texture(palette, 4);
+		use_texture(texture);
+	}
+
+	mlog("[SHADER] Inicializando...\n");
+	{
+		if (!(shader = create_shader()))
+		{
+			mlog("[SHADER] Error al inicializar...\n");
+			goto error_shader;
+		}
+		load_program_to_shader(shader, vs, VERTEX);
+		load_program_to_shader(shader, fs, FRAGMENT);
+		load_fix_matrix(shader, (float)WIDTH / HEIGHT);
+	}
+
+	mlog("[SHADER] Inicializando...\n");
+	{
+		if (!(shader_plain = create_shader()))
+		{
+			mlog("[SHADER] Error al inicializar...\n");
+			goto error_shader_plain;
+		}
+		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;
+		}
+	}
+
+	mlog("[MAIN LOOP] Inicializando...\n");
+#ifdef EMSCRIPTEN
+	emscripten_set_main_loop(&main_loop, 0, 1);
+#else
+	while (is_open_window(window))
+		main_loop();
+#endif
+	mlog("[MAIN LOOP] Terminando...\n");
+
+	mlog("[MESH] Destruyendo...\n");
+	destroy_mesh(m_axis);
+	mlog("[MESH] Destruyendo...\n");
+	destroy_mesh(m_surface);
+	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;

+	mlog("[MESH] Destruyendo...\n");
+	destroy_mesh(m_axis);
 error_mesh_axis:
-	destroy_mesh( m_cube );
-error_mesh_cube:
-	destroy_shader( shader_plain );
+	mlog("[MESH] Destruyendo...\n");
+	destroy_mesh(m_surface);
+error_mesh_surface:
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader_plain);
 error_shader_plain:
-	destroy_shader( shader );
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader);
 error_shader:
-	close_window( window );
-	destroy_texture( texture );
+	mlog("[TEXTURE] Destruyendo...\n");
+	destroy_texture(texture);
+error_context:
+	mlog("[WINDOW] Destruyendo...\n");
+	close_window(window);
 error_window:
 	return 1;
 }
--- a/src/main.h
+++ b/src/main.h
@@ -1,5 +1,11 @@
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
+/*
+	If DEBUG is set, we show the triangles of the mesh,
+	without illumination, and we write the compilation
+	error of the shaders.
+*/
+
+/* #define DEBUG */
+/* #define GLAD  */

 typedef const void * window_t;
 typedef unsigned int id_t;
@@ -7,13 +13,29 @@ typedef void * mesh_t;
 typedef float * quat_t;
 typedef float * mat4_t;

-typedef unsigned char narray_u8_t[];
+/* 
+	This struct represent the proyection, where:
+		mesh: data of surface.
+		m: the dimention of the surface.
+		x: the coordanate of the x axis.
+		y: the coordanate of the y axis.
+		z: the coordanate of the z axis.
+		w: the coordanate of the w axis.
+*/

-enum
+struct projection
 {
-	VERTEX, FRAGMENT
+	mesh_t mesh;
+	unsigned char m, x, y, z, w;
 };

+/* 
+	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);

 void use_window(window_t window);
@@ -22,32 +44,92 @@ int is_open_window(window_t window);

 void close_window(window_t window);

-mesh_t create_mesh( float * d, float * n, unsigned char * coordanate, unsigned char m );
+/* 
+	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 );
+
+void set_projection_mesh( struct projection );

 void destroy_mesh(mesh_t p);

 void draw_mesh(mesh_t p);

-void set_clean_color_context(unsigned char, unsigned char, unsigned char);
+/*
+	Set background color:
+		r: red value in hex.
+		g: green value in hex.
+		b: blue value in hex.
+*/
+
+void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b);

 void clean_context(void);

+int init_context( void );
+
 void destroy_shader(id_t shader);

 id_t create_shader(void);

-void use_shader(id_t program);
+void use_shader(id_t shader);

-unsigned char gload_program(id_t program, const char * src, unsigned int type);
+enum
+{
+	VERTEX, FRAGMENT
+};

-void gload_float(id_t program, char * var, float f);
+/*
+	Load program to shader:
+		src: GLSL source code as string.
+		type: VERTEX or FRAGMENT
+*/

-void gload_mat4(id_t program, char * var, mat4_t m);
+unsigned char load_program_to_shader(id_t shader, const char * src, unsigned int type);

+/*
+	load float to shader:
+		var: name of glsl variable.
+		f: float to load
+*/
+
+void load_float_to_shader(id_t shader, char * var, float f);
+
+/*
+	load matrix 4 to shader:
+		var: name of glsl variable.
+		m: Matrix to load
+*/
+
+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);

+/*
+	Generate and load rotation matrix.
+		q: quaterinon describing the rotation.
+*/
+
 void load_rot_matrix(id_t shader, quat_t q);

 id_t config_texture(unsigned short type);
@@ -56,6 +138,11 @@ void use_texture(id_t texture);

 void destroy_texture(id_t texture);

-id_t create_palette_texture(const narray_u8_t colors);
+/*
+	Set color palette as 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 );

 quat_t poll_input(window_t window);
--- a/src/matrix.c
+++ b/src/matrix.c
@@ -1,51 +1,50 @@
 #include "main.h"
-#include <cglm/mat4.h>
 #include <cglm/cam.h>
+#include <cglm/mat4.h>
 #include <cglm/quat.h>

-mat4 ortho[] =
-{
+mat4 ortho[] = {
 	{
-		{ 1, 0, 0, 0 },
-		{ 0, 1, 0, 0 },
-		{ 0, 0, 1, 0 },
-		{ 0, 0, 0, 1 },
+		{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, 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 },
+		{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 )
+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 );
+	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);

-	gload_mat4( shader, "fix", (mat4_t) m );
+	load_mat4_to_shader(shader, "fix", (mat4_t)m);
 }

-void load_mdl_matrix( id_t shader, unsigned char i, unsigned char c )
+void load_mdl_matrix(id_t shader, unsigned char i, unsigned char c)
 {
-	gload_float( shader, "idx", c );
-	gload_mat4( shader, "mdl", (mat4_t)ortho[i] );
+	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 )
+void load_rot_matrix(id_t shader, quat_t q)
 {
 	mat4 m;
-	glm_quat_mat4( q, m );
-	gload_mat4( shader, "rot", (mat4_t)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,10 @@
 #include "main.h"
+#ifdef GLAD
+#include <glad.h>
+#else
 #include <GL/glew.h>
+#endif
+#include <stdio.h>
 #include <stdlib.h>

 struct obj
@@ -7,69 +12,110 @@ struct obj
 	unsigned int vertex, vao, n_vbo, d_vbo;
 };

-mesh_t create_mesh( float * d, float * n, unsigned char * coordanate, unsigned char m )
+void set_projection_mesh(struct projection projection)
 {
-	struct obj * p;
+	struct obj *p;
+	p = projection.mesh;

-	p=malloc(sizeof(struct obj));
+	glBindVertexArray(p->vao);

-	p->vertex=(*d)/m;
+	glBindBuffer(GL_ARRAY_BUFFER, p->d_vbo);
+	glVertexAttribPointer(0, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.x * sizeof(float)));
+	glVertexAttribPointer(1, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.y * sizeof(float)));
+	glVertexAttribPointer(2, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.z * sizeof(float)));
+	glVertexAttribPointer(3, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.w * sizeof(float)));

-	glGenVertexArrays( 1, &p->vao );
+	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),
+		(float *)(projection.y * sizeof(float)));
+	glVertexAttribPointer(6, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.z * sizeof(float)));
+	glVertexAttribPointer(7, 1, GL_FLOAT, 0, projection.m * sizeof(float),
+		(float *)(projection.w * sizeof(float)));
+}

-	glGenBuffers( 1, &p->d_vbo );
-	glBindVertexArray( p->vao );
-	glBindBuffer( GL_ARRAY_BUFFER, p->d_vbo );
-	glBufferData( GL_ARRAY_BUFFER, p->vertex*m*sizeof(float), d+1, 
-		GL_STATIC_DRAW );
-	glVertexAttribPointer( 0,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[0]*sizeof(float)) );
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer( 1,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[1]*sizeof(float)) );
-	glEnableVertexAttribArray(1);
-	glVertexAttribPointer( 2,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[2]*sizeof(float)) );
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer( 3,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[3]*sizeof(float)) );
-	glEnableVertexAttribArray(3);
+/*
+	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.
+*/

-	glGenBuffers( 1, &p->n_vbo );
-	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, p->n_vbo );
-	glBufferData( GL_ELEMENT_ARRAY_BUFFER, p->vertex*m*sizeof(float), n+1, 
-		GL_STATIC_DRAW );
-	glVertexAttribPointer( 4,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[0]*sizeof(float)) );
-	glEnableVertexAttribArray(4);
-	glVertexAttribPointer( 5,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[1]*sizeof(float)) );
-	glEnableVertexAttribArray(5);
-	glVertexAttribPointer( 6,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[2]*sizeof(float)) );
-	glEnableVertexAttribArray(6);
-	glVertexAttribPointer( 7,1,GL_FLOAT, 0, m*sizeof(float), (float*)(coordanate[3]*sizeof(float)) );
-	glEnableVertexAttribArray(7);
+mesh_t create_mesh(float *d, float *n, unsigned char m)
+{
+	unsigned char i;
+	struct obj *p;

+	p = malloc(sizeof(struct obj));
+
+	p->vertex = (*d) / m;
+
+	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);
+
+	if (n)
+	{
+		glGenBuffers(1, &p->n_vbo);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, p->n_vbo);
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER, p->vertex * m * sizeof(float),
+			n + 1, GL_STATIC_DRAW);
+	}
+
+	for (i = 0; i < 4; ++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;
 }

-void destroy_mesh( mesh_t p )
+void destroy_mesh(mesh_t p)
 {
-	struct obj * obj ;
+	struct obj *obj;
 	obj = p;
-	glDeleteVertexArrays( 1, &obj->vao );
-	glDeleteBuffers( 1, &obj->d_vbo );
-	glDeleteBuffers( 1, &obj->n_vbo );
-	free( p );
+	glDeleteVertexArrays(1, &obj->vao);
+	glDeleteBuffers(1, &obj->d_vbo);
+	glDeleteBuffers(1, &obj->n_vbo);
+	free(p);
 }

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

-	glBindVertexArray( obj->vao );
+	glBindVertexArray(obj->vao);
 #ifdef DEBUG
 	{
 		int i;
-		for( i=0; i<obj->vertex;i+=3 )
-			glDrawArrays(GL_LINE_LOOP, i, 3 );
+		for (i = 0; i < obj->vertex; i += 3)
+			glDrawArrays(GL_LINE_LOOP, i, 3);
 	}
 #else
-	glDrawArrays(GL_TRIANGLES, 0, obj->vertex );
+	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
 #endif
 }
--- a/src/shader.c
+++ b/src/shader.c
@@ -1,51 +1,43 @@
 #include "main.h"
+
+#ifdef GLAD
+#include <glad.h>
+#else
 #include <GL/glew.h>
+#endif

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

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

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

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

-unsigned char gload_program( unsigned int program, const char * src, 
-	unsigned int i )
+unsigned char load_program_to_shader(
+	unsigned int program, const char *src, unsigned int i)
 {
 	int shader, status;
-	unsigned int type[] = 
-	{
-		[VERTEX]=GL_VERTEX_SHADER,
-		[FRAGMENT]=GL_FRAGMENT_SHADER 
-	};
+	unsigned int type[] = {
+		[VERTEX] = GL_VERTEX_SHADER, [FRAGMENT] = GL_FRAGMENT_SHADER};

-
-	if( !src )
+	if (!src)
 		return 0;

 	shader = glCreateShader(type[i]);
-	glShaderSource( shader, 1, (const GLchar **)&src, ((void*)0 ));
+	glShaderSource(shader, 1, (const GLchar **)&src, ((void *)0));
 	glCompileShader(shader);

-	glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

-	if( !status )
+	if (!status)
 	{
 #ifdef DEBUG
 		char log[256];
-		glGetShaderInfoLog( shader, 256, NULL, log );
-		printf( "%s", log );
+		glGetShaderInfoLog(shader, 256, NULL, log);
+		printf("%s", log);
 #endif
 		return 0;
 	}
@@ -56,14 +48,14 @@ unsigned char gload_program( unsigned int program, const char * src,
 	return 1;
 }

-void gload_float( unsigned int program, char * var, float f )
+void load_float_to_shader(unsigned int program, char *var, float f)
 {
-	glUseProgram( program );
-	glUniform1f( glGetUniformLocation( program, var ), f ); 
+	glUseProgram(program);
+	glUniform1f(glGetUniformLocation(program, var), f);
 }

-void gload_mat4( unsigned int program, char * var, float * mat )
+void load_mat4_to_shader(unsigned int program, char *var, float *mat)
 {
-	glUseProgram( program );
-	glUniformMatrix4fv( glGetUniformLocation( program, var ), 1, 0, mat ); 
+	glUseProgram(program);
+	glUniformMatrix4fv(glGetUniformLocation(program, var), 1, 0, mat);
 }
--- a/src/surface.c
+++ b/src/surface.c
@@ -1,78 +1,211 @@
-#include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
+#include <string.h>
+
+#define CGLM_ALL_UNALIGNED
+#include <cglm/vec3.h>
+#include <cglm/vec4.h>

 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif

-typedef void(*function_t)(float*,int, int, int);
-
 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;
+	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 toro(float *d_surface, int i, int j, int grid_size)
+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 );
+	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);
+	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 );
+	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);
+	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);
 }

-float * generate_surface(int grid_size)
+typedef void (*function_t)(float *, int, int, int);
+
+float *generate_data_surface(int grid_size, unsigned char *m)
 {
-	unsigned char m = 4;
-	function_t f = klein;
+	unsigned int i, j, k = 0;
+	long size;
+	function_t f;
+	float *d_surface;

-	long size = grid_size*grid_size*6*m;
-	float * d_surface;
-	int k=0;
-
-	d_surface = malloc((size+1)*sizeof(float));
+	f = klein;
+	*m = 4;
+	size = grid_size * grid_size * 6 * (*m);
+	d_surface = malloc((size + 1) * sizeof(float));
 	d_surface[0] = size;

-	for (int i = 0; i < grid_size; i++)
+	for (i = 0; i < grid_size; i++)
 	{
-		for (int j = 0; j < grid_size; j++)
+		for (j = 0; j < grid_size; j++)
 		{
-			// triangle 1, back
-			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
-			k+=m;
+			// 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, j, grid_size);
-			k+=m;
-
-			// triangle 2, font
-			f(&d_surface[k + 1], i, j, grid_size);
-			k+=m;
-			f(&d_surface[k + 1], i, j + 1, grid_size);
-			k+=m;
+			k += *m;
 			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
-			k+=m;
+			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 **u;
+	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;
+#if 0
+		/*
+			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.
+		*/
+    case 4:
+        glm_vec4_sub(p2, p1, v1);
+        glm_vec4_sub(p3, p1, v2);
+        glm_vec4_copy(p1, v3);
+        glm_vec4_copy(v1, u1);
+        {
+            vec4 proj;
+            alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
+            glm_vec4_scale(u1, alpha, proj);
+            glm_vec4_sub(v2, proj, u2);
+        }
+		
+        {
+            vec4 proj1, proj2;
+            alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
+            glm_vec4_scale(u1, alpha, proj1);
+
+            alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
+            glm_vec4_scale(u2, alpha, proj2);
+
+            glm_vec4_sub(v3, proj1, u3);
+            glm_vec4_sub(u3, proj2, u3);
+        }
+
+        glm_vec4_copy(u3, normal);
+        glm_vec4_normalize(normal);
+        return;
+#endif
+	default:
+		u = malloc((n - 1) * sizeof(float *));
+		for (unsigned char i = 0; i < n - 1; i++)
+		{
+			u[i] = malloc(n * sizeof(float));
+		}
+
+		for (unsigned char i = 0; i < n - 1; i++)
+		{
+			float *vi = malloc(n * sizeof(float));
+			for (unsigned char j = 0; j < n; j++)
+			{
+				vi[j] = p2[j] - p1[j];
+			}
+
+			for (unsigned char j = 0; j < i; j++)
+			{
+				float dot_vu = 0.0f, dot_uu = 0.0f;
+
+				for (unsigned char k = 0; k < n; k++)
+				{
+					dot_vu += vi[k] * u[j][k];
+					dot_uu += u[j][k] * u[j][k];
+				}
+
+				for (unsigned char k = 0; k < n; k++)
+				{
+					vi[k] -= (dot_vu / dot_uu) * u[j][k];
+				}
+			}
+
+			memcpy(u[i], vi, n * sizeof(float));
+			free(vi);
+		}
+
+		memcpy(normal, u[n - 2], n * sizeof(float));
+
+		float norm = 0.0f;
+		for (unsigned char i = 0; i < n; i++)
+		{
+			norm += normal[i] * normal[i];
+		}
+		norm = sqrtf(norm);
+		for (unsigned char i = 0; i < n; i++)
+		{
+			normal[i] /= norm;
+		}
+
+		for (unsigned char i = 0; i < n - 1; i++)
+		{
+			free(u[i]);
+		}
+		free(u);
+		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,37 +1,38 @@
 #include "main.h"
+#ifdef GLAD
+#include <glad.h>
+#else
 #include <GL/glew.h>
+#endif

 #define TYPE GL_TEXTURE_2D_ARRAY

-id_t config_texture( unsigned short type )
+static id_t __config_texture(unsigned short type)
 {
 	id_t texture;

-	glGenTextures( 1, &texture );
-	glBindTexture( TYPE, texture );
+	glGenTextures(1, &texture);
+	glBindTexture(TYPE, texture);

 	{
-		glTexParameteri( TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-		glTexParameteri( TYPE, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+		glTexParameteri(TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(TYPE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	}

 	return texture;
 }

-void use_texture( id_t texture )
+void use_texture(id_t texture) { return glBindTexture(TYPE, texture); }
+
+void destroy_texture(unsigned int texture)
 {
-	return glBindTexture( TYPE, texture );
+	return glDeleteTextures(1, &texture);
 }

-void destroy_texture( unsigned int texture )
+id_t create_palette_texture(const unsigned char colors[][4], unsigned char n)
 {
-	return glDeleteTextures( 1, &texture );
-}
-
-id_t create_palette_texture( const unsigned char * colors )
-{
-	id_t texture = config_texture( TYPE );
-	glTexImage3D( TYPE, 0, GL_RGBA,
-		1, 1, (*colors)/4, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors+1);
+	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
@@ -1,55 +1,88 @@
 #include "main.h"
 #include <GLFW/glfw3.h>
+#include <stdio.h>
+#include <time.h>

-void __window_callback(GLFWwindow *, int, int);
-void __mouse_callback(GLFWwindow *, int, int, int);
-void __scroll_callback(GLFWwindow *, double, double);
-void __key_callback(GLFWwindow *, int, int, int, int);
+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);

-window_t init_window(unsigned int w, unsigned int h, const char * name)
+window_t init_window(unsigned int w, unsigned int h, const char *name);
+
+/*
+	Limitamos los FPS, contando el tiempo en el que
+	se ejecuta el main loop, y esperando el tiempo restante
+	para lograr los fps deseados.
+*/
+
+static void __limit_fps_window(int max_fps)
 {
-	void * window;
+	static double previous_time = 0.0;
+	double current_time;
+	double frame_time;
+	double elapsed_time;

-	if( !glfwInit() )
+	current_time = glfwGetTime();
+	frame_time = 1.0 / max_fps;
+	elapsed_time = current_time - previous_time;
+
+	if (elapsed_time < frame_time)
+	{
+		struct timespec sleep_time;
+		sleep_time.tv_sec = 0;
+		sleep_time.tv_nsec = (long)((frame_time - elapsed_time) * 1e9);
+		nanosleep(&sleep_time, NULL);
+
+		current_time = glfwGetTime();
+	}
+
+	previous_time = current_time;
+}
+
+window_t init_window(unsigned int width, unsigned int height, const char *title)
+{
+	window_t window;
+
+	if (!glfwInit())
 		return NULL;

 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

-	window = glfwCreateWindow(w, h, name, NULL, NULL);
-
-	if( !window )
+	window = (window_t)glfwCreateWindow(width, height, title, NULL, NULL);
+	if (!(window))
 	{
 		glfwTerminate();
 		return NULL;
 	}

-	glfwSetWindowSizeCallback(window, __window_callback);
-	glfwSetMouseButtonCallback((GLFWwindow*)window, __mouse_callback);
-	glfwSetScrollCallback((GLFWwindow*)window, __scroll_callback);
-	glfwSetKeyCallback((GLFWwindow*)window, __key_callback);
+	glfwMakeContextCurrent((GLFWwindow *)(window));

-	__window_callback( window, w, h );
+	glfwSetWindowSizeCallback((GLFWwindow *)window, __window_callback_input);
+	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);

 	return window;
 }

-void use_window(window_t window)
-{
-	glfwMakeContextCurrent((void*)window);
-}
+void use_window(window_t window) { glfwMakeContextCurrent((void *)window); }

 int is_open_window(window_t window)
 {
-	glfwSwapBuffers((void*)window);
+	glfwSwapBuffers((void *)window);
 	glfwPollEvents();

-	return !glfwWindowShouldClose((void*)window);
+	__limit_fps_window(60);
+	return !glfwWindowShouldClose((void *)window);
 }

 void close_window(window_t window)
 {
-	glfwDestroyWindow((void*)window);
+	glfwDestroyWindow((GLFWwindow *)window);
 	glfwTerminate();
 }
--- a/102
+++ b/102
@@ -1,102 +0,0 @@
-[33mcommit 252aab3dd289cdd7cc5f4fe0edb31654e687ec22[m[33m ([m[1;36mHEAD[m[33m -> [m[1;32mroberto[m[33m, [m[1;31morigin/roberto[m[33m, [m[1;31morigin/main[m[33m, [m[1;31morigin/HEAD[m[33m, [m[1;32mmain[m[33m)[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Wed Oct 9 20:45:05 2024 -0600
-
-    Merge: crisel -> main
-
-[33mcommit e25f509ce112050b265f8740998ce30f5e702dba[m
-Merge: 1997801 a650807
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Wed Oct 9 20:41:43 2024 -0600
-
-    Merge: issue-01 -> main
-
-[33mcommit 1997801f88c7581849cc52f2b71b3257165fd95b[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Fri Oct 4 00:37:52 2024 -0600
-
-    Merge: doc -> main
-
-[33mcommit d22daff16d9bd7d85cfaeca14f2500bd8686d44c[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Wed Oct 2 13:10:08 2024 -0600
-
-    Merge: doc -> main
-
-[33mcommit a650807b94b69ce45666ed19d57fcbf806ad7d46[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Sun Sep 29 16:08:18 2024 -0600
-
-    ISSUE #1: Normalize quaternion to avoid deformation
-
-[33mcommit 6c3b268a6598aab4e69201073206b37cd0b823ed[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 19 10:37:00 2024 +0600
-
-    First doc update
-
-[33mcommit 3c9690a2a7db196b851ff64edbe414f18a94d9da[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 19 10:15:25 2024 +0600
-
-    doc/: definir como funcionan los archivos
-
-[33mcommit 86ad43c2dc507b5257685c847683a23420eaf752[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 19 08:58:36 2024 +0600
-
-    nlroff -> markdown
-
-[33mcommit cb525a1f2033e512aa55af3cd5036b5ee18bc976[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Tue Sep 17 22:05:34 2024 +0000
-
-    nulldoc -> nlroff
-
-[33mcommit 98b0d7888072bb9beafb4910ec00b86fde18ad87[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Tue Sep 17 22:04:25 2024 +0000
-
-    Make doc directory
-
-[33mcommit 25e08fc4062a5735e231dc617a70494556a184d7[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Mon Sep 16 23:50:50 2024 +0600
-
-    Add documentation build
-
-[33mcommit 15dc499cd9233c28778cffc925d9d045f2e39302[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Fri Sep 13 01:23:57 2024 +0600
-
-    Add src/input.c
-
-[33mcommit 6161d310bcb50a13e9cb853045cbe2da2b0a1957[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Fri Sep 6 05:08:07 2024 +0600
-
-    0.3 Rotate axis
-
-[33mcommit 0f387f8a71fd504bc5d08bdae850af6a0c8cba6e[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 5 15:05:33 2024 +0000
-
-    0.2 Clean up
-
-[33mcommit 06e8e9074b8a55a7854045fcb5cea9e5e1f6018d[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 5 14:48:51 2024 +0000
-
-    0.2 Draw axis
-
-[33mcommit a2f49afbf412dd4ee39c57438363cb0c1a8d12cd[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Thu Sep 5 11:31:50 2024 +0000
-
-    0.1 Add external dependecies
-
-[33mcommit cce685d90c3c4abaa6effe291def4d2c42bb6db2[m
-Author: PedroEdiaz <ppedroediaz@gmail.com>
-Date:   Wed Sep 4 22:35:31 2024 +0000
-
-    0.1 Graph cube