0.2 Draw axis

src/color.c

@@ -4,10 +4,11 @@
 
 void set_color( unsigned char r, unsigned char g, unsigned char b )
 {
+	glEnable( GL_DEPTH_TEST );
 	glClearColor( (float)r/0xff, (float)g/0xff, (float)b/0xff, 1.0 );
 }
 
 void draw_color( void )
 {
-	glClear( GL_COLOR_BUFFER_BIT );
+	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 }

src/data/axis.h

@@ -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.1;
+const float Z = 0.1;
+
+#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 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
+
+};

src/data/cube.h

@@ -1,15 +1,15 @@
-#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,
+#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,
 
-int cube[] =
+float cube[] =
 {
-	4*3*2*6,
+	3*3*2*6,
 
 	A C E
 	C E G

src/data/shaders.h

@@ -3,21 +3,28 @@ const char * vs =
 
 	"layout (location = 0) in vec3 aPos;"
 
-	"uniform mat4 cam;"
-	"uniform mat4 pry;"
-	"uniform mat4 rotx;"
-	"uniform mat4 roty;"
-	"uniform mat4 rotz;"
+	"uniform float idx;"
+	"uniform mat4 fix;"
+	"uniform mat4 rot;"
+	"uniform mat4 mdl;"
+
+	"out float index;"
 
 	"void main()"
 	"{"
-	"	gl_Position = pry * cam * rotx * roty * rotz * vec4( aPos, 1.0 );\n"
+	"	index=idx;"
+	"	gl_Position = fix * rot * mdl * vec4( aPos, 1.0 );\n"
 	"}";
 
 const char * fs =
 	"#version 330 core\n"
+
+	"uniform sampler2DArray palette;"
+
+	"in float index;"
 	"out vec4 FragColor;"
+
 	"void main()"
 	"{"
-	"	FragColor = vec4( 1.0, 0.5, 0.2, 1.0 );"
+	"	FragColor = texture( palette, vec3( 0, 0, index ) ).rgba;"
 	"}";

src/main.c

@@ -1,25 +1,37 @@
+#include <GL/gl.h>
+
 #include "main.h"
 #include "data/cube.h"
+#include "data/axis.h"
 #include "data/shaders.h"
 
 #define WIDTH 512
 #define HEIGHT 512
 
+unsigned char palette[] =
+{
+	16,
+	0x90,0x90,0x90,0xff,
+	0x91,0x91,0x91,0xff,
+	0x92,0x92,0x92,0xff,
+	0xff,0x88,0x33,0xff,
+};
+
 const char * wname = "manigraph: manifold grapher";
 
 int main( void )
 {
 	unsigned char rot[3] = {0,0,0};
+	unsigned int shader, texture;
+	void * m_cube, *m_axis;
 
-	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 );
+	set_color( 0x33, 0x00, 0x00 );
 
 	if( !( shader = create_shader() ) )
 		goto error_shader;
@@ -30,28 +42,49 @@ int main( void )
 
 	load_fix_matrix( shader, (float)WIDTH/HEIGHT );
 
-	if( !( mesh = create_mesh( cube ) ) )
-		goto error_mesh; 
+	if( !( m_cube = create_mesh( cube ) ) )
+		goto error_mesh_cube; 
+
+	if( !( m_axis = create_mesh( axis ) ) )
+		goto error_mesh_axis; 
+
+
+	texture=create_palette_texture( palette );
+	use_texture( texture );
 
 	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 );
+		load_rot_matrix( shader, rot );
 
 		++rot[1];
 
 		draw_color();
-		draw_mesh( mesh );
+
+		load_mdl_matrix( shader, 2 );
+		gload_float( shader, "idx", 2 );
+		draw_mesh( m_axis );
+
+		load_mdl_matrix( shader, 1 );
+		gload_float( shader, "idx", 1 );
+		draw_mesh( m_axis );
+
+		load_mdl_matrix( shader, 0 );
+		gload_float( shader, "idx", 0 );
+		draw_mesh( m_axis );
+		gload_float( shader, "idx", 3 );
+		draw_mesh( m_cube );
 	}
 
-	destroy_mesh( mesh );
+	destroy_texture( texture );
+	destroy_mesh( m_axis );
+	destroy_mesh( m_cube );
 	destroy_shader( shader );
 	close_window( window );
 	return 0;
 
-	destroy_mesh( mesh );
-error_mesh:
+error_mesh_axis:
+	destroy_mesh( m_cube );
+error_mesh_cube:
 	destroy_shader( shader );
 error_shader:
 	close_window( window );

src/main.h

@@ -13,7 +13,7 @@ int is_open_window( window_t window );
 
 void close_window( window_t window );
 
-void * create_mesh( int * mesh );
+void * create_mesh( float * mesh );
 
 void destroy_mesh( void * p );
 
@@ -37,4 +37,14 @@ 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 );
+void load_mdl_matrix( unsigned int shader, unsigned char i );
+
+void load_rot_matrix( unsigned int shader, unsigned char * angle );
+
+unsigned int config_texture( unsigned short type );
+
+void use_texture( unsigned int texture );
+
+void destroy_texture( unsigned int texture );
+
+unsigned int create_palette_texture( const unsigned char * colors );

src/matrix.c

@@ -2,25 +2,53 @@
 #define inline
 #include <cglm/cglm.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( unsigned int shader, float ratio )
 {
-	mat4 m;
+	mat4 m, n;
 
 	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, 2, 8, n );
+	glm_mat4_mul( n, m, m );
 
-	glm_perspective( 45.0, ratio, 3, 7, m );
-	gload_mat4( shader, "pry", (float*)m );
+	gload_mat4( shader, "fix", (float*)m );
 }
 
-void load_rot_matrix( unsigned int shader, char angle, unsigned char i )
+void load_mdl_matrix( unsigned int shader, 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 );
+	gload_mat4( shader, "mdl", (float*)ortho[i] );
+}
+
+void load_rot_matrix( unsigned int shader, unsigned char * angle )
+{
+	mat4 m, n;
+
+	glm_rotate_make( m, (float)angle[0]/0xff*2*GLM_PI, (vec3){1,0,0} );
+	glm_rotate_make( n, (float)angle[1]/0xff*2*GLM_PI, (vec3){0,1,0} );
+	glm_mat4_mul( n, m, m );
+	glm_rotate_make( n, (float)angle[2]/0xff*2*GLM_PI, (vec3){0,0,1} );
+	glm_mat4_mul( n, m, m );
+
+	gload_mat4( shader, "rot", (float*)m );
 }

src/mesh.c

@@ -7,28 +7,25 @@ struct obj
 	unsigned int vertex, vao, vbo;
 };
 
-void * create_mesh( int * mesh )
+void * create_mesh( float * mesh )
 {
 	struct obj * p;
 
 	p=malloc(sizeof(struct obj));
 
-	p->vertex=(*mesh)/4;
+	p->vertex=(*mesh)/3;
 
 	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, 
+	glBufferData( GL_ARRAY_BUFFER, (p->vertex*3)*sizeof(int), mesh+1, 
 		GL_STATIC_DRAW );
 
-	glVertexAttribPointer( 0,3,GL_INT, 0, 4*sizeof(int), NULL );
+	glVertexAttribPointer( 0,3,GL_FLOAT, 0, 3*sizeof(int), NULL );
 	glEnableVertexAttribArray(0);
 
-	glVertexAttribPointer( 1,1,GL_INT, 0, 4*sizeof(int), 
-		(void*)(3*sizeof(int)) );
-	glEnableVertexAttribArray(1);
 	return p;
 }
 

src/shader.c

@@ -44,6 +44,7 @@ unsigned char gload_program( unsigned int program, const char * src,
 #ifdef DEBUG
 		char log[256];
 		glGetShaderInfoLog( shader, 256, NULL, log );
+		printf( log );
 #endif
 		return 0;
 	}

src/texture.c

@@ -0,0 +1,37 @@
+#include "main.h"
+#include <GL/gl.h>
+
+#define TYPE GL_TEXTURE_2D_ARRAY
+
+unsigned int config_texture( unsigned short type )
+{
+	unsigned int 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( unsigned int texture )
+{
+	return glBindTexture( TYPE, texture );
+}
+
+void destroy_texture( unsigned int texture )
+{
+	return glDeleteTextures( 1, &texture );
+}
+
+unsigned int create_palette_texture( const unsigned char * colors )
+{
+	unsigned int texture = config_texture( TYPE );
+	glTexImage3D( TYPE, 0, GL_RGBA,
+		1, 1, (*colors)/4, 0, GL_RGBA, GL_UNSIGNED_BYTE, colors+1);
+	return texture;
+}