OpenGL: implemenation of fixed function lighting as per pixel GLSL shaders. The

code is still unused, but the intention is to use this to solve the double sided
lighting problem on NVidia, and to make the materials work on OpenGL ES 2.0
eventually.

The code works and matches the fixed function lighting pretty much exactly, but
still needs optimizations. The actual integration in object draw will be
committed later when more fixing & testing, there's lots of different combinations
and unclear OpenGL state here.

4 files changed, 227 insertions, 18 deletions

diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index b27a4be9f21..59953659a2c 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -237,8 +237,6 @@ GPUFunction *GPU_lookup_function(const char *name)
 	if (!FUNCTION_HASH) {
 		FUNCTION_HASH = BLI_ghash_str_new("GPU_lookup_function gh");
 		gpu_parse_functions_string(FUNCTION_HASH, glsl_material_library);
-		/*FUNCTION_PROTOTYPES = gpu_generate_function_prototyps(FUNCTION_HASH);
-		FUNCTION_LIB = GPU_shader_create_lib(datatoc_gpu_shader_material_glsl);*/
 	}
 
 	return (GPUFunction*)BLI_ghash_lookup(FUNCTION_HASH, (void *)name);
@@ -758,7 +756,7 @@ static void GPU_nodes_extract_dynamic_inputs(GPUPass *pass, ListBase *nodes)
 		}
 	}
 
-	GPU_shader_unbind(shader);
+	GPU_shader_unbind();
 }
 
 void GPU_pass_bind(GPUPass *pass, double time, int mipmap)
@@ -820,7 +818,7 @@ void GPU_pass_unbind(GPUPass *pass)
 			input->tex = NULL;
 	}
 	
-	GPU_shader_unbind(shader);
+	GPU_shader_unbind();
 }
 
 /* Node Link Functions */
@@ -1368,7 +1366,7 @@ GPUPass *GPU_generate_pass(ListBase *nodes, GPUNodeLink *outlink, GPUVertexAttri
 	/* generate code and compile with opengl */
 	fragmentcode = code_generate_fragment(nodes, outlink->output, name);
 	vertexcode = code_generate_vertex(nodes);
-	shader = GPU_shader_create(vertexcode, fragmentcode, glsl_material_library); /*FUNCTION_LIB);*/
+	shader = GPU_shader_create(vertexcode, fragmentcode, glsl_material_library, NULL);
 
 	/* failed? */
 	if (!shader) {
diff --git a/source/blender/gpu/intern/gpu_extensions.c b/source/blender/gpu/intern/gpu_extensions.c
index e8e47013159..56aa4b222cb 100644
--- a/source/blender/gpu/intern/gpu_extensions.c
+++ b/source/blender/gpu/intern/gpu_extensions.c
@@ -205,12 +205,15 @@ void GPU_extensions_init(void)
 #else
 	GG.os = GPU_OS_UNIX;
 #endif
+
+	GPU_fixed_materials_init();
 }
 
 void GPU_extensions_exit(void)
 {
 	gpu_extensions_init = 0;
 	GPU_codegen_exit();
+	GPU_fixed_materials_exit();
 }
 
 int GPU_glsl_support(void)
@@ -1006,7 +1009,7 @@ void GPU_framebuffer_blur(GPUFrameBuffer *fb, GPUTexture *tex, GPUFrameBuffer *b
 	glTexCoord2d(0, 1); glVertex2f(1, -1);
 	glEnd();
 
-	GPU_shader_unbind(blur_shader);
+	GPU_shader_unbind();
 }
 
 /* GPUOffScreen */
@@ -1124,13 +1127,11 @@ static void shader_print_errors(const char *task, char *log, const char *code)
 	fprintf(stderr, "%s\n", log);
 }
 
-GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPUShader *lib,*/ const char *libcode)
+GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, const char *libcode, const char *defines)
 {
 	GLint status;
 	GLcharARB log[5000];
-	const char *fragsource[2];
 	GLsizei length = 0;
-	GLint count;
 	GPUShader *shader;
 
 	if (!GLEW_ARB_vertex_shader || !GLEW_ARB_fragment_shader)
@@ -1154,8 +1155,14 @@ GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPU
 	}
 
 	if (vertexcode) {
+		const char *source[2];
+		int num_source = 0;
+
+		if (defines) source[num_source++] = defines;
+		if (vertexcode) source[num_source++] = vertexcode;
+
 		glAttachObjectARB(shader->object, shader->vertex);
-		glShaderSourceARB(shader->vertex, 1, (const char**)&vertexcode, NULL);
+		glShaderSourceARB(shader->vertex, num_source, source, NULL);
 
 		glCompileShaderARB(shader->vertex);
 		glGetObjectParameterivARB(shader->vertex, GL_OBJECT_COMPILE_STATUS_ARB, &status);
@@ -1170,12 +1177,15 @@ GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPU
 	}
 
 	if (fragcode) {
-		count = 0;
-		if (libcode) fragsource[count++] = libcode;
-		if (fragcode) fragsource[count++] = fragcode;
+		const char *source[3];
+		int num_source = 0;
+
+		if (defines) source[num_source++] = defines;
+		if (libcode) source[num_source++] = libcode;
+		if (fragcode) source[num_source++] = fragcode;
 
 		glAttachObjectARB(shader->object, shader->fragment);
-		glShaderSourceARB(shader->fragment, count, fragsource, NULL);
+		glShaderSourceARB(shader->fragment, num_source, source, NULL);
 
 		glCompileShaderARB(shader->fragment);
 		glGetObjectParameterivARB(shader->fragment, GL_OBJECT_COMPILE_STATUS_ARB, &status);
@@ -1254,7 +1264,7 @@ void GPU_shader_bind(GPUShader *shader)
 	GPU_print_error("Post Shader Bind");
 }
 
-void GPU_shader_unbind(GPUShader *UNUSED(shader))
+void GPU_shader_unbind()
 {
 	GPU_print_error("Pre Shader Unbind");
 	glUseProgramObjectARB(0);
@@ -1296,6 +1306,16 @@ void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int leng
 	GPU_print_error("Post Uniform Vector");
 }
 
+void GPU_shader_uniform_int(GPUShader *UNUSED(shader), int location, int value)
+{
+	if (location == -1)
+		return;
+
+	GPU_print_error("Pre Uniform Int");
+	glUniform1iARB(location, value);
+	GPU_print_error("Post Uniform Int");
+}
+
 void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUTexture *tex)
 {
 	GLenum arbnumber;
@@ -1344,12 +1364,12 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 	switch (shader) {
 		case GPU_SHADER_VSM_STORE:
 			if (!GG.shaders.vsm_store)
-				GG.shaders.vsm_store = GPU_shader_create(datatoc_gpu_shader_vsm_store_vert_glsl, datatoc_gpu_shader_vsm_store_frag_glsl, NULL);
+				GG.shaders.vsm_store = GPU_shader_create(datatoc_gpu_shader_vsm_store_vert_glsl, datatoc_gpu_shader_vsm_store_frag_glsl, NULL, NULL);
 			retval = GG.shaders.vsm_store;
 			break;
 		case GPU_SHADER_SEP_GAUSSIAN_BLUR:
 			if (!GG.shaders.sep_gaussian_blur)
-				GG.shaders.sep_gaussian_blur = GPU_shader_create(datatoc_gpu_shader_sep_gaussian_blur_vert_glsl, datatoc_gpu_shader_sep_gaussian_blur_frag_glsl, NULL);
+				GG.shaders.sep_gaussian_blur = GPU_shader_create(datatoc_gpu_shader_sep_gaussian_blur_vert_glsl, datatoc_gpu_shader_sep_gaussian_blur_frag_glsl, NULL, NULL);
 			retval = GG.shaders.sep_gaussian_blur;
 			break;
 	}
diff --git a/source/blender/gpu/intern/gpu_fixed_material.c b/source/blender/gpu/intern/gpu_fixed_material.c
new file mode 100644
index 00000000000..d5a04c88e89
--- /dev/null
+++ b/source/blender/gpu/intern/gpu_fixed_material.c
@@ -0,0 +1,191 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2013 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Brecht Van Lommel.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/gpu/intern/gpu_fixed_material.c
+ *  \ingroup gpu
+ */
+
+/* GLSL shaders to replace fixed function OpenGL materials and lighting. These
+ * are deprecated in newer OpenGL versions and missing in OpenGL ES 2.0. Also,
+ * two sided lighting is no longer natively supported on NVidia cards which
+ * results in slow software fallback.
+ *
+ * Todo:
+ * - Replace glLight and glMaterial functions entirely with GLSL uniforms, to
+ *   make OpenGL ES 2.0 work.
+ * - Replace glTexCoord and glColor with generic attributes.
+ * - Optimize for case where fewer than 3 or 8 lights are used.
+ * - Optimize for case where specular is not used.
+ * - Optimize for case where no texture matrix is used.
+ */
+
+#include "GL/glew.h"
+
+#include "BLI_math.h"
+#include "BLI_utildefines.h"
+
+#include "DNA_mesh_types.h"
+#include "DNA_object_types.h"
+
+#include "GPU_extensions.h"
+
+/* Fixed function material types */
+
+static struct {
+	GPUShader *cached_shaders[GPU_FIXED_OPTION_COMBINATIONS];
+	bool failed_shaders[GPU_FIXED_OPTION_COMBINATIONS];
+
+	bool need_normals;
+} GPU_MATERIAL_STATE;
+
+/* Init / exit */
+
+void GPU_fixed_materials_init()
+{
+	memset(&GPU_MATERIAL_STATE, 0, sizeof(GPU_MATERIAL_STATE));
+}
+
+void GPU_fixed_materials_exit()
+{
+	int i;
+	
+	for (i = 0; i < GPU_FIXED_OPTION_COMBINATIONS; i++)
+		if (GPU_MATERIAL_STATE.cached_shaders[i])
+			GPU_shader_free(GPU_MATERIAL_STATE.cached_shaders[i]);
+}
+
+/* Shader lookup / create */
+
+static GPUShader *gpu_fixed_material_shader(int options)
+{
+	/* glsl code */
+	extern char datatoc_gpu_shader_fixed_vertex_glsl[];
+	extern char datatoc_gpu_shader_fixed_fragment_glsl[];
+
+	/* cached shaders */
+	GPUShader *shader = GPU_MATERIAL_STATE.cached_shaders[options];
+
+	if (!shader && !GPU_MATERIAL_STATE.failed_shaders[options]) {
+		/* create shader if it doesn't exist yet */
+		char defines[64*GPU_FIXED_OPTIONS_NUM] = "";
+
+		if (options & GPU_FIXED_COLOR_MATERIAL)
+			strcat(defines, "#define USE_COLOR\n");
+		if (options & GPU_FIXED_TWO_SIDED)
+			strcat(defines, "#define USE_TWO_SIDED\n");
+		if (options & GPU_FIXED_SOLID_LIGHTING)
+			strcat(defines, "#define USE_SOLID_LIGHTING\n");
+		if (options & GPU_FIXED_SCENE_LIGHTING)
+			strcat(defines, "#define USE_SCENE_LIGHTING\n");
+		if (options & GPU_FIXED_TEXTURE_2D)
+			strcat(defines, "#define USE_TEXTURE\n");
+
+		shader = GPU_shader_create(
+			datatoc_gpu_shader_fixed_vertex_glsl,
+			datatoc_gpu_shader_fixed_fragment_glsl,
+			NULL, defines);
+		
+		if (shader) {
+			/* set texture map to first texture unit */
+			if (options & GPU_FIXED_TEXTURE_2D)
+				glUniform1i(GPU_shader_get_uniform(shader, "texture_map"), 0);
+
+			GPU_MATERIAL_STATE.cached_shaders[options] = shader;
+		}
+		else
+			GPU_MATERIAL_STATE.failed_shaders[options] = true;
+	}
+
+	return shader;
+}
+
+/* Bind / unbind */
+
+void GPU_fixed_material_shader_bind(int options)
+{
+	if (GPU_glsl_support()) {
+		GPUShader *shader = gpu_fixed_material_shader(options);
+
+		if (shader)
+			GPU_shader_bind(shader);
+	}
+	else {
+		if (options & (GPU_FIXED_SOLID_LIGHTING|GPU_FIXED_SCENE_LIGHTING))
+			glEnable(GL_LIGHTING);
+
+		if (options & GPU_FIXED_TWO_SIDED)
+			glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
+
+		if (options & GPU_FIXED_COLOR_MATERIAL) {
+			glEnable(GL_COLOR_MATERIAL);
+			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+		}
+
+		if (options & GPU_FIXED_TEXTURE_2D)
+			glEnable(GL_TEXTURE_2D);
+	}
+
+	/* temporary hack, should be solved outside of this file */
+	GPU_MATERIAL_STATE.need_normals = (options & (GPU_FIXED_SOLID_LIGHTING|GPU_FIXED_SCENE_LIGHTING));
+}
+
+void GPU_fixed_material_shader_unbind()
+{
+	if (GPU_glsl_support()) {
+		GPU_shader_unbind();
+	}
+	else {
+		glDisable(GL_LIGHTING);
+		glDisable(GL_COLOR_MATERIAL);
+		glDisable(GL_TEXTURE_2D);
+		glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
+	}
+}
+
+/* Material Colors */
+
+void GPU_fixed_material_colors(const float diffuse[3], const float specular[3],
+	int shininess, float alpha)
+{
+	float gl_diffuse[4], gl_specular[4];
+
+	copy_v3_v3(gl_diffuse, diffuse);
+	gl_diffuse[3] = alpha;
+
+	copy_v3_v3(gl_specular, specular);
+	gl_specular[3] = 1.0f;
+
+	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
+	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
+	glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, CLAMPIS(shininess, 1, 128));
+}
+
+bool GPU_fixed_material_need_normals()
+{
+	return GPU_MATERIAL_STATE.need_normals;
+}
+
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index b5ef27a338d..d7ac6febfb7 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -1919,7 +1919,7 @@ void GPU_lamp_shadow_buffer_bind(GPULamp *lamp, float viewmat[4][4], int *winsiz
 void GPU_lamp_shadow_buffer_unbind(GPULamp *lamp)
 {
 	if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE) {
-		GPU_shader_unbind(GPU_shader_get_builtin_shader(GPU_SHADER_VSM_STORE));
+		GPU_shader_unbind();
 		GPU_framebuffer_blur(lamp->fb, lamp->tex, lamp->blurfb, lamp->blurtex);
 	}