0.1 Graph cube

src/Makefile

@@ -0,0 +1,31 @@
+BIN = ./manigraph
+LIBGLFW=./libglfw.so
+
+LIB= $(LIBGLFW)
+
+OBJ = \
+	window.o \
+	matrix.o \
+	shader.o \
+	color.o \
+	mesh.o \
+	main.o 
+
+CFLAGS=  \
+	-I../ext/cglm/include  \
+	-I../ext/glfw/include  \
+	-Wall -Wno-unused-function -std=c89 
+
+
+$(BIN): $(OBJ) $(LIB)
+	$(CC) -lGL -lglfw -L.  -o $(BIN) $(OBJ)
+
+
+$(LIBGLFW):
+	$(CC) -fPIC -shared -D_GLFW_X11 -D_GLFW_BUILD_DLL ../ext/glfw/src/*.c -o $@ 
+
+run:
+	LD_LIBRARY_PATH=. $(BIN)
+
+clean:
+	rm $(BIN) $(OBJ) $(LIB)

src/color.c

@@ -0,0 +1,13 @@
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include "main.h"
+
+void set_color( unsigned char r, unsigned char g, unsigned char b )
+{
+	glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
+}
+
+void draw_color( void )
+{
+	glClear( GL_COLOR_BUFFER_BIT );
+}

src/data/cube.h

@@ -0,0 +1,32 @@
+#define A -1,-1,-1,0,
+#define B -1,-1, 1,0,
+#define C -1, 1,-1,0,
+#define D -1, 1, 1,0,
+#define E  1,-1,-1,0,
+#define F  1,-1, 1,0,
+#define G  1, 1,-1,0,
+#define H  1, 1, 1,0,
+
+int cube[] =
+{
+	4*3*2*6,
+
+	A C E
+	C E G
+
+	E G F
+	G F H
+
+	F H B
+	H B D
+
+	B D A
+	D A C
+
+	C D G
+	D G H
+
+	A B E 
+	B E F
+
+};

src/data/shaders.h

@@ -0,0 +1,23 @@
+const char * vs =
+	"#version 330 core\n"
+
+	"layout (location = 0) in vec3 aPos;"
+
+	"uniform mat4 cam;"
+	"uniform mat4 pry;"
+	"uniform mat4 rotx;"
+	"uniform mat4 roty;"
+	"uniform mat4 rotz;"
+
+	"void main()"
+	"{"
+	"	gl_Position = pry * cam * rotx * roty * rotz * vec4( aPos, 1.0 );\n"
+	"}";
+
+const char * fs =
+	"#version 330 core\n"
+	"out vec4 FragColor;"
+	"void main()"
+	"{"
+	"	FragColor = vec4( 1.0, 0.5, 0.2, 1.0 );"
+	"}";

src/main.c

@@ -0,0 +1,60 @@
+#include "main.h"
+#include "data/cube.h"
+#include "data/shaders.h"
+
+#define WIDTH 512
+#define HEIGHT 512
+
+const char * wname = "manigraph: manifold grapher";
+
+int main( void )
+{
+	unsigned char rot[3] = {0,0,0};
+
+	int shader;
+	void * mesh;
+	window_t window;
+
+	if( !( window = init_window( WIDTH, HEIGHT, wname ) ) )
+		goto error_window;
+
+	use_window( window );
+	set_color( 51, 76, 76 );
+
+	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( !( mesh = create_mesh( cube ) ) )
+		goto error_mesh; 
+
+	while( is_open_window( window ) )
+	{
+		load_rot_matrix( shader, rot[0], 0 );
+		load_rot_matrix( shader, rot[1], 1 );
+		load_rot_matrix( shader, rot[2], 2 );
+
+		++rot[1];
+
+		draw_color();
+		draw_mesh( mesh );
+	}
+
+	destroy_mesh( mesh );
+	destroy_shader( shader );
+	close_window( window );
+	return 0;
+
+	destroy_mesh( mesh );
+error_mesh:
+	destroy_shader( shader );
+error_shader:
+	close_window( window );
+error_window:
+	return 1;
+}

src/main.h

@@ -0,0 +1,40 @@
+typedef const void * window_t;
+
+enum
+{
+	VERTEX, FRAGMENT
+};
+
+window_t init_window( unsigned int w, unsigned int h, const char * name );
+
+void use_window( window_t window );
+
+int is_open_window( window_t window );
+
+void close_window( window_t window );
+
+void * create_mesh( int * mesh );
+
+void destroy_mesh( void * p );
+
+void draw_mesh( void * p );
+
+void set_color( unsigned char, unsigned char, unsigned char );
+
+void draw_color( void );
+
+void destroy_shader( unsigned int shader );
+
+unsigned int create_shader( void );
+
+void use_shader( unsigned int program );
+
+unsigned char gload_program( unsigned int program, const char * src, unsigned int type );
+
+void gload_float( unsigned int program, char * var, float f );
+
+void gload_mat4( unsigned int program, char * var, float * m );
+
+void load_fix_matrix( unsigned int shader, float ratio );
+
+void load_rot_matrix( unsigned int shader, char angle, unsigned char i );

src/matrix.c

@@ -0,0 +1,26 @@
+#include "main.h"
+#define inline
+#include <cglm/cglm.h>
+
+void load_fix_matrix( unsigned int shader, float ratio )
+{
+	mat4 m;
+
+	glm_lookat( (vec3){0,0,-5}, (vec3){0,0,0}, (vec3){0,1,0}, m );
+	gload_mat4( shader, "cam", (float*)m );
+
+	glm_perspective( 45.0, ratio, 3, 7, m );
+	gload_mat4( shader, "pry", (float*)m );
+}
+
+void load_rot_matrix( unsigned int shader, char angle, unsigned char i )
+{
+	mat4 m;
+	char * name[] = {"rotx", "roty", "rotz"};
+	vec3 axis = {0,0,0};
+
+	axis[(int)i]=1;
+
+	glm_rotate_make( m, (float)angle/0xff*GLM_PI, axis );
+	gload_mat4( shader, name[(int)i], (float*)m );
+}

src/mesh.c

@@ -0,0 +1,50 @@
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include <stdlib.h>
+
+struct obj 
+{
+	unsigned int vertex, vao, vbo;
+};
+
+void * create_mesh( int * mesh )
+{
+	struct obj * p;
+
+	p=malloc(sizeof(struct obj));
+
+	p->vertex=(*mesh)/4;
+
+	glGenVertexArrays( 1, &p->vao );
+	glGenBuffers( 1, &p->vbo );
+
+	glBindVertexArray( p->vao );
+	glBindBuffer( GL_ARRAY_BUFFER, p->vbo );
+	glBufferData( GL_ARRAY_BUFFER, (p->vertex*4)*sizeof(int), mesh+1, 
+		GL_STATIC_DRAW );
+
+	glVertexAttribPointer( 0,3,GL_INT, 0, 4*sizeof(int), NULL );
+	glEnableVertexAttribArray(0);
+
+	glVertexAttribPointer( 1,1,GL_INT, 0, 4*sizeof(int), 
+		(void*)(3*sizeof(int)) );
+	glEnableVertexAttribArray(1);
+	return p;
+}
+
+void destroy_mesh( void * p )
+{
+	struct obj * obj ;
+	obj = p;
+	glDeleteVertexArrays( 1, &obj->vao );
+	glDeleteBuffers( 1, &obj->vbo );
+	free( p );
+}
+
+void draw_mesh( void * p )
+{
+	struct obj * obj=p;
+
+	glBindVertexArray( obj->vao );
+	glDrawArrays(GL_TRIANGLES, 0, obj->vertex );
+}

src/shader.c

@@ -0,0 +1,67 @@
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include "main.h"
+
+#define NULL ((void*)0)
+
+void destroy_shader( unsigned int shader )
+{ 
+	return glDeleteProgram( shader );
+}
+
+unsigned int create_shader( void )
+{
+	return glCreateProgram();
+}
+
+void use_shader( unsigned int program )
+{
+	return glUseProgram( program );
+}
+
+unsigned char gload_program( unsigned int program, const char * src, 
+	unsigned int i )
+{
+	int shader, status;
+	unsigned int type[] = 
+	{
+		[VERTEX]=GL_VERTEX_SHADER,
+		[FRAGMENT]=GL_FRAGMENT_SHADER 
+	};
+
+
+	if( !src )
+		return 0;
+
+	shader = glCreateShader(type[i]);
+	glShaderSource( shader, 1, (const GLchar **)&src, NULL);
+	glCompileShader(shader);
+	glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
+
+
+	if( !status )
+	{
+#ifdef DEBUG
+		char log[256];
+		glGetShaderInfoLog( shader, 256, NULL, log );
+#endif
+		return 0;
+	}
+
+	glAttachShader(program, shader);
+	glDeleteShader(shader);
+	glLinkProgram(program);
+	return 1;
+}
+
+void gload_float( unsigned int program, char * var, float f )
+{
+	glUseProgram( program );
+	glUniform1f( glGetUniformLocation( program, var ), f ); 
+}
+
+void gload_mat4( unsigned int program, char * var, float * mat )
+{
+	glUseProgram( program );
+	glUniformMatrix4fv( glGetUniformLocation( program, var ), 1, 0, mat ); 
+}

src/window.c

@@ -0,0 +1,51 @@
+#include <GLFW/glfw3.h>
+#include "main.h"
+
+void window_callback( GLFWwindow * window, int w, int h )
+{
+	int m = ( w<h )? w: h;
+
+	glViewport( (w-m)/2, (h-m)/2, m, m );
+}
+
+window_t init_window( unsigned int w, unsigned int h, const char * name )
+{
+	void * window;
+
+	if( !glfwInit() )
+		return NULL;
+
+	glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 );
+	glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
+	glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
+
+	window = glfwCreateWindow( w, h, name, NULL, NULL );
+
+	if( !window )
+	{
+		glfwTerminate();
+		return NULL;
+	}
+
+	glfwSetWindowSizeCallback( window, window_callback );
+
+	return window;
+}
+
+void use_window( window_t window )
+{
+	glfwMakeContextCurrent( (void*)window );
+}
+
+int is_open_window( window_t window )
+{
+	glfwSwapBuffers( (void*)window );
+	glfwPollEvents();
+	return !glfwWindowShouldClose( (void*)window );
+}
+
+void close_window( window_t window )
+{
+	glfwDestroyWindow( (void*)window );
+	glfwTerminate();
+}