World background working on cycle nodes.

This is added in the spirit of the general cycles GLSL system
which is pretty much WIP still.

This will only work on cycles at the moment but generating for blender
internal is possible too of course though it will be done in a separate
commit.

This hasn't been tested with all and every node in cycles, but
environment and regular textures with texture coordinates work.

There is some difference between the way cycles treats some coordinates,
which is in world space and the way GLSL treats them, which is in view
space.
We might want to explore and improve this further in the future.

...also </drumroll>

8 files changed, 203 insertions, 58 deletions

diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index 63eea9486ed..361c247767f 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -73,6 +73,7 @@ data_to_c_simple(shaders/gpu_shader_sep_gaussian_blur_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_simple_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_simple_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_vertex.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_vertex_world.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_vsm_store_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_vsm_store_vert.glsl SRC)
 
diff --git a/source/blender/gpu/GPU_material.h b/source/blender/gpu/GPU_material.h
index fab9c28cb61..09a5653b1ec 100644
--- a/source/blender/gpu/GPU_material.h
+++ b/source/blender/gpu/GPU_material.h
@@ -58,6 +58,7 @@ struct GPUMaterial;
 struct GPUTexture;
 struct GPULamp;
 struct PreviewImage;
+struct World;
 
 typedef struct GPUNode GPUNode;
 typedef struct GPUNodeLink GPUNodeLink;
@@ -95,6 +96,12 @@ typedef enum GPUOpenGLBuiltin {
 	GPU_COLOR = 2,
 } GPUOpenGLBuiltin;
 
+typedef enum GPUMatType {
+	GPU_MATERIAL_TYPE_MESH  = 1,
+	GPU_MATERIAL_TYPE_WORLD = 2,	
+} GPUMatType;
+
+
 typedef enum GPUBlendMode {
 	GPU_BLEND_SOLID = 0,
 	GPU_BLEND_ADD = 1,
@@ -131,10 +138,11 @@ void GPU_material_enable_alpha(GPUMaterial *material);
 GPUBlendMode GPU_material_alpha_blend(GPUMaterial *material, float obcol[4]);
 
 /* High level functions to create and use GPU materials */
+GPUMaterial *GPU_material_world(struct Scene *scene, struct World *wo);
 
 GPUMaterial *GPU_material_from_blender(struct Scene *scene, struct Material *ma);
 GPUMaterial *GPU_material_matcap(struct Scene *scene, struct Material *ma);
-void GPU_material_free(struct Material *ma);
+void GPU_material_free(struct ListBase *gpumaterial);
 
 void GPU_materials_free(void);
 
@@ -144,6 +152,7 @@ void GPU_material_bind_uniforms(GPUMaterial *material, float obmat[4][4], float
 void GPU_material_unbind(GPUMaterial *material);
 int GPU_material_bound(GPUMaterial *material);
 struct Scene *GPU_material_scene(GPUMaterial *material);
+GPUMatType GPU_Material_get_type(GPUMaterial *material);
 
 void GPU_material_vertex_attributes(GPUMaterial *material,
 	struct GPUVertexAttribs *attrib);
diff --git a/source/blender/gpu/SConscript b/source/blender/gpu/SConscript
index f11ecafc986..e44a99286a8 100644
--- a/source/blender/gpu/SConscript
+++ b/source/blender/gpu/SConscript
@@ -69,6 +69,7 @@ sources.extend((
     os.path.join(env['DATA_SOURCES'], "gpu_shader_sep_gaussian_blur_frag.glsl.c"),
     os.path.join(env['DATA_SOURCES'], "gpu_shader_sep_gaussian_blur_vert.glsl.c"),
     os.path.join(env['DATA_SOURCES'], "gpu_shader_vertex.glsl.c"),
+    os.path.join(env['DATA_SOURCES'], "gpu_shader_vertex_world.glsl.c"),
     os.path.join(env['DATA_SOURCES'], "gpu_shader_vsm_store_frag.glsl.c"),
     os.path.join(env['DATA_SOURCES'], "gpu_shader_vsm_store_vert.glsl.c"),
     ))
diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index 4182f51561b..1b99c6ee49a 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -58,6 +58,7 @@
 
 extern char datatoc_gpu_shader_material_glsl[];
 extern char datatoc_gpu_shader_vertex_glsl[];
+extern char datatoc_gpu_shader_vertex_world_glsl[];
 
 
 static char *glsl_material_library = NULL;
@@ -252,7 +253,7 @@ void gpu_codegen_exit(void)
 	extern Material defmaterial;    // render module abuse...
 
 	if (defmaterial.gpumaterial.first)
-		GPU_material_free(&defmaterial);
+		GPU_material_free(&defmaterial.gpumaterial);
 
 	if (FUNCTION_HASH) {
 		BLI_ghash_free(FUNCTION_HASH, NULL, MEM_freeN);
@@ -624,8 +625,7 @@ static char *code_generate_fragment(ListBase *nodes, GPUOutput *output, const ch
 
 	if (builtins & GPU_VIEW_NORMAL)
 		BLI_dynstr_append(ds, "\tvec3 facingnormal = (gl_FrontFacing)? varnormal: -varnormal;\n");
-		
-
+	
 	codegen_declare_tmps(ds, nodes);
 	codegen_call_functions(ds, nodes, output);
 
@@ -640,12 +640,13 @@ static char *code_generate_fragment(ListBase *nodes, GPUOutput *output, const ch
 	return code;
 }
 
-static char *code_generate_vertex(ListBase *nodes)
+static char *code_generate_vertex(ListBase *nodes, int type)
 {
 	DynStr *ds = BLI_dynstr_new();
 	GPUNode *node;
 	GPUInput *input;
 	char *code;
+	char *vertcode;
 	
 	for (node=nodes->first; node; node=node->next) {
 		for (input=node->inputs.first; input; input=input->next) {
@@ -659,8 +660,21 @@ static char *code_generate_vertex(ListBase *nodes)
 	}
 
 	BLI_dynstr_append(ds, "\n");
-	BLI_dynstr_append(ds, datatoc_gpu_shader_vertex_glsl);
 
+	switch (type) {
+		case GPU_MATERIAL_TYPE_MESH:
+			vertcode = datatoc_gpu_shader_vertex_glsl;
+			break;
+		case GPU_MATERIAL_TYPE_WORLD:
+			vertcode = datatoc_gpu_shader_vertex_world_glsl;
+			break;
+		default:
+			fprintf(stderr, "invalid material type, set one after GPU_material_construct_begin\n");
+			break;
+	}
+
+	BLI_dynstr_append(ds, vertcode);
+	
 	for (node=nodes->first; node; node=node->next)
 		for (input=node->inputs.first; input; input=input->next)
 			if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
@@ -1386,7 +1400,7 @@ static void gpu_nodes_prune(ListBase *nodes, GPUNodeLink *outlink)
 	}
 }
 
-GPUPass *GPU_generate_pass(ListBase *nodes, GPUNodeLink *outlink, GPUVertexAttribs *attribs, int *builtins, const char *name)
+GPUPass *GPU_generate_pass(ListBase *nodes, GPUNodeLink *outlink, GPUVertexAttribs *attribs, int *builtins, int type, const char *name)
 {
 	GPUShader *shader;
 	GPUPass *pass;
@@ -1405,7 +1419,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);
+	vertexcode = code_generate_vertex(nodes, type);
 	shader = GPU_shader_create(vertexcode, fragmentcode, glsl_material_library, NULL);
 
 	/* failed? */
diff --git a/source/blender/gpu/intern/gpu_codegen.h b/source/blender/gpu/intern/gpu_codegen.h
index 69213925931..a0698235db6 100644
--- a/source/blender/gpu/intern/gpu_codegen.h
+++ b/source/blender/gpu/intern/gpu_codegen.h
@@ -175,7 +175,7 @@ struct GPUPass {
 typedef struct GPUPass GPUPass;
 
 GPUPass *GPU_generate_pass(ListBase *nodes, struct GPUNodeLink *outlink,
-	struct GPUVertexAttribs *attribs, int *builtin, const char *name);
+	struct GPUVertexAttribs *attribs, int *builtin, int type, const char *name);
 
 struct GPUShader *GPU_pass_shader(GPUPass *pass);
 
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index e4228bedf9d..31b499d54ab 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -76,10 +76,15 @@ typedef enum DynMatProperty {
 	DYN_LAMP_PERSMAT = 8,
 } DynMatProperty;
 
+
 struct GPUMaterial {
 	Scene *scene;
 	Material *ma;
 
+	/* material for mesh surface, worlds or something else.
+	 * some code generation is done differently depending on the use case */
+	int type;
+	
 	/* for creating the material */
 	ListBase nodes;
 	GPUNodeLink *outlink;
@@ -194,7 +199,7 @@ static void gpu_material_set_attrib_id(GPUMaterial *material)
 	attribs->totlayer = b;
 }
 
-static int GPU_material_construct_end(GPUMaterial *material)
+static int GPU_material_construct_end(GPUMaterial *material, const char *passname)
 {
 	if (material->outlink) {
 		GPUNodeLink *outlink;
@@ -202,7 +207,7 @@ static int GPU_material_construct_end(GPUMaterial *material)
 
 		outlink = material->outlink;
 		material->pass = GPU_generate_pass(&material->nodes, outlink,
-			&material->attribs, &material->builtins, material->ma->id.name);
+			&material->attribs, &material->builtins, material->type, passname);
 
 		if (!material->pass)
 			return 0;
@@ -229,12 +234,12 @@ static int GPU_material_construct_end(GPUMaterial *material)
 	return 0;
 }
 
-void GPU_material_free(Material *ma)
+void GPU_material_free(ListBase *gpumaterial)
 {
 	LinkData *link;
 	LinkData *nlink, *mlink, *next;
 
-	for (link=ma->gpumaterial.first; link; link=link->next) {
+	for (link=gpumaterial->first; link; link=link->next) {
 		GPUMaterial *material = link->data;
 
 		if (material->pass)
@@ -243,19 +248,23 @@ void GPU_material_free(Material *ma)
 		for (nlink=material->lamps.first; nlink; nlink=nlink->next) {
 			GPULamp *lamp = nlink->data;
 
-			for (mlink=lamp->materials.first; mlink; mlink=next) {
-				next = mlink->next;
-				if (mlink->data == ma)
-					BLI_freelinkN(&lamp->materials, mlink);
+			if (material->ma) {
+				Material *ma = material->ma;
+				
+				for (mlink=lamp->materials.first; mlink; mlink=next) {
+					next = mlink->next;
+					if (mlink->data == ma)
+						BLI_freelinkN(&lamp->materials, mlink);
+				}
 			}
 		}
-
+		
 		BLI_freelistN(&material->lamps);
 
 		MEM_freeN(material);
 	}
 
-	BLI_freelistN(&ma->gpumaterial);
+	BLI_freelistN(gpumaterial);
 }
 
 bool GPU_lamp_override_visible(GPULamp *lamp, SceneRenderLayer *srl, Material *ma)
@@ -280,42 +289,44 @@ void GPU_material_bind(GPUMaterial *material, int oblay, int viewlay, double tim
 			viewlay &= srl->lay;
 
 		/* handle layer lamps */
-		for (nlink=material->lamps.first; nlink; nlink=nlink->next) {
-			lamp= nlink->data;
-
-			if (!lamp->hide && (lamp->lay & viewlay) && (!(lamp->mode & LA_LAYER) || (lamp->lay & oblay))
-			    && GPU_lamp_override_visible(lamp, srl, material->ma)) {
-				lamp->dynenergy = lamp->energy;
-				copy_v3_v3(lamp->dyncol, lamp->col);
-			}
-			else {
-				lamp->dynenergy = 0.0f;
-				lamp->dyncol[0]= lamp->dyncol[1]= lamp->dyncol[2] = 0.0f;
-			}
-
-			if (material->dynproperty & DYN_LAMP_VEC) {
-				copy_v3_v3(lamp->dynvec, lamp->vec);
-				normalize_v3(lamp->dynvec);
-				negate_v3(lamp->dynvec);
-				mul_mat3_m4_v3(viewmat, lamp->dynvec);
-			}
-
-			if (material->dynproperty & DYN_LAMP_CO) {
-				copy_v3_v3(lamp->dynco, lamp->co);
-				mul_m4_v3(viewmat, lamp->dynco);
-			}
-
-			if (material->dynproperty & DYN_LAMP_IMAT) {
-				mul_m4_m4m4(lamp->dynimat, lamp->imat, viewinv);
-			}
-
-			if (material->dynproperty & DYN_LAMP_PERSMAT) {
-				if (!GPU_lamp_has_shadow_buffer(lamp)) /* The lamp matrices are already updated if we're using shadow buffers */
-					GPU_lamp_update_buffer_mats(lamp);
-				mul_m4_m4m4(lamp->dynpersmat, lamp->persmat, viewinv);
+		if (material->type == GPU_MATERIAL_TYPE_MESH) {
+			for (nlink=material->lamps.first; nlink; nlink=nlink->next) {
+				lamp= nlink->data;
+				
+				if (!lamp->hide && (lamp->lay & viewlay) && (!(lamp->mode & LA_LAYER) || (lamp->lay & oblay))
+				        && GPU_lamp_override_visible(lamp, srl, material->ma)) {
+					lamp->dynenergy = lamp->energy;
+					copy_v3_v3(lamp->dyncol, lamp->col);
+				}
+				else {
+					lamp->dynenergy = 0.0f;
+					lamp->dyncol[0]= lamp->dyncol[1]= lamp->dyncol[2] = 0.0f;
+				}
+				
+				if (material->dynproperty & DYN_LAMP_VEC) {
+					copy_v3_v3(lamp->dynvec, lamp->vec);
+					normalize_v3(lamp->dynvec);
+					negate_v3(lamp->dynvec);
+					mul_mat3_m4_v3(viewmat, lamp->dynvec);
+				}
+				
+				if (material->dynproperty & DYN_LAMP_CO) {
+					copy_v3_v3(lamp->dynco, lamp->co);
+					mul_m4_v3(viewmat, lamp->dynco);
+				}
+				
+				if (material->dynproperty & DYN_LAMP_IMAT) {
+					mul_m4_m4m4(lamp->dynimat, lamp->imat, viewinv);
+				}
+				
+				if (material->dynproperty & DYN_LAMP_PERSMAT) {
+					if (!GPU_lamp_has_shadow_buffer(lamp)) /* The lamp matrices are already updated if we're using shadow buffers */
+						GPU_lamp_update_buffer_mats(lamp);
+					mul_m4_m4m4(lamp->dynpersmat, lamp->persmat, viewinv);
+				}
 			}
 		}
-
+		
 		/* note material must be bound before setting uniforms */
 		GPU_pass_bind(material->pass, time, mipmap);
 
@@ -376,6 +387,12 @@ Scene *GPU_material_scene(GPUMaterial *material)
 	return material->scene;
 }
 
+GPUMatType GPU_Material_get_type(GPUMaterial *material)
+{
+	return material->type;
+}
+
+
 void GPU_material_vertex_attributes(GPUMaterial *material, GPUVertexAttribs *attribs)
 {
 	*attribs = material->attribs;
@@ -1589,6 +1606,7 @@ GPUMaterial *GPU_material_matcap(Scene *scene, Material *ma)
 	/* allocate material */
 	mat = GPU_material_construct_begin(ma);
 	mat->scene = scene;
+	mat->type = GPU_MATERIAL_TYPE_MESH;
 	
 	if (ma->preview && ma->preview->rect[0]) {
 		outlink = gpu_material_preview_matcap(mat, ma);
@@ -1599,7 +1617,7 @@ GPUMaterial *GPU_material_matcap(Scene *scene, Material *ma)
 		
 	GPU_material_output_link(mat, outlink);
 
-	GPU_material_construct_end(mat);
+	GPU_material_construct_end(mat, "matcap_pass");
 	
 	/* note that even if building the shader fails in some way, we still keep
 	 * it to avoid trying to compile again and again, and simple do not use
@@ -1612,6 +1630,45 @@ GPUMaterial *GPU_material_matcap(Scene *scene, Material *ma)
 	return mat;
 }
 
+GPUMaterial *GPU_material_world(struct Scene *scene, struct World *wo)
+{
+	LinkData *link;
+	GPUMaterial *mat;
+
+	for (link=wo->gpumaterial.first; link; link=link->next)
+		if (((GPUMaterial*)link->data)->scene == scene)
+			return link->data;
+
+	/* allocate material */
+	mat = GPU_material_construct_begin(NULL);
+	mat->scene = scene;
+	mat->type = GPU_MATERIAL_TYPE_WORLD;
+	
+	/* create nodes */
+	if (BKE_scene_use_new_shading_nodes(scene) && wo->nodetree && wo->use_nodes)
+		ntreeGPUMaterialNodes(wo->nodetree, mat, NODE_NEW_SHADING);
+	else {
+		/* old fixed function world */
+	}
+
+	if (GPU_material_do_color_management(mat))
+		if (mat->outlink)
+			GPU_link(mat, "linearrgb_to_srgb", mat->outlink, &mat->outlink);
+
+	GPU_material_construct_end(mat, wo->id.name);
+	
+	/* note that even if building the shader fails in some way, we still keep
+	 * it to avoid trying to compile again and again, and simple do not use
+	 * the actual shader on drawing */
+
+	link = MEM_callocN(sizeof(LinkData), "GPUMaterialLink");
+	link->data = mat;
+	BLI_addtail(&wo->gpumaterial, link);
+
+	return mat;
+}
+
+
 GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma)
 {
 	GPUMaterial *mat;
@@ -1625,6 +1682,7 @@ GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma)
 	/* allocate material */
 	mat = GPU_material_construct_begin(ma);
 	mat->scene = scene;
+	mat->type = GPU_MATERIAL_TYPE_MESH;
 
 	/* render pipeline option */
 	if (ma->mode & MA_TRANSP)
@@ -1654,7 +1712,7 @@ GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma)
 		if (mat->outlink)
 			GPU_link(mat, "linearrgb_to_srgb", mat->outlink, &mat->outlink);
 
-	GPU_material_construct_end(mat);
+	GPU_material_construct_end(mat, ma->id.name);
 
 	/* note that even if building the shader fails in some way, we still keep
 	 * it to avoid trying to compile again and again, and simple do not use
@@ -1671,12 +1729,16 @@ void GPU_materials_free(void)
 {
 	Object *ob;
 	Material *ma;
+	World *wo;
 	extern Material defmaterial;
 
 	for (ma=G.main->mat.first; ma; ma=ma->id.next)
-		GPU_material_free(ma);
+		GPU_material_free(&ma->gpumaterial);
 
-	GPU_material_free(&defmaterial);
+	for (wo=G.main->world.first; wo; wo=wo->id.next)
+		GPU_material_free(&ma->gpumaterial);
+	
+	GPU_material_free(&defmaterial.gpumaterial);
 
 	for (ob=G.main->object.first; ob; ob=ob->id.next)
 		GPU_lamp_free(ob);
@@ -1945,7 +2007,7 @@ void GPU_lamp_free(Object *ob)
 			BLI_freelinkN(&lamp->materials, nlink);
 
 			if (ma->gpumaterial.first)
-				GPU_material_free(ma);
+				GPU_material_free(&ma->gpumaterial);
 		}
 
 		gpu_lamp_shadow_free(lamp);
diff --git a/source/blender/gpu/shaders/gpu_shader_material.glsl b/source/blender/gpu/shaders/gpu_shader_material.glsl
index 867270a6d7a..c463fb25ded 100644
--- a/source/blender/gpu/shaders/gpu_shader_material.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_material.glsl
@@ -2256,6 +2256,22 @@ void node_emission(vec4 color, float strength, vec3 N, out vec4 result)
 	result = color*strength;
 }
 
+/* background */
+
+void background_transform_to_world(vec3 viewvec, out vec3 worldvec)
+{
+	vec4 v = (gl_ProjectionMatrix[3][3] == 0.0) ? vec4(viewvec, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
+	vec4 co_homogenous = (gl_ProjectionMatrixInverse * v);
+
+	vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
+	worldvec = (gl_ModelViewMatrixInverse * co).xyz;
+}
+
+void node_background(vec4 color, float strength, vec3 N, out vec4 result)
+{
+	result = color*strength;
+}
+
 /* closures */
 
 void node_mix_shader(float fac, vec4 shader1, vec4 shader2, out vec4 shader)
@@ -2364,6 +2380,30 @@ void node_tex_coord(vec3 I, vec3 N, mat4 viewinvmat, mat4 obinvmat,
 	reflection = (viewinvmat*vec4(view_reflection, 0.0)).xyz;
 }
 
+void node_tex_coord_background(vec3 I, vec3 N, mat4 viewinvmat, mat4 obinvmat,
+	vec3 attr_orco, vec3 attr_uv,
+	out vec3 generated, out vec3 normal, out vec3 uv, out vec3 object,
+	out vec3 camera, out vec3 window, out vec3 reflection)
+{
+	vec4 v = (gl_ProjectionMatrix[3][3] == 0.0) ? vec4(I, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
+	vec4 co_homogenous = (gl_ProjectionMatrixInverse * v);
+
+	vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
+
+	co = normalize(co);
+	vec3 coords = (gl_ModelViewMatrixInverse * co).xyz;
+
+	generated = coords;
+	normal = -coords;
+	uv = attr_uv;
+	object = coords;
+
+	camera = co.xyz;
+	window = mtex_2d_mapping(I);
+
+	reflection = -coords;
+}
+
 /* textures */
 
 void node_tex_gradient(vec3 co, out vec4 color, out float fac)
@@ -2525,6 +2565,11 @@ void node_output_material(vec4 surface, vec4 volume, float displacement, out vec
 	result = surface;
 }
 
+void node_output_world(vec4 surface, vec4 volume, out vec4 result)
+{
+	result = surface;
+}
+
 /* ********************** matcap style render ******************** */
 
 void material_preview_matcap(vec4 color, sampler2D ima, vec4 N, vec4 mask, out vec4 result)
diff --git a/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl b/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl
new file mode 100644
index 00000000000..9dbcaeb7a32
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl
@@ -0,0 +1,13 @@
+
+varying vec3 varposition;
+varying vec3 varnormal;
+
+void main()
+{
+	/* position does not need to be transformed, we already have it */
+	gl_Position = gl_Vertex;
+
+	varposition = gl_Vertex.xyz;
+
+	varnormal = normalize(-varposition);
+