habemos botella de klein

Fix: trous, the good one
Fix: Torus
2024-10-18 15:01:38 -06:00 · 2024-10-18 10:35:42 -06:00 · 2024-10-18 10:27:38 -06:00 · 2024-10-18 09:44:38 -06:00 · 2024-10-18 09:30:11 -06:00 · 2024-10-17 20:14:50 -06:00
23 changed files with 345 additions and 6080 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,19 +0,0 @@
---
-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
@@ -1,5 +0,0 @@
-manigraph
-**.o
-**.so
-**.exe
-**.dll
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,6 +4,3 @@
 [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/51
+++ b/51
@@ -1,7 +1,6 @@
 BIN = manigraph

 OBJ = \
-	ext/glad/glad.o \
 	src/surface.o \
 	src/context.o \
 	src/texture.o \
@@ -15,20 +14,7 @@ OBJ = \
 CFLAGS = \
 	-I./ext/cglm/include  \
 	-I./ext/glfw/include  \
-	-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
+	-Wall -Wno-unused-function -std=c99   \

 help:
 	@echo "Para compilar el proyecto a tu sistema operativo"
@@ -37,16 +23,11 @@ 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 
@@ -54,20 +35,15 @@ 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/axis.h
+src/main.o: src/data/shaders.h src/data/cube.h src/data/axis.h

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

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

 run-linux:
@@ -75,19 +51,16 @@ run-linux:

 # COCOA
 cocoa: $(OBJ)
-	$(MAKE) DFLAGS="-D_GLFW_COCOA" libglfw.so
-	$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw 
+	$(MAKE) BKN=_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: 
-	$(CC) -fPIC -shared $(DFLAGS) -D_GLFW_BUILD_DLL -Iext/glfw/deps/wayland ./ext/glfw/src/*.c -o $@ 
+libglfw.so:
+	$(CC) -fPIC -shared -D$(BKN) -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ 

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

-.SUFFIXES: .c .o 
+.SUFFIXES: .c .o

 .c.o:
 	$(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. (no incluidas)
+Para compilar `glfw` en linux hacen falta las siguientes librerías según el caso. (no incluidas)
 - `x11`: libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel
 - `wayland`: libwayland-dev libxkbcommon-dev wayland-protocols

--- a/compile.bat
+++ b/compile.bat
@@ -1,3 +0,0 @@
-:: 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
@@ -1,311 +0,0 @@
-#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,35 +1,13 @@
 #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);
-
-	glClearColor((float)r / 0xff, (float)g / 0xff, (float)b / 0xff, 1.0);
+	glEnable( GL_DEPTH_TEST );
+	glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
 }

-int init_context(void)
+void clean_context( void )
 {
-#ifdef EMSCRIPTEN
-	return 1;
-#else
-#ifdef GLAD
-
-	return gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
-#else
-	return glewInit();
-#endif
-#endif
+	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 }
-
-void clean_context(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
--- a/src/data/axis.h
+++ b/src/data/axis.h
@@ -1,40 +1,45 @@
 #undef A
-#undef B 
-#undef C 
+#undef B
+#undef C
 #undef D
 #undef E
 #undef F
-#undef G 
+#undef G
 #undef H

-#define A -2.0,-0.05,-0.05,
-#define B -2.0,-0.05, 0.05,
-#define C -2.0, 0.05,-0.05,
-#define D -2.0, 0.05, 0.05,
-#define E  2.0,-0.05,-0.05,
-#define F  2.0,-0.05, 0.05,
-#define G  2.0, 0.05,-0.05,
-#define H  2.0, 0.05, 0.05,
+const float X = 2.0;
+const float Y = 0.05;
+const float Z = 0.05;
+
+#define A -X,-Y,-Z,
+#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,

 float d_axis[] =
 {
 	3*3*2*6,

 	A C E
-	G E C
+	C E G

 	E G F
-	H F G
+	G F H

 	F H B
-	D B H
+	H B D

 	B D A
-	C A D 
+	D A C

 	C D G
-	H G D
+	D G H

-	E B A
+	A B E 
 	B E F
+
 };
--- a/src/data/cube.h
+++ b/src/data/cube.h
@@ -0,0 +1,32 @@
+#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
+
+};
--- a/src/data/shaders.h
+++ b/src/data/shaders.h
@@ -1,19 +1,7 @@
 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 = 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;"
+	"layout (location = 0) in vec3 aPos;"

 	"uniform float idx;"
 	"uniform mat4 fix;"
@@ -21,73 +9,22 @@ 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_plain =
-#ifdef EMSCRIPTEN
-	"#version 300 es\n"
-
-	"precision highp float;"
-	"precision highp sampler2DArray;"
-#else
+const char * fs =
 	"#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"
-    "}";
--- a/src/input.c
+++ b/src/input.c
@@ -1,9 +1,8 @@
 #include "main.h"
-#include <GLFW/glfw3.h>
 #include <cglm/quat.h>
-#include <stdio.h>
+#include <GLFW/glfw3.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,67 +10,14 @@ int window_height;

 versor q = GLM_QUAT_IDENTITY_INIT;

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

-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)
+void __window_callback(GLFWwindow * window, int w, int h)
 {
 	int m;

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

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

-	if (button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS)
-		return;
+	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);
+	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_input(GLFWwindow *window, double xoffset, double yoffset)
+void __scroll_callback(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]);
@@ -120,42 +65,43 @@ 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
@@ -1,194 +1,97 @@
 #include "main.h"
 #include "data/axis.h"
 #include "data/shaders.h"
-
-#include <stdio.h>
+#include <stdlib.h>
+#include <GL/glew.h>
 #include <stdlib.h>

 #define WIDTH 512
 #define HEIGHT 512

-#ifdef EMSCRIPTEN
-#include <emscripten.h>
-#endif
-
-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},
+unsigned char palette[] =
+{
+	16,
+	0xEB,0xD3,0xF8,0xff,
+	0xEB,0xD4,0xF8,0xff,
+	0xEB,0xD5,0xF8,0xff,
+	0x7A,0x1C,0xAC,0xff,
 };

-void mlog(char *msg)
+const char * wname = "manigraph: manifold grapher";
+float * generate_surface();
+
+int main( void )
 {
-#ifdef DEBUG
-	printf(msg);
-#endif
-}
+	float * points;
+	id_t shader, texture;
+	mesh_t m_cube, m_axis;
+	window_t window;

-window_t window;
-mesh_t m_surface, m_axis;
-id_t shader, shader_plain;
+	if( !( window = init_window( WIDTH, HEIGHT, wname ) ) )
+		goto error_window;

-#ifndef EMSCRIPTEN
-static inline
-#endif
-void main_loop(void)
-{
-	quat_t q;
+	use_window( window );
+	set_clean_color_context( 0x2E, 0x07, 0x3F );

-	q = poll_input(window);
-	load_rot_matrix(shader, q);
-	load_rot_matrix(shader_plain, q);
+	glewInit(); 

-	clean_context();
+	points = generate_surface(16);

+	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( points ) ) )
+		goto error_mesh_cube;
+
+	free(points);
+
+	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_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);
+		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
-	draw_mesh(m_surface);
-}

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

-	mlog("[VENTANA] Inicializando...\n");
-	{
-		if (!(window = init_window(WIDTH, HEIGHT, wname)))
-		{
-			mlog("[VENTANA] Error al inicializar...\n");
-			goto error_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);
+	destroy_texture( texture );
+	destroy_mesh( m_axis );
+	destroy_mesh( m_cube );
+	destroy_shader( shader );
+	close_window( window );
 	return 0;

-	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_axis);
 error_mesh_axis:
-	mlog("[MESH] Destruyendo...\n");
-	destroy_mesh(m_surface);
-error_mesh_surface:
-	mlog("[SHADER] Destruyendo...\n");
-	destroy_shader(shader_plain);
-error_shader_plain:
-	mlog("[SHADER] Destruyendo...\n");
-	destroy_shader(shader);
+	destroy_mesh( m_cube );
+error_mesh_cube:
+	destroy_shader( shader );
 error_shader:
-	mlog("[TEXTURE] Destruyendo...\n");
-	destroy_texture(texture);
-error_context:
-	mlog("[WINDOW] Destruyendo...\n");
-	close_window(window);
+	close_window( window );
 error_window:
 	return 1;
 }
--- a/src/main.h
+++ b/src/main.h
@@ -1,11 +1,5 @@
-/*
-	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  */
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>

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

-/* 
-	This struct represent the proyection, where:
-		mesh: data of surface.
-		m: the dimention of the surface.
-		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.
-*/
+typedef float narray_float_t[];
+typedef unsigned char narray_u8_t[];

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

-/* 
-	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);
@@ -44,92 +23,32 @@ int is_open_window(window_t window);

 void close_window(window_t window);

-/* 
-	Create mesh:
-		d: array of floats with the vertex data.
-		n: array of floats with the normal data.
-		m: Dimention of mesh
-*/
-
-mesh_t create_mesh( float * d, float * n, unsigned char m );
-
-void set_projection_mesh( struct projection );
+mesh_t create_mesh( float * mesh);

 void destroy_mesh(mesh_t p);

 void draw_mesh(mesh_t p);

-/*
-	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 set_clean_color_context(unsigned char, unsigned char, unsigned char);

 void clean_context(void);

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

 id_t create_shader(void);

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

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

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

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

-/*
-	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);
@@ -138,11 +57,6 @@ void use_texture(id_t texture);

 void destroy_texture(id_t texture);

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

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

-	load_mat4_to_shader(shader, "fix", (mat4_t)m);
+	gload_mat4( 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 )
 {
-	load_float_to_shader(shader, "idx", c);
-	load_mat4_to_shader(shader, "mdl", (mat4_t)ortho[i]);
+	gload_float( shader, "idx", c );
+	gload_mat4( 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);
-	load_mat4_to_shader(shader, "rot", (mat4_t)m);
+	glm_quat_mat4( q, m );
+	gload_mat4( shader, "rot", (mat4_t)m );
 }
--- a/src/mesh.c
+++ b/src/mesh.c
@@ -1,121 +1,55 @@
 #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, n_vbo, d_vbo;
+	unsigned int vertex, vao, vbo;
 };

-void set_projection_mesh(struct projection projection)
+mesh_t create_mesh( float * mesh )
 {
-	struct obj *p;
-	p = projection.mesh;
+	struct obj * p;

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

-	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)));
+	p->vertex=(*mesh)/3;

-	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)));
-}
+	glGenVertexArrays( 1, &p->vao );
+	glGenBuffers( 1, &p->vbo );

-/*
-	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.
-*/
+	glBindVertexArray( p->vao );
+	glBindBuffer( GL_ARRAY_BUFFER, p->vbo );
+	glBufferData( GL_ARRAY_BUFFER, (p->vertex*3)*sizeof(float), mesh+1, 
+		GL_STATIC_DRAW );

-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);
-	}
+	glVertexAttribPointer( 0,3,GL_FLOAT, 0, 3*sizeof(float), NULL );
+	glEnableVertexAttribArray(0);

 	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->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,43 +1,51 @@
 #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 load_program_to_shader(
-	unsigned int program, const char *src, unsigned int i)
+unsigned char gload_program( 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;
 	}
@@ -48,14 +56,14 @@ unsigned char load_program_to_shader(
 	return 1;
 }

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

-void load_mat4_to_shader(unsigned int program, char *var, float *mat)
+void gload_mat4( 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,234 +1,76 @@
-#include <complex.h>
+#include <stdio.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
+typedef void(*function_t)(float*,int, int, int);

-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)
+void mobius(float *d_surface, int i, int j, 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;
+	float u = (2*M_PI) * ((float)i/grid_size );
+	float v = (2*width) * ((float)j/grid_size ) - width;

 	d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
 	d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
 	d_surface[2] = v * sin(u / 2);
 }

-void torus(float *d_surface, int * coord, int grid_size)
+void toro(float *d_surface, int i, int j, int grid_size)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
-	float v = (2 * M_PI) * ((float)coord[1] / 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 * coord, int grid_size)
+void klein(float *d_surface, int i, int j, int grid_size)
 {
-	float u = (2 * M_PI) * ((float)coord[0] / grid_size);
-	float v = (2 * M_PI) * ((float)coord[1]/ 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[2] = sin(v)*sin(u/2);
 }

-typedef void (*function_t)(float *, int *, int);
-
-float *generate_data_surface(int grid_size, unsigned char *s)
+float * generate_surface(int grid_size)
 {
-	unsigned int i, j, k, o, p, l, n, m;
-	long size, q=0;
-	function_t f;
-	float *d_surface;
+	long size = grid_size*grid_size*2*3*3;
+	function_t f = klein;
+	float * d_surface;
+	int k=0;

-	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 = malloc((size+1)*sizeof(float));
 	d_surface[0] = size;
-	
-	for(o = 0; o < dim; o ++)
-	{  
-		for (p = 0; p < o; p++)
+
+	for (int i = 0; i < grid_size; i++)
+	{ 
+		for (int j = 0; j < grid_size; j++)
 		{
-			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++;
+			// Triángulo 1
+			f(&d_surface[k + 1], i, j, grid_size);
+			k+=3;
+			f(&d_surface[k + 1], i + 1, j, grid_size);
+			k+=3;
+			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
+			k+=3;

-					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;
-					}
-				}
-			}	
+			// Triángulo 2
+			f(&d_surface[k + 1], i, j, grid_size);
+			k+=3;
+			f(&d_surface[k + 1], i, j + 1, grid_size);
+			k+=3;
+			f(&d_surface[k + 1], i + 1, j + 1, grid_size);
+			k+=3;
 		}
 	}

 	return d_surface;
 }
-
-
-
-static void __calculate_normal(
-	float *p1, float *p2, float *p3, float *normal, unsigned char n)
-{
-	float alpha;
-	vec4 v1, v2, v3;
-	vec4 u1, u2, u3;
-
-	switch (n)
-	{
-	case 3:
-
-		glm_vec3_sub(p2, p1, v1);
-		glm_vec3_sub(p3, p1, v2);
-
-		glm_vec3_cross(v1, v2, normal);
-		glm_vec3_normalize(normal);
-		return;
-
-	case 4:
-
-		/*
-			In Grant-Shmidth we need 3 linearly independian vector that forms a
-		   basis, so we can have a ortonormal version of that basis, since, we
-		   must have v1 = p3 - p1 v2 = p2 - p1 Then v3 = p1, will most certantly
-		   be linerly independiant to v1 and v2.
-		*/
-		glm_vec4_sub(p2, p1, v1);
-		glm_vec4_sub(p3, p1, v2);
-		glm_vec4_copy(p1, v3);
-
-		/* Setup U1 */
-		{
-			glm_vec4_copy(v1, u1);
-		}
-
-		/* Setup U2 */
-		{
-			vec4 proj;
-
-			alpha = glm_vec4_dot(v2, u1) / glm_vec4_dot(u1, u1);
-			glm_vec4_scale(u1, alpha, proj);
-
-			glm_vec4_sub(v2, proj, u2);
-		}
-
-		/* Setup U3 */
-		{
-			vec4 proj1, proj2;
-
-			alpha = glm_vec4_dot(v3, u1) / glm_vec4_dot(u1, u1);
-			glm_vec4_scale(u1, alpha, proj1);
-
-			alpha = glm_vec4_dot(v3, u2) / glm_vec4_dot(u2, u2);
-			glm_vec4_scale(u2, alpha, proj2);
-
-			glm_vec4_sub(v3, proj1, u3);
-			glm_vec4_sub(u3, proj2, u3);
-		}
-
-		glm_vec4_copy(u3, normal);
-		glm_vec4_normalize(normal);
-		return;
-	}
-}
-
-float *generate_normals_surface(float *d, unsigned char m)
-{
-	float *n;
-	n = malloc((*d + 1) * sizeof(float));
-	*n = *d;
-	for (int i = 0; i < *d; i += 3 * m)
-	{
-
-		vec4 norm_vec;
-
-		__calculate_normal(
-			(d + 1) + i, (d + 1) + i + m, (d + 1) + i + 2 * m, norm_vec, m);
-		glm_vec3_copy(norm_vec, (n + 1) + i);
-		glm_vec3_copy(norm_vec, (n + 1) + i + m);
-		glm_vec3_copy(norm_vec, (n + 1) + i + 2 * m);
-	}
-	return n;
-}
--- a/src/texture.c
+++ b/src/texture.c
@@ -1,38 +1,37 @@
 #include "main.h"
-#ifdef GLAD
-#include <glad.h>
-#else
 #include <GL/glew.h>
-#endif

 #define TYPE GL_TEXTURE_2D_ARRAY

-static id_t __config_texture(unsigned short type)
+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) { return glBindTexture(TYPE, texture); }
-
-void destroy_texture(unsigned int texture)
+void use_texture( id_t texture )
 {
-	return glDeleteTextures(1, &texture);
+	return glBindTexture( TYPE, texture );
 }

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

-void __window_callback_input(GLFWwindow *, int, int);
-void __mouse_callback_input(GLFWwindow *, int, int, int);
-void __scroll_callback_input(GLFWwindow *, double, double);
-void __key_callback_input(GLFWwindow *, int, int, int, int);
+void __window_callback(GLFWwindow *, int, int);
+void __mouse_callback(GLFWwindow *, int, int, int);
+void __scroll_callback(GLFWwindow *, double, double);

-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)
+window_t init_window(unsigned int w, unsigned int h, const char * name)
 {
-	static double previous_time = 0.0;
-	double current_time;
-	double frame_time;
-	double elapsed_time;
+	void * window;
+	void __mouse_callback(GLFWwindow *window, int button, int action, int mods);
+	void __scroll_callback(GLFWwindow *window, double xoffset, double yoffset);

-	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())
+	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 = (window_t)glfwCreateWindow(width, height, title, NULL, NULL);
-	if (!(window))
+	window = glfwCreateWindow(w, h, name, NULL, NULL);
+
+	if( !window )
 	{
 		glfwTerminate();
 		return NULL;
 	}

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

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

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

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

 void close_window(window_t window)
 {
-	glfwDestroyWindow((GLFWwindow *)window);
+	glfwDestroyWindow((void*)window);
 	glfwTerminate();
 }
Author	SHA1	Message	Date
alan	7d3f8f71b2	habemos botella de klein	2024-10-18 15:01:38 -06:00
PedroEdiaz	5f392792c5	Fix: trous, the good one	2024-10-18 10:35:42 -06:00
PedroEdiaz	a131ff6da1	Fix: Torus	2024-10-18 10:27:38 -06:00
alan	27d43e6bca	funciones renombradas	2024-10-18 09:44:38 -06:00
alan	994bd3987c	Toro agregado	2024-10-18 09:30:11 -06:00
PedroEdiaz	af2c2afa1d	Fix alan	2024-10-17 20:14:50 -06:00
alan	7333f3933c	Grafica algo pero no la banda	2024-10-17 19:37:00 -06:00