Fix: Compilation errors alan

Muy bien!!, nada mas habian 2 errores por mi parte,
'Normal' no estaba normalizado, lo que afectaba las potencias con 'pow'.
Ademas habia un error con los buffers del shader lo que afectaba toda la iluminacion.
Sin embargo lo hiciste muy bien, solo que te falto definir viewPos.

.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
+...

.gitignore

@@ -0,0 +1,5 @@
+manigraph
+**.o
+**.so
+**.exe
+**.dll

.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

Makefile

@@ -1,6 +1,8 @@
 BIN = manigraph
 
 OBJ = \
+	ext/glad/glad.o \
+	src/surface.o \
 	src/context.o \
 	src/texture.o \
 	src/window.o \
@@ -8,13 +10,25 @@ OBJ = \
 	src/shader.o \
 	src/input.o \
 	src/mesh.o \
-	src/alan.o \
 	src/main.o 
 
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
-	-Wall -Wno-unused-function -std=c99   \
+	-I./ext/glad  \
+	-DGLAD  \
+	-Wall -Wno-unused-function -std=c99 -D_GNU_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
 
 help:
 	@echo "Para compilar el proyecto a tu sistema operativo"
@@ -23,11 +37,16 @@ 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/shaders.h
+
+$(OBJ): src/main.h
+
 # WINDOWS
 windows: $(OBJ) glfw.dll
 	$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 -lglew32 
@@ -35,30 +54,40 @@ windows: $(OBJ) glfw.dll
 glfw.dll:
 	$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32 
 
-# LINUX
+src/main.o: src/data/shaders.h src/data/axis.h
-linux-x11: $(OBJ)
-	$(MAKE) BKN=_GLFW_X11 libglfw.so
-	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
 
+# LINUX
 linux-wayland: $(OBJ)
-	$(MAKE) BKN=_GLFW_WAYLAND libglfw.so
+	for i in $(WAYLAND-LIB); \
-	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
+	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-x11: $(OBJ)
+	$(MAKE) DFLAGS="-D_GLFW_X11" libglfw.so
+	$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm
 
 run-linux:
 	LD_LIBRARY_PATH=. ./$(BIN)
 
 # 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
+	$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
 
-libglfw.so:
+wasm: $(OBJ)
-	$(CC) -fPIC -shared -D$(BKN) -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ 
+	$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o mani.html $(OBJ)
+
+libglfw.so: 
+	$(CC) -fPIC -shared $(DFLAGS) -D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 
 
 clean:
-	rm $(OBJ) $(BIN)
+	rm $(OBJ) $(BIN) ext/glfw/deps/wayland/*.h
 
-.SUFFIXES: .c .o
+.SUFFIXES: .c .o 
 
 .c.o:
 	$(CC) $(CFLAGS) -c -o $@ $<

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
 

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

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_ */

src/context.c

@@ -1,13 +1,35 @@
 #include "main.h"
+
+#ifdef EMSCRIPTEN
 #include <GL/gl.h>
+#else
+#ifdef GLAD
+#include <glad.h>
+#include <GLFW/glfw3.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); }

src/data/axis.h

@@ -1,45 +1,40 @@
 #undef A
-#undef B
+#undef B 
-#undef C
+#undef C 
 #undef D
 #undef E
 #undef F
-#undef G
+#undef G 
 #undef H
 
-const float X = 2.0;
+#define A -2.0,-0.05,-0.05,
-const float Y = 0.05;
+#define B -2.0,-0.05, 0.05,
-const float Z = 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,
 
-#define A -X,-Y,-Z,
+float d_axis[] =
-#define B -X,-Y, Z,
-#define C -X, Y,-Z,
-#define D -X, Y, Z,
-#define E  X,-Y,-Z,
-#define F  X,-Y, Z,
-#define G  X, Y,-Z,
-#define H  X, Y, Z,
-
-narray_float_t d_axis =
 {
 	3*3*2*6,
 
 	A C E
-	C E G
+	G E C
 
 	E G F
-	G F H
+	H F G
 
 	F H B
-	H B D
+	D B H
 
 	B D A
-	D A C
+	C A D 
 
 	C D G
-	D G H
+	H G D
 
-	A B E 
+	E B A
 	B E F
-
 };

src/data/cube.h

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

src/data/shaders.h

@@ -1,7 +1,19 @@
 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;"
+	"layout (location = 3) in float aPos_w;"
 
-	"layout (location = 0) in vec3 aPos;"
+	"layout (location = 4) in float aNormal_x;"
+	"layout (location = 5) in float aNormal_y;"
+	"layout (location = 6) in float aNormal_z;"
+	"layout (location = 7) in float aNormal_w;"
 
 	"uniform float idx;"
 	"uniform mat4 fix;"
@@ -9,22 +21,73 @@ const char * vs =
 	"uniform mat4 mdl;"
 
 	"out float index;"
+	"out vec3 Normal;"
+	"out vec3 FragPos;"
 
 	"void main()"
 	"{"
 	"	index=idx;"
+	"	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));"
 	"}";
 
-const char * fs =
+	
-	"#version 330 core\n"
+const char * fs_plain =
+#ifdef EMSCRIPTEN
+	"#version 300 es\n"
 
+	"precision highp float;"
+	"precision highp sampler2DArray;"
+#else
+	"#version 330 core\n"
+#endif
 	"uniform sampler2DArray palette;"
 
 	"in float index;"
 	"out vec4 FragColor;"
+	"in vec3 Normal;"
+	"in vec3 FragPos;"
 
 	"void main()"
 	"{"
 	"	FragColor = texture( palette, vec3( 0, 0, index ) ).rgba;"
 	"}";
+
+const char * fs =
+#ifdef EMSCRIPTEN
+    "#version 300 es\n"
+	"precision highp float;"
+	"precision highp sampler2DArray;"
+#else
+    "#version 330 core\n"
+#endif
+
+    "uniform sampler2DArray palette;"
+
+    "in float index;"
+    "in vec3 Normal;"
+    "in vec3 FragPos;"
+
+    "out vec4 FragColor;"
+
+    "void main()"
+    "{"
+    "   vec4 color = texture(palette, vec3(0, 0, index));\n"
+
+    "   vec3 viewPos = vec3(0, 0, -15);\n"
+    "   vec3 viewDir = normalize(viewPos - FragPos);\n"
+
+    "   vec3 lightPos = viewPos;\n"
+    "   vec3 lightDir = normalize(lightPos - FragPos);\n"
+
+    "   vec3 halfwayDir = normalize(lightDir + viewDir);\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"
+    "   FragColor = vec4(result, color.a);\n"
+    "}";

src/input.c

@@ -1,8 +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;
@@ -10,14 +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 __window_callback(GLFWwindow * window, int w, int h)
+extern struct projection projection;
+
+void __key_callback_input(
+	GLFWwindow *window, int key, int scancode, int action, int mods)
+{
+	if (action != GLFW_PRESS)
+		return;
+
+	if (GLFW_KEY_0 < key && key <= GLFW_KEY_9)
+	{
+		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_input(GLFWwindow *window, int w, int h)
 {
 	int m;
 
@@ -28,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;
+		return;
 
 	glfwGetCursorPos(window, &xpos, &ypos);
-	glReadPixels((int)xpos, (int)(window_height - ypos), 1, 1, GL_GREEN, GL_UNSIGNED_BYTE, &green_value);
+	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]);
@@ -65,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_mul(p, q, q);
-	glm_quat_rotatev( p, axis[0], axis[0] );
+	glm_quat_rotatev(p, axis[0], axis[0]);
-	glm_quat_rotatev( p, axis[1], axis[1] );
+	glm_quat_rotatev(p, axis[1], axis[1]);
-	glm_quat_rotatev( p, axis[2], axis[2] );
+	glm_quat_rotatev(p, axis[2], axis[2]);
-	glm_quat_normalize( q );
+	glm_quat_normalize(q);
 	return q;
 }
-

src/main.c

@@ -1,88 +1,194 @@
 #include "main.h"
-#include "data/cube.h"
 #include "data/axis.h"
 #include "data/shaders.h"
-#include <GL/glew.h>
+
- 
+#include <stdio.h>
+#include <stdlib.h>
+
 #define WIDTH 512
 #define HEIGHT 512
 
-unsigned char palette[] =
+#ifdef EMSCRIPTEN
-{
+#include <emscripten.h>
-	16,
+#endif
-	0xEB,0xD3,0xF8,0xff,
+
-	0xEB,0xD4,0xF8,0xff,
+float *generate_data_surface(unsigned int, unsigned char *);
-	0xEB,0xD5,0xF8,0xff,
+float *generate_normals_surface(float *, unsigned char);
-	0x7A,0x1C,0xAC,0xff,
+
+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},
 };
 
-const char * wname = "manigraph: manifold grapher";
+void mlog(char *msg)
-
-int main( void )
 {
-	id_t shader, texture;
+#ifdef DEBUG
-	mesh_t m_cube, m_axis;
+	printf(msg);
-	window_t window;
-
-	if( !( window = init_window( WIDTH, HEIGHT, wname ) ) )
-		goto error_window;
-
-	use_window( window );
-	set_clean_color_context( 0x2E, 0x07, 0x3F );
-
-	glewInit(); 
-
-	if( !( shader = create_shader() ) )
-		goto error_shader;
-
-	gload_program( shader, vs, VERTEX );
-	gload_program( shader, fs, FRAGMENT );
-	use_shader( shader );
-
-	load_fix_matrix( shader, (float)WIDTH/HEIGHT );
-
-	if( !( m_cube = create_mesh( d_cube ) ) )
-		goto error_mesh_cube; 
-
-	if( !( m_axis = create_mesh( d_axis ) ) )
-		goto error_mesh_axis; 
-
-	texture=create_palette_texture( palette );
-	use_texture( texture );
-
-	while( is_open_window( window ) )
-	{
-		quat_t q;
-
-		q=poll_input( window );
-		load_rot_matrix( shader, q );
-		
-		clean_context();
-#ifndef DEBUG
-		load_mdl_matrix( shader, 0, 0 );
-		draw_mesh( m_axis );
-		load_mdl_matrix( shader, 1, 1 );
-		draw_mesh( m_axis );
-		load_mdl_matrix( shader, 2, 2 );
-		draw_mesh( m_axis );
 #endif
-		load_mdl_matrix( shader, 0, 3 );
+}
-		draw_mesh( m_cube );
+
+window_t window;
+mesh_t m_surface, m_axis;
+id_t shader, shader_plain;
+
+#ifndef EMSCRIPTEN
+static inline
+#endif
+void main_loop(void)
+{
+	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);
+#else
+	load_mdl_matrix(shader_plain, 0, 3);
+#endif
+	draw_mesh(m_surface);
+}
+
+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;
+		}
+
+		use_window(window);
 	}
 
-	destroy_texture( texture );
+	mlog("[CONTEXT] Inicializando...\n");
-	destroy_mesh( m_axis );
+	{
-	destroy_mesh( m_cube );
+		if (!(init_context()))
-	destroy_shader( shader );
+		{
-	close_window( window );
+			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 );
+	mlog("[MESH] Destruyendo...\n");
-error_mesh_cube:
+	destroy_mesh(m_surface);
-	destroy_shader( shader );
+error_mesh_surface:
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader_plain);
+error_shader_plain:
+	mlog("[SHADER] Destruyendo...\n");
+	destroy_shader(shader);
 error_shader:
-	close_window( window );
+	mlog("[TEXTURE] Destruyendo...\n");
+	destroy_texture(texture);
+error_context:
+	mlog("[WINDOW] Destruyendo...\n");
+	close_window(window);
 error_window:
 	return 1;
 }

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,14 +13,29 @@ typedef void * mesh_t;
 typedef float * quat_t;
 typedef float * mat4_t;
 
-typedef float narray_float_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);
@@ -23,32 +44,92 @@ int is_open_window(window_t window);
 
 void close_window(window_t window);
 
-mesh_t create_mesh(narray_float_t mesh);
+/* 
+	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);
@@ -57,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);

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 },
+		{1, 0, 0, 0},
-		{ 0, 1, 0, 0 },
+		{0, 1, 0, 0},
-		{ 0, 0, 1, 0 },
+		{0, 0, 1, 0},
-		{ 0, 0, 0, 1 },
+		{0, 0, 0, 1},
 	},
 	{
-		{ 0, 1, 0, 0 },
+		{0, 1, 0, 0},
-		{ 1, 0, 0, 0 },
+		{-1, 0, 0, 0},
-		{ 0, 0, 1, 0 },
+		{0, 0, 1, 0},
-		{ 0, 0, 0, 1 },
+		{0, 0, 0, 1},
 	},
 	{
-		{ 0, 0, 1, 0 },
+		{0, 0, 1, 0},
-		{ 0, 1, 0, 0 },
+		{0, 1, 0, 0},
-		{ 1, 0, 0, 0 },
+		{-1, 0, 0, 0},
-		{ 0, 0, 0, 1 },
+		{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_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_perspective(CGLM_PI / 4, ratio, d - 3, d + 3, n);
-	glm_mat4_mul( n, m, m );
+	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 );
+	load_float_to_shader(shader, "idx", c);
-	gload_mat4( shader, "mdl", (mat4_t)ortho[i] );
+	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 );
+	glm_quat_mat4(q, m);
-	gload_mat4( shader, "rot", (mat4_t)m );
+	load_mat4_to_shader(shader, "rot", (mat4_t)m);
 }

src/mesh.c

@@ -1,55 +1,121 @@
 #include "main.h"
+#ifdef GLAD
+#include <glad.h>
+#else
 #include <GL/glew.h>
+#endif
+#include <stdio.h>
 #include <stdlib.h>
 
-struct obj 
+struct obj
 {
-	unsigned int vertex, vao, vbo;
+	unsigned int vertex, vao, n_vbo, d_vbo;
 };
 
-mesh_t create_mesh( narray_float_t mesh )
+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=(*mesh)/3;
+	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);
-	glGenBuffers( 1, &p->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)));
+}
 
-	glBindVertexArray( p->vao );
+/*
-	glBindBuffer( GL_ARRAY_BUFFER, p->vbo );
+	In this function we load all the vertex and ELEMENT_ARRAY datas on two
-	glBufferData( GL_ARRAY_BUFFER, (p->vertex*3)*sizeof(int), mesh+1, 
+	diferents buffers, so we can access the coordanates that we want
-		GL_STATIC_DRAW );
+	to display using the layout location in GLSL.
+	This trick can be done with glVertexAttribPointer.
+*/
 
-	glVertexAttribPointer( 0,3,GL_FLOAT, 0, 3*sizeof(int), NULL );
+mesh_t create_mesh(float *d, float *n, unsigned char m)
-	glEnableVertexAttribArray(0);
+{
+	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 );
+	glDeleteVertexArrays(1, &obj->vao);
-	glDeleteBuffers( 1, &obj->vbo );
+	glDeleteBuffers(1, &obj->d_vbo);
-	free( p );
+	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 )
+		for (i = 0; i < obj->vertex; i += 3)
-			glDrawArrays(GL_LINE_LOOP, i, 3 );
+			glDrawArrays(GL_LINE_LOOP, i, 3);
 	}
 #else
-	glDrawArrays(GL_TRIANGLES, 0, obj->vertex );
+	glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
 #endif
 }

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 )
+void destroy_shader(unsigned int shader) { return glDeleteProgram(shader); }
-{ 
-	return glDeleteProgram( shader );
-}
 
-unsigned int create_shader( void )
+unsigned int create_shader(void) { return glCreateProgram(); }
-{
-	return glCreateProgram();
-}
 
-void use_shader( unsigned int program )
+void use_shader(unsigned int program) { return glUseProgram(program); }
-{
-	return glUseProgram( program );
-}
 
-unsigned char gload_program( unsigned int program, const char * src, 
+unsigned char load_program_to_shader(
-	unsigned int i )
+	unsigned int program, const char *src, unsigned int i)
 {
 	int shader, status;
-	unsigned int type[] = 
+	unsigned int type[] = {
-	{
+		[VERTEX] = GL_VERTEX_SHADER, [FRAGMENT] = GL_FRAGMENT_SHADER};
-		[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 );
+		glGetShaderInfoLog(shader, 256, NULL, log);
-		printf( "%s", 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 );
+	glUseProgram(program);
-	glUniform1f( glGetUniformLocation( program, var ), f ); 
+	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 );
+	glUseProgram(program);
-	glUniformMatrix4fv( glGetUniformLocation( program, var ), 1, 0, mat ); 
+	glUniformMatrix4fv(glGetUniformLocation(program, var), 1, 0, mat);
 }

src/surface.c

@@ -0,0 +1,234 @@
+#include <complex.h>
+#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
+
+#ifndef CMPLX
+#define CMPLX(a,b) (a+I*b)
+#endif
+
+void riemman(float *d_surface, int * coords, int grid_size)
+{
+	complex double eq;
+	float u = 2 * ((float)coords[0] / grid_size) - 1;
+	float v = 2 * ((float)coords[1] / grid_size) - 1;
+
+	eq = csqrt(CMPLX(u,v));
+
+	d_surface[0] = u;
+	d_surface[1] = v;
+	d_surface[2] = creal(eq);
+	d_surface[3] = cimag(eq);
+}
+
+
+void cube( float *d_surface, int * coord, int grid_size )
+{
+	unsigned char i;
+
+	for(int i=0; i<4; i++ )
+		d_surface[i]=(float)coord[i]/grid_size;
+}
+
+void mobius(float *d_surface, int * coord, int grid_size)
+{
+	const float width = 0.5;
+	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float v = (2 * width) * ((float)coord[1] / 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 * coord, int grid_size)
+{
+	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float v = (2 * M_PI) * ((float)coord[1] / 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 * coord, int grid_size)
+{
+	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
+	float v = (2 * M_PI) * ((float)coord[1]/ 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);
+
+float *generate_data_surface(int grid_size, unsigned char *s)
+{
+	unsigned int i, j, k, o, p, l, n, m;
+	long size, q=0;
+	function_t f;
+	float *d_surface;
+
+	const int dim =2;
+	int cara[dim];
+	char bits[dim+1];
+	bits[dim]=0;
+
+	f =klein ;
+	*s = 4;
+
+	size = grid_size * grid_size * 6 * (*s) * 24;
+	d_surface = malloc((size + 1) * sizeof(float));
+	d_surface[0] = size;
+	
+	for(o = 0; o < dim; o ++)
+	{  
+		for (p = 0; p < o; p++)
+		{
+			for (k = 0; k < (1 << (dim-2)); k++)
+			{
+				unsigned char skip=0;
+				for(n = 0; n < dim-2; n++)
+				{
+					if( n==(o-1) || n==p )
+						skip++;
+
+					cara[n+skip] = (k & (1<<n))?grid_size:0;
+				}
+
+				for(i = 0; i < grid_size; i++)
+				{
+					for (j = 0; j < grid_size; j++)
+					{
+						cara[o] = i;
+						cara[p] = j;
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+
+						cara[o] = i + 1;
+						cara[p] = j;
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+
+						cara[o] = i + 1;
+						cara [p] = j + 1;
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+
+						cara[o] = i;
+						cara [p] = j; 
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+
+						cara[o] = i;
+						cara [p] = j + 1;
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+
+						cara[o] = i + 1;
+						cara [p] = j + 1;
+						f(&d_surface[q + 1], cara, grid_size);
+						q += *s;
+					}
+				}
+			}	
+		}
+	}
+
+	return d_surface;
+}
+
+
+
+static void __calculate_normal(
+	float *p1, float *p2, float *p3, float *normal, unsigned char n)
+{
+	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;
+}

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 );
+	glGenTextures(1, &texture);
-	glBindTexture( TYPE, texture );
+	glBindTexture(TYPE, texture);
 
 	{
-		glTexParameteri( TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+		glTexParameteri(TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		glTexParameteri( TYPE, GL_TEXTURE_MAG_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 texture = __config_texture(TYPE);
-}
+	glTexImage3D(
-
+		TYPE, 0, GL_RGBA, 1, 1, n, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors);
-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);
 	return texture;
 }

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 __window_callback_input(GLFWwindow *, int, int);
-void __mouse_callback(GLFWwindow *, int, int, int);
+void __mouse_callback_input(GLFWwindow *, int, int, int);
-void __scroll_callback(GLFWwindow *, double, double);
+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;
-	void __mouse_callback(GLFWwindow *window, int button, int action, int mods);
+	double current_time;
-	void __scroll_callback(GLFWwindow *window, double xoffset, double yoffset);
+	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);
+	window = (window_t)glfwCreateWindow(width, height, title, NULL, NULL);
-
+	if (!(window))
-	if( !window )
 	{
 		glfwTerminate();
 		return NULL;
 	}
 
-	glfwSetWindowSizeCallback(window, __window_callback);
+	glfwMakeContextCurrent((GLFWwindow *)(window));
-	glfwSetMouseButtonCallback((GLFWwindow*)window, __mouse_callback);
-	glfwSetScrollCallback((GLFWwindow*)window, __scroll_callback);
 
-	__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)
+void use_window(window_t window) { glfwMakeContextCurrent((void *)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();
 }