Move shader utilities to a separate file

git-svn-id: svn://cook.msm.cam.ac.uk:745/thrust3d/thrust3d@211 84d2e878-0bd5-11dd-ad15-13eda11d74c5

1 files changed, 34 insertions, 133 deletions

diff --git a/src/render.c b/src/render.c
index c554e8a..ce25c5e 100644
--- a/src/render.c
+++ b/src/render.c
@@ -25,128 +25,29 @@
 #include "texture.h"
 #include "utils.h"
 #include "render-text.h"
+#include "shaderutils.h"
 
 #define PANEL_ALPHA 0.3
 
-static void render_setunf(GLuint program, const char *name, GLfloat val) {
-	GLint loc;
-	loc = glGetUniformLocation(program, name);
-	glUniform1f(loc, val);
-}
-
-static void render_setun2f(GLuint program, const char *name, GLfloat val1, GLfloat val2) {
-	GLint loc;
-	loc = glGetUniformLocation(program, name);
-	glUniform2f(loc, val1, val2);
-}
-
-static void render_setuni(GLuint program, const char *name, GLint val) {
-	GLint loc;
-	loc = glGetUniformLocation(program, name);
-	glUniform1i(loc, val);
-}
-
-/* Utility function to load and compile a shader, checking the info log */
-static GLuint render_load_shader(const char *filename, GLenum type) {
-
-	GLuint shader;
-	char text[4096];
-	size_t len;
-	FILE *fh;
-	int l;
-	GLint status;
-	
-	fh = fopen(filename, "r");
-	if ( fh == NULL ) {
-		fprintf(stderr, "Couldn't load shader '%s'\n", filename);
-		return 0;
-	}
-	len = fread(text, 1, 4095, fh);
-	fclose(fh);
-	text[len] = '\0';
-	const GLchar *source = text;
-	shader = glCreateShader(type);
-	glShaderSource(shader, 1, &source, NULL);
-	glCompileShader(shader);
-	glGetShaderiv(shader, GL_COMPILE_STATUS, &status); 
-	if ( status == GL_FALSE ) {
-		glGetShaderInfoLog(shader, 4095, &l, text);
-		if ( l > 0 ) {
-			printf("%s\n", text); fflush(stdout);
-		} else {
-			printf("Shader compilation failed.\n");
-		}
-	}
-	
-	return shader;
-	
-}
-
-static int render_link_program(GLuint program) {
-
-	int l;
-	GLint status;
-	char text[4096];
-	
-	glLinkProgram(program);
-	
-	glGetProgramiv(program, GL_LINK_STATUS, &status); 
-	if ( status == GL_FALSE ) {
-		printf("Program linking errors:\n");
-		glGetProgramInfoLog(program, 4095, &l, text);
-		if ( l > 0 ) {
-			printf("%s\n", text); fflush(stdout);
-		} else {
-			printf("Program linking failed.\n");
-		}
-	}
-	
-	return status;
-	
-}
-
-static int render_validate_program(GLuint program) {
-	
-	GLint status;
-	int l;
-	char text[4096];
-	
-	glValidateProgram(program);
-	glGetProgramiv(program, GL_VALIDATE_STATUS, &status); 
-	if ( status == GL_FALSE ) {
-		printf("Program validation errors:\n");
-		glGetProgramInfoLog(program, 4095, &l, text);
-		if ( l > 0 ) {
-			printf("%s\n", text); fflush(stdout);
-		} else {
-			printf("Program did not validate successfully.\n");
-		}
-		return 0;
-	}
-	
-	return 1;
-	
-}
-
 static void render_load_shaders(RenderContext *r) {
 	
 	/* Lighting */
-	r->lighting_vert = render_load_shader(DATADIR"/shaders/lighting.vert", GL_VERTEX_SHADER);
-	r->lighting_frag = render_load_shader(DATADIR"/shaders/lighting.frag", GL_FRAGMENT_SHADER);
+	r->lighting_vert = shaderutils_load_shader(DATADIR"/shaders/lighting.vert", GL_VERTEX_SHADER);
+	r->lighting_frag = shaderutils_load_shader(DATADIR"/shaders/lighting.frag", GL_FRAGMENT_SHADER);
 	r->lighting_program = glCreateProgram();
 	glAttachShader(r->lighting_program, r->lighting_vert);
 	glAttachShader(r->lighting_program, r->lighting_frag);
-	render_link_program(r->lighting_program);
-	render_validate_program(r->lighting_program);
+	shaderutils_link_program(r->lighting_program);
+	shaderutils_validate_program(r->lighting_program);
 	
 	/* Swirlyness */
-	r->swirly_vert = render_load_shader(DATADIR"/shaders/swirlytron.vert", GL_VERTEX_SHADER);
-	r->swirly_frag = render_load_shader(DATADIR"/shaders/swirlytron.frag", GL_FRAGMENT_SHADER);
+	r->swirly_vert = shaderutils_load_shader(DATADIR"/shaders/swirlytron.vert", GL_VERTEX_SHADER);
+	r->swirly_frag = shaderutils_load_shader(DATADIR"/shaders/swirlytron.frag", GL_FRAGMENT_SHADER);
 	r->swirly_program = glCreateProgram();
 	glAttachShader(r->swirly_program, r->swirly_vert);
 	glAttachShader(r->swirly_program, r->swirly_frag);
-	render_link_program(r->swirly_program);
-	render_validate_program(r->swirly_program);
+	shaderutils_link_program(r->swirly_program);
+	shaderutils_validate_program(r->swirly_program);
 	
 }
 
@@ -295,7 +196,7 @@ static int render_model_instance_draw(ModelInstance *instance, Uint32 t, RenderC
 	GLfloat black[] = {0.0, 0.0, 0.0, 1.0};
 	int wibble;
 	
-	if ( r->shaders ) render_setunf(r->lighting_program, "alpha", alpha);
+	if ( r->shaders ) shaderutils_setunf(r->lighting_program, "alpha", alpha);
 	
 	if ( nvert == NULL ) nvert = &wibble;
 	
@@ -347,10 +248,10 @@ static int render_model_instance_draw(ModelInstance *instance, Uint32 t, RenderC
 				glEnable(GL_TEXTURE_2D);
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-				render_setuni(r->lighting_program, "texture_emits", 1);
+				shaderutils_setuni(r->lighting_program, "texture_emits", 1);
 			} else {
 				if ( r->shaders ) {
-					render_setuni(r->lighting_program, "texture_enabled", 0);
+					shaderutils_setuni(r->lighting_program, "texture_enabled", 0);
 				} /* else don't enable texturing */
 			}
 		} else if ( p->texture != NULL ) {
@@ -360,18 +261,18 @@ static int render_model_instance_draw(ModelInstance *instance, Uint32 t, RenderC
 				glBindTexture(GL_TEXTURE_2D, texture->texname);
 				glEnable(GL_TEXTURE_2D);
 				glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-				if ( r->shaders ) render_setuni(r->lighting_program, "texture_enabled", 1);
+				if ( r->shaders ) shaderutils_setuni(r->lighting_program, "texture_enabled", 1);
 				if ( r->shaders && texture->has_normals ) {
 					glActiveTexture(GL_TEXTURE1);
 					glBindTexture(GL_TEXTURE_2D, texture->normalmap);
-					render_setuni(r->lighting_program, "has_normals", 1);
+					shaderutils_setuni(r->lighting_program, "has_normals", 1);
 					glActiveTexture(GL_TEXTURE0);
 				}
 			} else {
-				if ( r->shaders ) render_setuni(r->lighting_program, "texture_enabled", 0);
+				if ( r->shaders ) shaderutils_setuni(r->lighting_program, "texture_enabled", 0);
 			}
 		} else {
-			if ( r->shaders ) render_setuni(r->lighting_program, "texture_enabled", 0);
+			if ( r->shaders ) shaderutils_setuni(r->lighting_program, "texture_enabled", 0);
 		}
 		if ( r->vbos ) {
 			glBindBuffer(GL_ARRAY_BUFFER, p->vertices_buffer);
@@ -389,11 +290,11 @@ static int render_model_instance_draw(ModelInstance *instance, Uint32 t, RenderC
 		glDrawArrays(render_gltype(p->type), 0, p->num_vertices);
 		*nvert += p->num_vertices;
 		glDisable(GL_TEXTURE_2D);
-		render_setuni(r->lighting_program, "has_normals", 0);
+		shaderutils_setuni(r->lighting_program, "has_normals", 0);
 		glPopMatrix();
 		
 		if ( p->attribs & ATTRIB_SWIRLY ) {
-			if ( r->shaders ) render_setuni(r->lighting_program, "texture_emits", 0);
+			if ( r->shaders ) shaderutils_setuni(r->lighting_program, "texture_emits", 0);
 		}
 
 	}
@@ -633,21 +534,21 @@ void render_draw(Game *game, Uint32 t) {
 			GLfloat rrb = 0.0;
 		
 			glUseProgram(r->swirly_program);
-			render_setunf(game->render->swirly_program, "time", t);
-			render_setuni(game->render->swirly_program, "landed", game->lander->recharging);
+			shaderutils_setunf(game->render->swirly_program, "time", t);
+			shaderutils_setuni(game->render->swirly_program, "landed", game->lander->recharging);
 			if ( game->lander->recharging ) {
 				/* Fade in */
 				rrb = fminf(((GLfloat)t-game->time_of_landing_event)/1500.0, 1.0);
-				render_setuni(game->render->swirly_program, "rechargeripple", 1);
+				shaderutils_setuni(game->render->swirly_program, "rechargeripple", 1);
 			} else if ( game->time_of_landing_event - t < 750 ) {
 				/* Fade out */
 				rrb = fmaxf(1.0 - ((GLfloat)t-game->time_of_landing_event)/750.0, 0.0);
-				render_setuni(game->render->swirly_program, "rechargeripple", 1);
+				shaderutils_setuni(game->render->swirly_program, "rechargeripple", 1);
 			} else {
-				render_setuni(game->render->swirly_program, "rechargeripple", 0);
+				shaderutils_setuni(game->render->swirly_program, "rechargeripple", 0);
 			}
-			render_setunf(game->render->swirly_program, "rrb", rrb);
-			render_setun2f(game->render->swirly_program, "lander",
+			shaderutils_setunf(game->render->swirly_program, "rrb", rrb);
+			shaderutils_setun2f(game->render->swirly_program, "lander",
 									game->platform_rel_x, game->platform_rel_y);
 			
 		} /* else this is all a little pointless... */
@@ -698,12 +599,12 @@ void render_draw(Game *game, Uint32 t) {
 	
 	if ( r->shaders ) {
 		glUseProgram(r->lighting_program);
-		render_setuni(game->render->lighting_program, "texture", 0); /* GL_TEXTURE0 */
-		render_setuni(game->render->lighting_program, "normalmap", 1); /* GL_TEXTURE1 */
-		render_setuni(game->render->lighting_program, "texture_only", 0);
-		render_setuni(game->render->lighting_program, "texture_enabled", 1);
-		render_setuni(game->render->lighting_program, "has_normals", 0);
-		render_setuni(game->render->lighting_program, "fill_light_enabled", 0);
+		shaderutils_setuni(game->render->lighting_program, "texture", 0); /* GL_TEXTURE0 */
+		shaderutils_setuni(game->render->lighting_program, "normalmap", 1); /* GL_TEXTURE1 */
+		shaderutils_setuni(game->render->lighting_program, "texture_only", 0);
+		shaderutils_setuni(game->render->lighting_program, "texture_enabled", 1);
+		shaderutils_setuni(game->render->lighting_program, "has_normals", 0);
+		shaderutils_setuni(game->render->lighting_program, "fill_light_enabled", 0);
 	}
 	render_setup_lighting(game);
 	amb[0] = 0.02;  amb[1] = 0.02;  amb[2] = 0.02;
@@ -718,11 +619,11 @@ void render_draw(Game *game, Uint32 t) {
 	glEnableClientState(GL_VERTEX_ARRAY);
 	glEnableClientState(GL_NORMAL_ARRAY);
 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	if ( r->shaders ) render_setuni(game->render->lighting_program, "fill_light_enabled", 1);
+	if ( r->shaders ) shaderutils_setuni(game->render->lighting_program, "fill_light_enabled", 1);
 	render_model_instance_draw(game->lander, t, r, NULL, 1.0);
-	if ( r->shaders ) render_setuni(game->render->lighting_program, "fill_light_enabled", 0);
+	if ( r->shaders ) shaderutils_setuni(game->render->lighting_program, "fill_light_enabled", 0);
 	glPopClientAttrib();
-	if ( r->shaders ) render_setuni(game->render->lighting_program, "texture_enabled", 0);
+	if ( r->shaders ) shaderutils_setuni(game->render->lighting_program, "texture_enabled", 0);
 	render_draw_line(game->lander->x, game->lander->y, game->lander->z,
 			 game->lander->x, game->lander->y, game->lander->z-200.0);
 	glDisable(GL_LIGHT2);