Merge branch 'master' into blender2.8

Conflicts:
	intern/cycles/blender/blender_curves.cpp
	source/blender/blenkernel/intern/dynamicpaint.c
	source/blender/blenkernel/intern/particle.c
	source/blender/blenloader/intern/versioning_270.c
	source/blender/editors/physics/particle_edit.c
	source/blender/editors/transform/transform_snap_object.c
	source/blender/editors/util/undo.c
	source/blender/makesrna/intern/rna_object_force.c

15 files changed, 278 insertions, 36 deletions

diff --git a/source/blender/nodes/shader/node_shader_tree.c b/source/blender/nodes/shader/node_shader_tree.c
index c4ec55c8d06..29b1e5bc5c7 100644
--- a/source/blender/nodes/shader/node_shader_tree.c
+++ b/source/blender/nodes/shader/node_shader_tree.c
@@ -199,12 +199,172 @@ void register_node_tree_type_sh(void)
 
 /* GPU material from shader nodes */
 
+/* Find an output node of the shader tree.
+ *
+ * NOTE: it will only return output which is NOT in the group, which isn't how
+ * render engines works but it's how the GPU shader compilation works. This we
+ * can change in the future and make it a generic function, but for now it stays
+ * private here.
+ */
+static bNode *ntree_shader_output_node(bNodeTree *ntree)
+{
+	/* Make sure we only have single node tagged as output. */
+	ntreeSetOutput(ntree);
+	for (bNode *node = ntree->nodes.first; node != NULL; node = node->next) {
+		if (node->flag & NODE_DO_OUTPUT) {
+			return node;
+		}
+	}
+	return NULL;
+}
+
+/* Find socket with a specified identifier. */
+static bNodeSocket *ntree_shader_node_find_socket(ListBase *sockets,
+                                                  const char *identifier)
+{
+	for (bNodeSocket *sock = sockets->first; sock != NULL; sock = sock->next) {
+		if (STREQ(sock->identifier, identifier)) {
+			return sock;
+		}
+	}
+	return NULL;
+}
+
+/* Find input socket with a specified identifier. */
+static bNodeSocket *ntree_shader_node_find_input(bNode *node,
+                                                 const char *identifier)
+{
+	return ntree_shader_node_find_socket(&node->inputs, identifier);
+}
+
+/* Find output socket with a specified identifier. */
+static bNodeSocket *ntree_shader_node_find_output(bNode *node,
+                                                  const char *identifier)
+{
+	return ntree_shader_node_find_socket(&node->outputs, identifier);
+}
+
+/* Check whether shader has a displacement.
+ *
+ * Will also return a node and it's socket which is connected to a displacement
+ * output. Additionally, link which is attached to the displacement output is
+ * also returned.
+ */
+static bool ntree_shader_has_displacement(bNodeTree *ntree,
+                                          bNode **r_node,
+                                          bNodeSocket **r_socket,
+                                          bNodeLink **r_link)
+{
+	bNode *output_node = ntree_shader_output_node(ntree);
+	if (output_node == NULL) {
+		/* We can't have displacement without output node, apparently. */
+		return false;
+	}
+	/* Make sure sockets links pointers are correct. */
+	ntreeUpdateTree(G.main, ntree);
+	bNodeSocket *displacement = ntree_shader_node_find_input(output_node,
+	                                                         "Displacement");
+
+	if (displacement == NULL) {
+		/* Non-cycles node is used as an output. */
+		return false;
+	}
+	if (displacement->link != NULL) {
+		*r_node = displacement->link->fromnode;
+		*r_socket = displacement->link->fromsock;
+		*r_link = displacement->link;
+	}
+	return displacement->link != NULL;
+}
+
+/* Use specified node and socket as an input for unconnected normal sockets. */
+static void ntree_shader_link_builtin_normal(bNodeTree *ntree,
+                                             bNode *node_from,
+                                             bNodeSocket *socket_from)
+{
+	for (bNode *node = ntree->nodes.first; node != NULL; node = node->next) {
+		if (node == node_from) {
+			/* Don't connect node itself! */
+			continue;
+		}
+		bNodeSocket *sock = ntree_shader_node_find_input(node, "Normal");
+		/* TODO(sergey): Can we do something smarter here than just a name-based
+		 * matching?
+		 */
+		if (sock == NULL) {
+			/* There's no Normal input, nothing to link. */
+			continue;
+		}
+		if (sock->link != NULL) {
+			/* Something is linked to the normal input already. can't
+			 * use other input for that.
+			 */
+			continue;
+		}
+		/* Create connection between specified node and the normal input. */
+		nodeAddLink(ntree, node_from, socket_from, node, sock);
+	}
+}
+
+/* Re-link displacement output to unconnected normal sockets via bump node.
+ * This way material with have proper displacement in the viewport.
+ */
+static void ntree_shader_relink_displacement(bNodeTree *ntree,
+                                             short compatibility)
+{
+	if (compatibility != NODE_NEW_SHADING) {
+		/* We can only deal with new shading system here. */
+		return;
+	}
+	bNode *displacement_node;
+	bNodeSocket *displacement_socket;
+	bNodeLink *displacement_link;
+	if (!ntree_shader_has_displacement(ntree,
+	                                   &displacement_node,
+	                                   &displacement_socket,
+	                                   &displacement_link))
+	{
+		/* There is no displacement output connected, nothing to re-link. */
+		return;
+	}
+	/* We have to disconnect displacement output socket, otherwise we'll have
+	 * cycles in the Cycles material :)
+	 */
+	nodeRemLink(ntree, displacement_link);
+	/* We can't connect displacement to normal directly, use bump node for that
+	 * and hope that it gives good enough approximation.
+	 */
+	bNode *bump_node = nodeAddStaticNode(NULL, ntree, SH_NODE_BUMP);
+	bNodeSocket *bump_input_socket = ntree_shader_node_find_input(bump_node, "Height");
+	bNodeSocket *bump_output_socket = ntree_shader_node_find_output(bump_node, "Normal");
+	BLI_assert(bump_input_socket != NULL);
+	BLI_assert(bump_output_socket != NULL);
+	/* Connect bump node to where displacement output was originally
+	 * connected to.
+	 */
+	nodeAddLink(ntree,
+	            displacement_node, displacement_socket,
+	            bump_node, bump_input_socket);
+	/* Connect all free-standing Normal inputs. */
+	ntree_shader_link_builtin_normal(ntree, bump_node, bump_output_socket);
+	/* TODO(sergey): Reconnect Geometry Info->Normal sockets to the new
+	 * bump node.
+	 */
+	/* We modified the tree, it needs to be updated now. */
+	ntreeUpdateTree(G.main, ntree);
+}
+
 void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat, short compatibility)
 {
 	/* localize tree to create links for reroute and mute */
 	bNodeTree *localtree = ntreeLocalize(ntree);
 	bNodeTreeExec *exec;
 
+	/* Perform all needed modifications on the tree in order to support
+	 * displacement/bump mapping.
+	 */
+	ntree_shader_relink_displacement(localtree, compatibility);
+
 	exec = ntreeShaderBeginExecTree(localtree);
 	ntreeExecGPUNodes(exec, mat, 1, compatibility);
 	ntreeShaderEndExecTree(exec);
diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.c b/source/blender/nodes/shader/nodes/node_shader_attribute.c
index 61bdfb3dfd6..0a69593cf07 100644
--- a/source/blender/nodes/shader/nodes/node_shader_attribute.c
+++ b/source/blender/nodes/shader/nodes/node_shader_attribute.c
@@ -45,9 +45,9 @@ static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node)
 static int node_shader_gpu_attribute(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
 	NodeShaderAttribute *attr = node->storage;
-	GPUNodeLink *mtface = GPU_attribute(CD_MTFACE, attr->name);
+	GPUNodeLink *cd_attr = GPU_attribute(CD_AUTO_FROM_NAME, attr->name);
 
-	return GPU_stack_link(mat, "node_attribute", in, out, mtface);
+	return GPU_stack_link(mat, "node_attribute", in, out, cd_attr);
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_bump.c b/source/blender/nodes/shader/nodes/node_shader_bump.c
index 22027d58385..b39ca5d90ee 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bump.c
+++ b/source/blender/nodes/shader/nodes/node_shader_bump.c
@@ -45,14 +45,21 @@ static bNodeSocketTemplate sh_node_bump_out[] = {
 	{ -1, 0, "" }
 };
 
-static int gpu_shader_bump(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
+static int gpu_shader_bump(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
 	if (!in[3].link)
 		in[3].link = GPU_builtin(GPU_VIEW_NORMAL);
 	else
 		GPU_link(mat, "direction_transform_m4v3", in[3].link, GPU_builtin(GPU_VIEW_MATRIX), &in[3].link);
-
-	return GPU_stack_link(mat, "node_bump", in, out);
+	float invert = node->custom1;
+	GPU_stack_link(mat, "node_bump", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_uniform(&invert));
+	/* Other nodes are applying view matrix if the input Normal has a link.
+	 * We don't want normal to have view matrix applied twice, so we cancel it here.
+	 *
+	 * TODO(sergey): This is an extra multiplication which cancels each other,
+	 * better avoid this but that requires bigger refactor.
+	 */
+	return GPU_link(mat, "direction_transform_m4v3", out[0].link, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &out[0].link);
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_mapping.c b/source/blender/nodes/shader/nodes/node_shader_mapping.c
index cd398cc8264..2044f5390cc 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mapping.c
+++ b/source/blender/nodes/shader/nodes/node_shader_mapping.c
@@ -42,6 +42,15 @@ static bNodeSocketTemplate sh_node_mapping_out[] = {
 	{	-1, 0, ""	}
 };
 
+static void *node_shader_initexec_mapping(bNodeExecContext *UNUSED(context),
+                                          bNode *node,
+                                          bNodeInstanceKey UNUSED(key))
+{
+	TexMapping *texmap = node->storage;
+	BKE_texture_mapping_init(texmap);
+	return NULL;
+}
+
 /* do the regular mapping options for blender textures */
 static void node_shader_exec_mapping(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out)
 {
@@ -103,7 +112,7 @@ void register_node_type_sh_mapping(void)
 	node_type_size(&ntype, 320, 160, 360);
 	node_type_init(&ntype, node_shader_init_mapping);
 	node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage);
-	node_type_exec(&ntype, NULL, NULL, node_shader_exec_mapping);
+	node_type_exec(&ntype, node_shader_initexec_mapping, NULL, node_shader_exec_mapping);
 	node_type_gpu(&ntype, gpu_shader_mapping);
 	
 	nodeRegisterType(&ntype);
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 642e5b296be..d2695609a88 100644
--- a/source/blender/nodes/shader/nodes/node_shader_normal_map.c
+++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.c
@@ -121,35 +121,69 @@ static int gpu_shader_normal_map(GPUMaterial *mat, bNode *node, bNodeExecData *U
 	else
 		strength = GPU_uniform(in[0].vec);
 
-	if (in[1].link) {
-		GPU_link(mat, "color_to_normal", in[1].link, &realnorm);
-		GPU_link(mat, "mtex_negate_texnormal", realnorm,  &realnorm);
-	}
+	if (in[1].link)
+		realnorm = in[1].link;
+	else
+		realnorm = GPU_uniform(in[1].vec);
 
+	negnorm = GPU_builtin(GPU_VIEW_NORMAL);
 	GPU_link(mat, "math_max", strength, GPU_uniform(d), &strength);
-	GPU_link(mat, "vec_math_negate", GPU_builtin(GPU_VIEW_NORMAL), &negnorm);
 
-	if (in[1].link) {
+	if (GPU_material_use_new_shading_nodes(mat)) {
+
+		/* **************** CYCLES ******************** */
+
+		GPU_link(mat, "direction_transform_m4v3", negnorm, GPU_builtin(GPU_INVERSE_VIEW_MATRIX), &negnorm);
+
 		switch (nm->space) {
 			case SHD_NORMAL_MAP_TANGENT:
-				GPU_link(mat, "node_normal_map", GPU_attribute(CD_TANGENT, nm->uv_map), negnorm, realnorm, &out[0].link);
+				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);
 				break;
 			case SHD_NORMAL_MAP_OBJECT:
+				GPU_link(mat, "color_to_normal_new_shading", realnorm, &realnorm);
+				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_OBJECT_MATRIX),  &realnorm);
+				break;
 			case SHD_NORMAL_MAP_BLENDER_OBJECT:
-				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_LOC_TO_VIEW_MATRIX),  &out[0].link);
+				GPU_link(mat, "color_to_blender_normal_new_shading", realnorm, &realnorm);
+				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_OBJECT_MATRIX),  &realnorm);
 				break;
 			case SHD_NORMAL_MAP_WORLD:
+				GPU_link(mat, "color_to_normal_new_shading", realnorm, &realnorm);
+				break;
 			case SHD_NORMAL_MAP_BLENDER_WORLD:
-				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_VIEW_MATRIX),  &out[0].link);
+				GPU_link(mat, "color_to_blender_normal_new_shading", realnorm, &realnorm);
 				break;
+
+		GPU_link(mat, "vect_normalize", realnorm, &realnorm);
 		}
-	}
 
-	if (out[0].link) {
-		GPU_link(mat, "vec_math_mix", strength, out[0].link, negnorm,  &out[0].link);
-		GPU_link(mat, "vect_normalize", out[0].link, &out[0].link);
+	} else {
+
+		/* *********** BLENDER INTERNAL *************** */
+
+		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_NORMAL_MAP_TANGENT:
+				GPU_link(mat, "node_normal_map", GPU_attribute(CD_TANGENT, nm->uv_map), negnorm, realnorm, &realnorm);
+				break;
+			case SHD_NORMAL_MAP_OBJECT:
+			case SHD_NORMAL_MAP_BLENDER_OBJECT:
+				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_LOC_TO_VIEW_MATRIX),  &realnorm);
+				break;
+			case SHD_NORMAL_MAP_WORLD:
+			case SHD_NORMAL_MAP_BLENDER_WORLD:
+				GPU_link(mat, "direction_transform_m4v3", realnorm, GPU_builtin(GPU_VIEW_MATRIX),  &realnorm);
+				break;
+		}
 	}
 
+	GPU_link(mat, "vec_math_mix", strength, realnorm, negnorm,  &out[0].link);
+	GPU_link(mat, "vect_normalize", out[0].link, &out[0].link);
+
 	return true;
 }
 
@@ -169,4 +203,3 @@ void register_node_type_sh_normal_map(void)
 
 	nodeRegisterType(&ntype);
 }
-
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c
index 569eaf5ff9b..bb7f2166a8a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c
@@ -64,12 +64,19 @@ static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
-
-	return GPU_stack_link(mat, "node_tex_brick", in, out);
+	NodeTexBrick *tex = (NodeTexBrick *)node->storage;
+	float offset_freq = tex->offset_freq;
+	float squash_freq = tex->squash_freq;
+	return GPU_stack_link(mat, "node_tex_brick",
+	                      in, out,
+	                      GPU_uniform(&tex->offset), GPU_uniform(&offset_freq),
+	                      GPU_uniform(&tex->squash), GPU_uniform(&squash_freq));
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c
index b7498df1706..77edd0e115e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c
@@ -54,8 +54,10 @@ static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c
index 292221c9555..2f8f95b0675 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c
@@ -82,7 +82,7 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, bNodeE
 		
 	ImBuf *ibuf = BKE_image_acquire_ibuf(ima, iuser, NULL);
 	if (ibuf && (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA) == 0 &&
-		GPU_material_do_color_management(mat))
+	    GPU_material_do_color_management(mat))
 	{
 		GPU_link(mat, "srgb_to_linearrgb", out[0].link, &out[0].link);
 	}
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c
index 24916e8f013..18a8065fb57 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c
@@ -52,12 +52,16 @@ static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
-	return GPU_stack_link(mat, "node_tex_gradient", in, out);
+	NodeTexGradient *tex = (NodeTexGradient *)node->storage;
+	float gradient_type = tex->gradient_type;
+	return GPU_stack_link(mat, "node_tex_gradient", in, out, GPU_uniform(&gradient_type));
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c
index 80904e376bc..8700d7954e7 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c
@@ -57,8 +57,10 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, bNodeExecDat
 	NodeTexMagic *tex = (NodeTexMagic *)node->storage;
 	float depth = tex->depth;
 
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
index 825ba7eb3c1..51d6699fadd 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
@@ -58,12 +58,17 @@ static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
-	return GPU_stack_link(mat, "node_tex_musgrave", in, out);
+	NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
+	float type = tex->musgrave_type;
+
+	return GPU_stack_link(mat, "node_tex_musgrave", in, out, GPU_uniform(&type));
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c
index d806140694e..91015b3db25 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c
@@ -54,8 +54,10 @@ static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
index 88596a4a72f..c994798e2da 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
@@ -53,12 +53,17 @@ static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
-	return GPU_stack_link(mat, "node_tex_voronoi", in, out);
+	NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
+	float coloring = tex->coloring;
+
+	return GPU_stack_link(mat, "node_tex_voronoi", in, out, GPU_uniform(&coloring));
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c
index 100510641e8..1194874e06c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c
@@ -56,12 +56,18 @@ static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node)
 
 static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out)
 {
-	if (!in[0].link)
+	if (!in[0].link) {
 		in[0].link = GPU_attribute(CD_ORCO, "");
+		GPU_link(mat, "generated_from_orco", in[0].link, &in[0].link);
+	}
 
 	node_shader_gpu_tex_mapping(mat, node, in, out);
 
-	return GPU_stack_link(mat, "node_tex_wave", in, out);
+	NodeTexWave *tex = (NodeTexWave *)node->storage;
+	float wave_type = tex->wave_type;
+	float wave_profile = tex->wave_profile;
+
+	return GPU_stack_link(mat, "node_tex_wave", in, out, GPU_uniform(&wave_type), GPU_uniform(&wave_profile));
 }
 
 /* node type definition */
diff --git a/source/blender/nodes/shader/nodes/node_shader_texture.c b/source/blender/nodes/shader/nodes/node_shader_texture.c
index 2ce38a068b7..6edf6c2a0b4 100644
--- a/source/blender/nodes/shader/nodes/node_shader_texture.c
+++ b/source/blender/nodes/shader/nodes/node_shader_texture.c
@@ -127,7 +127,7 @@ static int gpu_shader_texture(GPUMaterial *mat, bNode *node, bNodeExecData *UNUS
 
 		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_material_do_color_management(mat))
 		{
 			GPU_link(mat, "srgb_to_linearrgb", out[1].link, &out[1].link);
 		}