Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
7d3f8f71b2 | ||
|
|
5f392792c5 | ||
|
|
a131ff6da1 | ||
|
|
27d43e6bca | ||
|
|
994bd3987c | ||
|
|
af2c2afa1d | ||
|
|
7333f3933c |
@@ -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
|
|
||||||
...
|
|
||||||
5
.gitignore
vendored
5
.gitignore
vendored
@@ -1,5 +0,0 @@
|
|||||||
manigraph
|
|
||||||
**.o
|
|
||||||
**.so
|
|
||||||
**.exe
|
|
||||||
**.dll
|
|
||||||
3
.gitmodules
vendored
3
.gitmodules
vendored
@@ -4,6 +4,3 @@
|
|||||||
[submodule "ext/glfw"]
|
[submodule "ext/glfw"]
|
||||||
path = ext/glfw
|
path = ext/glfw
|
||||||
url = https://github.com/glfw/glfw
|
url = https://github.com/glfw/glfw
|
||||||
[submodule "ext/nuklear"]
|
|
||||||
path = ext/nuklear
|
|
||||||
url = https://github.com/Immediate-Mode-UI/Nuklear
|
|
||||||
|
|||||||
74
Makefile
74
Makefile
@@ -1,80 +1,66 @@
|
|||||||
BIN = manigraph
|
BIN = manigraph
|
||||||
|
|
||||||
OBJ = \
|
OBJ = \
|
||||||
ext/glad/glad.o \
|
src/surface.o \
|
||||||
src/context.o \
|
src/context.o \
|
||||||
|
src/texture.o \
|
||||||
src/window.o \
|
src/window.o \
|
||||||
|
src/matrix.o \
|
||||||
src/shader.o \
|
src/shader.o \
|
||||||
src/klein.o \
|
|
||||||
src/input.o \
|
src/input.o \
|
||||||
src/load.o \
|
|
||||||
src/mesh.o \
|
src/mesh.o \
|
||||||
src/main.o
|
src/main.o
|
||||||
|
|
||||||
EXAMPLES = \
|
|
||||||
example/basic \
|
|
||||||
example/riemman \
|
|
||||||
example/n-cube \
|
|
||||||
example/n-hilbert-cube \
|
|
||||||
example/light-cone \
|
|
||||||
example/lens
|
|
||||||
|
|
||||||
CFLAGS = \
|
CFLAGS = \
|
||||||
-I./ext/cglm/include \
|
-I./ext/cglm/include \
|
||||||
-I./ext/glfw/include \
|
-I./ext/glfw/include \
|
||||||
-I./ext/glad \
|
-Wall -Wno-unused-function -std=c99 \
|
||||||
-I./include \
|
|
||||||
-Wall -Wno-unused-function -std=c99 -D_GNU_SOURCE \
|
|
||||||
|
|
||||||
help:
|
help:
|
||||||
@echo "Usage:"
|
@echo "Para compilar el proyecto a tu sistema operativo"
|
||||||
|
@echo "porfavor usa uno de los siguientes comandos:"
|
||||||
@echo " $(MAKE) windows"
|
@echo " $(MAKE) windows"
|
||||||
@echo " $(MAKE) linux-x11"
|
@echo " $(MAKE) linux-x11"
|
||||||
@echo " $(MAKE) linux-wayland"
|
@echo " $(MAKE) linux-wayland"
|
||||||
@echo " $(MAKE) cocoa"
|
@echo " $(MAKE) cocoa"
|
||||||
@echo " $(MAKE) CC=emcc wasm"
|
@echo "Para limpiar los archivos compilados se puede usar"
|
||||||
@echo "Examples"
|
|
||||||
@echo " $(MAKE) examples"
|
|
||||||
@echo "Clean"
|
|
||||||
@echo " $(MAKE) clean"
|
@echo " $(MAKE) clean"
|
||||||
|
@echo "Para ejecturar el programa sin instalarlos se puede usar:"
|
||||||
|
@echo " $(MAKE) run-linux"
|
||||||
|
|
||||||
src/main.o: src/data/shaders.h
|
# WINDOWS
|
||||||
|
windows: $(OBJ) glfw.dll
|
||||||
windows: $(OBJ)
|
$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 -lglew32
|
||||||
#cd ext; $(MAKE) -f glfw.mk windows; cd -
|
|
||||||
$(CC) $(CFLAGS) $(OBJ) -o $(BIN) -L. -lglfw -lopengl32 -lgdi32
|
|
||||||
|
|
||||||
glfw.dll:
|
glfw.dll:
|
||||||
$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32
|
$(CC) -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@ -lgdi32
|
||||||
|
|
||||||
|
src/main.o: src/data/shaders.h src/data/cube.h src/data/axis.h
|
||||||
|
|
||||||
# LINUX
|
# LINUX
|
||||||
linux-wayland: $(OBJ)
|
|
||||||
cd ext; $(MAKE) -f glfw.mk linux-wayland; cd -
|
|
||||||
$(CC) -o $(BIN) $(OBJ) ext/libglfw.a -lm
|
|
||||||
|
|
||||||
linux-x11: $(OBJ)
|
linux-x11: $(OBJ)
|
||||||
cd ext; $(MAKE) -f glfw.mk linux-x11; cd -
|
$(MAKE) BKN=_GLFW_X11 libglfw.so
|
||||||
$(CC) -o $(BIN) $(OBJ) ext/libglfw.a -lm
|
$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm
|
||||||
|
|
||||||
|
linux-wayland: $(OBJ)
|
||||||
|
$(MAKE) BKN=_GLFW_WAYLAND libglfw.so
|
||||||
|
$(CC) -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw -lm
|
||||||
|
|
||||||
|
run-linux:
|
||||||
|
LD_LIBRARY_PATH=. ./$(BIN)
|
||||||
|
|
||||||
|
# COCOA
|
||||||
cocoa: $(OBJ)
|
cocoa: $(OBJ)
|
||||||
cd ext; $(MAKE) -f glfw.mk cocoa; cd -
|
$(MAKE) BKN=_GLFW_COCOA libglfw.so
|
||||||
$(CC) -framework OpenGL -o $(BIN) $(OBJ) ext/glfw.a -lGL -lglfw
|
$(CC) -framework OpenGL -o $(BIN) $(OBJ) -L. -lGLEW -lGL -lglfw
|
||||||
|
|
||||||
wasm: $(OBJ)
|
libglfw.so:
|
||||||
$(CC) -sUSE_WEBGL2=1 -sUSE_GLFW=3 -o $(BIN).html $(OBJ)
|
$(CC) -fPIC -shared -D$(BKN) -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o $@
|
||||||
chmod -x $(BIN).wasm
|
|
||||||
|
|
||||||
clean:
|
clean:
|
||||||
rm $(OBJ) $(BIN) $(EXAMPLES)
|
rm $(OBJ) $(BIN)
|
||||||
cd ext; $(MAKE) -f glfw.mk clean; cd -
|
|
||||||
|
|
||||||
|
|
||||||
examples: $(EXAMPLES)
|
|
||||||
|
|
||||||
.SUFFIXES: .c .o
|
.SUFFIXES: .c .o
|
||||||
|
|
||||||
.c.o:
|
.c.o:
|
||||||
$(CC) -Wno-implicit-function-declaration $(CFLAGS) -c -o $@ $<
|
$(CC) $(CFLAGS) -c -o $@ $<
|
||||||
|
|
||||||
.c:
|
|
||||||
$(CC) -I include -o $@ $< -lm
|
|
||||||
|
|||||||
110
README.md
110
README.md
@@ -1,62 +1,92 @@
|
|||||||
# Manigraph
|
# Manigraph: Graficadora de variedades
|
||||||
Manigraph is a cutting-edge tool for multidimentional surface visualization,
|
Diaz Camacho Pedro Emilio
|
||||||
capable of handling over a hundred dimensions. It allows users to interactively
|
|
||||||
explore each dimension in an intuitive and dynamic way.
|
|
||||||
Import your .klein files, which represents multidimentional surface.
|
|
||||||
|
|
||||||
# Building
|
# Resumen
|
||||||
Manigraph is written in C99, and uses OpenGL 2.0 for the rendering. So you just
|
manigraph es un graficador interactiva de variedades que lee archivos binarios, con la información de
|
||||||
need a C compiler to build this project.
|
una variedad multidimensional y grafica esta variedad en una proyección tridimensional.
|
||||||
|
|
||||||
## Source code
|
# Dependencias
|
||||||
|
Para poder compilar el proyecto hace falta lo siguiente.
|
||||||
|
## Programas
|
||||||
|
- `cc`: Cualquier compilador de C.
|
||||||
|
- `git`: Gestor de dependencias. (Opcional)
|
||||||
|
- `make`: Herramienta para compilar automáticamente. (Opcional)
|
||||||
|
|
||||||
|
## Librerías
|
||||||
|
- `openGL`: A cross-platform API for rendering 2D and 3D graphics. (no incluida)
|
||||||
|
- `glew`: The OpenGL Extension Wrangler Library (no incluida)
|
||||||
|
- `glfw`: A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input.
|
||||||
|
- `cglm`: Highly Optimized 2D / 3D Graphics Math (glm) for C.
|
||||||
|
### Linux
|
||||||
|
Para compilar `glfw` en linux hacen falta las siguientes librerías según el caso. (no incluidas)
|
||||||
|
- `x11`: libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel
|
||||||
|
- `wayland`: libwayland-dev libxkbcommon-dev wayland-protocols
|
||||||
|
|
||||||
|
# Descargas
|
||||||
|
- [git](https://git-scm.com/downloads/win)
|
||||||
|
- [MinGW](https://github.com/niXman/mingw-builds-binaries/releases)
|
||||||
|
- [glew](https://glew.sourceforge.net/)
|
||||||
|
|
||||||
|
# Clonar el código fuente
|
||||||
```
|
```
|
||||||
git clone https://gitea.axiolutions.top/software/manigraph.git
|
git clone https://gitea.adles.top/software/manigraph.git
|
||||||
cd manigraph
|
cd manigraph
|
||||||
git submodule update --init --recursive
|
git submodule update --init --recursive
|
||||||
```
|
```
|
||||||
|
|
||||||
## Dependecies
|
# Compilación
|
||||||
You may need system specific dependecies to build *Manigraph*.
|
Para compilar manualmente el proyecto se puede usar `make` o ejecutar los comandos manualmente
|
||||||
[Reference](https://www.glfw.org/docs/3.3/compile.html#compile_deps)
|
en el código fuente de `manigraph`.
|
||||||
|
|
||||||
### Linux
|
## Make
|
||||||
- `x11`: libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel
|
Los siguientes comandos sirven para compilar `manigraph` deacuerdo al sistema operativo.
|
||||||
- `wayland`: libwayland-dev libxkbcommon-dev wayland-protocols
|
|
||||||
|
|
||||||
## Commands
|
|
||||||
A C compiler is needed for building *Manigraph*. and any of those commands
|
|
||||||
|
|
||||||
```
|
```
|
||||||
make windows
|
make windows
|
||||||
./compile.bat
|
|
||||||
make linux-x11
|
make linux-x11
|
||||||
make linux-wayland
|
make linux-wayland
|
||||||
make cocoa
|
make cocoa
|
||||||
make CC=emcc wasm
|
|
||||||
```
|
```
|
||||||
|
|
||||||
# Flow of Manigraph
|
## Manualmente
|
||||||
|
se pueden compilar el proyecto manualmente sin necesidad del programa `make`.
|
||||||
|
|
||||||
# Design
|
### GLFW
|
||||||
Manigraph is a program designed with sustainability in mind. It is built to be
|
Si tienes problemas compilando `GLFW` puedes checar su página web oficial
|
||||||
portable, resource-efficient, and easy to maintain and scale. The program
|
explicando el tema: [Compiling GLFW](https://www.glfw.org/docs/3.3/compile.html).
|
||||||
follows a Data-Oriented Programming (DOP) paradigm, where each file is
|
|
||||||
responsible for a specific data type and manages its own dependencies. Each
|
|
||||||
function is named after the file it resides in, ensuring a clear organization
|
|
||||||
and structure.
|
|
||||||
|
|
||||||
The independence of data types allows for efficient scaling and maintenance.
|
#### Windows
|
||||||
The main file is a special case in this design: it is responsible for combining
|
```
|
||||||
all the data types in a comprehensive manner, actng as the workflow of the program.
|
cc -fPIC -shared -D_GLFW_WIN32 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o glfw.dll -lgdi32
|
||||||
|
```
|
||||||
|
|
||||||
# Contributing
|
#### Linux
|
||||||
Before commiting use `clang-format`, for coding style consistency. Your
|
```
|
||||||
contribution must be whitin the design principles and the concept of Manigraph.
|
cc -fPIC -shared -D_GLFW_X11 -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o libglfw.so
|
||||||
|
cc -fPIC -shared -D_GLFW_WAYLAND -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o libglfw.so
|
||||||
|
```
|
||||||
|
|
||||||
The following diagram illustrates the relationships between files, showing how
|
#### Mac
|
||||||
they are connected through dependencies. It also highlights the scenarios where
|
```
|
||||||
files are not independent of one another,
|
cc -fPIC -shared -D_GLFW_COCOA -D_GLFW_BUILD_DLL ./ext/glfw/src/*.c -o libglfw.so
|
||||||
|
```
|
||||||
|
|
||||||
|
### Manigraph
|
||||||
|
#### Windows
|
||||||
|
```
|
||||||
|
cc -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lopengl32 -lglew32
|
||||||
|
```
|
||||||
|
#### Linux
|
||||||
|
```
|
||||||
|
cc -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lGL -lGLEW
|
||||||
|
```
|
||||||
|
#### Mac
|
||||||
|
```
|
||||||
|
cc -framework GL -I ext/cglm/include/ -I ext/glfw/include/ src/*.c -o manigraph -L. -lglfw -lGLEW
|
||||||
|
```
|
||||||
|
|
||||||
|
# Ejecutar
|
||||||
|
En linux se puede ejecutar el programa sin instalar la libreria de glfw usando:
|
||||||
|
```
|
||||||
|
LD_LIBRARY_PATH=. ./manigraph
|
||||||
|
```
|
||||||
|
|||||||
@@ -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
|
|
||||||
80
doc/es/dev/estructura-archivos.md
Normal file
80
doc/es/dev/estructura-archivos.md
Normal file
@@ -0,0 +1,80 @@
|
|||||||
|
# Estructura de archivos
|
||||||
|
Díaz Camacho Pedro Emilio
|
||||||
|
|
||||||
|
# Headers
|
||||||
|
## main.h
|
||||||
|
Este archivo incluye los prototipos internos, que va a usar el programa
|
||||||
|
funge como api interna para los desarrolladores y debe estar bien documentada.
|
||||||
|
|
||||||
|
# codigo fuente
|
||||||
|
|
||||||
|
## main.c
|
||||||
|
Este archivo debe configurar el programa antes de iniciarse, avisar de los problemas
|
||||||
|
que eviten que el programa se ejecute correctamente, iniciar y terminar los objetos que use el
|
||||||
|
programa, así como ejecutar la función principal
|
||||||
|
### Depende de
|
||||||
|
- <GL/gl.h>
|
||||||
|
|
||||||
|
## context.c
|
||||||
|
En este archivo se escoge un color para limpiar la pantalla y tiene una función para limpiar
|
||||||
|
tanto lo dibujado en pantalla, como distintos buffers gráficos.
|
||||||
|
### Depende de
|
||||||
|
- <GL/gl.h>
|
||||||
|
|
||||||
|
## input.c
|
||||||
|
Incluye la función `poll_input`, que se ejecuta en cada ciclo del programa y devuelve un
|
||||||
|
cuaternion de tipo `float *` que representa la rotación total del cubo, después de interactuar
|
||||||
|
con el programa.
|
||||||
|
### Depende de
|
||||||
|
- <GLFW/glfw3.h>
|
||||||
|
- <cglm/quat.h>
|
||||||
|
|
||||||
|
## matrix.c
|
||||||
|
Incluye las funciónes para configurar y cargar en la GPU las 3 matrices principales.
|
||||||
|
- `fix_matrix` esta matriz no cambia y se usa para configurar la perspectiva y la vista que
|
||||||
|
va a usar el programa en todo momento.
|
||||||
|
- `mdl_matrix` esta matriz depende de cada mesh y describe la rotación única de cada objeto,
|
||||||
|
se usa para rotar los ejes ortogonamente con un indice.
|
||||||
|
- `rot_matrix` esta matriz describe la rotación total de todos los objetos y se configura con
|
||||||
|
un cuaternio
|
||||||
|
### Depende de
|
||||||
|
- <cglm/mat4.h>
|
||||||
|
- <cglm/cam.h>
|
||||||
|
- <cglm/quat.h>
|
||||||
|
|
||||||
|
## mesh.c
|
||||||
|
Este archivo se usa para crear, destruir y dibujar objetos de tipo `mesh`, un `mesh` es una
|
||||||
|
colección de triángulos que describen un objeto multidimensional.
|
||||||
|
### Depende de
|
||||||
|
- <GL/gl.h>
|
||||||
|
- <stdlib.h>
|
||||||
|
|
||||||
|
## shader.c
|
||||||
|
Debe crear, destruir y usar los shaders, estos shaders son programas para la gpu escritos en glsl para
|
||||||
|
además aquí se carga memoria en gpu con las funciónes `gload_`
|
||||||
|
### Depende de
|
||||||
|
- <GL/gl.h>
|
||||||
|
|
||||||
|
## texture.c
|
||||||
|
Debe cargar, usar y destruir las texturas, que va a usar la gpu, también crea una textura
|
||||||
|
para una paleta de colores definida, esto para manipular fácilmente los colores que usará el programa.
|
||||||
|
### Depende de
|
||||||
|
- <GL/gl.h>
|
||||||
|
|
||||||
|
## window.c
|
||||||
|
Crea, usa, limpie y cierra una ventana, una ventana tiene un contexto de OpenGL asociado para poder
|
||||||
|
dibujar objetos en ella, tiene una función especial para avisar si la ventana está abierta para
|
||||||
|
dibujar.
|
||||||
|
### Depende de
|
||||||
|
- <GLFW/glfw3.h>
|
||||||
|
|
||||||
|
# Datos
|
||||||
|
## data/cube.h
|
||||||
|
Aquí esta la información del mesh de un cubo, este se va a borrar cuando podamos
|
||||||
|
importar meshes para graficarlos.
|
||||||
|
|
||||||
|
## data/axis.h
|
||||||
|
Aquí está el mesh de un solo eje, este se va a rotar para hacer los otros 2 ejes.
|
||||||
|
|
||||||
|
## data/shaders.h
|
||||||
|
Aquí estan los shaders en glsl para dibujar en pantalla
|
||||||
43
doc/es/dev/tipos.md
Normal file
43
doc/es/dev/tipos.md
Normal file
@@ -0,0 +1,43 @@
|
|||||||
|
# Tipos de datos del proyecto
|
||||||
|
Díaz Camacho Pedro Emilio
|
||||||
|
|
||||||
|
# Introducción
|
||||||
|
En este archivo vamos a detallar los tipos de datos únicos del programa, estos
|
||||||
|
tipos de datos son estructuras que representan objetos computacionales y son
|
||||||
|
necesarios para integrar las distintas partes del programa.
|
||||||
|
|
||||||
|
## window_t
|
||||||
|
En `window.c` tenemos una estructura que es la ventana y esta se representa por `window_t`,
|
||||||
|
este tipo de dato es un pointer que es manejado por `glfw`.
|
||||||
|
|
||||||
|
## id_t
|
||||||
|
`id_t` es un tipo de dato que representa objetos de `OpenGL`, estos datos
|
||||||
|
normalmente vienen enumerados, y en `manigraph` se usan para representar `shaders`,
|
||||||
|
`programs` y `texture`.
|
||||||
|
|
||||||
|
## mesh_t
|
||||||
|
Este es un tipo de dato usado para interactuar con `mesh.c`, este representa la triangulación de un
|
||||||
|
objeto gráfico y funciona ocultando las variables que `OpenGL` necesita en un `void *`.
|
||||||
|
|
||||||
|
## mat4_t
|
||||||
|
`mat4_t` se usará para representar las matrices, se usará este tipo de dato exclusivamente
|
||||||
|
en `matrix.c` y funcionará con el tipo de dato `mat4` de `cglm`.
|
||||||
|
|
||||||
|
## quat_t
|
||||||
|
Este tipo de dato sirve para representar un quaternio, este quaternio representa la rotación
|
||||||
|
del objeto gráficado en la proyección tridimensional, y se usará para crear una matriz que
|
||||||
|
pueda entender `glsl`.
|
||||||
|
|
||||||
|
## narray
|
||||||
|
`narray` es un tipo de dato que funciona como un `array` enumerado, esto significa que el primer
|
||||||
|
elemento del `array` dice cuantos elementos tiene este, sin contar el primer elemento, y los demas elementos
|
||||||
|
funcionan como un `array` normal.
|
||||||
|
|
||||||
|
esta estructura nos ayuda a trabajar con arrays de tamaños arbitrario de forma óptima y sin tener que marcar el
|
||||||
|
último elemento de forma especial.
|
||||||
|
|
||||||
|
### narray_u8_t
|
||||||
|
es un `narray` para `char` y `unsigned char`.
|
||||||
|
### narray_float_t
|
||||||
|
es un `narray` para `float`.
|
||||||
|
|
||||||
59
doc/es/tech/diseno.md
Normal file
59
doc/es/tech/diseno.md
Normal file
@@ -0,0 +1,59 @@
|
|||||||
|
# Manual de Diseño
|
||||||
|
Diaz Camacho Pedro Emilio
|
||||||
|
|
||||||
|
# Objetivos
|
||||||
|
## Prioridad alta
|
||||||
|
- [ ] El programa debe actualizarse cuando interactuan con el.
|
||||||
|
- [ ] El usuario quiere:
|
||||||
|
- [X] Ver 3 ejes en todo momento.
|
||||||
|
- [ ] Ver que ejes esta viendo.
|
||||||
|
- [ ] Ver cuantos ejes hay.
|
||||||
|
- [X] El usuario quiere:
|
||||||
|
- [X] Rotar estos ejes,
|
||||||
|
- [X] Ver donde quedan los ejes despues de la rotados.
|
||||||
|
- [ ] El usuario experimentado quiere ejecutar el programa y pasar la variedad:
|
||||||
|
- [ ] Como argumento del programa.
|
||||||
|
- [ ] Desde la entrada estandar del programa.
|
||||||
|
|
||||||
|
## Prioridad media
|
||||||
|
|
||||||
|
- [ ] El usuario quiere:
|
||||||
|
- [ ] Cambiar los ejes que se ven por pares.
|
||||||
|
- [ ] Cambiar los ejes donde esta la informacion de los ejes.
|
||||||
|
- [ ] El usuario quiere interactuar con el programa:
|
||||||
|
- [ ] Usando solo el mouse.
|
||||||
|
- [ ] Usando solo el teclado.
|
||||||
|
|
||||||
|
## Prioridad baja
|
||||||
|
- [ ] El usuario quiere guardar las transformaciones como un archivo GIF.
|
||||||
|
|
||||||
|
# Camino
|
||||||
|
|
||||||
|
0. Graficadora de un cubo.
|
||||||
|
1. Se hace un programa que muestre un cubo.
|
||||||
|
1. Se muestran los 3 ejes del cubo
|
||||||
|
1. Se rota el cubo en sus 3 ejes usando el teclado.
|
||||||
|
1. Se rota el cubo en sus 3 ejes usando el mouse.
|
||||||
|
1. Se muestran la etiqueta de los ejes.
|
||||||
|
1. Se hace el formato de objetos multidimensionales.
|
||||||
|
0. Programa ejemplo
|
||||||
|
1. Se hace un programa que divida un cuadrado en triangulos.
|
||||||
|
1. Se mapea cada vertice del triangulo en un punto de la cinta de
|
||||||
|
mobius usando una parametrizacion
|
||||||
|
1. Se mapea cada vertice del triangulo en un punto de la botella de
|
||||||
|
klein usando una parametrizacion
|
||||||
|
1. Se divide cada lado de un cubo de n dimensiones, en triangulos.
|
||||||
|
|
||||||
|
0. Graficadora de variedades
|
||||||
|
1. Se generaliza el programa para usar este formato.
|
||||||
|
1. Se muestran la informacion de los ejes mostrados y cuantos hay.
|
||||||
|
1. Se pueden cambiar los ejes por pares
|
||||||
|
1. Usando el mouse.
|
||||||
|
1. Usando el teclado.
|
||||||
|
0. Detalles.
|
||||||
|
1. Se anima el cambio de eje.
|
||||||
|
1. Se hace el generador de GIF.
|
||||||
|
1. Se puede cambiar el shader
|
||||||
|
1. Documentacion
|
||||||
|
|
||||||
|
|
||||||
22
doc/es/tech/problemas.md
Normal file
22
doc/es/tech/problemas.md
Normal file
@@ -0,0 +1,22 @@
|
|||||||
|
# Problemas esperados al desarrollar
|
||||||
|
Diaz Camacho Pedro Emilio
|
||||||
|
|
||||||
|
## OpenGL esperan objetos tridimensionales, no de n dimensiones.
|
||||||
|
|
||||||
|
Usando glVertexAttribPointer podemos pasar las coordenadas que
|
||||||
|
queramos de los puntos de las variedades, y con ello usar objetos 3D en
|
||||||
|
el shader.
|
||||||
|
|
||||||
|
## Rotar ejes por pares en una animacion continua.
|
||||||
|
- Con glVertexAttribPointer podemos pasar las coordenadas del eje
|
||||||
|
seleccionado, al shader.
|
||||||
|
- Con la funcion mix del shader y bloqueando el input, podemos hacer
|
||||||
|
una animacion pasando una variable con la cpu.
|
||||||
|
- Cuando la animacion termine intercambiar los indices del layout,
|
||||||
|
usando glVertexAttribPointer otra vez.
|
||||||
|
|
||||||
|
## Volumen de la variedad.
|
||||||
|
Dado que la funcion parametrizadora es continua, mandamos la frontera
|
||||||
|
de un n-cubo a la frontera de una variedad, por lo que solo basta
|
||||||
|
graficar la frontera de la variedad.
|
||||||
|
|
||||||
19
doc/es/user.md
Normal file
19
doc/es/user.md
Normal file
@@ -0,0 +1,19 @@
|
|||||||
|
# Manual de usario para Manigraph
|
||||||
|
Manigraph es un graficador interactivo de variedades que lee archivos
|
||||||
|
binarios de una variedad multidimensional y los proyecta a 3 dimensiones.
|
||||||
|
|
||||||
|
# Glosario
|
||||||
|
Llamaremos a los 3 ejes de la proyección tridimensional `X`, `Y` y `Z`,
|
||||||
|
este sistema de coordenadas es derecho con el eje `Z` apuntando afuera de la pantalla
|
||||||
|
|
||||||
|
# Controles
|
||||||
|
## Teclado
|
||||||
|
- `Q` Rota el eje `X` de forma horaria.
|
||||||
|
- `W` Rota el eje `X` de forma antihoraria.
|
||||||
|
- `A` Rota el eje `Y` de forma horaria.
|
||||||
|
- `S` Rota el eje `Y` de forma antihoraria.
|
||||||
|
- `Z` Rota el eje `Z` de forma horaria.
|
||||||
|
- `X` Rota el eje `Z` de forma antihoraria.
|
||||||
|
## Mouse
|
||||||
|
- Hacer `click` en un eje lo selecciona.
|
||||||
|
- El `scroll` del mouse hace girar al eje seleccionado.
|
||||||
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 39 KiB |
10
doc/flow.svg
10
doc/flow.svg
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 107 KiB |
@@ -1,95 +0,0 @@
|
|||||||
#include <math.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#define KLEIN_IMPLEMENT
|
|
||||||
#include <klein/klein.h>
|
|
||||||
#include <klein/norm.h>
|
|
||||||
#include <klein/parm.h>
|
|
||||||
|
|
||||||
#ifndef M_PI
|
|
||||||
#define M_PI 3.14159265358979323846
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void cube(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < 4; i++)
|
|
||||||
d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
|
|
||||||
|
|
||||||
if (4 == 2)
|
|
||||||
d_surface[2] = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void mobius(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
const float width = 0.5;
|
|
||||||
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
|
||||||
float v = (2 * width) * ((float)coord[1] / grid[1]) - width;
|
|
||||||
|
|
||||||
d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
|
|
||||||
d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
|
|
||||||
d_surface[2] = v * sin(u / 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
void torus(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
float u = (M_PI) * ((float)coord[0] / grid[0]) + M_PI;
|
|
||||||
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
|
||||||
|
|
||||||
d_surface[0] = (1 + 0.5 * cos(v)) * cos(u);
|
|
||||||
d_surface[1] = (1 + 0.5 * cos(v)) * sin(u);
|
|
||||||
d_surface[2] = 0.5 * sin(v);
|
|
||||||
}
|
|
||||||
|
|
||||||
void klein(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
float u = (2 * M_PI) * ((float)coord[0] / grid[0]);
|
|
||||||
float v = (2 * M_PI) * ((float)coord[1] / grid[1]);
|
|
||||||
|
|
||||||
d_surface[0] = (0.5 * cos(v) + 0.5) * cos(u);
|
|
||||||
d_surface[1] = (0.5 * cos(v) + 0.5) * sin(u);
|
|
||||||
d_surface[2] = sin(v) * cos(u / 2);
|
|
||||||
d_surface[3] = sin(v) * sin(u / 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
unsigned char i = 0;
|
|
||||||
const char *file_name[] = {"mobius.klein", "torus.klein", "klein.klein"};
|
|
||||||
struct parm parametrization[] = {
|
|
||||||
{
|
|
||||||
.grid = (unsigned char[]){16, 4},
|
|
||||||
|
|
||||||
.m = 2,
|
|
||||||
.n = 3,
|
|
||||||
.f = mobius,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.grid = (unsigned char[]){16, 8},
|
|
||||||
.m = 2,
|
|
||||||
.n = 3,
|
|
||||||
.f = torus,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.grid = (unsigned char[]){16, 16},
|
|
||||||
.m = 2,
|
|
||||||
.n = 4,
|
|
||||||
.f = klein,
|
|
||||||
},
|
|
||||||
};
|
|
||||||
|
|
||||||
for (i = 0; i < 4; ++i)
|
|
||||||
{
|
|
||||||
struct klein klein;
|
|
||||||
printf("writing %s\n", file_name[i]);
|
|
||||||
|
|
||||||
klein_parametrize(&klein, parametrization[i]);
|
|
||||||
klein_normalize(&klein);
|
|
||||||
klein_export_file(klein, file_name[i]);
|
|
||||||
|
|
||||||
free(klein.vertex);
|
|
||||||
free(klein.normals);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,54 +0,0 @@
|
|||||||
#include <math.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#define KLEIN_IMPLEMENT
|
|
||||||
#include <klein/klein.h>
|
|
||||||
#include <klein/norm.h>
|
|
||||||
#include <klein/parm.h>
|
|
||||||
|
|
||||||
int p = 37;
|
|
||||||
int q = 7;
|
|
||||||
|
|
||||||
void lens(float *d_surface, int *coord, unsigned char * grid)
|
|
||||||
{
|
|
||||||
|
|
||||||
float norm = 0;
|
|
||||||
float sphere[4];
|
|
||||||
|
|
||||||
for (int i = 0; i < 4; i++)
|
|
||||||
sphere[i] = ((float)coord[i] / grid[i]) - 0.5;
|
|
||||||
|
|
||||||
for(int i = 0; i < 4; i++)
|
|
||||||
norm += sphere[i] * sphere[i];
|
|
||||||
|
|
||||||
for (int i = 0; i < 4; i++)
|
|
||||||
sphere[i] = sphere[i] / sqrt(norm);
|
|
||||||
|
|
||||||
d_surface[0] = (sphere[0] * cos(2 * M_PI / p)) - (sphere[1] * sin(2 * M_PI / p));
|
|
||||||
d_surface[1] = (sphere[0] * sin(2 * M_PI / p)) + (sphere[1] * cos(2 * M_PI / p));
|
|
||||||
d_surface[2] = (sphere[2] * cos(2 * M_PI * q / p)) - (sphere[3] * sin(2 * M_PI * q / p));
|
|
||||||
d_surface[3] = (sphere[2] * sin(2 * M_PI * q / p)) + (sphere[3] * cos(2 * M_PI * q / p));
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
char file_name[0xff];
|
|
||||||
struct klein klein;
|
|
||||||
struct parm parametrization = {
|
|
||||||
.grid = (unsigned char[]){8, 8,8,8},
|
|
||||||
.m = 4,
|
|
||||||
.n = 4,
|
|
||||||
.f = lens,
|
|
||||||
};
|
|
||||||
|
|
||||||
snprintf(file_name, 0xff, "lens-%03d-%03d.klein", p, q);
|
|
||||||
printf("writing %s\n", file_name);
|
|
||||||
|
|
||||||
klein_parametrize(&klein, parametrization);
|
|
||||||
klein_normalize(&klein);
|
|
||||||
klein_export_file(klein, file_name);
|
|
||||||
|
|
||||||
free(klein.vertex);
|
|
||||||
free(klein.normals);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,50 +0,0 @@
|
|||||||
#include <math.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#define KLEIN_IMPLEMENT
|
|
||||||
#include <klein/klein.h>
|
|
||||||
#include <klein/norm.h>
|
|
||||||
#include <klein/parm.h>
|
|
||||||
|
|
||||||
#ifndef M_PI
|
|
||||||
#define M_PI 3.14159265358979323846
|
|
||||||
#endif
|
|
||||||
|
|
||||||
unsigned char dim = 17;
|
|
||||||
|
|
||||||
void cube(float *d_surface, int *coord, unsigned char *grid)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < dim; i++)
|
|
||||||
d_surface[i] = (2 * (float)coord[i] / grid[i]) - 1;
|
|
||||||
|
|
||||||
if (dim == 2)
|
|
||||||
d_surface[2] = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
unsigned char i;
|
|
||||||
char file_name[0xff];
|
|
||||||
struct klein klein;
|
|
||||||
struct parm parametrization = {
|
|
||||||
.m = dim,
|
|
||||||
.n = dim,
|
|
||||||
.f = cube,
|
|
||||||
};
|
|
||||||
|
|
||||||
parametrization.grid = malloc(dim);
|
|
||||||
|
|
||||||
for (i = 0; i < dim; ++i)
|
|
||||||
parametrization.grid[i] = 1 + i;
|
|
||||||
|
|
||||||
snprintf(file_name, 0xff, "cube-%03d.klein", dim);
|
|
||||||
printf("writing %s\n", file_name);
|
|
||||||
|
|
||||||
klein_parametrize(&klein, parametrization);
|
|
||||||
klein_normalize(&klein);
|
|
||||||
klein_export_file(klein, file_name);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,50 +0,0 @@
|
|||||||
#include <complex.h>
|
|
||||||
#include <math.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#define KLEIN_IMPLEMENT
|
|
||||||
#include <klein/klein.h>
|
|
||||||
#include <klein/norm.h>
|
|
||||||
#include <klein/parm.h>
|
|
||||||
|
|
||||||
#ifndef CMPLX
|
|
||||||
#define CMPLX(a, b) (a + I * b)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
complex float f(complex float z) { return csqrt(z); }
|
|
||||||
|
|
||||||
void riemman(float *d_surface, int *coords, unsigned char *grid)
|
|
||||||
{
|
|
||||||
complex float eq;
|
|
||||||
float u = 2 * ((float)coords[0] / grid[0]) - 1;
|
|
||||||
float v = 2 * ((float)coords[1] / grid[1]) - 1;
|
|
||||||
|
|
||||||
eq = f(CMPLX(u, v));
|
|
||||||
|
|
||||||
d_surface[0] = u;
|
|
||||||
d_surface[1] = v;
|
|
||||||
d_surface[2] = creal(eq);
|
|
||||||
d_surface[3] = cimag(eq);
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
const char *file_name = "riemman.klein";
|
|
||||||
struct klein klein;
|
|
||||||
struct parm parametrization = {
|
|
||||||
.grid = (unsigned char[]){16, 4},
|
|
||||||
.m = 2,
|
|
||||||
.n = 4,
|
|
||||||
.f = riemman,
|
|
||||||
};
|
|
||||||
|
|
||||||
printf("writing %s\n", file_name);
|
|
||||||
|
|
||||||
klein_parametrize(&klein, parametrization);
|
|
||||||
klein_normalize(&klein);
|
|
||||||
klein_export_file(klein, file_name);
|
|
||||||
|
|
||||||
free(klein.vertex);
|
|
||||||
free(klein.normals);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
1641
ext/glad/glad.c
1641
ext/glad/glad.c
File diff suppressed because it is too large
Load Diff
3191
ext/glad/glad.h
3191
ext/glad/glad.h
File diff suppressed because it is too large
Load Diff
@@ -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_ */
|
|
||||||
71
ext/glfw.mk
71
ext/glfw.mk
@@ -1,71 +0,0 @@
|
|||||||
BIN = libglfw.a
|
|
||||||
OBJ = \
|
|
||||||
glfw/src/context.o \
|
|
||||||
glfw/src/egl_context.o \
|
|
||||||
glfw/src/glx_context.o \
|
|
||||||
glfw/src/init.o \
|
|
||||||
glfw/src/input.o \
|
|
||||||
glfw/src/linux_joystick.o \
|
|
||||||
glfw/src/monitor.o \
|
|
||||||
glfw/src/null_init.o \
|
|
||||||
glfw/src/null_joystick.o \
|
|
||||||
glfw/src/null_monitor.o \
|
|
||||||
glfw/src/null_window.o \
|
|
||||||
glfw/src/osmesa_context.o \
|
|
||||||
glfw/src/platform.o \
|
|
||||||
glfw/src/posix_module.o \
|
|
||||||
glfw/src/posix_poll.o \
|
|
||||||
glfw/src/posix_thread.o \
|
|
||||||
glfw/src/posix_time.o \
|
|
||||||
glfw/src/vulkan.o \
|
|
||||||
glfw/src/wgl_context.o \
|
|
||||||
glfw/src/win32_init.o \
|
|
||||||
glfw/src/win32_joystick.o \
|
|
||||||
glfw/src/win32_module.o \
|
|
||||||
glfw/src/win32_monitor.o \
|
|
||||||
glfw/src/win32_thread.o \
|
|
||||||
glfw/src/win32_time.o \
|
|
||||||
glfw/src/win32_window.o \
|
|
||||||
glfw/src/window.o \
|
|
||||||
glfw/src/wl_init.o \
|
|
||||||
glfw/src/wl_monitor.o \
|
|
||||||
glfw/src/wl_window.o \
|
|
||||||
glfw/src/x11_init.o \
|
|
||||||
glfw/src/x11_monitor.o \
|
|
||||||
glfw/src/x11_window.o \
|
|
||||||
glfw/src/xkb_unicode.o
|
|
||||||
|
|
||||||
WAYLAND-LIB = \
|
|
||||||
xdg-shell \
|
|
||||||
relative-pointer-unstable-v1 \
|
|
||||||
xdg-decoration-unstable-v1 \
|
|
||||||
pointer-constraints-unstable-v1 \
|
|
||||||
viewporter \
|
|
||||||
idle-inhibit-unstable-v1 \
|
|
||||||
fractional-scale-v1 \
|
|
||||||
xdg-activation-v1 \
|
|
||||||
wayland
|
|
||||||
|
|
||||||
windows:
|
|
||||||
$(MAKE) $(OBJ) CFLAGS="-D_GLFW_WIN32 -Iglfw/deps/wayland"
|
|
||||||
$(AR) rsc $(BIN) $(OBJ)
|
|
||||||
|
|
||||||
linux-x11:
|
|
||||||
$(MAKE) $(OBJ) CFLAGS="-D_GLFW_X11 -Iglfw/deps/wayland"
|
|
||||||
$(AR) rsc $(BIN) $(OBJ)
|
|
||||||
|
|
||||||
|
|
||||||
linux-wayland:
|
|
||||||
for i in $(WAYLAND-LIB); \
|
|
||||||
do \
|
|
||||||
wayland-scanner client-header glfw/deps/wayland/$$i.xml glfw/deps/wayland/$$i-client-protocol.h; \
|
|
||||||
wayland-scanner private-code glfw/deps/wayland/$$i.xml glfw/deps/wayland/$$i-client-protocol-code.h; \
|
|
||||||
done
|
|
||||||
$(MAKE) $(OBJ) CFLAGS="-D_GLFW_WAYLAND -fPIC -Iglfw/deps/wayland"
|
|
||||||
$(AR) rsc $(BIN) $(OBJ)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
clean:
|
|
||||||
rm $(OBJ) $(BIN)
|
|
||||||
rm glfw/deps/wayland/*.h
|
|
||||||
Submodule ext/nuklear deleted from 6566d9075d
@@ -1,50 +0,0 @@
|
|||||||
#ifdef KLEIN_H
|
|
||||||
#error file included twice
|
|
||||||
#endif
|
|
||||||
#define KLEIN_H
|
|
||||||
|
|
||||||
#include <stdint.h>
|
|
||||||
|
|
||||||
#ifdef KLEIN_IMPLEMENT
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct klein
|
|
||||||
{
|
|
||||||
float *vertex, *normals;
|
|
||||||
uint64_t vertex_size;
|
|
||||||
uint8_t dim;
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
The klein format must have:
|
|
||||||
5 bytes with klein.
|
|
||||||
1 byte empty for expantions
|
|
||||||
1 byte with the dimention of the surface
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
static inline
|
|
||||||
int klein_export_file(struct klein klein, const char * filename);
|
|
||||||
|
|
||||||
|
|
||||||
#ifdef KLEIN_IMPLEMENT
|
|
||||||
static inline
|
|
||||||
int klein_export_file(struct klein klein, const char * filename)
|
|
||||||
{
|
|
||||||
FILE *file = fopen(filename, "wb");
|
|
||||||
if (!file)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
fwrite("KLEIN", 1, 5, file);
|
|
||||||
fwrite("\0", 1, 1, file);
|
|
||||||
fwrite(&klein.dim, 1, 1, file);
|
|
||||||
fwrite(&klein.vertex_size, 8, 1, file);
|
|
||||||
fwrite(klein.vertex, 4, klein.vertex_size * klein.dim, file);
|
|
||||||
fwrite(klein.normals, 4, klein.vertex_size * klein.dim, file);
|
|
||||||
|
|
||||||
fclose(file);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,132 +0,0 @@
|
|||||||
#ifdef KLEIN_NORM_H
|
|
||||||
#error file included twice
|
|
||||||
#endif
|
|
||||||
#define KLEIN_NORM_H
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef KLEIN_H
|
|
||||||
#warning Please include klein/klein.h
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void klein_normalize(struct klein * klein);
|
|
||||||
|
|
||||||
#ifdef KLEIN_IMPLEMENT
|
|
||||||
static inline
|
|
||||||
void __calculate_normal( float *p1, float *p2, float *p3, float *normal, unsigned char n)
|
|
||||||
{ unsigned char i;
|
|
||||||
float alpha;
|
|
||||||
float *v1, *v2, *v3;
|
|
||||||
float *u1, *u2, *u3;
|
|
||||||
|
|
||||||
v1 = malloc(n * sizeof(float));
|
|
||||||
v2 = malloc(n * sizeof(float));
|
|
||||||
v3 = malloc(n * sizeof(float));
|
|
||||||
u1 = malloc(n * sizeof(float));
|
|
||||||
u2 = malloc(n * sizeof(float));
|
|
||||||
u3 = malloc(n * sizeof(float));
|
|
||||||
|
|
||||||
/*
|
|
||||||
Calculate a normal vector of a plain using Gram-Schmidt process
|
|
||||||
*/
|
|
||||||
{
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
v1[i] = p2[i] - p1[i];
|
|
||||||
v2[i] = p3[i] - p1[i];
|
|
||||||
v3[i] = p1[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
u1[i] = v1[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
float proj[n];
|
|
||||||
float dot_v2_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v2_u1 += v2[i] * u1[i];
|
|
||||||
dot_u1_u1 += u1[i] * u1[i];
|
|
||||||
}
|
|
||||||
alpha = dot_v2_u1 / dot_u1_u1;
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj[i] = u1[i] * alpha;
|
|
||||||
u2[i] = v2[i] - proj[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
float proj1[n], proj2[n];
|
|
||||||
float dot_v3_u1 = 0.0f, dot_u1_u1 = 0.0f;
|
|
||||||
float dot_v3_u2 = 0.0f, dot_u2_u2 = 0.0f;
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v3_u1 += v3[i] * u1[i];
|
|
||||||
dot_u1_u1 += u1[i] * u1[i];
|
|
||||||
}
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj1[i] = u1[i] * (dot_v3_u1 / dot_u1_u1);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
dot_v3_u2 += v3[i] * u2[i];
|
|
||||||
dot_u2_u2 += u2[i] * u2[i];
|
|
||||||
}
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
proj2[i] = u2[i] * (dot_v3_u2 / dot_u2_u2);
|
|
||||||
u3[i] = v3[i] - proj1[i] - proj2[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
float magnitude = 0.0f;
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
magnitude += u3[i] * u3[i];
|
|
||||||
}
|
|
||||||
magnitude = sqrtf(magnitude);
|
|
||||||
|
|
||||||
for (i = 0; i < n; ++i)
|
|
||||||
{
|
|
||||||
normal[i] = u3[i] / magnitude;
|
|
||||||
}
|
|
||||||
|
|
||||||
free(v1);
|
|
||||||
free(v2);
|
|
||||||
free(v3);
|
|
||||||
free(u1);
|
|
||||||
free(u2);
|
|
||||||
free(u3);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void klein_normalize(struct klein * klein)
|
|
||||||
{
|
|
||||||
unsigned long i;
|
|
||||||
unsigned char j;
|
|
||||||
float *norm_vec;
|
|
||||||
|
|
||||||
klein->normals = malloc((klein->dim * klein->vertex_size) * sizeof(float));
|
|
||||||
norm_vec = malloc(klein->dim * sizeof(float));
|
|
||||||
|
|
||||||
for (i = 0; i < klein->vertex_size; i += 3 * klein->dim)
|
|
||||||
{
|
|
||||||
__calculate_normal(klein->vertex + i, klein->vertex + i + klein->dim, klein->vertex + i + 2 * klein->dim, norm_vec, klein->dim);
|
|
||||||
for (j = 0; j < klein->dim; ++j )
|
|
||||||
{
|
|
||||||
(klein->normals + i)[j]=norm_vec[j];
|
|
||||||
(klein->normals + i + klein->dim)[j]=norm_vec[j];
|
|
||||||
(klein->normals + i + 2*klein->dim)[j]=norm_vec[j];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
free(norm_vec);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,136 +0,0 @@
|
|||||||
#ifndef KLEIN_H
|
|
||||||
#warning Please include klein/klein.h before klein/parm.h
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef KLEIN_PARM_H
|
|
||||||
#error file included twice
|
|
||||||
#endif
|
|
||||||
#define KLEIN_PARM_H
|
|
||||||
|
|
||||||
|
|
||||||
typedef void (*function_t)(float *, int *, unsigned char *);
|
|
||||||
|
|
||||||
struct parm
|
|
||||||
{
|
|
||||||
unsigned char *grid;
|
|
||||||
unsigned char m, n;
|
|
||||||
function_t f;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
void klein_parametrize( struct klein * klein, struct parm parm );
|
|
||||||
|
|
||||||
#ifdef KLEIN_IMPLEMENT
|
|
||||||
#ifdef TEST
|
|
||||||
#include <assert.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static inline uint64_t __factorial(uint64_t n)
|
|
||||||
{
|
|
||||||
if (n == 1)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
return n * __factorial(n - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline uint64_t __face(int n)
|
|
||||||
{
|
|
||||||
if (n == 2)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
return (1 << (n - 3)) * __factorial(n) / __factorial(n - 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
void klein_parametrize( struct klein * klein, struct parm parm)
|
|
||||||
{
|
|
||||||
unsigned long i, j, o, p, n;
|
|
||||||
uint64_t k, size, q = 0;
|
|
||||||
int *face;
|
|
||||||
|
|
||||||
#ifdef TEST
|
|
||||||
assert(__face(2) == 1);
|
|
||||||
assert(__face(3) == 6);
|
|
||||||
assert(__face(4) == 24);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
klein->dim = parm.n;
|
|
||||||
klein->vertex_size = 0;
|
|
||||||
{
|
|
||||||
uint64_t test = 0;
|
|
||||||
|
|
||||||
for (o = 0; o < parm.m; o++)
|
|
||||||
for (p = 0; p < o; p++)
|
|
||||||
test += 1;
|
|
||||||
|
|
||||||
|
|
||||||
for (o = 0; o < parm.m; o++)
|
|
||||||
for (p = 0; p < o; p++)
|
|
||||||
klein->vertex_size += (uint64_t)parm.grid[p] * parm.grid[o] * 6 * __face(parm.m)/test;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
size = klein->vertex_size*klein->dim;
|
|
||||||
|
|
||||||
klein->vertex = malloc(size * sizeof(float));
|
|
||||||
face = malloc(parm.m * sizeof(int));
|
|
||||||
|
|
||||||
|
|
||||||
for (o = 0; o < parm.m; o++)
|
|
||||||
{
|
|
||||||
for (p = 0; p < o; p++)
|
|
||||||
{
|
|
||||||
for (k = 0; k < ((uint64_t)1 << (parm.m - 2)); k++)
|
|
||||||
{
|
|
||||||
unsigned char skip = 0;
|
|
||||||
for (n = 0; n < parm.m; n++)
|
|
||||||
{
|
|
||||||
if (n == o || n == p)
|
|
||||||
skip++;
|
|
||||||
|
|
||||||
face[n] = (k & ((uint64_t)1 << (n - skip))) ? parm.grid[n] : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < parm.grid[p]; i++)
|
|
||||||
{
|
|
||||||
for (j = 0; j < parm.grid[o]; j++)
|
|
||||||
{
|
|
||||||
face[p] = i;
|
|
||||||
face[o] = j;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
|
|
||||||
face[p] = i + 1;
|
|
||||||
face[o] = j;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
|
|
||||||
face[p] = i + 1;
|
|
||||||
face[o] = j + 1;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
|
|
||||||
face[p] = i;
|
|
||||||
face[o] = j;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
|
|
||||||
face[p] = i;
|
|
||||||
face[o] = j + 1;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
|
|
||||||
face[p] = i + 1;
|
|
||||||
face[o] = j + 1;
|
|
||||||
parm.f(&klein->vertex[q], face, parm.grid);
|
|
||||||
q += parm.n;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef TEST
|
|
||||||
assert(q == size);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,11 +1,5 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
|
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
#include <GL/gl.h>
|
#include <GL/gl.h>
|
||||||
#else
|
|
||||||
#include <glad.h>
|
|
||||||
#include <GLFW/glfw3.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void set_clean_color_context( unsigned char r, unsigned char g, unsigned char b )
|
void set_clean_color_context( unsigned char r, unsigned char g, unsigned char b )
|
||||||
{
|
{
|
||||||
@@ -13,13 +7,7 @@ void set_clean_color_context(unsigned char r, unsigned char g, unsigned char b)
|
|||||||
glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
|
glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
|
||||||
}
|
}
|
||||||
|
|
||||||
int init_context(void)
|
void clean_context( void )
|
||||||
{
|
{
|
||||||
#ifdef EMSCRIPTEN
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
|
||||||
return 1;
|
|
||||||
#else
|
|
||||||
return gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void clean_context(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }
|
|
||||||
|
|||||||
45
src/data/axis.h
Normal file
45
src/data/axis.h
Normal file
@@ -0,0 +1,45 @@
|
|||||||
|
#undef A
|
||||||
|
#undef B
|
||||||
|
#undef C
|
||||||
|
#undef D
|
||||||
|
#undef E
|
||||||
|
#undef F
|
||||||
|
#undef G
|
||||||
|
#undef H
|
||||||
|
|
||||||
|
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
|
||||||
|
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
|
||||||
|
|
||||||
|
};
|
||||||
32
src/data/cube.h
Normal file
32
src/data/cube.h
Normal file
@@ -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
|
||||||
|
|
||||||
|
};
|
||||||
@@ -1,98 +1,30 @@
|
|||||||
const char * vs =
|
const char * vs =
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
"#version 300 es\n"
|
|
||||||
"precision highp float;"
|
|
||||||
#else
|
|
||||||
"#version 330 core\n"
|
"#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 = 0) in vec3 aPos;"
|
||||||
"layout (location = 5) in float aNormal_y;"
|
|
||||||
"layout (location = 6) in float aNormal_z;"
|
|
||||||
"layout (location = 7) in float aNormal_w;"
|
|
||||||
|
|
||||||
"uniform float angle;"
|
|
||||||
"uniform float i;"
|
|
||||||
"uniform vec4 color;"
|
|
||||||
|
|
||||||
|
"uniform float idx;"
|
||||||
"uniform mat4 fix;"
|
"uniform mat4 fix;"
|
||||||
"uniform mat4 rot;"
|
"uniform mat4 rot;"
|
||||||
|
"uniform mat4 mdl;"
|
||||||
|
|
||||||
"out vec3 Normal;"
|
"out float index;"
|
||||||
"out vec3 FragPos;"
|
|
||||||
"out vec4 Color;"
|
|
||||||
|
|
||||||
"mat2 rotate2d( float angle )"
|
|
||||||
"{"
|
|
||||||
"return mat2( cos(angle), sin(angle), -sin(angle), cos(angle) );"
|
|
||||||
"}"
|
|
||||||
|
|
||||||
"void main()"
|
"void main()"
|
||||||
"{"
|
"{"
|
||||||
" Color=color;"
|
" index=idx;"
|
||||||
|
" gl_Position = fix * rot * mdl * vec4( aPos, 1.0 );\n"
|
||||||
" vec3 aNormal = vec3(aNormal_x,aNormal_y,aNormal_z);"
|
|
||||||
" vec3 aPos = vec3(aPos_x,aPos_y,aPos_z);"
|
|
||||||
|
|
||||||
" aNormal[int(i)] = (vec2(aNormal[int(i)], aNormal_w) * "
|
|
||||||
"rotate2d(angle))[0];"
|
|
||||||
" aPos[int(i)] = (vec2(aPos[int(i)], aPos_w) * rotate2d(angle))[0];"
|
|
||||||
|
|
||||||
" Normal = mat3(transpose(inverse(rot))) * aNormal;"
|
|
||||||
" gl_Position = fix * rot * vec4( aPos, 1.0 );\n"
|
|
||||||
" FragPos = vec3( rot * vec4(aPos, 1.0));"
|
|
||||||
"}";
|
|
||||||
|
|
||||||
const char *fs_plain =
|
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
"#version 300 es\n"
|
|
||||||
"precision highp float;"
|
|
||||||
#else
|
|
||||||
"#version 330 core\n"
|
|
||||||
#endif
|
|
||||||
"out vec4 FragColor;"
|
|
||||||
"in vec3 Normal;"
|
|
||||||
"in vec3 FragPos;"
|
|
||||||
"in vec4 Color;"
|
|
||||||
|
|
||||||
"void main()"
|
|
||||||
"{"
|
|
||||||
" FragColor = vec4(pow(vec3(Color),vec3(1.0/1.0)),Color.a);"
|
|
||||||
"}";
|
"}";
|
||||||
|
|
||||||
const char * fs =
|
const char * fs =
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
"#version 300 es\n"
|
|
||||||
"precision highp float;"
|
|
||||||
#else
|
|
||||||
"#version 330 core\n"
|
"#version 330 core\n"
|
||||||
#endif
|
|
||||||
|
|
||||||
"in vec3 Normal;"
|
"uniform sampler2DArray palette;"
|
||||||
"in vec3 FragPos;"
|
|
||||||
"in vec4 Color;"
|
|
||||||
|
|
||||||
|
"in float index;"
|
||||||
"out vec4 FragColor;"
|
"out vec4 FragColor;"
|
||||||
|
|
||||||
"void main()"
|
"void main()"
|
||||||
"{"
|
"{"
|
||||||
|
" FragColor = texture( palette, vec3( 0, 0, index ) ).rgba;"
|
||||||
" 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(abs(dot(normalize(Normal), halfwayDir)), 32.0);\n"
|
|
||||||
" float diffuse = abs(dot(normalize(Normal), lightDir));\n"
|
|
||||||
|
|
||||||
" vec3 result = pow((0.5 + 0.5*diffuse + 1*specular) * Color.rgb, "
|
|
||||||
"vec3(1.0/2.2));\n"
|
|
||||||
" FragColor = vec4(result, Color.a);\n"
|
|
||||||
"}";
|
"}";
|
||||||
|
|||||||
213
src/input.c
213
src/input.c
@@ -1,8 +1,6 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
#include <glad.h>
|
|
||||||
#include <GLFW/glfw3.h>
|
|
||||||
#include <cglm/quat.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)
|
||||||
|
|
||||||
@@ -10,93 +8,16 @@ unsigned char selected_axis = 0;
|
|||||||
int window_width;
|
int window_width;
|
||||||
int window_height;
|
int window_height;
|
||||||
|
|
||||||
static versor q = GLM_QUAT_IDENTITY_INIT;
|
versor q = GLM_QUAT_IDENTITY_INIT;
|
||||||
unsigned char animate_index = 0;
|
|
||||||
|
|
||||||
|
vec3 axis[3] =
|
||||||
vec3 axis[3] = {
|
{
|
||||||
{1, 0, 0},
|
{1, 0, 0},
|
||||||
{0, 1, 0},
|
{0, 1, 0},
|
||||||
{0, 0, 1},
|
{0, 0, 1},
|
||||||
};
|
};
|
||||||
|
|
||||||
extern struct projection projection;
|
void __window_callback(GLFWwindow * window, int w, int h)
|
||||||
|
|
||||||
static inline
|
|
||||||
void __input_update_q(versor p)
|
|
||||||
{
|
|
||||||
glm_quat_mul(p, q, q);
|
|
||||||
glm_quat_rotatev(p, axis[0], axis[0]);
|
|
||||||
glm_quat_rotatev(p, axis[1], axis[1]);
|
|
||||||
glm_quat_rotatev(p, axis[2], axis[2]);
|
|
||||||
glm_quat_normalize(q);
|
|
||||||
}
|
|
||||||
|
|
||||||
void __error_callback_input(int x, const char * msg )
|
|
||||||
{
|
|
||||||
mlog("[GLFW] ");
|
|
||||||
mlog(msg);
|
|
||||||
mlog("\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
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;
|
|
||||||
|
|
||||||
projection.w = selected_coord;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (projection.w >= projection.m)
|
|
||||||
return;
|
|
||||||
|
|
||||||
switch (key)
|
|
||||||
{
|
|
||||||
unsigned char tmp;
|
|
||||||
case GLFW_KEY_Z:
|
|
||||||
tmp = projection.w;
|
|
||||||
projection.w = projection.x;
|
|
||||||
projection.x = tmp;
|
|
||||||
|
|
||||||
animate_index = 1;
|
|
||||||
break;
|
|
||||||
case GLFW_KEY_X:
|
|
||||||
tmp = projection.w;
|
|
||||||
projection.w = projection.y;
|
|
||||||
projection.y = tmp;
|
|
||||||
animate_index = 2;
|
|
||||||
break;
|
|
||||||
case GLFW_KEY_C:
|
|
||||||
tmp = projection.w;
|
|
||||||
projection.w = projection.z;
|
|
||||||
projection.z = tmp;
|
|
||||||
animate_index = 3;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
printf("[AXIS] (X,Y,Z,W) = (%d,%d,%d,%d)\n", projection.x, projection.y, projection.z, projection.w);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
void __window_callback_input(GLFWwindow *window, int w, int h)
|
|
||||||
{
|
{
|
||||||
int m;
|
int m;
|
||||||
|
|
||||||
@@ -107,138 +28,80 @@ void __window_callback_input(GLFWwindow *window, int w, int h)
|
|||||||
glViewport((w - m) / 2, (h - m) / 2, m, m);
|
glViewport((w - m) / 2, (h - m) / 2, m, m);
|
||||||
}
|
}
|
||||||
|
|
||||||
static double xpos_s, ypos_s;
|
void __mouse_callback(GLFWwindow* window, int button, int action, int mods)
|
||||||
static char lbutton_down = 0;
|
|
||||||
|
|
||||||
void __mouse_callback_input(GLFWwindow* window, int button, int action, int mods)
|
|
||||||
{
|
{
|
||||||
if( button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
|
unsigned char green_value;
|
||||||
lbutton_down = 1;
|
double xpos, ypos;
|
||||||
|
|
||||||
if( button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE)
|
if( button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS )
|
||||||
|
return;
|
||||||
|
|
||||||
|
glfwGetCursorPos(window, &xpos, &ypos);
|
||||||
|
glReadPixels((int)xpos, (int)(window_height - ypos), 1, 1, GL_GREEN, GL_UNSIGNED_BYTE, &green_value);
|
||||||
|
|
||||||
|
|
||||||
|
switch(green_value)
|
||||||
{
|
{
|
||||||
glfwGetCursorPos(window, &xpos_s, &ypos_s);
|
case 0xD3:
|
||||||
lbutton_down = 0;
|
case 0xD4:
|
||||||
|
case 0xD5:
|
||||||
|
selected_axis = green_value-0xD3;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
void __scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
|
||||||
|
|
||||||
void __cursor_callback_input(
|
|
||||||
GLFWwindow *window, double xpos, double ypos)
|
|
||||||
{
|
|
||||||
if( lbutton_down )
|
|
||||||
{
|
{
|
||||||
versor p = GLM_QUAT_IDENTITY_INIT;
|
versor p = GLM_QUAT_IDENTITY_INIT;
|
||||||
glm_quatv(p, ANGLE, (vec3){-1*(ypos-ypos_s),(xpos-xpos_s),0});
|
|
||||||
__input_update_q(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
glm_quatv(p, yoffset*ANGLE, axis[selected_axis]);
|
||||||
|
|
||||||
void __scroll_callback_input(GLFWwindow *window, double xoffset, double yoffset)
|
|
||||||
{
|
|
||||||
versor p = GLM_QUAT_IDENTITY_INIT;
|
|
||||||
versor r = GLM_QUAT_IDENTITY_INIT;
|
|
||||||
|
|
||||||
// glm_quatv(p, yoffset * ANGLE, axis[selected_axis]);
|
|
||||||
glm_quatv(p, yoffset * ANGLE * 2, (vec3){-1, 0, 0});
|
|
||||||
glm_quatv(r, xoffset * ANGLE * 2, (vec3){0, 1, 0});
|
|
||||||
glm_quat_mul(p, q, q);
|
glm_quat_mul(p, q, q);
|
||||||
glm_quat_mul(r, q, q);
|
|
||||||
|
|
||||||
glm_quat_rotatev(p, axis[0], axis[0]);
|
glm_quat_rotatev(p, axis[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_rotatev(r, axis[0], axis[0]);
|
|
||||||
glm_quat_rotatev(r, axis[1], axis[1]);
|
|
||||||
glm_quat_rotatev(r, axis[2], axis[2]);
|
|
||||||
}
|
|
||||||
|
|
||||||
void __drop_callback_input(GLFWwindow *window, int count, char **path)
|
|
||||||
{
|
|
||||||
struct surface surface;
|
|
||||||
|
|
||||||
if (create_surface_klein(*path, &surface))
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (!(projection.mesh = create_mesh(surface)))
|
|
||||||
return;
|
|
||||||
|
|
||||||
projection.m = surface.dim;
|
|
||||||
set_projection_mesh(projection);
|
|
||||||
|
|
||||||
free(surface.norm);
|
|
||||||
free(surface.data);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
quat_t poll_input(window_t window)
|
quat_t poll_input(window_t window)
|
||||||
{
|
{
|
||||||
versor p = GLM_QUAT_IDENTITY_INIT;
|
versor p = GLM_QUAT_IDENTITY_INIT;
|
||||||
|
|
||||||
if (glfwGetKey((GLFWwindow *)window, 'W') == GLFW_PRESS)
|
if( glfwGetKey((GLFWwindow*)window, 'Q') == GLFW_PRESS )
|
||||||
{
|
{
|
||||||
glm_quatv(p, ANGLE, axis[0]);
|
glm_quatv(p, ANGLE, axis[0]);
|
||||||
goto end;
|
goto end;
|
||||||
}
|
}
|
||||||
if (glfwGetKey((GLFWwindow *)window, 'S') == GLFW_PRESS)
|
if( glfwGetKey((GLFWwindow*)window, 'W') == GLFW_PRESS )
|
||||||
{
|
{
|
||||||
glm_quatv(p, -ANGLE, axis[0]);
|
glm_quatv(p, -ANGLE, axis[0]);
|
||||||
goto end;
|
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, 'D') == GLFW_PRESS)
|
|
||||||
{
|
{
|
||||||
glm_quatv(p, ANGLE, axis[1]);
|
glm_quatv(p, ANGLE, axis[1]);
|
||||||
goto end;
|
goto end;
|
||||||
}
|
}
|
||||||
if (glfwGetKey((GLFWwindow *)window, 'Q') == GLFW_PRESS)
|
if( glfwGetKey((GLFWwindow*)window, 'S') == GLFW_PRESS )
|
||||||
|
{
|
||||||
|
glm_quatv(p, -ANGLE, axis[1]);
|
||||||
|
goto end;
|
||||||
|
}
|
||||||
|
if( glfwGetKey((GLFWwindow*)window, 'Z') == GLFW_PRESS )
|
||||||
{
|
{
|
||||||
glm_quatv(p, ANGLE, axis[2]);
|
glm_quatv(p, ANGLE, axis[2]);
|
||||||
goto end;
|
goto end;
|
||||||
}
|
}
|
||||||
if (glfwGetKey((GLFWwindow *)window, 'E') == GLFW_PRESS)
|
if( glfwGetKey((GLFWwindow*)window, 'X') == GLFW_PRESS )
|
||||||
{
|
{
|
||||||
glm_quatv(p, -ANGLE, axis[2]);
|
glm_quatv(p, -ANGLE, axis[2]);
|
||||||
goto end;
|
goto end;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_UP) == GLFW_PRESS)
|
|
||||||
{
|
|
||||||
glm_quatv(p, ANGLE, (vec3){1,0,0});
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_DOWN) == GLFW_PRESS)
|
|
||||||
{
|
|
||||||
glm_quatv(p, -ANGLE, (vec3){1,0,0});
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_RIGHT) == GLFW_PRESS)
|
|
||||||
{
|
|
||||||
glm_quatv(p, ANGLE, (vec3){0,1,0});
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
if (glfwGetKey((GLFWwindow *)window, GLFW_KEY_LEFT) == GLFW_PRESS)
|
|
||||||
{
|
|
||||||
|
|
||||||
glm_quatv(p, -ANGLE, (vec3){0,1,0});
|
|
||||||
goto end;
|
|
||||||
}
|
|
||||||
|
|
||||||
end:
|
end:
|
||||||
/*
|
glm_quat_mul( p, q, q );
|
||||||
// LOG INFO
|
glm_quat_rotatev( p, axis[0], axis[0] );
|
||||||
if (0)
|
glm_quat_rotatev( p, axis[1], axis[1] );
|
||||||
{
|
glm_quat_rotatev( p, axis[2], axis[2] );
|
||||||
printf("QUAT: %2.5f %2.5f %2.5f %2.5f\n", q[0], q[1], q[2], q[3]);
|
glm_quat_normalize( q );
|
||||||
printf("\n");
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
__input_update_q(p);
|
|
||||||
return q;
|
return q;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
45
src/klein.c
45
src/klein.c
@@ -1,45 +0,0 @@
|
|||||||
#include "main.h"
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
KLEIN Format:
|
|
||||||
5 bytes with KLEIN
|
|
||||||
1 byte empty for scaling
|
|
||||||
1 byte with the dimention of the surface
|
|
||||||
8 bytes interprated as an int with the number of vertex
|
|
||||||
n bytes with the vertex data of the surface
|
|
||||||
n bytes with the normal data of the surface
|
|
||||||
|
|
||||||
where n is the size of the vertex and normal data that could be
|
|
||||||
calculated as the dimention of the surface time the number of vertes
|
|
||||||
time the size of a 16 bytes float.
|
|
||||||
*/
|
|
||||||
|
|
||||||
int create_surface_klein(unsigned char *path, struct surface *surface)
|
|
||||||
{
|
|
||||||
unsigned long size;
|
|
||||||
char buffer[5];
|
|
||||||
FILE *file = fopen(path, "rb");
|
|
||||||
if (!file)
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
fread(buffer, 1, 5, file);
|
|
||||||
|
|
||||||
if (strncmp(buffer, "KLEIN", 5))
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
fread(buffer, 1, 1, file);
|
|
||||||
fread(&surface->dim, 1, 1, file);
|
|
||||||
fread(&surface->vertex, 8, 1, file);
|
|
||||||
|
|
||||||
size = surface->dim * surface->vertex;
|
|
||||||
|
|
||||||
surface->data = malloc(4 * size);
|
|
||||||
fread(surface->data, 4, size, file);
|
|
||||||
|
|
||||||
surface->norm = malloc(4 * size);
|
|
||||||
fread(surface->norm, 4, size, file);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
34
src/load.c
34
src/load.c
@@ -1,34 +0,0 @@
|
|||||||
#include "main.h"
|
|
||||||
#include <cglm/cam.h>
|
|
||||||
#include <cglm/mat4.h>
|
|
||||||
#include <cglm/quat.h>
|
|
||||||
|
|
||||||
void fix_matrix_load(id_t shader, float ratio)
|
|
||||||
{
|
|
||||||
mat4 m, n;
|
|
||||||
const int d = 7;
|
|
||||||
|
|
||||||
glm_lookat((vec3){0, 0, -d}, (vec3){0, 0, 0}, (vec3){0, 1, 0}, m);
|
|
||||||
glm_perspective(CGLM_PI / 6, ratio, d - 3, d + 3, n);
|
|
||||||
glm_mat4_mul(n, m, m);
|
|
||||||
|
|
||||||
load_mat4_to_shader(shader, "fix", (mat4_t)m);
|
|
||||||
}
|
|
||||||
|
|
||||||
void rot_matrix_load(id_t shader, quat_t q)
|
|
||||||
{
|
|
||||||
mat4 m;
|
|
||||||
glm_quat_mat4(q, m);
|
|
||||||
load_mat4_to_shader(shader, "rot", (mat4_t)m);
|
|
||||||
}
|
|
||||||
|
|
||||||
void color_load(id_t shader, unsigned char color[4])
|
|
||||||
{
|
|
||||||
float res[4];
|
|
||||||
|
|
||||||
res[0] = (float)color[0] / 0xff;
|
|
||||||
res[1] = (float)color[1] / 0xff;
|
|
||||||
res[2] = (float)color[2] / 0xff;
|
|
||||||
res[3] = (float)color[3] / 0xff;
|
|
||||||
load_float4_to_shader(shader, "color", res);
|
|
||||||
}
|
|
||||||
216
src/main.c
216
src/main.c
@@ -1,184 +1,96 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
|
#include "data/axis.h"
|
||||||
#include "data/shaders.h"
|
#include "data/shaders.h"
|
||||||
|
#include <stdlib.h>
|
||||||
#include <stdio.h>
|
#include <GL/glew.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
|
|
||||||
#define WIDTH 512
|
#define WIDTH 512
|
||||||
#define HEIGHT 512
|
#define HEIGHT 512
|
||||||
|
|
||||||
#ifdef EMSCRIPTEN
|
unsigned char palette[] =
|
||||||
#include <emscripten.h>
|
{
|
||||||
#endif
|
16,
|
||||||
|
0xEB,0xD3,0xF8,0xff,
|
||||||
#ifndef M_PI
|
0xEB,0xD4,0xF8,0xff,
|
||||||
#define M_PI 3.14159
|
0xEB,0xD5,0xF8,0xff,
|
||||||
#endif
|
0x7A,0x1C,0xAC,0xff,
|
||||||
|
};
|
||||||
struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3, .mesh = NULL};
|
|
||||||
|
|
||||||
const char * wname = "manigraph: manifold grapher";
|
const char * wname = "manigraph: manifold grapher";
|
||||||
const char *input_map =
|
float * generate_surface();
|
||||||
"\n"
|
|
||||||
"DRAG AND DROP: Graph a klein file from the file system\n"
|
|
||||||
"LEFT-CLICK: Rotate surface on DRAG direction\n"
|
|
||||||
"SCROLL: Rotate surface on SCROLL direction\n"
|
|
||||||
"\n"
|
|
||||||
"W,S: Rotate sufrace on X axis\n"
|
|
||||||
"A,D: Rotate sufrace on Y axis\n"
|
|
||||||
"Q,E: Rotate sufrace on Z axis\n"
|
|
||||||
"LEFT-RIGHT: Rotate sufrace Horizontally\n"
|
|
||||||
"UP-DOWN: Rotate sufrace Vetrically\n"
|
|
||||||
"\n"
|
|
||||||
"Z: Rotate W axis to X axis\n"
|
|
||||||
"X: Rotate W axis to Y axis\n"
|
|
||||||
"C: Rotate W axis to Z axis\n"
|
|
||||||
"1-9: Rotate n axis to W axis\n"
|
|
||||||
"\n"
|
|
||||||
;
|
|
||||||
|
|
||||||
unsigned char color[4] = {0x2F, 0x3C, 0x7E, 0xff};
|
int main( void )
|
||||||
|
|
||||||
void mlog(char *msg)
|
|
||||||
{
|
{
|
||||||
#ifdef DEBUG
|
float * points;
|
||||||
printf(msg);
|
id_t shader, texture;
|
||||||
#endif
|
mesh_t m_cube, m_axis;
|
||||||
}
|
|
||||||
|
|
||||||
window_t window;
|
window_t window;
|
||||||
id_t shader, shader_plain;
|
|
||||||
|
|
||||||
extern volatile unsigned char animate_index;
|
if( !( window = init_window( WIDTH, HEIGHT, wname ) ) )
|
||||||
|
goto error_window;
|
||||||
|
|
||||||
#ifndef EMSCRIPTEN
|
use_window( window );
|
||||||
static inline
|
set_clean_color_context( 0x2E, 0x07, 0x3F );
|
||||||
#endif
|
|
||||||
|
|
||||||
void
|
glewInit();
|
||||||
main_loop(void)
|
|
||||||
|
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;
|
quat_t q;
|
||||||
|
|
||||||
q=poll_input( window );
|
q=poll_input( window );
|
||||||
|
load_rot_matrix( shader, q );
|
||||||
|
|
||||||
rot_matrix_load(shader, q);
|
|
||||||
rot_matrix_load(shader_plain, q);
|
|
||||||
color_load(shader, color);
|
|
||||||
color_load(shader_plain, color);
|
|
||||||
|
|
||||||
{
|
|
||||||
static float angle = 0;
|
|
||||||
|
|
||||||
if (angle > M_PI / 2)
|
|
||||||
{
|
|
||||||
animate_index = 0;
|
|
||||||
angle = 0;
|
|
||||||
|
|
||||||
load_float_to_shader(shader, "angle", angle);
|
|
||||||
load_float_to_shader(shader_plain, "angle", angle);
|
|
||||||
set_projection_mesh(projection);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (animate_index)
|
|
||||||
{
|
|
||||||
load_float_to_shader(shader, "i", animate_index - 1);
|
|
||||||
load_float_to_shader(shader_plain, "i", animate_index - 1);
|
|
||||||
|
|
||||||
angle += 0.01;
|
|
||||||
load_float_to_shader(shader, "angle", angle);
|
|
||||||
load_float_to_shader(shader_plain, "angle", angle);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
clean_context();
|
clean_context();
|
||||||
|
#ifndef DEBUG
|
||||||
if (!projection.mesh)
|
load_mdl_matrix( shader, 0, 0 );
|
||||||
return;
|
draw_mesh( m_axis );
|
||||||
|
load_mdl_matrix( shader, 1, 1 );
|
||||||
draw_mesh(shader, projection.mesh);
|
draw_mesh( m_axis );
|
||||||
draw_mesh_lines(shader_plain, projection.mesh);
|
load_mdl_matrix( shader, 2, 2 );
|
||||||
}
|
draw_mesh( m_axis );
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
|
|
||||||
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(0xFF, 0xFF, 0xFF);
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
fix_matrix_load(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);
|
|
||||||
fix_matrix_load(shader_plain, (float)WIDTH / HEIGHT);
|
|
||||||
}
|
|
||||||
|
|
||||||
mlog("[INPUTS] Imprimiendo...\n");
|
|
||||||
printf(input_map);
|
|
||||||
|
|
||||||
mlog("[MAIN LOOP] Inicializando...\n");
|
|
||||||
|
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
emscripten_set_main_loop(&main_loop, 60, 1);
|
|
||||||
return 0;
|
|
||||||
#else
|
|
||||||
while (is_open_window(window))
|
|
||||||
main_loop();
|
|
||||||
#endif
|
#endif
|
||||||
mlog("[MAIN LOOP] Terminando...\n");
|
|
||||||
|
|
||||||
mlog("[MESH] Destruyendo...\n");
|
load_mdl_matrix( shader, 0, 3 );
|
||||||
destroy_mesh(projection.mesh);
|
draw_mesh( m_cube );
|
||||||
mlog("[SHADER] Destruyendo...\n");
|
|
||||||
destroy_shader(shader_plain);
|
}
|
||||||
mlog("[SHADER] Destruyendo...\n");
|
|
||||||
|
destroy_texture( texture );
|
||||||
|
destroy_mesh( m_axis );
|
||||||
|
destroy_mesh( m_cube );
|
||||||
destroy_shader( shader );
|
destroy_shader( shader );
|
||||||
mlog("[WINDOW] Destruyendo...\n");
|
|
||||||
close_window( window );
|
close_window( window );
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
error_context:
|
error_mesh_axis:
|
||||||
mlog("[SHADER] Destruyendo...\n");
|
destroy_mesh( m_cube );
|
||||||
destroy_shader(shader_plain);
|
error_mesh_cube:
|
||||||
error_shader_plain:
|
|
||||||
mlog("[SHADER] Destruyendo...\n");
|
|
||||||
destroy_shader( shader );
|
destroy_shader( shader );
|
||||||
error_shader:
|
error_shader:
|
||||||
mlog("[WINDOW] Destruyendo...\n");
|
|
||||||
close_window( window );
|
close_window( window );
|
||||||
error_window:
|
error_window:
|
||||||
return 1;
|
return 1;
|
||||||
|
|||||||
155
src/main.h
155
src/main.h
@@ -1,12 +1,5 @@
|
|||||||
/*
|
#include <GL/glew.h>
|
||||||
If DEBUG is set, we show the triangles of the mesh,
|
#include <GLFW/glfw3.h>
|
||||||
without illumination, and we write the compilation
|
|
||||||
error of the shaders.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <stdint.h>
|
|
||||||
#define DEBUG
|
|
||||||
#define GLFW_INCLUDE_NONE
|
|
||||||
|
|
||||||
typedef const void * window_t;
|
typedef const void * window_t;
|
||||||
typedef unsigned int id_t;
|
typedef unsigned int id_t;
|
||||||
@@ -14,47 +7,14 @@ typedef void *mesh_t;
|
|||||||
typedef float * quat_t;
|
typedef float * quat_t;
|
||||||
typedef float * mat4_t;
|
typedef float * mat4_t;
|
||||||
|
|
||||||
/*
|
typedef float narray_float_t[];
|
||||||
This struct represent the proyection, where:
|
typedef unsigned char narray_u8_t[];
|
||||||
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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
struct projection
|
enum
|
||||||
{
|
{
|
||||||
mesh_t mesh;
|
VERTEX, FRAGMENT
|
||||||
unsigned char m, x, y, z, w;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
/*
|
|
||||||
this structure has all the information to generate
|
|
||||||
a mesh, where:
|
|
||||||
data: the buffer with the vertex coords
|
|
||||||
norm: the buffer with the norm coords
|
|
||||||
vertex: the number of vertex
|
|
||||||
dim: the dimentions of the surface
|
|
||||||
*/
|
|
||||||
|
|
||||||
struct surface
|
|
||||||
{
|
|
||||||
float *data, *norm;
|
|
||||||
uint64_t vertex;
|
|
||||||
uint8_t dim;
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
Init window:
|
|
||||||
w: default width;
|
|
||||||
h: default height;
|
|
||||||
name: Name of the window.
|
|
||||||
*/
|
|
||||||
|
|
||||||
int create_surface_klein( unsigned char *, struct surface * );
|
|
||||||
|
|
||||||
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);
|
||||||
|
|
||||||
void use_window(window_t window);
|
void use_window(window_t window);
|
||||||
@@ -63,109 +23,33 @@ int is_open_window(window_t window);
|
|||||||
|
|
||||||
void close_window(window_t window);
|
void close_window(window_t window);
|
||||||
|
|
||||||
/*
|
mesh_t create_mesh( float * 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(struct surface);
|
|
||||||
|
|
||||||
void set_projection_mesh(struct projection);
|
|
||||||
|
|
||||||
void destroy_mesh(mesh_t p);
|
void destroy_mesh(mesh_t p);
|
||||||
|
|
||||||
void draw_mesh(id_t, mesh_t p);
|
void draw_mesh(mesh_t p);
|
||||||
|
|
||||||
void draw_mesh_lines(id_t, 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);
|
void clean_context(void);
|
||||||
|
|
||||||
int init_context(void);
|
|
||||||
|
|
||||||
void destroy_shader(id_t shader);
|
void destroy_shader(id_t shader);
|
||||||
|
|
||||||
id_t create_shader(void);
|
id_t create_shader(void);
|
||||||
|
|
||||||
void use_shader(id_t shader);
|
void use_shader(id_t program);
|
||||||
|
|
||||||
enum
|
unsigned char gload_program(id_t program, const char * src, unsigned int type);
|
||||||
{
|
|
||||||
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
|
|
||||||
*/
|
|
||||||
|
|
||||||
unsigned char load_program_to_shader(
|
void gload_mat4(id_t program, char * var, mat4_t m);
|
||||||
id_t shader, const char *src, unsigned int type);
|
|
||||||
|
|
||||||
/*
|
void load_fix_matrix(id_t shader, float ratio);
|
||||||
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);
|
void load_mdl_matrix(id_t shader, unsigned char i, unsigned char c);
|
||||||
|
|
||||||
/*
|
void load_rot_matrix(id_t shader, quat_t q);
|
||||||
load unsigned int to shader:
|
|
||||||
var: name of glsl variable.
|
|
||||||
u: unsigned int to load
|
|
||||||
*/
|
|
||||||
|
|
||||||
void load_uint_to_shader(id_t shader, char *var, unsigned int u);
|
|
||||||
|
|
||||||
/*
|
|
||||||
load float[4] to shader:
|
|
||||||
var: name of glsl variable.
|
|
||||||
f: float[4] to load
|
|
||||||
*/
|
|
||||||
|
|
||||||
void load_float4_to_shader(id_t shader, char *var, float f[4]);
|
|
||||||
|
|
||||||
/*
|
|
||||||
load matrix 4 to shader:
|
|
||||||
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 fix_matrix_load(id_t shader, float ratio);
|
|
||||||
|
|
||||||
/*
|
|
||||||
Generate and load rotation matrix.
|
|
||||||
q: quaterinon describing the rotation.
|
|
||||||
*/
|
|
||||||
|
|
||||||
void rot_matrix_load(id_t shader, quat_t q);
|
|
||||||
|
|
||||||
/*
|
|
||||||
*/
|
|
||||||
|
|
||||||
void color_load(id_t shader, unsigned char color[4]);
|
|
||||||
|
|
||||||
id_t config_texture(unsigned short type);
|
id_t config_texture(unsigned short type);
|
||||||
|
|
||||||
@@ -173,11 +57,6 @@ void use_texture(id_t texture);
|
|||||||
|
|
||||||
void destroy_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);
|
quat_t poll_input(window_t window);
|
||||||
|
|||||||
51
src/matrix.c
Normal file
51
src/matrix.c
Normal file
@@ -0,0 +1,51 @@
|
|||||||
|
#include "main.h"
|
||||||
|
#include <cglm/mat4.h>
|
||||||
|
#include <cglm/cam.h>
|
||||||
|
#include <cglm/quat.h>
|
||||||
|
|
||||||
|
mat4 ortho[] =
|
||||||
|
{
|
||||||
|
{
|
||||||
|
{ 1, 0, 0, 0 },
|
||||||
|
{ 0, 1, 0, 0 },
|
||||||
|
{ 0, 0, 1, 0 },
|
||||||
|
{ 0, 0, 0, 1 },
|
||||||
|
},
|
||||||
|
{
|
||||||
|
{ 0, 1, 0, 0 },
|
||||||
|
{ 1, 0, 0, 0 },
|
||||||
|
{ 0, 0, 1, 0 },
|
||||||
|
{ 0, 0, 0, 1 },
|
||||||
|
},
|
||||||
|
{
|
||||||
|
{ 0, 0, 1, 0 },
|
||||||
|
{ 0, 1, 0, 0 },
|
||||||
|
{ 1, 0, 0, 0 },
|
||||||
|
{ 0, 0, 0, 1 },
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
void load_fix_matrix( id_t shader, float ratio )
|
||||||
|
{
|
||||||
|
mat4 m, n;
|
||||||
|
const int d = 7;
|
||||||
|
|
||||||
|
glm_lookat( (vec3){0,0,-d}, (vec3){0,0,0}, (vec3){0,1,0}, m );
|
||||||
|
glm_perspective( CGLM_PI/4, ratio, d-3, d+3, n );
|
||||||
|
glm_mat4_mul( n, m, m );
|
||||||
|
|
||||||
|
gload_mat4( shader, "fix", (mat4_t) m );
|
||||||
|
}
|
||||||
|
|
||||||
|
void load_mdl_matrix( id_t shader, unsigned char i, unsigned char c )
|
||||||
|
{
|
||||||
|
gload_float( shader, "idx", c );
|
||||||
|
gload_mat4( shader, "mdl", (mat4_t)ortho[i] );
|
||||||
|
}
|
||||||
|
|
||||||
|
void load_rot_matrix( id_t shader, quat_t q )
|
||||||
|
{
|
||||||
|
mat4 m;
|
||||||
|
glm_quat_mat4( q, m );
|
||||||
|
gload_mat4( shader, "rot", (mat4_t)m );
|
||||||
|
}
|
||||||
99
src/mesh.c
Normal file → Executable file
99
src/mesh.c
Normal file → Executable file
@@ -1,82 +1,30 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
|
#include <GL/glew.h>
|
||||||
#ifdef EMSCRIPTEN
|
|
||||||
#include <GL/gl.h>
|
|
||||||
#else
|
|
||||||
#include <glad.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.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;
|
struct obj * p;
|
||||||
p = projection.mesh;
|
|
||||||
|
|
||||||
glBindVertexArray(p->vao);
|
|
||||||
|
|
||||||
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)));
|
|
||||||
|
|
||||||
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)));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
In this function we load all the vertex and ELEMENT_ARRAY datas on two
|
|
||||||
diferents buffers, so we can access the coordanates that we want
|
|
||||||
to display using the layout location in GLSL.
|
|
||||||
This trick can be done with glVertexAttribPointer.
|
|
||||||
*/
|
|
||||||
|
|
||||||
mesh_t create_mesh(struct surface surface)
|
|
||||||
{
|
|
||||||
unsigned char i;
|
|
||||||
struct obj *p;
|
|
||||||
|
|
||||||
p=malloc(sizeof(struct obj));
|
p=malloc(sizeof(struct obj));
|
||||||
|
|
||||||
p->vertex = surface.vertex;
|
p->vertex=(*mesh)/3;
|
||||||
|
|
||||||
glGenVertexArrays( 1, &p->vao );
|
glGenVertexArrays( 1, &p->vao );
|
||||||
|
glGenBuffers( 1, &p->vbo );
|
||||||
|
|
||||||
glBindVertexArray( p->vao );
|
glBindVertexArray( p->vao );
|
||||||
|
glBindBuffer( GL_ARRAY_BUFFER, p->vbo );
|
||||||
glGenBuffers(1, &p->d_vbo);
|
glBufferData( GL_ARRAY_BUFFER, (p->vertex*3)*sizeof(float), mesh+1,
|
||||||
glBindBuffer(GL_ARRAY_BUFFER, p->d_vbo);
|
|
||||||
glBufferData(GL_ARRAY_BUFFER, p->vertex * surface.dim * sizeof(float),
|
|
||||||
surface.data, GL_STATIC_DRAW);
|
|
||||||
|
|
||||||
if (surface.norm)
|
|
||||||
{
|
|
||||||
glGenBuffers(1, &p->n_vbo);
|
|
||||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, p->n_vbo);
|
|
||||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
|
|
||||||
p->vertex * surface.dim * sizeof(float), surface.norm,
|
|
||||||
GL_STATIC_DRAW );
|
GL_STATIC_DRAW );
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < 8; ++i)
|
glVertexAttribPointer( 0,3,GL_FLOAT, 0, 3*sizeof(float), NULL );
|
||||||
glEnableVertexAttribArray(i);
|
glEnableVertexAttribArray(0);
|
||||||
|
|
||||||
return p;
|
return p;
|
||||||
}
|
}
|
||||||
@@ -86,33 +34,22 @@ void destroy_mesh(mesh_t p)
|
|||||||
struct obj * obj ;
|
struct obj * obj ;
|
||||||
obj = p;
|
obj = p;
|
||||||
glDeleteVertexArrays( 1, &obj->vao );
|
glDeleteVertexArrays( 1, &obj->vao );
|
||||||
glDeleteBuffers(1, &obj->d_vbo);
|
glDeleteBuffers( 1, &obj->vbo );
|
||||||
glDeleteBuffers(1, &obj->n_vbo);
|
|
||||||
free( p );
|
free( p );
|
||||||
}
|
}
|
||||||
|
|
||||||
void draw_mesh(id_t shader, mesh_t p)
|
void draw_mesh( mesh_t p )
|
||||||
{
|
{
|
||||||
struct obj * obj=p;
|
struct obj * obj=p;
|
||||||
|
|
||||||
glUseProgram(shader);
|
|
||||||
glBindVertexArray( obj->vao );
|
glBindVertexArray( obj->vao );
|
||||||
#ifndef EMSCRIPTEN
|
#ifdef DEBUG
|
||||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
{
|
||||||
#endif
|
int i;
|
||||||
glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
|
for( i=0; i<obj->vertex;i+=3 )
|
||||||
|
glDrawArrays(GL_LINE_LOOP, i, 3 );
|
||||||
}
|
}
|
||||||
void draw_mesh_lines(id_t shader, mesh_t p)
|
|
||||||
{
|
|
||||||
struct obj *obj = p;
|
|
||||||
|
|
||||||
glLineWidth(4);
|
|
||||||
glUseProgram(shader);
|
|
||||||
glBindVertexArray(obj->vao);
|
|
||||||
#ifndef EMSCRIPTEN
|
|
||||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
||||||
glDrawArrays(GL_TRIANGLES, 0, obj->vertex);
|
|
||||||
#else
|
#else
|
||||||
glDrawArrays(GL_LINES, 0, obj->vertex);
|
glDrawArrays(GL_TRIANGLES, 0, obj->vertex );
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|||||||
47
src/shader.c
47
src/shader.c
@@ -1,27 +1,35 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
|
#include <GL/glew.h>
|
||||||
#ifndef EMSCRIPTEN
|
|
||||||
#include <glad.h>
|
|
||||||
#else
|
|
||||||
#include <GL/gl.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef DEBUG
|
#ifdef DEBUG
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
void destroy_shader(unsigned int shader) { 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) { glUseProgram(program); }
|
void use_shader( unsigned int program )
|
||||||
|
{
|
||||||
|
return glUseProgram( program );
|
||||||
|
}
|
||||||
|
|
||||||
unsigned char load_program_to_shader(
|
unsigned char gload_program( unsigned int program, const char * src,
|
||||||
unsigned int program, const char *src, unsigned int i)
|
unsigned int i )
|
||||||
{
|
{
|
||||||
int shader, status;
|
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;
|
return 0;
|
||||||
@@ -29,9 +37,9 @@ unsigned char load_program_to_shader(
|
|||||||
shader = glCreateShader(type[i]);
|
shader = glCreateShader(type[i]);
|
||||||
glShaderSource( shader, 1, (const GLchar **)&src, ((void*)0 ));
|
glShaderSource( shader, 1, (const GLchar **)&src, ((void*)0 ));
|
||||||
glCompileShader(shader);
|
glCompileShader(shader);
|
||||||
|
|
||||||
glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
|
glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
|
||||||
|
|
||||||
|
|
||||||
if( !status )
|
if( !status )
|
||||||
{
|
{
|
||||||
#ifdef DEBUG
|
#ifdef DEBUG
|
||||||
@@ -48,21 +56,14 @@ unsigned char load_program_to_shader(
|
|||||||
return 1;
|
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 );
|
glUseProgram( program );
|
||||||
glUniform1f( glGetUniformLocation( program, var ), f );
|
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 );
|
glUseProgram( program );
|
||||||
glUniformMatrix4fv( glGetUniformLocation( program, var ), 1, 0, mat );
|
glUniformMatrix4fv( glGetUniformLocation( program, var ), 1, 0, mat );
|
||||||
}
|
}
|
||||||
|
|
||||||
void load_float4_to_shader(unsigned int program, char *var, float float4[4])
|
|
||||||
{
|
|
||||||
glUseProgram(program);
|
|
||||||
glUniform4f(glGetUniformLocation(program, var), float4[0], float4[1],
|
|
||||||
float4[2], float4[3]);
|
|
||||||
}
|
|
||||||
|
|||||||
76
src/surface.c
Normal file
76
src/surface.c
Normal file
@@ -0,0 +1,76 @@
|
|||||||
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
|
||||||
|
#ifndef M_PI
|
||||||
|
#define M_PI 3.14159265358979323846
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef void(*function_t)(float*,int, int, int);
|
||||||
|
|
||||||
|
void mobius(float *d_surface, int i, int j, int grid_size)
|
||||||
|
{
|
||||||
|
const float width = 0.5;
|
||||||
|
float u = (2*M_PI) * ((float)i/grid_size );
|
||||||
|
float v = (2*width) * ((float)j/grid_size ) - width;
|
||||||
|
|
||||||
|
d_surface[0] = cos(u) + v * cos(u / 2) * cos(u);
|
||||||
|
d_surface[1] = sin(u) + v * cos(u / 2) * sin(u);
|
||||||
|
d_surface[2] = v * sin(u / 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
void toro(float *d_surface, int i, int j, int grid_size)
|
||||||
|
{
|
||||||
|
float u = (2*M_PI) * ((float)i/grid_size );
|
||||||
|
float v = (2*M_PI) * ((float)j/grid_size );
|
||||||
|
|
||||||
|
d_surface[0] = (1 + 0.5*cos(v))*cos(u);
|
||||||
|
d_surface[1] = (1 + 0.5*cos(v))*sin(u);
|
||||||
|
d_surface[2] = 0.5*sin(v);
|
||||||
|
}
|
||||||
|
|
||||||
|
void klein(float *d_surface, int i, int j, int grid_size)
|
||||||
|
{
|
||||||
|
float u = (2*M_PI) * ((float)i/grid_size );
|
||||||
|
float v = (2*M_PI) * ((float)j/grid_size );
|
||||||
|
|
||||||
|
d_surface[0] = (0.5*cos(v) + 0.5) * cos(u);
|
||||||
|
d_surface[1] = (0.5*cos(v) + 0.5) * sin(u);
|
||||||
|
d_surface[2] = sin(v) * cos(u/2);
|
||||||
|
//d_surface[2] = sin(v)*sin(u/2);
|
||||||
|
}
|
||||||
|
|
||||||
|
float * generate_surface(int grid_size)
|
||||||
|
{
|
||||||
|
long size = grid_size*grid_size*2*3*3;
|
||||||
|
function_t f = klein;
|
||||||
|
float * d_surface;
|
||||||
|
int k=0;
|
||||||
|
|
||||||
|
d_surface = malloc((size+1)*sizeof(float));
|
||||||
|
d_surface[0] = size;
|
||||||
|
|
||||||
|
for (int i = 0; i < grid_size; i++)
|
||||||
|
{
|
||||||
|
for (int j = 0; j < grid_size; j++)
|
||||||
|
{
|
||||||
|
// 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;
|
||||||
|
|
||||||
|
// 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;
|
||||||
|
}
|
||||||
37
src/texture.c
Normal file
37
src/texture.c
Normal file
@@ -0,0 +1,37 @@
|
|||||||
|
#include "main.h"
|
||||||
|
#include <GL/glew.h>
|
||||||
|
|
||||||
|
#define TYPE GL_TEXTURE_2D_ARRAY
|
||||||
|
|
||||||
|
id_t config_texture( unsigned short type )
|
||||||
|
{
|
||||||
|
id_t texture;
|
||||||
|
|
||||||
|
glGenTextures( 1, &texture );
|
||||||
|
glBindTexture( TYPE, texture );
|
||||||
|
|
||||||
|
{
|
||||||
|
glTexParameteri( TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
||||||
|
glTexParameteri( TYPE, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
|
||||||
|
}
|
||||||
|
|
||||||
|
return texture;
|
||||||
|
}
|
||||||
|
|
||||||
|
void use_texture( id_t texture )
|
||||||
|
{
|
||||||
|
return glBindTexture( TYPE, texture );
|
||||||
|
}
|
||||||
|
|
||||||
|
void destroy_texture( unsigned int texture )
|
||||||
|
{
|
||||||
|
return glDeleteTextures( 1, &texture );
|
||||||
|
}
|
||||||
|
|
||||||
|
id_t create_palette_texture( const unsigned char * colors )
|
||||||
|
{
|
||||||
|
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;
|
||||||
|
}
|
||||||
80
src/window.c
80
src/window.c
@@ -1,56 +1,15 @@
|
|||||||
#include "main.h"
|
#include "main.h"
|
||||||
#include <GLFW/glfw3.h>
|
#include <GLFW/glfw3.h>
|
||||||
#include <stdio.h>
|
|
||||||
#include <time.h>
|
|
||||||
|
|
||||||
void __window_callback_input(GLFWwindow *, int, int);
|
void __window_callback(GLFWwindow *, int, int);
|
||||||
void __cursor_callback_input(GLFWwindow *, double, double);
|
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);
|
|
||||||
void __drop_callback_input(GLFWwindow *, int, const char **);
|
|
||||||
void __error_callback_input(int, const char *);
|
|
||||||
|
|
||||||
window_t init_window(unsigned int w, unsigned int h, const char *name);
|
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)
|
|
||||||
{
|
{
|
||||||
static double previous_time = 0.0;
|
void * window;
|
||||||
double current_time;
|
void __mouse_callback(GLFWwindow *window, int button, int action, int mods);
|
||||||
double frame_time;
|
void __scroll_callback(GLFWwindow *window, double xoffset, double yoffset);
|
||||||
double elapsed_time;
|
|
||||||
|
|
||||||
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);
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
usleep(sleep_time.tv_nsec/1000);
|
|
||||||
#else
|
|
||||||
nanosleep(&sleep_time, NULL);
|
|
||||||
#endif
|
|
||||||
current_time = glfwGetTime();
|
|
||||||
}
|
|
||||||
|
|
||||||
previous_time = current_time;
|
|
||||||
}
|
|
||||||
|
|
||||||
window_t init_window(unsigned int width, unsigned int height, const char *title)
|
|
||||||
{
|
|
||||||
window_t window;
|
|
||||||
glfwSetErrorCallback(__error_callback_input);
|
|
||||||
|
|
||||||
if( !glfwInit() )
|
if( !glfwInit() )
|
||||||
return NULL;
|
return NULL;
|
||||||
@@ -58,40 +17,39 @@ window_t init_window(unsigned int width, unsigned int height, const char *title)
|
|||||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
||||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
||||||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||||
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1);
|
|
||||||
|
|
||||||
window = (window_t)glfwCreateWindow(width, height, title, NULL, NULL);
|
window = glfwCreateWindow(w, h, name, NULL, NULL);
|
||||||
if (!(window))
|
|
||||||
|
if( !window )
|
||||||
{
|
{
|
||||||
glfwTerminate();
|
glfwTerminate();
|
||||||
return NULL;
|
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);
|
__window_callback( window, w, h );
|
||||||
glfwSetCursorPosCallback((GLFWwindow *)window, __cursor_callback_input);
|
|
||||||
glfwSetMouseButtonCallback((GLFWwindow *)window, __mouse_callback_input);
|
|
||||||
glfwSetScrollCallback((GLFWwindow *)window, __scroll_callback_input);
|
|
||||||
glfwSetKeyCallback((GLFWwindow *)window, __key_callback_input);
|
|
||||||
glfwSetDropCallback((GLFWwindow *)window, __drop_callback_input);
|
|
||||||
|
|
||||||
return window;
|
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)
|
int is_open_window(window_t window)
|
||||||
{
|
{
|
||||||
glfwSwapBuffers((void*)window);
|
glfwSwapBuffers((void*)window);
|
||||||
glfwPollEvents();
|
glfwPollEvents();
|
||||||
|
|
||||||
__limit_fps_window(60);
|
|
||||||
return !glfwWindowShouldClose((void*)window);
|
return !glfwWindowShouldClose((void*)window);
|
||||||
}
|
}
|
||||||
|
|
||||||
void close_window(window_t window)
|
void close_window(window_t window)
|
||||||
{
|
{
|
||||||
glfwDestroyWindow((GLFWwindow *)window);
|
glfwDestroyWindow((void*)window);
|
||||||
glfwTerminate();
|
glfwTerminate();
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user