Remove Blender Internal and legacy viewport from Blender 2.8.

Brecht authored this commit, but he gave me the honours to actually
do it. Here it goes; Blender Internal. Bye bye, you did great!

* Point density, voxel data, ocean, environment map textures were removed,
  as these only worked within BI rendering. Note that the ocean modifier
  and the Cycles point density shader node continue to work.
* Dynamic paint using material shading was removed, as this only worked
  with BI. If we ever wanted to support this again probably it should go
  through the baking API.
* GPU shader export through the Python API was removed. This only worked
  for the old BI GLSL shaders, which no longer exists. Doing something
  similar for Eevee would be significantly more complicated because it
  uses a lot of multiplass rendering and logic outside the shader, it's
  probably impractical.
* Collada material import / export code is mostly gone, as it only worked
  for BI materials. We need to add Cycles / Eevee material support at some
  point.
* The mesh noise operator was removed since it only worked with BI
  material texture slots. A displacement modifier can be used instead.
* The delete texture paint slot operator was removed since it only worked
  for BI material texture slots. Could be added back with node support.

* Not all legacy viewport features are supported in the new viewport, but
  their code was removed. If we need to bring anything back we can look at
  older git revisions.
* There is some legacy viewport code that I could not remove yet, and some
  that I probably missed.
* Shader node execution code was left mostly intact, even though it is not
  used anywhere now. We may eventually use this to replace the texture
  nodes with Cycles / Eevee shader nodes.

* The Cycles Bake panel now includes settings for baking multires normal
  and displacement maps. The underlying code needs to be merged properly,
  and we plan to add back support for multires AO baking and add support
  to Cycles baking for features like vertex color, displacement, and other
  missing baking features.

* This commit removes DNA and the Python API for BI material, lamp, world
  and scene settings. This breaks a lot of addons.
* There is more DNA that can be removed or renamed, where Cycles or Eevee
  are reusing some old BI properties but the names are not really correct
  anymore.
* Texture slots for materials, lamps and world were removed. They remain
  for brushes, particles and freestyle linestyles.
* 'BLENDER_RENDER' remains in the COMPAT_ENGINES of UI panels. Cycles and
  other renderers use this to find all panels to show, minus a few panels
  that they have their own replacement for.

25 files changed, 56 insertions, 1338 deletions

diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt
index ee70fcf510f..efe7db088f8 100644
--- a/source/blender/nodes/CMakeLists.txt
+++ b/source/blender/nodes/CMakeLists.txt
@@ -135,22 +135,17 @@ set(SRC
 	shader/nodes/node_shader_curves.c
 	shader/nodes/node_shader_gamma.c
 	shader/nodes/node_shader_brightness.c
-	shader/nodes/node_shader_geom.c
 	shader/nodes/node_shader_hueSatVal.c
 	shader/nodes/node_shader_invert.c
-	shader/nodes/node_shader_lamp.c
 	shader/nodes/node_shader_mapping.c
-	shader/nodes/node_shader_material.c
 	shader/nodes/node_shader_math.c
 	shader/nodes/node_shader_mixRgb.c
 	shader/nodes/node_shader_normal.c
-	shader/nodes/node_shader_output.c
 	shader/nodes/node_shader_rgb.c
 	shader/nodes/node_shader_sepcombRGB.c
 	shader/nodes/node_shader_sepcombHSV.c
 	shader/nodes/node_shader_sepcombXYZ.c
 	shader/nodes/node_shader_squeeze.c
-	shader/nodes/node_shader_texture.c
 	shader/nodes/node_shader_valToRgb.c
 	shader/nodes/node_shader_value.c
 	shader/nodes/node_shader_wireframe.c
diff --git a/source/blender/nodes/NOD_shader.h b/source/blender/nodes/NOD_shader.h
index a507fdbd787..e411ceb6a23 100644
--- a/source/blender/nodes/NOD_shader.h
+++ b/source/blender/nodes/NOD_shader.h
@@ -44,20 +44,15 @@ void register_node_tree_type_sh(void);
 
 void register_node_type_sh_group(void);
 
-void register_node_type_sh_output(void);
-void register_node_type_sh_material(void);
 void register_node_type_sh_camera(void);
-void register_node_type_sh_lamp(void);
 void register_node_type_sh_value(void);
 void register_node_type_sh_rgb(void);
 void register_node_type_sh_mix_rgb(void);
 void register_node_type_sh_valtorgb(void);
 void register_node_type_sh_rgbtobw(void);
-void register_node_type_sh_texture(void);
 void register_node_type_sh_normal(void);
 void register_node_type_sh_gamma(void);
 void register_node_type_sh_brightcontrast(void);
-void register_node_type_sh_geom(void);
 void register_node_type_sh_mapping(void);
 void register_node_type_sh_curve_vec(void);
 void register_node_type_sh_curve_rgb(void);
@@ -65,7 +60,6 @@ void register_node_type_sh_math(void);
 void register_node_type_sh_vect_math(void);
 void register_node_type_sh_squeeze(void);
 void register_node_type_sh_dynamic(void);
-void register_node_type_sh_material_ext(void);
 void register_node_type_sh_invert(void);
 void register_node_type_sh_seprgb(void);
 void register_node_type_sh_combrgb(void);
diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h
index 44713a7a000..299c3a627ee 100644
--- a/source/blender/nodes/NOD_static_types.h
+++ b/source/blender/nodes/NOD_static_types.h
@@ -40,27 +40,21 @@ DefNode( Node,           NODE_GROUP_INPUT,        def_group_input,        "GROUP
 DefNode( Node,           NODE_GROUP_OUTPUT,       def_group_output,       "GROUP_OUTPUT",   GroupOutput,      "Group Output",      ""              )
 DefNode( Node,           NODE_REROUTE,            0,                      "REROUTE",        Reroute,          "Reroute",           ""              )
 
-DefNode( ShaderNode,     SH_NODE_OUTPUT,          def_sh_output,          "OUTPUT",         Output,           "Output",            ""              )
-DefNode( ShaderNode,     SH_NODE_MATERIAL,        def_sh_material,        "MATERIAL",       Material,         "Material",          ""              )
 DefNode( ShaderNode,     SH_NODE_RGB,             0,                      "RGB",            RGB,              "RGB",               ""              )
 DefNode( ShaderNode,     SH_NODE_VALUE,           0,                      "VALUE",          Value,            "Value",             ""              )
 DefNode( ShaderNode,     SH_NODE_MIX_RGB,         def_mix_rgb,            "MIX_RGB",        MixRGB,           "MixRGB",            ""              )
 DefNode( ShaderNode,     SH_NODE_VALTORGB,        def_colorramp,          "VALTORGB",       ValToRGB,         "ColorRamp",         ""              )
 DefNode( ShaderNode,     SH_NODE_RGBTOBW,         0,                      "RGBTOBW",        RGBToBW,          "RGB to BW",         ""              )
-DefNode( ShaderNode,     SH_NODE_TEXTURE,         def_texture,            "TEXTURE",        Texture,          "Texture",           ""              )
 DefNode( ShaderNode,     SH_NODE_NORMAL,          0,                      "NORMAL",         Normal,           "Normal",            ""              )
 DefNode( ShaderNode,     SH_NODE_GAMMA,           0,                      "GAMMA",          Gamma,            "Gamma",             ""              )
 DefNode( ShaderNode,     SH_NODE_BRIGHTCONTRAST,  0,                      "BRIGHTCONTRAST", BrightContrast,   "Bright Contrast",   ""              )
-DefNode( ShaderNode,     SH_NODE_GEOMETRY,        def_sh_geometry,        "GEOMETRY",       Geometry,         "Geometry",          ""              )
 DefNode( ShaderNode,     SH_NODE_MAPPING,         def_sh_mapping,         "MAPPING",        Mapping,          "Mapping",           ""              )
 DefNode( ShaderNode,     SH_NODE_CURVE_VEC,       def_vector_curve,       "CURVE_VEC",      VectorCurve,      "Vector Curves",     ""              )
 DefNode( ShaderNode,     SH_NODE_CURVE_RGB,       def_rgb_curve,          "CURVE_RGB",      RGBCurve,         "RGB Curves",        ""              )
 DefNode( ShaderNode,     SH_NODE_CAMERA,          0,                      "CAMERA",         CameraData,       "Camera Data",       ""              )
-DefNode( ShaderNode,     SH_NODE_LAMP,            def_sh_lamp,            "LAMP",           LampData,         "Lamp Data",         ""              )
 DefNode( ShaderNode,     SH_NODE_MATH,            def_math,               "MATH",           Math,             "Math",              ""              )
 DefNode( ShaderNode,     SH_NODE_VECT_MATH,       def_vector_math,        "VECT_MATH",      VectorMath,       "Vector Math",       ""              )
 DefNode( ShaderNode,     SH_NODE_SQUEEZE,         0,                      "SQUEEZE",        Squeeze,          "Squeeze Value",     ""              )
-DefNode( ShaderNode,     SH_NODE_MATERIAL_EXT,    def_sh_material,        "MATERIAL_EXT",   ExtendedMaterial, "Extended Material", ""              )
 DefNode( ShaderNode,     SH_NODE_INVERT,          0,                      "INVERT",         Invert,           "Invert",            ""              )
 DefNode( ShaderNode,     SH_NODE_SEPRGB,          0,                      "SEPRGB",         SeparateRGB,      "Separate RGB",      ""              )
 DefNode( ShaderNode,     SH_NODE_COMBRGB,         0,                      "COMBRGB",        CombineRGB,       "Combine RGB",       ""              )
diff --git a/source/blender/nodes/intern/node_exec.c b/source/blender/nodes/intern/node_exec.c
index 0cf131adbdc..ac4031f4932 100644
--- a/source/blender/nodes/intern/node_exec.c
+++ b/source/blender/nodes/intern/node_exec.c
@@ -304,8 +304,6 @@ bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *call
 			 * If the mute func is not set, assume the node should never be muted,
 			 * and hence execute it!
 			 */
-//			if (node->typeinfo->compatibility == NODE_NEW_SHADING)
-//				return false;
 			if (node->typeinfo->execfunc && !(node->flag & NODE_MUTED))
 				node->typeinfo->execfunc(callerdata, thread, node, &nodeexec->data, nsin, nsout);
 		}
diff --git a/source/blender/nodes/shader/node_shader_tree.c b/source/blender/nodes/shader/node_shader_tree.c
index 07fe49889a0..f4e084929cc 100644
--- a/source/blender/nodes/shader/node_shader_tree.c
+++ b/source/blender/nodes/shader/node_shader_tree.c
@@ -72,7 +72,6 @@ static int shader_tree_poll(const bContext *C, bNodeTreeType *UNUSED(treetype))
 
 	/* allow empty engine string too, this is from older versions that didn't have registerable engines yet */
 	return (engine_id[0] == '\0' ||
-	        STREQ(engine_id, RE_engine_id_BLENDER_RENDER) ||
 	        STREQ(engine_id, RE_engine_id_CYCLES) ||
 	        !BKE_scene_use_shading_nodes_custom(scene));
 }
@@ -84,9 +83,7 @@ static void shader_get_from_context(const bContext *C, bNodeTreeType *UNUSED(tre
 	ViewLayer *view_layer = CTX_data_view_layer(C);
 	Object *ob = OBACT(view_layer);
 	
-	if ((snode->shaderfrom == SNODE_SHADER_OBJECT) ||
-	    (BKE_scene_use_new_shading_nodes(scene) == false))
-	{
+	if (snode->shaderfrom == SNODE_SHADER_OBJECT) {
 		if (ob) {
 			*r_from = &ob->id;
 			if (ob->type == OB_LAMP) {
@@ -121,16 +118,12 @@ static void shader_get_from_context(const bContext *C, bNodeTreeType *UNUSED(tre
 	}
 }
 
-static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback func)
+static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
 {
 	func(calldata, NODE_CLASS_INPUT, N_("Input"));
 	func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
-
-	if (BKE_scene_use_new_shading_nodes(scene)) {
-		func(calldata, NODE_CLASS_SHADER, N_("Shader"));
-		func(calldata, NODE_CLASS_TEXTURE, N_("Texture"));
-	}
-	
+	func(calldata, NODE_CLASS_SHADER, N_("Shader"));
+	func(calldata, NODE_CLASS_TEXTURE, N_("Texture"));
 	func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
 	func(calldata, NODE_CLASS_OP_VECTOR, N_("Vector"));
 	func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
@@ -625,16 +618,6 @@ void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat, short compatibili
 	MEM_freeN(localtree);
 }
 
-/* **************** call to switch lamploop for material node ************ */
-
-void (*node_shader_lamp_loop)(struct ShadeInput *, struct ShadeResult *);
-
-void set_node_shader_lamp_loop(void (*lamp_loop_func)(ShadeInput *, ShadeResult *))
-{
-	node_shader_lamp_loop = lamp_loop_func;
-}
-
-
 bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key)
 {
 	bNodeTreeExec *exec;
@@ -709,26 +692,14 @@ void ntreeShaderEndExecTree(bNodeTreeExec *exec)
 	}
 }
 
-/* only for Blender internal */
-bool ntreeShaderExecTree(bNodeTree *ntree, ShadeInput *shi, ShadeResult *shr)
+/* TODO: left over from Blender Internal, could reuse for new texture nodes. */
+bool ntreeShaderExecTree(bNodeTree *ntree, int thread)
 {
 	ShaderCallData scd;
-	/**
-	 * \note: preserve material from ShadeInput for material id, nodetree execs change it
-	 * fix for bug "[#28012] Mat ID messy with shader nodes"
-	 */
-	Material *mat = shi->mat;
 	bNodeThreadStack *nts = NULL;
 	bNodeTreeExec *exec = ntree->execdata;
 	int compat;
 	
-	/* convert caller data to struct */
-	scd.shi = shi;
-	scd.shr = shr;
-	
-	/* each material node has own local shaderesult, with optional copying */
-	memset(shr, 0, sizeof(ShadeResult));
-	
 	/* ensure execdata is only initialized once */
 	if (!exec) {
 		BLI_thread_lock(LOCK_NODES);
@@ -739,18 +710,10 @@ bool ntreeShaderExecTree(bNodeTree *ntree, ShadeInput *shi, ShadeResult *shr)
 		exec = ntree->execdata;
 	}
 	
-	nts = ntreeGetThreadStack(exec, shi->thread);
-	compat = ntreeExecThreadNodes(exec, nts, &scd, shi->thread);
+	nts = ntreeGetThreadStack(exec, thread);
+	compat = ntreeExecThreadNodes(exec, nts, &scd, thread);
 	ntreeReleaseThreadStack(nts);
 	
-	// \note: set material back to preserved material
-	shi->mat = mat;
-		
-	/* better not allow negative for now */
-	if (shr->combined[0] < 0.0f) shr->combined[0] = 0.0f;
-	if (shr->combined[1] < 0.0f) shr->combined[1] = 0.0f;
-	if (shr->combined[2] < 0.0f) shr->combined[2] = 0.0f;
-	
 	/* if compat is zero, it has been using non-compatible nodes */
 	return compat;
 }
diff --git a/source/blender/nodes/shader/node_shader_util.c b/source/blender/nodes/shader/node_shader_util.c
index 22171f28790..69a69c156e3 100644
--- a/source/blender/nodes/shader/node_shader_util.c
+++ b/source/blender/nodes/shader/node_shader_util.c
@@ -91,53 +91,6 @@ void nodestack_get_vec(float *in, short type_in, bNodeStack *ns)
 }
 
 
-/* go over all used Geometry and Texture nodes, and return a texco flag */
-/* no group inside needed, this function is called for groups too */
-void ntreeShaderGetTexcoMode(bNodeTree *ntree, int r_mode, short *texco, int *mode)
-{
-	bNode *node;
-	bNodeSocket *sock;
-	int a;
-	
-	for (node = ntree->nodes.first; node; node = node->next) {
-		if (node->type == SH_NODE_TEXTURE) {
-			if ((r_mode & R_OSA) && node->id) {
-				Tex *tex = (Tex *)node->id;
-				if (ELEM(tex->type, TEX_IMAGE, TEX_ENVMAP)) {
-					*texco |= TEXCO_OSA | NEED_UV;
-				}
-			}
-			/* usability exception... without input we still give the node orcos */
-			sock = node->inputs.first;
-			if (sock == NULL || sock->link == NULL)
-				*texco |= TEXCO_ORCO | NEED_UV;
-		}
-		else if (node->type == SH_NODE_GEOMETRY) {
-			/* note; sockets always exist for the given type! */
-			for (a = 0, sock = node->outputs.first; sock; sock = sock->next, a++) {
-				if (sock->flag & SOCK_IN_USE) {
-					switch (a) {
-						case GEOM_OUT_GLOB: 
-							*texco |= TEXCO_GLOB | NEED_UV; break;
-						case GEOM_OUT_VIEW: 
-							*texco |= TEXCO_VIEW | NEED_UV; break;
-						case GEOM_OUT_ORCO: 
-							*texco |= TEXCO_ORCO | NEED_UV; break;
-						case GEOM_OUT_UV: 
-							*texco |= TEXCO_UV | NEED_UV; break;
-						case GEOM_OUT_NORMAL: 
-							*texco |= TEXCO_NORM | NEED_UV; break;
-						case GEOM_OUT_VCOL:
-							*texco |= NEED_UV; *mode |= MA_VERTEXCOL; break;
-						case GEOM_OUT_VCOL_ALPHA:
-							*texco |= NEED_UV; *mode |= MA_VERTEXCOL; break;
-					}
-				}
-			}
-		}
-	}
-}
-
 void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, bNodeStack *ns)
 {
 	memset(gs, 0, sizeof(*gs));
diff --git a/source/blender/nodes/shader/node_shader_util.h b/source/blender/nodes/shader/node_shader_util.h
index 2363addb56a..94f89443b1d 100644
--- a/source/blender/nodes/shader/node_shader_util.h
+++ b/source/blender/nodes/shader/node_shader_util.h
@@ -77,7 +77,6 @@
 #include "RE_pipeline.h"
 #include "RE_shader_ext.h"
 
-#include "GPU_lamp.h"
 #include "GPU_material.h"
 #include "GPU_uniformbuffer.h"
 
@@ -89,11 +88,9 @@ void sh_node_type_base(struct bNodeType *ntype, int type, const char *name, shor
 /* ********* exec data struct, remains internal *********** */
 
 typedef struct ShaderCallData {
-	ShadeInput *shi;		/* from render pipe */
-	ShadeResult *shr;		/* from render pipe */
+	/* Empty for now, may be reused if we convert shader to texture nodes. */
 } ShaderCallData;
 
-
 void nodestack_get_vec(float *in, short type_in, bNodeStack *ns);
 
 void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, struct bNodeStack *ns);
diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.c b/source/blender/nodes/shader/nodes/node_shader_camera.c
index ac0880d22ba..245360e789f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_camera.c
+++ b/source/blender/nodes/shader/nodes/node_shader_camera.c
@@ -40,28 +40,12 @@ static bNodeSocketTemplate sh_node_camera_out[] = {
 	{	-1, 0, ""	}
 };
 
-
-static void node_shader_exec_camera(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out)
-{
-	if (data) {
-		ShadeInput *shi = ((ShaderCallData *)data)->shi;  /* Data we need for shading. */
-		
-		copy_v3_v3(out[0]->vec, shi->co);       /* get view vector */
-		out[1]->vec[0] = fabsf(shi->co[2]);      /* get view z-depth */
-		out[2]->vec[0] = normalize_v3(out[0]->vec); /* get view distance */
-	}
-}
-
 static int gpu_shader_camera(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
 	GPUNodeLink *viewvec;
 
 	viewvec = GPU_builtin(GPU_VIEW_POSITION);
-
-	/* Blender has negative Z, Cycles positive Z convention */
-	if (GPU_material_use_new_shading_nodes(mat))
-		GPU_link(mat, "invert_z", viewvec, &viewvec);
-
+	GPU_link(mat, "invert_z", viewvec, &viewvec);
 	return GPU_stack_link(mat, node, "camera", in, out, viewvec);
 }
 
@@ -73,7 +57,6 @@ void register_node_type_sh_camera(void)
 	node_type_compatibility(&ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
 	node_type_socket_templates(&ntype, NULL, sh_node_camera_out);
 	node_type_storage(&ntype, "", NULL, NULL);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_camera);
 	node_type_gpu(&ntype, gpu_shader_camera);
 
 	nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.c b/source/blender/nodes/shader/nodes/node_shader_fresnel.c
index b285f1a8a3e..30bdf0b0f42 100644
--- a/source/blender/nodes/shader/nodes/node_shader_fresnel.c
+++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.c
@@ -44,40 +44,15 @@ static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *node, bNodeExecData
 	if (!in[1].link) {
 		in[1].link = GPU_builtin(GPU_VIEW_NORMAL);
 	}
-	else if (GPU_material_use_world_space_shading(mat)) {
+	else {
 		GPU_link(mat, "direction_transform_m4v3", in[1].link, GPU_builtin(GPU_VIEW_MATRIX), &in[1].link);
 	}
 	
 	return GPU_stack_link(mat, node, "node_fresnel", in, out, GPU_builtin(GPU_VIEW_POSITION));
 }
 
-static void node_shader_exec_fresnel(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out)
+static void node_shader_exec_fresnel(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	ShadeInput *shi = ((ShaderCallData *)data)->shi;
-
-	/* Compute IOR. */
-	float eta;
-	nodestack_get_vec(&eta, SOCK_FLOAT, in[0]);
-	eta = max_ff(eta, 0.00001);
-	eta = shi->flippednor ? 1 / eta : eta;
-
-	/* Get normal from socket, but only if linked. */
-	bNodeSocket *sock_normal = node->inputs.first;
-	sock_normal = sock_normal->next;
-
-	float n[3];
-	if (sock_normal->link) {
-		nodestack_get_vec(n, SOCK_VECTOR, in[1]);
-	}
-	else {
-		copy_v3_v3(n, shi->vn);
-	}
-
-	if (shi->use_world_space_shading) {
-		mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEW_MATRIX), n);
-	}
-
-	out[0]->vec[0] = RE_fresnel_dielectric(shi->view, n, eta);
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_geom.c b/source/blender/nodes/shader/nodes/node_shader_geom.c
deleted file mode 100644
index 57bef4a6784..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_geom.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * ***** 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) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/nodes/shader/nodes/node_shader_geom.c
- *  \ingroup shdnodes
- */
-
-
-#include "node_shader_util.h"
-
-#include "DNA_customdata_types.h"
-
-/* **************** GEOMETRY  ******************** */
-
-/* output socket type definition */
-static bNodeSocketTemplate sh_node_geom_out[] = {
-	{	SOCK_VECTOR, 0, N_("Global")},
-	{	SOCK_VECTOR, 0, N_("Local")},
-	{	SOCK_VECTOR, 0, N_("View")},
-	{	SOCK_VECTOR, 0, N_("Orco")},
-	{	SOCK_VECTOR, 0, N_("UV")},
-	{	SOCK_VECTOR, 0, N_("Normal")},
-	{	SOCK_RGBA,   0, N_("Vertex Color")},
-	{	SOCK_FLOAT,   0, N_("Vertex Alpha")},
-	{	SOCK_FLOAT,   0, N_("Front/Back")},
-	{	-1, 0, ""	}
-};
-
-/* node execute callback */
-static void node_shader_exec_geom(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out)
-{
-	if (data) {
-		ShadeInput *shi = ((ShaderCallData *)data)->shi;
-		NodeGeometry *ngeo = (NodeGeometry *)node->storage;
-		ShadeInputUV *suv = &shi->uv[shi->actuv];
-		static float defaultvcol[4] = {1.0f, 1.0f, 1.0f, 1.0f};
-		int i;
-
-		if (ngeo->uvname[0]) {
-			/* find uv map by name */
-			for (i = 0; i < shi->totuv; i++) {
-				if (STREQ(shi->uv[i].name, ngeo->uvname)) {
-					suv = &shi->uv[i];
-					break;
-				}
-			}
-		}
-
-		/* out: global, local, view, orco, uv, normal, vertex color */
-		copy_v3_v3(out[GEOM_OUT_GLOB]->vec, shi->gl);
-		copy_v3_v3(out[GEOM_OUT_LOCAL]->vec, shi->co);
-		copy_v3_v3(out[GEOM_OUT_VIEW]->vec, shi->view);
-		copy_v3_v3(out[GEOM_OUT_ORCO]->vec, shi->lo);
-		copy_v3_v3(out[GEOM_OUT_UV]->vec, suv->uv);
-		copy_v3_v3(out[GEOM_OUT_NORMAL]->vec, shi->vno);
-
-		if (shi->use_world_space_shading) {
-			negate_v3(out[GEOM_OUT_NORMAL]->vec);
-			mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), out[GEOM_OUT_NORMAL]->vec);
-		}
-		if (shi->totcol) {
-			/* find vertex color layer by name */
-			ShadeInputCol *scol = &shi->col[0];
-
-			if (ngeo->colname[0]) {
-				for (i = 0; i < shi->totcol; i++) {
-					if (STREQ(shi->col[i].name, ngeo->colname)) {
-						scol = &shi->col[i];
-						break;
-					}
-				}
-			}
-
-			srgb_to_linearrgb_v3_v3(out[GEOM_OUT_VCOL]->vec, scol->col);
-			out[GEOM_OUT_VCOL]->vec[3] = scol->col[3];
-			out[GEOM_OUT_VCOL_ALPHA]->vec[0] = scol->col[3];
-		}
-		else {
-			memcpy(out[GEOM_OUT_VCOL]->vec, defaultvcol, sizeof(defaultvcol));
-			out[GEOM_OUT_VCOL_ALPHA]->vec[0] = 1.0f;
-		}
-		
-		if (shi->osatex) {
-			out[GEOM_OUT_GLOB]->data = shi->dxgl;
-			out[GEOM_OUT_GLOB]->datatype = NS_OSA_VECTORS;
-			out[GEOM_OUT_LOCAL]->data = shi->dxco;
-			out[GEOM_OUT_LOCAL]->datatype = NS_OSA_VECTORS;
-			out[GEOM_OUT_VIEW]->data = &shi->dxview;
-			out[GEOM_OUT_VIEW]->datatype = NS_OSA_VALUES;
-			out[GEOM_OUT_ORCO]->data = shi->dxlo;
-			out[GEOM_OUT_ORCO]->datatype = NS_OSA_VECTORS;
-			out[GEOM_OUT_UV]->data = suv->dxuv;
-			out[GEOM_OUT_UV]->datatype = NS_OSA_VECTORS;
-			out[GEOM_OUT_NORMAL]->data = shi->dxno;
-			out[GEOM_OUT_NORMAL]->datatype = NS_OSA_VECTORS;
-		}
-		
-		/* front/back, normal flipping was stored */
-		out[GEOM_OUT_FRONTBACK]->vec[0] = (shi->flippednor) ? 0.0f : 1.0f;
-	}
-}
-
-static void node_shader_init_geometry(bNodeTree *UNUSED(ntree), bNode *node)
-{
-	node->storage = MEM_callocN(sizeof(NodeGeometry), "NodeGeometry");
-}
-
-static int gpu_shader_geom(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
-{
-	NodeGeometry *ngeo = (NodeGeometry *)node->storage;
-	GPUNodeLink *orco = GPU_attribute(CD_ORCO, "");
-	GPUNodeLink *mtface = GPU_attribute(CD_MTFACE, ngeo->uvname);
-	GPUNodeLink *mcol = GPU_attribute(CD_MCOL, ngeo->colname);
-
-	bool ret = GPU_stack_link(mat, node, "geom", in, out,
-	                      GPU_builtin(GPU_VIEW_POSITION), GPU_builtin(GPU_VIEW_NORMAL),
-	                      GPU_builtin(GPU_INVERSE_VIEW_MATRIX), orco, mtface, mcol);
-	if (GPU_material_use_world_space_shading(mat)) {
-		GPU_link(mat, "vec_math_negate", out[5].link, &out[5].link);
-		ret &= GPU_link(mat, "direction_transform_m4v3", out[5].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[5].link);
-	}
-	return ret;
-}
-
-/* node type definition */
-void register_node_type_sh_geom(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, NULL, sh_node_geom_out);
-	node_type_init(&ntype, node_shader_init_geometry);
-	node_type_storage(&ntype, "NodeGeometry", node_free_standard_storage, node_copy_standard_storage);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_geom);
-	node_type_gpu(&ntype, gpu_shader_geom);
-
-	nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_lamp.c b/source/blender/nodes/shader/nodes/node_shader_lamp.c
deleted file mode 100644
index 3c41227ab8b..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_lamp.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * ***** 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): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/nodes/shader/nodes/node_shader_lamp.c
- *  \ingroup shdnodes
- */
-
-
-#include "node_shader_util.h"
-
-/* **************** LAMP INFO  ******************** */
-static bNodeSocketTemplate sh_node_lamp_out[] = {
-	{	SOCK_RGBA, 0, N_("Color")},
-	{	SOCK_VECTOR, 0, N_("Light Vector")},
-	{	SOCK_FLOAT, 0, N_("Distance")},
-	{	SOCK_RGBA, 0, N_("Shadow")},
-	{	SOCK_FLOAT, 0, N_("Visibility Factor")},
-	{	-1, 0, ""	}
-};
-
-
-static void node_shader_exec_lamp(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out)
-{
-	if (data) {
-		Object *ob = (Object *)node->id;
-
-		if (ob) {
-			ShadeInput *shi = ((ShaderCallData *)data)->shi;
-
-			shi->nodes = 1; /* temp hack to prevent trashadow recursion */
-			out[4]->vec[0] = RE_lamp_get_data(shi, ob, out[0]->vec, out[1]->vec, out[2]->vec, out[3]->vec);
-			shi->nodes = 0;
-			if (shi->use_world_space_shading)
-				mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), out[1]->vec);
-		}
-	}
-}
-
-static int gpu_shader_lamp(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
-{
-	if (node->id) {
-		GPULamp *lamp = GPU_lamp_from_blender(GPU_material_scene(mat), (Object *)node->id, NULL);
-		GPUNodeLink *col, *lv, *dist, *visifac, *shadow, *energy;
-
-		visifac = GPU_lamp_get_data(mat, lamp, &col, &lv, &dist, &shadow, &energy);
-
-		bool ret = GPU_stack_link(mat, node, "lamp", in, out, col, energy, lv, dist, shadow, visifac);
-		if (GPU_material_use_world_space_shading(mat))
-			ret &= GPU_link(mat, "direction_transform_m4v3", out[1].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[1].link);
-		return ret;
-	}
-
-	return false;
-}
-
-void register_node_type_sh_lamp(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_LAMP, "Lamp Data", NODE_CLASS_INPUT, 0);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, NULL, sh_node_lamp_out);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_lamp);
-	node_type_gpu(&ntype, gpu_shader_lamp);
-
-	nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c
index 3ab73fdde18..87ed85ffa99 100644
--- a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c
+++ b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c
@@ -43,50 +43,18 @@ static bNodeSocketTemplate sh_node_layer_weight_out[] = {
 
 static int node_shader_gpu_layer_weight(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[1].link)
+	if (!in[1].link) {
 		in[1].link = GPU_builtin(GPU_VIEW_NORMAL);
-	else if (GPU_material_use_world_space_shading(mat)) {
+	}
+	else {
 		GPU_link(mat, "direction_transform_m4v3", in[1].link, GPU_builtin(GPU_VIEW_MATRIX), &in[1].link);
 	}
 
 	return GPU_stack_link(mat, node, "node_layer_weight", in, out, GPU_builtin(GPU_VIEW_POSITION));
 }
 
-static void node_shader_exec_layer_weight(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out)
+static void node_shader_exec_layer_weight(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	ShadeInput *shi = ((ShaderCallData *)data)->shi;
-
-	/* Compute IOR. */
-	float blend;
-	nodestack_get_vec(&blend, SOCK_FLOAT, in[0]);
-	float eta = max_ff(1 - blend, 0.00001);
-	eta = shi->flippednor ? eta : 1 / eta;
-
-	/* Get normal from socket, but only if linked. */
-	bNodeSocket *sock_normal = node->inputs.first;
-	sock_normal = sock_normal->next;
-
-	float n[3];
-	if (sock_normal->link) {
-		nodestack_get_vec(n, SOCK_VECTOR, in[1]);
-	}
-	else {
-		copy_v3_v3(n, shi->vn);
-	}
-
-
-	if (shi->use_world_space_shading)
-		mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEW_MATRIX), n);
-
-	out[0]->vec[0] = RE_fresnel_dielectric(shi->view, n, eta);
-
-	float facing = fabs(dot_v3v3(shi->view, n));
-	if (blend != 0.5) {
-		CLAMP(blend, 0.0, 0.99999);
-		blend = (blend < 0.5) ? 2.0 * blend : 0.5 / (1.0 - blend);
-		facing = pow(facing, blend);
-	}
-	out[1]->vec[0] = 1.0 - facing;
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_material.c b/source/blender/nodes/shader/nodes/node_shader_material.c
deleted file mode 100644
index 6850cdbf6ea..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_material.c
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
- * ***** 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) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/nodes/shader/nodes/node_shader_material.c
- *  \ingroup shdnodes
- */
-
-#include "node_shader_util.h"
-
-/* **************** MATERIAL ******************** */
-
-static bNodeSocketTemplate sh_node_material_in[] = {
-	{	SOCK_RGBA, 1, N_("Color"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_RGBA, 1, N_("Spec"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_FLOAT, 1, N_("DiffuseIntensity"),		0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
-	{	SOCK_VECTOR, 1, N_("Normal"),	0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION},
-	{	-1, 0, ""	}
-};
-
-static bNodeSocketTemplate sh_node_material_out[] = {
-	{	SOCK_RGBA, 0, N_("Color")},
-	{	SOCK_FLOAT, 0, N_("Alpha")},
-	{	SOCK_VECTOR, 0, N_("Normal")},
-	{	-1, 0, ""	}
-};
-
-/* **************** EXTENDED MATERIAL ******************** */
-
-static bNodeSocketTemplate sh_node_material_ext_in[] = {
-	{	SOCK_RGBA, 1, N_("Color"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_RGBA, 1, N_("Spec"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_FLOAT, 1, N_("DiffuseIntensity"),		0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
-	{	SOCK_VECTOR, 1, N_("Normal"),	0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION},
-	{	SOCK_RGBA, 1, N_("Mirror"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_FLOAT, 1, N_("Ambient"),	0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
-	{	SOCK_FLOAT, 1, N_("Emit"),		0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
-	{	SOCK_FLOAT, 1, N_("SpecTra"),	0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
-	{	SOCK_FLOAT, 1, N_("Reflectivity"),	0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
-	{	SOCK_FLOAT, 1, N_("Alpha"),		0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
-	{	SOCK_FLOAT, 1, N_("Translucency"),	0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
-	{	-1, 0, ""	}
-};
-
-static bNodeSocketTemplate sh_node_material_ext_out[] = {
-	{	SOCK_RGBA, 0, N_("Color")},
-	{	SOCK_FLOAT, 0, N_("Alpha")},
-	{	SOCK_VECTOR, 0, N_("Normal")},
-	{	SOCK_RGBA, 0, N_("Diffuse")},
-	{	SOCK_RGBA, 0, N_("Spec")},
-	{	SOCK_RGBA, 0, N_("AO")},
-	{	-1, 0, ""	}
-};
-
-static void node_shader_exec_material(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out)
-{
-	if (data && node->id) {
-		ShadeResult shrnode;
-		ShadeInput *shi;
-		ShaderCallData *shcd = data;
-		float col[4];
-		bNodeSocket *sock;
-		char hasinput[NUM_MAT_IN] = {'\0'};
-		int i, mode;
-		
-		/* note: cannot use the in[]->hasinput flags directly, as these are not necessarily
-		 * the constant input stack values (e.g. in case material node is inside a group).
-		 * we just want to know if a node input uses external data or the material setting.
-		 * this is an ugly hack, but so is this node as a whole.
-		 */
-		for (sock = node->inputs.first, i = 0; sock; sock = sock->next, ++i)
-			hasinput[i] = (sock->link != NULL);
-		
-		shi = shcd->shi;
-		shi->mat = (Material *)node->id;
-		
-		/* copy all relevant material vars, note, keep this synced with render_types.h */
-		memcpy(&shi->r, &shi->mat->r, 23 * sizeof(float));
-		shi->har = shi->mat->har;
-		
-		/* write values */
-		if (hasinput[MAT_IN_COLOR])
-			nodestack_get_vec(&shi->r, SOCK_VECTOR, in[MAT_IN_COLOR]);
-		
-		if (hasinput[MAT_IN_SPEC])
-			nodestack_get_vec(&shi->specr, SOCK_VECTOR, in[MAT_IN_SPEC]);
-		
-		if (hasinput[MAT_IN_REFL])
-			nodestack_get_vec(&shi->refl, SOCK_FLOAT, in[MAT_IN_REFL]);
-		
-		/* retrieve normal */
-		if (hasinput[MAT_IN_NORMAL]) {
-			nodestack_get_vec(shi->vn, SOCK_VECTOR, in[MAT_IN_NORMAL]);
-			if (shi->use_world_space_shading) {
-				negate_v3(shi->vn);
-				mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEW_MATRIX), shi->vn);
-			}
-			normalize_v3(shi->vn);
-		}
-		else
-			copy_v3_v3(shi->vn, shi->vno);
-		
-		/* custom option to flip normal */
-		if (node->custom1 & SH_NODE_MAT_NEG) {
-			negate_v3(shi->vn);
-		}
-		
-		if (node->type == SH_NODE_MATERIAL_EXT) {
-			if (hasinput[MAT_IN_MIR])
-				nodestack_get_vec(&shi->mirr, SOCK_VECTOR, in[MAT_IN_MIR]);
-			if (hasinput[MAT_IN_AMB])
-				nodestack_get_vec(&shi->amb, SOCK_FLOAT, in[MAT_IN_AMB]);
-			if (hasinput[MAT_IN_EMIT])
-				nodestack_get_vec(&shi->emit, SOCK_FLOAT, in[MAT_IN_EMIT]);
-			if (hasinput[MAT_IN_SPECTRA])
-				nodestack_get_vec(&shi->spectra, SOCK_FLOAT, in[MAT_IN_SPECTRA]);
-			if (hasinput[MAT_IN_RAY_MIRROR])
-				nodestack_get_vec(&shi->ray_mirror, SOCK_FLOAT, in[MAT_IN_RAY_MIRROR]);
-			if (hasinput[MAT_IN_ALPHA])
-				nodestack_get_vec(&shi->alpha, SOCK_FLOAT, in[MAT_IN_ALPHA]);
-			if (hasinput[MAT_IN_TRANSLUCENCY])
-				nodestack_get_vec(&shi->translucency, SOCK_FLOAT, in[MAT_IN_TRANSLUCENCY]);
-		}
-		
-		/* make alpha output give results even if transparency is only enabled on
-		 * the material linked in this not and not on the parent material */
-		mode = shi->mode;
-		if (shi->mat->mode & MA_TRANSP)
-			shi->mode |= MA_TRANSP;
-
-		shi->nodes = 1; /* temp hack to prevent trashadow recursion */
-		node_shader_lamp_loop(shi, &shrnode);   /* clears shrnode */
-		shi->nodes = 0;
-		
-		shi->mode = mode;
-
-		/* write to outputs */
-		if (node->custom1 & SH_NODE_MAT_DIFF) {
-			copy_v3_v3(col, shrnode.combined);
-			if (!(node->custom1 & SH_NODE_MAT_SPEC)) {
-				sub_v3_v3(col, shrnode.spec);
-			}
-		}
-		else if (node->custom1 & SH_NODE_MAT_SPEC) {
-			copy_v3_v3(col, shrnode.spec);
-		}
-		else
-			col[0] = col[1] = col[2] = 0.0f;
-		
-		col[3] = shrnode.alpha;
-		
-		if (shi->do_preview)
-			BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage);
-		
-		copy_v3_v3(out[MAT_OUT_COLOR]->vec, col);
-		out[MAT_OUT_ALPHA]->vec[0] = shrnode.alpha;
-		
-		if (node->custom1 & SH_NODE_MAT_NEG) {
-			shi->vn[0] = -shi->vn[0];
-			shi->vn[1] = -shi->vn[1];
-			shi->vn[2] = -shi->vn[2];
-		}
-		
-		copy_v3_v3(out[MAT_OUT_NORMAL]->vec, shi->vn);
-
-		if (shi->use_world_space_shading) {
-			negate_v3(out[MAT_OUT_NORMAL]->vec);
-			mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), out[MAT_OUT_NORMAL]->vec);
-		}
-		/* Extended material options */
-		if (node->type == SH_NODE_MATERIAL_EXT) {
-			/* Shadow, Reflect, Refract, Radiosity, Speed seem to cause problems inside
-			 * a node tree :( */
-			copy_v3_v3(out[MAT_OUT_DIFFUSE]->vec, shrnode.diffshad);
-			copy_v3_v3(out[MAT_OUT_SPEC]->vec, shrnode.spec);
-			copy_v3_v3(out[MAT_OUT_AO]->vec, shrnode.ao);
-		}
-		
-		/* copy passes, now just active node */
-		if (node->flag & NODE_ACTIVE_ID) {
-			float combined[4], alpha;
-
-			copy_v4_v4(combined, shcd->shr->combined);
-			alpha = shcd->shr->alpha;
-
-			*(shcd->shr) = shrnode;
-
-			copy_v4_v4(shcd->shr->combined, combined);
-			shcd->shr->alpha = alpha;
-		}
-	}
-}
-
-
-static void node_shader_init_material(bNodeTree *UNUSED(ntree), bNode *node)
-{
-	node->custom1 = SH_NODE_MAT_DIFF | SH_NODE_MAT_SPEC;
-}
-
-/* XXX this is also done as a local static function in gpu_codegen.c,
- * but we need this to hack around the crappy material node.
- */
-static GPUNodeLink *gpu_get_input_link(GPUMaterial *mat, GPUNodeStack *in)
-{
-	if (in->link) {
-		return in->link;
-	}
-	else {
-		GPUNodeLink *result = NULL;
-
-		/* note GPU_uniform() is only intended to be used as a parameter to
-		 * GPU_link(), returning it directly results in leaks or double frees */
-		if (in->type == GPU_FLOAT)
-			GPU_link(mat, "set_value", GPU_uniform(in->vec), &result);
-		else if (in->type == GPU_VEC3)
-			GPU_link(mat, "set_rgb", GPU_uniform(in->vec), &result);
-		else if (in->type == GPU_VEC4)
-			GPU_link(mat, "set_rgba", GPU_uniform(in->vec), &result);
-		else
-			BLI_assert(0);
-
-		return result;
-	}
-}
-
-static int gpu_shader_material(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
-{
-	if (node->id) {
-		GPUShadeInput shi;
-		GPUShadeResult shr;
-		bNodeSocket *sock;
-		char hasinput[NUM_MAT_IN] = {'\0'};
-		int i;
-		
-		/* note: cannot use the in[]->hasinput flags directly, as these are not necessarily
-		 * the constant input stack values (e.g. in case material node is inside a group).
-		 * we just want to know if a node input uses external data or the material setting.
-		 */
-		for (sock = node->inputs.first, i = 0; sock; sock = sock->next, ++i)
-			hasinput[i] = (sock->link != NULL);
-
-		GPU_shadeinput_set(mat, (Material *)node->id, &shi);
-
-		/* write values */
-		if (hasinput[MAT_IN_COLOR])
-			shi.rgb = gpu_get_input_link(mat, &in[MAT_IN_COLOR]);
-		
-		if (hasinput[MAT_IN_SPEC])
-			shi.specrgb = gpu_get_input_link(mat, &in[MAT_IN_SPEC]);
-		
-		if (hasinput[MAT_IN_REFL])
-			shi.refl = gpu_get_input_link(mat, &in[MAT_IN_REFL]);
-		
-		/* retrieve normal */
-		if (hasinput[MAT_IN_NORMAL]) {
-			GPUNodeLink *tmp;
-			shi.vn = gpu_get_input_link(mat, &in[MAT_IN_NORMAL]);
-			if (GPU_material_use_world_space_shading(mat)) {
-				GPU_link(mat, "vec_math_negate", shi.vn, &shi.vn);
-				GPU_link(mat, "direction_transform_m4v3", shi.vn, GPU_builtin(GPU_VIEW_MATRIX), &shi.vn);
-			}
-			GPU_link(mat, "vec_math_normalize", shi.vn, &shi.vn, &tmp);
-		}
-		
-		/* custom option to flip normal */
-		if (node->custom1 & SH_NODE_MAT_NEG)
-			GPU_link(mat, "vec_math_negate", shi.vn, &shi.vn);
-
-		if (node->type == SH_NODE_MATERIAL_EXT) {
-			if (hasinput[MAT_IN_MIR])
-				shi.mir = gpu_get_input_link(mat, &in[MAT_IN_MIR]);
-			if (hasinput[MAT_IN_AMB])
-				shi.amb = gpu_get_input_link(mat, &in[MAT_IN_AMB]);
-			if (hasinput[MAT_IN_EMIT])
-				shi.emit = gpu_get_input_link(mat, &in[MAT_IN_EMIT]);
-			if (hasinput[MAT_IN_SPECTRA])
-				shi.spectra = gpu_get_input_link(mat, &in[MAT_IN_SPECTRA]);
-			if (hasinput[MAT_IN_ALPHA])
-				shi.alpha = gpu_get_input_link(mat, &in[MAT_IN_ALPHA]);
-		}
-
-		GPU_shaderesult_set(&shi, &shr); /* clears shr */
-		
-		/* write to outputs */
-		if (node->custom1 & SH_NODE_MAT_DIFF) {
-			out[MAT_OUT_COLOR].link = shr.combined;
-
-			if (!(node->custom1 & SH_NODE_MAT_SPEC)) {
-				GPUNodeLink *link;
-				GPU_link(mat, "vec_math_sub", shr.combined, shr.spec, &out[MAT_OUT_COLOR].link, &link);
-			}
-		}
-		else if (node->custom1 & SH_NODE_MAT_SPEC) {
-			out[MAT_OUT_COLOR].link = shr.spec;
-		}
-		else
-			GPU_link(mat, "set_rgb_zero", &out[MAT_OUT_COLOR].link);
-
-		GPU_link(mat, "mtex_alpha_to_col", out[MAT_OUT_COLOR].link, shr.alpha, &out[MAT_OUT_COLOR].link);
-
-		out[MAT_OUT_ALPHA].link = shr.alpha; //
-		
-		if (node->custom1 & SH_NODE_MAT_NEG)
-			GPU_link(mat, "vec_math_negate", shi.vn, &shi.vn);
-		out[MAT_OUT_NORMAL].link = shi.vn;
-		if (GPU_material_use_world_space_shading(mat)) {
-			GPU_link(mat, "vec_math_negate", out[MAT_OUT_NORMAL].link, &out[MAT_OUT_NORMAL].link);
-			GPU_link(mat, "direction_transform_m4v3", out[MAT_OUT_NORMAL].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[MAT_OUT_NORMAL].link);
-		}
-
-		if (node->type == SH_NODE_MATERIAL_EXT) {
-			out[MAT_OUT_DIFFUSE].link = shr.diff;
-			out[MAT_OUT_SPEC].link = shr.spec;
-			GPU_link(mat, "set_rgb_one", &out[MAT_OUT_AO].link);
-		}
-
-		return 1;
-	}
-
-	return 0;
-}
-
-void register_node_type_sh_material(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_PREVIEW);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, sh_node_material_in, sh_node_material_out);
-	node_type_init(&ntype, node_shader_init_material);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_material);
-	node_type_gpu(&ntype, gpu_shader_material);
-
-	nodeRegisterType(&ntype);
-}
-
-
-void register_node_type_sh_material_ext(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_PREVIEW);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, sh_node_material_ext_in, sh_node_material_ext_out);
-	node_type_init(&ntype, node_shader_init_material);
-	node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_material);
-	node_type_gpu(&ntype, gpu_shader_material);
-
-	nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_normal.c b/source/blender/nodes/shader/nodes/node_shader_normal.c
index 64f3ec94369..7033eeaead0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_normal.c
+++ b/source/blender/nodes/shader/nodes/node_shader_normal.c
@@ -61,12 +61,7 @@ static void node_shader_exec_normal(void *UNUSED(data), int UNUSED(thread), bNod
 static int gpu_shader_normal(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
 	GPUNodeLink *vec = GPU_uniform(out[0].vec);
-	if (GPU_material_use_new_shading_nodes(mat)) {
-		return GPU_stack_link(mat, node, "normal_new_shading", in, out, vec);
-	}
-	else {
-		return GPU_stack_link(mat, node, "normal", in, out, vec);
-	}
+	return GPU_stack_link(mat, node, "normal_new_shading", in, out, vec);
 }
 
 void register_node_type_sh_normal(void)
diff --git a/source/blender/nodes/shader/nodes/node_shader_normal_map.c b/source/blender/nodes/shader/nodes/node_shader_normal_map.c
index 7584b5eba4d..0d58be76030 100644
--- a/source/blender/nodes/shader/nodes/node_shader_normal_map.c
+++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.c
@@ -47,80 +47,9 @@ static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node)
 }
 
 static void node_shader_exec_normal_map(
-        void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata),
-        bNodeStack **in, bNodeStack **out)
+        void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata),
+        bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	if (data) {
-		ShadeInput *shi = ((ShaderCallData *)data)->shi;
-
-		NodeShaderNormalMap *nm = node->storage;
-
-		float strength, vecIn[3];
-		nodestack_get_vec(&strength, SOCK_FLOAT, in[0]);
-		nodestack_get_vec(vecIn, SOCK_VECTOR, in[1]);
-
-		vecIn[0] = -2 * (vecIn[0] - 0.5f);
-		vecIn[1] =  2 * (vecIn[1] - 0.5f);
-		vecIn[2] =  2 * (vecIn[2] - 0.5f);
-
-		CLAMP_MIN(strength, 0.0f);
-
-		float *N = shi->nmapnorm;
-		int uv_index = 0;
-		switch (nm->space) {
-			case SHD_SPACE_TANGENT:
-				if (nm->uv_map[0]) {
-					/* find uv map by name */
-					for (int i = 0; i < shi->totuv; i++) {
-						if (STREQ(shi->uv[i].name, nm->uv_map)) {
-							uv_index = i;
-							break;
-						}
-					}
-				}
-				else {
-					uv_index = shi->actuv;
-				}
-
-				float *T = shi->tangents[uv_index];
-
-				float B[3];
-				cross_v3_v3v3(B, N, T);
-				mul_v3_fl(B, T[3]);
-
-				for (int j = 0; j < 3; j++)
-					out[0]->vec[j] = vecIn[0] * T[j] + vecIn[1] * B[j] + vecIn[2] * N[j];
-				interp_v3_v3v3(out[0]->vec, N, out[0]->vec, strength);
-				if (shi->use_world_space_shading) {
-					mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), out[0]->vec);
-				}
-				break;
-
-			case SHD_SPACE_OBJECT:
-			case SHD_SPACE_BLENDER_OBJECT:
-				if (shi->use_world_space_shading) {
-					mul_mat3_m4_v3((float (*)[4])RE_object_instance_get_matrix(shi->obi, RE_OBJECT_INSTANCE_MATRIX_OB), vecIn);
-					mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), N);
-				}
-				else
-					mul_mat3_m4_v3((float (*)[4])RE_object_instance_get_matrix(shi->obi, RE_OBJECT_INSTANCE_MATRIX_LOCALTOVIEW), vecIn);
-				interp_v3_v3v3(out[0]->vec, N, vecIn, strength);
-				break;
-
-			case SHD_SPACE_WORLD:
-			case SHD_SPACE_BLENDER_WORLD:
-				if (shi->use_world_space_shading)
-					mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEWINV_MATRIX), N);
-				else
-					mul_mat3_m4_v3((float (*)[4])RE_render_current_get_matrix(RE_VIEW_MATRIX), vecIn);
-				interp_v3_v3v3(out[0]->vec, N, vecIn, strength);
-				break;
-		}
-		if (shi->use_world_space_shading) {
-			negate_v3(out[0]->vec);
-		}
-		normalize_v3(out[0]->vec);
-	}
 }
 
 static int gpu_shader_normal_map(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
@@ -145,57 +74,29 @@ static int gpu_shader_normal_map(GPUMaterial *mat, bNode *node, bNodeExecData *U
 	negnorm = GPU_builtin(GPU_VIEW_NORMAL);
 	GPU_link(mat, "math_max", strength, GPU_uniform(d), &strength);
 
-	if (GPU_material_use_world_space_shading(mat)) {
-
-		/* ******* CYCLES or BLENDER INTERNAL with world space shading flag ******* */
-
-		const char *color_to_normal_fnc_name = "color_to_normal_new_shading";
-		if (nm->space == SHD_SPACE_BLENDER_OBJECT || nm->space == SHD_SPACE_BLENDER_WORLD || !GPU_material_use_new_shading_nodes(mat))
-			color_to_normal_fnc_name = "color_to_blender_normal_new_shading";
-		switch (nm->space) {
-			case SHD_SPACE_TANGENT:
-				GPU_link(mat, "color_to_normal_new_shading", realnorm, &realnorm);
-				GPU_link(mat, "node_normal_map", GPU_attribute(CD_TANGENT, nm->uv_map), negnorm, realnorm, &realnorm);
-				GPU_link(mat, "vec_math_mix", strength, realnorm, GPU_builtin(GPU_VIEW_NORMAL), &out[0].link);
-				/* for uniform scale this is sufficient to match Cycles */
-				GPU_link(mat, "direction_transform_m4v3", out[0].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[0].link);
-				GPU_link(mat, "vect_normalize", out[0].link, &out[0].link);
-				return true;
-			case SHD_SPACE_OBJECT:
-			case SHD_SPACE_BLENDER_OBJECT:
-				GPU_link(mat, "direction_transform_m4v3", negnorm, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &negnorm);
-				GPU_link(mat, color_to_normal_fnc_name, realnorm, &realnorm);
-				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_OBJECT_MATRIX), &realnorm);
-				break;
-			case SHD_SPACE_WORLD:
-			case SHD_SPACE_BLENDER_WORLD:
-				GPU_link(mat, "direction_transform_m4v3", negnorm, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &negnorm);
-				GPU_link(mat, color_to_normal_fnc_name, realnorm, &realnorm);
-				break;
-		}
-
-	}
-	else {
-
-		/* ************** BLENDER INTERNAL without world space shading flag ******* */
-
-		GPU_link(mat, "color_to_normal", realnorm, &realnorm);
-		GPU_link(mat, "mtex_negate_texnormal", realnorm,  &realnorm);
-		GPU_link(mat, "vec_math_negate", negnorm, &negnorm);
-
-		switch (nm->space) {
-			case SHD_SPACE_TANGENT:
-				GPU_link(mat, "node_normal_map", GPU_attribute(CD_TANGENT, nm->uv_map), negnorm, realnorm, &realnorm);
-				break;
-			case SHD_SPACE_OBJECT:
-			case SHD_SPACE_BLENDER_OBJECT:
-				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_LOC_TO_VIEW_MATRIX),  &realnorm);
-				break;
-			case SHD_SPACE_WORLD:
-			case SHD_SPACE_BLENDER_WORLD:
-				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_VIEW_MATRIX),  &realnorm);
-				break;
-		}
+	const char *color_to_normal_fnc_name = "color_to_normal_new_shading";
+	if (nm->space == SHD_SPACE_BLENDER_OBJECT || nm->space == SHD_SPACE_BLENDER_WORLD)
+		color_to_normal_fnc_name = "color_to_blender_normal_new_shading";
+	switch (nm->space) {
+		case SHD_SPACE_TANGENT:
+			GPU_link(mat, "color_to_normal_new_shading", realnorm, &realnorm);
+			GPU_link(mat, "node_normal_map", GPU_attribute(CD_TANGENT, nm->uv_map), negnorm, realnorm, &realnorm);
+			GPU_link(mat, "vec_math_mix", strength, realnorm, GPU_builtin(GPU_VIEW_NORMAL), &out[0].link);
+			/* for uniform scale this is sufficient to match Cycles */
+			GPU_link(mat, "direction_transform_m4v3", out[0].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[0].link);
+			GPU_link(mat, "vect_normalize", out[0].link, &out[0].link);
+			return true;
+		case SHD_SPACE_OBJECT:
+		case SHD_SPACE_BLENDER_OBJECT:
+			GPU_link(mat, "direction_transform_m4v3", negnorm, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &negnorm);
+			GPU_link(mat, color_to_normal_fnc_name, realnorm, &realnorm);
+			GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_OBJECT_MATRIX), &realnorm);
+			break;
+		case SHD_SPACE_WORLD:
+		case SHD_SPACE_BLENDER_WORLD:
+			GPU_link(mat, "direction_transform_m4v3", negnorm, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &negnorm);
+			GPU_link(mat, color_to_normal_fnc_name, realnorm, &realnorm);
+			break;
 	}
 
 	GPU_link(mat, "vec_math_mix", strength, realnorm, negnorm,  &out[0].link);
diff --git a/source/blender/nodes/shader/nodes/node_shader_object_info.c b/source/blender/nodes/shader/nodes/node_shader_object_info.c
index 471331beae3..25c9bd77250 100644
--- a/source/blender/nodes/shader/nodes/node_shader_object_info.c
+++ b/source/blender/nodes/shader/nodes/node_shader_object_info.c
@@ -42,13 +42,8 @@ static int node_shader_gpu_object_info(GPUMaterial *mat, bNode *node, bNodeExecD
 	return GPU_stack_link(mat, node, "node_object_info", in, out, GPU_builtin(GPU_OBJECT_MATRIX), GPU_builtin(GPU_OBJECT_INFO));
 }
 
-static void node_shader_exec_object_info(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out)
+static void node_shader_exec_object_info(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	ShaderCallData *scd = (ShaderCallData *)data;
-	copy_v4_v4(out[0]->vec, RE_object_instance_get_matrix(scd->shi->obi, RE_OBJECT_INSTANCE_MATRIX_OB)[3]);
-	out[1]->vec[0] = RE_object_instance_get_object_pass_index(scd->shi->obi);
-	out[2]->vec[0] = scd->shi->mat->index;
-	out[3]->vec[0] = RE_object_instance_get_random_id(scd->shi->obi) * (1.0f / (float)0xFFFFFFFF);
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_output.c b/source/blender/nodes/shader/nodes/node_shader_output.c
deleted file mode 100644
index 52f659d8321..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_output.c
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * ***** 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) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/nodes/shader/nodes/node_shader_output.c
- *  \ingroup shdnodes
- */
-
-
-#include "node_shader_util.h"
-
-#include "BKE_scene.h"
-
-/* **************** OUTPUT ******************** */
-static bNodeSocketTemplate sh_node_output_in[] = {
-	{	SOCK_RGBA, 1, N_("Color"),		0.0f, 0.0f, 0.0f, 1.0f},
-	{	SOCK_FLOAT, 1, N_("Alpha"),		1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
-	{	-1, 0, ""	}
-};
-
-static void node_shader_exec_output(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out))
-{
-	if (data) {
-		ShadeInput *shi = ((ShaderCallData *)data)->shi;
-		float col[4];
-		
-		/* stack order input sockets: col, alpha, normal */
-		nodestack_get_vec(col, SOCK_VECTOR, in[0]);
-		nodestack_get_vec(col + 3, SOCK_FLOAT, in[1]);
-		
-		if (shi->do_preview) {
-			BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage);
-			node->lasty = shi->ys;
-		}
-		
-		if (node->flag & NODE_DO_OUTPUT) {
-			ShadeResult *shr = ((ShaderCallData *)data)->shr;
-			
-			copy_v4_v4(shr->combined, col);
-			shr->alpha = col[3];
-			
-			//	copy_v3_v3(shr->nor, in[3]->vec);
-		}
-	}
-}
-
-static int gpu_shader_output(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
-{
-	GPUNodeLink *outlink;
-
-#if 0
-	if (in[1].hasinput)
-		GPU_material_enable_alpha(mat);
-#endif
-
-	GPU_stack_link(mat, node, "output_node", in, out, &outlink);
-	GPU_material_output_link(mat, outlink);
-
-	return 1;
-}
-
-void register_node_type_sh_output(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, sh_node_output_in, NULL);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_output);
-	node_type_gpu(&ntype, gpu_shader_output);
-
-	/* Do not allow muting output node. */
-	node_type_internal_links(&ntype, NULL);
-
-	nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.c b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
index 69fcbba8f88..46cb513a6d9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_particle_info.c
+++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
@@ -42,11 +42,8 @@ static bNodeSocketTemplate outputs[] = {
 	{ SOCK_VECTOR,  0, "Angular Velocity" },
 	{ -1, 0, "" }
 };
-static void node_shader_exec_particle_info(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out)
+static void node_shader_exec_particle_info(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	ShadeInput *shi = ((ShaderCallData *)data)->shi;
-
-	RE_instance_get_particle_info(shi->obi, out[0]->vec, out[1]->vec, out[2]->vec, out[3]->vec, out[4]->vec, out[5]->vec, out[6]->vec, out[7]->vec);
 }
 
 static int gpu_shader_particle_info(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
diff --git a/source/blender/nodes/shader/nodes/node_shader_texture.c b/source/blender/nodes/shader/nodes/node_shader_texture.c
deleted file mode 100644
index 755ef106ade..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_texture.c
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * ***** 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) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/nodes/shader/nodes/node_shader_texture.c
- *  \ingroup shdnodes
- */
-
-#include "DNA_texture_types.h"
-
-#include "node_shader_util.h"
-
-#include "GPU_material.h"
-
-/* **************** TEXTURE ******************** */
-static bNodeSocketTemplate sh_node_texture_in[] = {
-	{	SOCK_VECTOR, 1, "Vector",	0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},	/* no limit */
-	{	-1, 0, ""	}
-};
-static bNodeSocketTemplate sh_node_texture_out[] = {
-	{	SOCK_FLOAT, 0, N_("Value"), 0, 0, 0, 0, 0, 0, PROP_NONE, SOCK_NO_INTERNAL_LINK},
-	{	SOCK_RGBA, 0, N_("Color"), 0, 0, 0, 0, 0, 0, PROP_NONE, SOCK_NO_INTERNAL_LINK},
-	{	SOCK_VECTOR, 0, N_("Normal"), 0, 0, 0, 0, 0, 0, PROP_NONE, SOCK_NO_INTERNAL_LINK},
-	{	-1, 0, ""	}
-};
-
-static void node_shader_exec_texture(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out)
-{
-	if (data && node->id) {
-		ShadeInput *shi = ((ShaderCallData *)data)->shi;
-		TexResult texres;
-		bNodeSocket *sock_vector = node->inputs.first;
-		float vec[3], nor[3] = {0.0f, 0.0f, 0.0f};
-		int retval;
-		short which_output = node->custom1;
-		
-		short thread = shi->thread;
-		
-		/* out: value, color, normal */
-		
-		/* we should find out if a normal as output is needed, for now we do all */
-		texres.nor = nor;
-		texres.tr = texres.tg = texres.tb = 0.0f;
-		
-		/* don't use in[0]->hasinput, see material node for explanation */
-		if (sock_vector->link) {
-			nodestack_get_vec(vec, SOCK_VECTOR, in[0]);
-			
-			if (in[0]->datatype == NS_OSA_VECTORS) {
-				float *fp = in[0]->data;
-				retval = multitex_nodes((Tex *)node->id, vec, fp, fp + 3, shi->osatex, &texres, thread, which_output, NULL, NULL, NULL);
-			}
-			else if (in[0]->datatype == NS_OSA_VALUES) {
-				const float *fp = in[0]->data;
-				float dxt[3], dyt[3];
-				
-				dxt[0] = fp[0]; dxt[1] = dxt[2] = 0.0f;
-				dyt[0] = fp[1]; dyt[1] = dyt[2] = 0.0f;
-				retval = multitex_nodes((Tex *)node->id, vec, dxt, dyt, shi->osatex, &texres, thread, which_output, NULL, NULL, NULL);
-			}
-			else
-				retval = multitex_nodes((Tex *)node->id, vec, NULL, NULL, 0, &texres, thread, which_output, NULL, NULL, NULL);
-		}
-		else {
-			copy_v3_v3(vec, shi->lo);
-			retval = multitex_nodes((Tex *)node->id, vec, NULL, NULL, 0, &texres, thread, which_output, NULL, NULL, NULL);
-		}
-		
-		/* stupid exception */
-		if ( ((Tex *)node->id)->type == TEX_STUCCI) {
-			texres.tin = 0.5f + 0.7f * texres.nor[0];
-			CLAMP(texres.tin, 0.0f, 1.0f);
-		}
-		
-		/* intensity and color need some handling */
-		if (texres.talpha)
-			out[0]->vec[0] = texres.ta;
-		else
-			out[0]->vec[0] = texres.tin;
-		
-		if ((retval & TEX_RGB) == 0) {
-			copy_v3_fl(out[1]->vec, out[0]->vec[0]);
-			out[1]->vec[3] = 1.0f;
-		}
-		else {
-			copy_v3_v3(out[1]->vec, &texres.tr);
-			out[1]->vec[3] = 1.0f;
-		}
-		
-		copy_v3_v3(out[2]->vec, nor);
-		
-		if (shi->do_preview) {
-			BKE_node_preview_set_pixel(execdata->preview, out[1]->vec, shi->xs, shi->ys, shi->do_manage);
-		}
-		
-	}
-}
-
-static int gpu_shader_texture(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
-{
-	Tex *tex = (Tex *)node->id;
-
-	if (tex && tex->ima && (tex->type == TEX_IMAGE || tex->type == TEX_ENVMAP)) {
-		if (tex->type == TEX_IMAGE) {
-			GPUNodeLink *texlink = GPU_image(tex->ima, &tex->iuser, false);
-			GPU_stack_link(mat, node, "texture_image", in, out, texlink);
-		}
-		else { /* TEX_ENVMAP */
-			if (!in[0].link)
-				in[0].link = GPU_uniform(in[0].vec);
-			if (!GPU_material_use_world_space_shading(mat))
-				GPU_link(mat, "direction_transform_m4v3", in[0].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &in[0].link);
-			GPU_link(mat, "mtex_cube_map_refl_from_refldir",
-				GPU_cube_map(tex->ima, &tex->iuser, false), in[0].link, &out[0].link, &out[1].link);
-			GPU_link(mat, "color_to_normal", out[1].link, &out[2].link);
-		}
-
-		ImBuf *ibuf = BKE_image_acquire_ibuf(tex->ima, &tex->iuser, NULL);
-		if (ibuf && (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA) == 0 &&
-		    GPU_material_do_color_management(mat))
-		{
-			GPU_link(mat, "srgb_to_linearrgb", out[1].link, &out[1].link);
-		}
-		BKE_image_release_ibuf(tex->ima, ibuf, NULL);
-
-		return true;
-	}
-
-	return false;
-}
-
-void register_node_type_sh_texture(void)
-{
-	static bNodeType ntype;
-
-	sh_node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW);
-	node_type_compatibility(&ntype, NODE_OLD_SHADING);
-	node_type_socket_templates(&ntype, sh_node_texture_in, sh_node_texture_out);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_texture);
-	node_type_gpu(&ntype, gpu_shader_texture);
-
-	nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_vectTransform.c b/source/blender/nodes/shader/nodes/node_shader_vectTransform.c
index 74e23aed7de..71bb88f892f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vectTransform.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vectTransform.c
@@ -52,68 +52,8 @@ static void node_shader_init_vect_transform(bNodeTree *UNUSED(ntree), bNode *nod
 	node->storage = vect;
 }
 
-static const float (* get_matrix_from_to(ShaderCallData *scd, short from, short to))[4]
+static void node_shader_exec_vect_transform(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out))
 {
-	switch (from) {
-		case SHD_VECT_TRANSFORM_SPACE_OBJECT:
-			switch (to) {
-				case SHD_VECT_TRANSFORM_SPACE_OBJECT:
-					return NULL;
-				case SHD_VECT_TRANSFORM_SPACE_WORLD:
-					return RE_object_instance_get_matrix(scd->shi->obi, RE_OBJECT_INSTANCE_MATRIX_OB);
-				case SHD_VECT_TRANSFORM_SPACE_CAMERA:
-					return RE_object_instance_get_matrix(scd->shi->obi, RE_OBJECT_INSTANCE_MATRIX_LOCALTOVIEW);
-			}
-			break;
-		case SHD_VECT_TRANSFORM_SPACE_WORLD:
-			switch (to) {
-				case SHD_VECT_TRANSFORM_SPACE_WORLD:
-					return NULL;
-				case SHD_VECT_TRANSFORM_SPACE_CAMERA:
-					return RE_render_current_get_matrix(RE_VIEW_MATRIX);
-				case SHD_VECT_TRANSFORM_SPACE_OBJECT:
-					return RE_object_instance_get_matrix(scd->shi->obi, RE_OBJECT_INSTANCE_MATRIX_OBINV);
-			}
-			break;
-		case SHD_VECT_TRANSFORM_SPACE_CAMERA:
-			switch (to) {
-				case SHD_VECT_TRANSFORM_SPACE_CAMERA:
-					return NULL;
-				case SHD_VECT_TRANSFORM_SPACE_WORLD:
-					return RE_render_current_get_matrix(RE_VIEWINV_MATRIX);
-				case SHD_VECT_TRANSFORM_SPACE_OBJECT:
-					return RE_object_instance_get_matrix(scd->shi->obi, RE_OBJECT_INSTANCE_MATRIX_LOCALTOVIEWINV);
-			}
-			break;
-	}
-	return NULL;
-}
-
-static void node_shader_exec_vect_transform(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out)
-{
-	float vec[4];
-	const float (*mat)[4];
-
-	if (data) {
-		NodeShaderVectTransform *nodeprop = (NodeShaderVectTransform *)node->storage;
-
-		nodestack_get_vec(vec, SOCK_VECTOR, in[0]);
-
-		if (nodeprop->type == SHD_VECT_TRANSFORM_TYPE_POINT)
-			vec[3] = 1.0f;
-		else
-			vec[3] = 0.0f;
-
-		mat = get_matrix_from_to((ShaderCallData *)data, nodeprop->convert_from, nodeprop->convert_to);
-		if (mat) {
-			mul_m4_v4((float(*)[4])mat, vec);
-		}
-
-		if (nodeprop->type == SHD_VECT_TRANSFORM_TYPE_NORMAL)
-			normalize_v3(vec);
-
-		copy_v4_v4(out[0]->vec, vec);
-	}
 }
 
 static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
@@ -161,8 +101,6 @@ static int gpu_shader_vect_transform(GPUMaterial *mat, bNode *node, bNodeExecDat
 	const char *ptransform = "point_transform_m4v3";
 	const char *func_name = 0;
 
-	bool new_shading = GPU_material_use_new_shading_nodes(mat);
-
 	NodeShaderVectTransform *nodeprop = (NodeShaderVectTransform *)node->storage;
 
 	if (in[0].hasinput)
@@ -174,19 +112,14 @@ static int gpu_shader_vect_transform(GPUMaterial *mat, bNode *node, bNodeExecDat
 
 	func_name = (nodeprop->type == SHD_VECT_TRANSFORM_TYPE_POINT) ? ptransform : vtransform;
 	if (fromto) {
-		if (new_shading) {
-			/* For cycles we have inverted Z */
-			/* TODO: pass here the correct matrices */
-			if (nodeprop->convert_from == SHD_VECT_TRANSFORM_SPACE_CAMERA && nodeprop->convert_to != SHD_VECT_TRANSFORM_SPACE_CAMERA) {
-				GPU_link(mat, "invert_z", inputlink, &inputlink);
-			}
-			GPU_link(mat, func_name, inputlink, fromto,  &out[0].link);
-			if (nodeprop->convert_to == SHD_VECT_TRANSFORM_SPACE_CAMERA && nodeprop->convert_from != SHD_VECT_TRANSFORM_SPACE_CAMERA) {
-				GPU_link(mat, "invert_z", out[0].link, &out[0].link);
-			}
+		/* For cycles we have inverted Z */
+		/* TODO: pass here the correct matrices */
+		if (nodeprop->convert_from == SHD_VECT_TRANSFORM_SPACE_CAMERA && nodeprop->convert_to != SHD_VECT_TRANSFORM_SPACE_CAMERA) {
+			GPU_link(mat, "invert_z", inputlink, &inputlink);
 		}
-		else {
-			GPU_link(mat, func_name, inputlink, fromto,  &out[0].link);
+		GPU_link(mat, func_name, inputlink, fromto,  &out[0].link);
+		if (nodeprop->convert_to == SHD_VECT_TRANSFORM_SPACE_CAMERA && nodeprop->convert_from != SHD_VECT_TRANSFORM_SPACE_CAMERA) {
+			GPU_link(mat, "invert_z", out[0].link, &out[0].link);
 		}
 	}
 	else
diff --git a/source/blender/nodes/texture/node_texture_tree.c b/source/blender/nodes/texture/node_texture_tree.c
index d001d80fa8f..5e57338dc57 100644
--- a/source/blender/nodes/texture/node_texture_tree.c
+++ b/source/blender/nodes/texture/node_texture_tree.c
@@ -68,32 +68,7 @@ static void texture_get_from_context(
 	Object *ob = OBACT(view_layer);
 	Tex *tx = NULL;
 
-	if (snode->texfrom == SNODE_TEX_OBJECT) {
-		if (ob) {
-			tx = give_current_object_texture(ob);
-			if (tx) {
-				if (ob->type == OB_LAMP)
-					*r_from = (ID *)ob->data;
-				else
-					*r_from = (ID *)give_current_material(ob, ob->actcol);
-				
-				/* from is not set fully for material nodes, should be ID + Node then */
-				*r_id = &tx->id;
-				*r_ntree = tx->nodetree;
-			}
-		}
-	}
-	else if (snode->texfrom == SNODE_TEX_WORLD) {
-		if (scene->world) {
-			*r_from = (ID *)scene->world;
-			tx = give_current_world_texture(scene->world);
-			if (tx) {
-				*r_id = &tx->id;
-				*r_ntree = tx->nodetree;
-			}
-		}
-	}
-	else if (snode->texfrom == SNODE_TEX_BRUSH) {
+	if (snode->texfrom == SNODE_TEX_BRUSH) {
 		struct Brush *brush = NULL;
 		
 		if (ob && (ob->mode & OB_MODE_SCULPT))
@@ -324,7 +299,6 @@ int ntreeTexExecTree(
         short which_output,
         int cfra,
         int preview,
-        ShadeInput *shi,
         MTex *mtex)
 {
 	TexCallData data;
@@ -339,12 +313,11 @@ int ntreeTexExecTree(
 	data.osatex = osatex;
 	data.target = texres;
 	data.do_preview = preview;
-	data.do_manage = (shi) ? shi->do_manage : true;
+	data.do_manage = true;
 	data.thread = thread;
 	data.which_output = which_output;
 	data.cfra = cfra;
 	data.mtex = mtex;
-	data.shi = shi;
 	
 	/* ensure execdata is only initialized once */
 	if (!exec) {
diff --git a/source/blender/nodes/texture/node_texture_util.c b/source/blender/nodes/texture/node_texture_util.c
index 32720364f73..8cb61478c41 100644
--- a/source/blender/nodes/texture/node_texture_util.c
+++ b/source/blender/nodes/texture/node_texture_util.c
@@ -124,7 +124,6 @@ void params_from_cdata(TexParams *out, TexCallData *in)
 	out->previewco = in->co;
 	out->osatex = in->osatex;
 	out->cfra = in->cfra;
-	out->shi = in->shi;
 	out->mtex = in->mtex;
 }
 
diff --git a/source/blender/nodes/texture/node_texture_util.h b/source/blender/nodes/texture/node_texture_util.h
index f6af5b1b6ca..82ba573425a 100644
--- a/source/blender/nodes/texture/node_texture_util.h
+++ b/source/blender/nodes/texture/node_texture_util.h
@@ -87,7 +87,6 @@ typedef struct TexCallData {
 	short which_output;
 	int cfra;
 
-	ShadeInput *shi;
 	MTex *mtex;
 } TexCallData;
 
@@ -100,7 +99,6 @@ typedef struct TexParams {
 
 	/* optional. we don't really want these here, but image
 	 * textures need to do mapping & color correction */
-	ShadeInput *shi;
 	MTex *mtex;
 } TexParams;
 
diff --git a/source/blender/nodes/texture/nodes/node_texture_proc.c b/source/blender/nodes/texture/nodes/node_texture_proc.c
index 0be5f875a23..c16d723e1e1 100644
--- a/source/blender/nodes/texture/nodes/node_texture_proc.c
+++ b/source/blender/nodes/texture/nodes/node_texture_proc.c
@@ -69,7 +69,7 @@ static void do_proc(float *result, TexParams *p, const float col1[4], const floa
 		texres.nor = NULL;
 	
 	textype = multitex_nodes(tex, p->co, p->dxt, p->dyt, p->osatex,
-	                         &texres, thread, 0, p->shi, p->mtex, NULL);
+	                         &texres, thread, 0, p->mtex, NULL);
 	
 	if (is_normal)
 		return;
diff --git a/source/blender/nodes/texture/nodes/node_texture_texture.c b/source/blender/nodes/texture/nodes/node_texture_texture.c
index 1fd0a55dc63..7e035d522f7 100644
--- a/source/blender/nodes/texture/nodes/node_texture_texture.c
+++ b/source/blender/nodes/texture/nodes/node_texture_texture.c
@@ -78,7 +78,7 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
 		
 		texres.nor = nor;
 		textype = multitex_nodes(nodetex, co, dxt, dyt, p->osatex,
-		                         &texres, thread, 0, p->shi, p->mtex, NULL);
+		                         &texres, thread, 0, p->mtex, NULL);
 		
 		if (textype & TEX_RGB) {
 			copy_v4_v4(out, &texres.tr);