Cycles: 4 new nodes.

* Tangent: generate a tangent direction for anisotropic shading. Can be either
  radial around X/Y/Z axis, or from a UV map. The default tangent for the
  anisotropic BSDF and geometry node is now always radial Z, for UV tangent use
  this node now.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent

* Normal Map: generate a perturbed normal from an RGB normal map image. This
  is usually chained with an Image Texture node in the color input, to specify
  the normal map image. For tangent space normal maps, the UV coordinates for
  the image must match, and the image texture should be set to Non-Color mode
  to give correct results.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map

* Refraction BSDF: for best results this node should be considered as a building
  block and not be used on its own, but rather mixed with a glossy node using a
  fresnel type factor. Otherwise it will give quite dark results at the edges for
  glossy refraction.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction

* Ambient Occlusion: controls the amount of AO a surface receives, rather than
  having just a global factor in the world. Note that this outputs a shader and
  not a color, that's for another time.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion

5 files changed, 190 insertions, 29 deletions

diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index 698ef5016f0..886fce63fd4 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -215,6 +215,9 @@ __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderT
 			case NODE_CLOSURE_HOLDOUT:
 				svm_node_closure_holdout(sd, stack, node);
 				break;
+			case NODE_CLOSURE_AMBIENT_OCCLUSION:
+				svm_node_closure_ambient_occlusion(sd, stack, node);
+				break;
 			case NODE_CLOSURE_VOLUME:
 				svm_node_closure_volume(kg, sd, stack, node, path_flag);
 				break;
@@ -398,6 +401,12 @@ __device_noinline void svm_eval_nodes(KernelGlobals *kg, ShaderData *sd, ShaderT
 			case NODE_LIGHT_FALLOFF:
 				svm_node_light_falloff(sd, stack, node);
 				break;
+			case NODE_TANGENT:
+				svm_node_tangent(kg, sd, stack, node);
+				break;
+			case NODE_NORMAL_MAP:
+				svm_node_normal_map(kg, sd, stack, node);
+				break;
 #endif			
 			case NODE_END:
 			default:
diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h
index 11ce3b7c5d1..f378d24463d 100644
--- a/intern/cycles/kernel/svm/svm_closure.h
+++ b/intern/cycles/kernel/svm/svm_closure.h
@@ -20,9 +20,9 @@ CCL_NAMESPACE_BEGIN
 
 /* Closure Nodes */
 
-__device void svm_node_glossy_setup(ShaderData *sd, ShaderClosure *sc, int type, float eta, float roughness, bool refract)
+__device void svm_node_glass_setup(ShaderData *sd, ShaderClosure *sc, int type, float eta, float roughness, bool refract)
 {
-	if(type == CLOSURE_BSDF_REFRACTION_ID) {
+	if(type == CLOSURE_BSDF_SHARP_GLASS_ID) {
 		if(refract) {
 			sc->data0 = eta;
 			sd->flag |= bsdf_refraction_setup(sc);
@@ -30,7 +30,7 @@ __device void svm_node_glossy_setup(ShaderData *sd, ShaderClosure *sc, int type,
 		else
 			sd->flag |= bsdf_reflection_setup(sc);
 	}
-	else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID) {
+	else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID) {
 		sc->data0 = roughness;
 		sc->data1 = eta;
 
@@ -159,6 +159,31 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 			if(kernel_data.integrator.no_caustics && (path_flag & PATH_RAY_DIFFUSE))
 				break;
 #endif
+			ShaderClosure *sc = svm_node_closure_get(sd);
+			sc->N = N;
+			sc->data0 = param1;
+			svm_node_closure_set_mix_weight(sc, mix_weight);
+
+			float eta = fmaxf(param2, 1.0f + 1e-5f);
+			sc->data1 = (sd->flag & SD_BACKFACING)? 1.0f/eta: eta;
+
+			/* setup bsdf */
+			if(type == CLOSURE_BSDF_REFRACTION_ID)
+				sd->flag |= bsdf_refraction_setup(sc);
+			else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID)
+				sd->flag |= bsdf_microfacet_beckmann_refraction_setup(sc);
+			else
+				sd->flag |= bsdf_microfacet_ggx_refraction_setup(sc);
+
+			break;
+		}
+		case CLOSURE_BSDF_SHARP_GLASS_ID:
+		case CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID:
+		case CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID: {
+#ifdef __CAUSTICS_TRICKS__
+			if(kernel_data.integrator.no_caustics && (path_flag & PATH_RAY_DIFFUSE))
+				break;
+#endif
 			/* index of refraction */
 			float eta = fmaxf(param2, 1.0f + 1e-5f);
 			eta = (sd->flag & SD_BACKFACING)? 1.0f/eta: eta;
@@ -177,7 +202,7 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 			float sample_weight = sc->sample_weight;
 
 			svm_node_closure_set_mix_weight(sc, mix_weight*fresnel);
-			svm_node_glossy_setup(sd, sc, type, eta, roughness, false);
+			svm_node_glass_setup(sd, sc, type, eta, roughness, false);
 
 			/* refraction */
 			sc = svm_node_closure_get(sd);
@@ -187,7 +212,7 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 			sc->sample_weight = sample_weight;
 
 			svm_node_closure_set_mix_weight(sc, mix_weight*(1.0f - fresnel));
-			svm_node_glossy_setup(sd, sc, type, eta, roughness, true);
+			svm_node_glass_setup(sd, sc, type, eta, roughness, true);
 #else
 			ShaderClosure *sc = svm_node_closure_get(sd);
 			sc->N = N;
@@ -195,7 +220,7 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 			bool refract = (randb > fresnel);
 
 			svm_node_closure_set_mix_weight(sc, mix_weight);
-			svm_node_glossy_setup(sd, sc, type, eta, roughness, refract);
+			svm_node_glass_setup(sd, sc, type, eta, roughness, refract);
 #endif
 
 			break;
@@ -222,12 +247,12 @@ __device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *st
 			float anisotropy = clamp(param2, -0.99f, 0.99f);
 
 			if(anisotropy < 0.0f) {
-				sc->data0 = roughness*(1.0f + anisotropy);
-				sc->data1 = roughness/(1.0f + anisotropy);
+				sc->data0 = roughness/(1.0f + anisotropy);
+				sc->data1 = roughness*(1.0f + anisotropy);
 			}
 			else {
-				sc->data0 = roughness/(1.0f - anisotropy);
-				sc->data1 = roughness*(1.0f - anisotropy);
+				sc->data0 = roughness*(1.0f - anisotropy);
+				sc->data1 = roughness/(1.0f - anisotropy);
 			}
 
 			sd->flag |= bsdf_ward_setup(sc);
@@ -372,6 +397,34 @@ __device void svm_node_closure_holdout(ShaderData *sd, float *stack, uint4 node)
 	sd->flag |= SD_HOLDOUT;
 }
 
+__device void svm_node_closure_ambient_occlusion(ShaderData *sd, float *stack, uint4 node)
+{
+#ifdef __MULTI_CLOSURE__
+	uint mix_weight_offset = node.y;
+
+	if(stack_valid(mix_weight_offset)) {
+		float mix_weight = stack_load_float(stack, mix_weight_offset);
+
+		if(mix_weight == 0.0f)
+			return;
+
+		ShaderClosure *sc = svm_node_closure_get(sd);
+		sc->weight *= mix_weight;
+		sc->type = CLOSURE_AMBIENT_OCCLUSION_ID;
+	}
+	else {
+		ShaderClosure *sc = svm_node_closure_get(sd);
+		sc->type = CLOSURE_AMBIENT_OCCLUSION_ID;
+	}
+
+#else
+	ShaderClosure *sc = &sd->closure;
+	sc->type = CLOSURE_AMBIENT_OCCLUSION_ID;
+#endif
+
+	sd->flag |= SD_AO;
+}
+
 /* Closure Nodes */
 
 __device_inline void svm_node_closure_store_weight(ShaderData *sd, float3 weight)
diff --git a/intern/cycles/kernel/svm/svm_geometry.h b/intern/cycles/kernel/svm/svm_geometry.h
index 8e772f849c7..68177493f4e 100644
--- a/intern/cycles/kernel/svm/svm_geometry.h
+++ b/intern/cycles/kernel/svm/svm_geometry.h
@@ -29,29 +29,18 @@ __device void svm_node_geometry(KernelGlobals *kg, ShaderData *sd, float *stack,
 		case NODE_GEOM_N: data = sd->N; break;
 #ifdef __DPDU__
 		case NODE_GEOM_T: {
-			/* first try to get tangent attribute */
-			int attr_offset = (sd->object != ~0)? find_attribute(kg, sd, ATTR_STD_TANGENT): ATTR_STD_NOT_FOUND;
+			/* try to create spherical tangent from generated coordinates */
+			int attr_offset = (sd->object != ~0)? find_attribute(kg, sd, ATTR_STD_GENERATED): ATTR_STD_NOT_FOUND;
 
 			if(attr_offset != ATTR_STD_NOT_FOUND) {
-				/* ensure orthogonal and normalized (interpolation breaks it) */
-				data = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_CORNER, attr_offset, NULL, NULL);
+				data = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_VERTEX, attr_offset, NULL, NULL);
+				data = make_float3(-(data.y - 0.5), (data.x - 0.5), 0.0f);
 				object_normal_transform(kg, sd, &data);
 				data = cross(sd->N, normalize(cross(data, sd->N)));;
 			}
 			else {
-				/* try to create spherical tangent from generated coordinates */
-				int attr_offset = (sd->object != ~0)? find_attribute(kg, sd, ATTR_STD_GENERATED): ATTR_STD_NOT_FOUND;
-
-				if(attr_offset != ATTR_STD_NOT_FOUND) {
-					data = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_VERTEX, attr_offset, NULL, NULL);
-					data = make_float3(-(data.y - 0.5), (data.x - 0.5), 0.0f);
-					object_normal_transform(kg, sd, &data);
-					data = cross(sd->N, normalize(cross(data, sd->N)));;
-				}
-				else {
-					/* otherwise use surface derivatives */
-					data = normalize(sd->dPdu);
-				}
+				/* otherwise use surface derivatives */
+				data = normalize(sd->dPdu);
 			}
 
 			break;
diff --git a/intern/cycles/kernel/svm/svm_tex_coord.h b/intern/cycles/kernel/svm/svm_tex_coord.h
index 6bd8f2ac69c..2f73f7b9d40 100644
--- a/intern/cycles/kernel/svm/svm_tex_coord.h
+++ b/intern/cycles/kernel/svm/svm_tex_coord.h
@@ -225,5 +225,91 @@ __device void svm_node_tex_coord_bump_dy(KernelGlobals *kg, ShaderData *sd, floa
 #endif
 }
 
+__device void svm_node_normal_map(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
+{
+	uint color_offset, normal_offset, space;
+	decode_node_uchar4(node.y, &color_offset, &normal_offset, &space, NULL);
+
+	float3 color = stack_load_float3(stack, color_offset);
+	color = 2.0f*make_float3(color.x - 0.5f, color.y - 0.5f, color.z - 0.5f);
+
+	if(space == NODE_NORMAL_MAP_TANGENT) {
+		/* tangent space */
+		if(sd->object == ~0) {
+			stack_store_float3(stack, normal_offset, make_float3(0.0f, 0.0f, 0.0f));
+			return;
+		}
+
+		/* first try to get tangent attribute */
+		int attr_offset = find_attribute(kg, sd, node.z);
+		int attr_sign_offset = find_attribute(kg, sd, node.w);
+
+		if(attr_offset == ATTR_STD_NOT_FOUND || attr_offset == ATTR_STD_NOT_FOUND) {
+			stack_store_float3(stack, normal_offset, make_float3(0.0f, 0.0f, 0.0f));
+			return;
+		}
+
+		/* ensure orthogonal and normalized (interpolation breaks it) */
+		float3 tangent = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_CORNER, attr_offset, NULL, NULL);
+		float sign = triangle_attribute_float(kg, sd, ATTR_ELEMENT_CORNER, attr_sign_offset, NULL, NULL);
+
+		object_normal_transform(kg, sd, &tangent);
+		tangent = cross(sd->N, normalize(cross(tangent, sd->N)));;
+
+		float3 B = sign * cross(sd->N, tangent);
+		float3 N = color.x * tangent + color.y * B + color.z * sd->N;
+
+		stack_store_float3(stack, normal_offset, normalize(N));
+	}
+	else {
+		/* object, world space */
+		float3 N = color;
+
+		if(space == NODE_NORMAL_MAP_OBJECT)
+			object_normal_transform(kg, sd, &N);
+
+		stack_store_float3(stack, normal_offset, normalize(N));
+	}
+}
+
+__device void svm_node_tangent(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
+{
+	uint tangent_offset, direction_type, axis;
+	decode_node_uchar4(node.y, &tangent_offset, &direction_type, &axis, NULL);
+
+	float3 tangent;
+
+	if(direction_type == NODE_TANGENT_UVMAP) {
+		/* UV map */
+		int attr_offset = find_attribute(kg, sd, node.z);
+
+		if(attr_offset == ATTR_STD_NOT_FOUND)
+			tangent = make_float3(0.0f, 0.0f, 0.0f);
+		else
+			tangent = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_CORNER, attr_offset, NULL, NULL);
+	}
+	else {
+		/* radial */
+		int attr_offset = find_attribute(kg, sd, node.z);
+		float3 generated;
+
+		if(attr_offset == ATTR_STD_NOT_FOUND)
+			generated = sd->P;
+		else
+			generated = triangle_attribute_float3(kg, sd, ATTR_ELEMENT_VERTEX, attr_offset, NULL, NULL);
+
+		if(axis == NODE_TANGENT_AXIS_X)
+			tangent = make_float3(0.0f, -(generated.z - 0.5f), (generated.y - 0.5f));
+		else if(axis == NODE_TANGENT_AXIS_Y)
+			tangent = make_float3(-(generated.z - 0.5f), 0.0f, (generated.x - 0.5f));
+		else
+			tangent = make_float3(-(generated.y - 0.5f), (generated.x - 0.5f), 0.0f);
+	}
+
+	object_normal_transform(kg, sd, &tangent);
+	tangent = cross(sd->N, normalize(cross(tangent, sd->N)));
+	stack_store_float3(stack, tangent_offset, tangent);
+}
+
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 77df373a159..54767f3c87f 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -94,6 +94,9 @@ typedef enum NodeType {
 	NODE_PARTICLE_INFO,
 	NODE_TEX_BRICK,
 	NODE_CLOSURE_SET_NORMAL,
+	NODE_CLOSURE_AMBIENT_OCCLUSION,
+	NODE_TANGENT,
+	NODE_NORMAL_MAP
 } NodeType;
 
 typedef enum NodeAttributeType {
@@ -279,6 +282,23 @@ typedef enum NodeBlendWeightType {
 	NODE_LAYER_WEIGHT_FACING
 } NodeBlendWeightType;
 
+typedef enum NodeTangentDirectionType {
+	NODE_TANGENT_RADIAL,
+	NODE_TANGENT_UVMAP
+} NodeTangentDirectionType;
+
+typedef enum NodeTangentAxis {
+	NODE_TANGENT_AXIS_X,
+	NODE_TANGENT_AXIS_Y,
+	NODE_TANGENT_AXIS_Z
+} NodeTangentAxis;
+
+typedef enum NodeNormalMapSpace {
+	NODE_NORMAL_MAP_TANGENT,
+	NODE_NORMAL_MAP_OBJECT,
+	NODE_NORMAL_MAP_WORLD
+} NodeNormalMapSpace;
+
 typedef enum ShaderType {
 	SHADER_TYPE_SURFACE,
 	SHADER_TYPE_VOLUME,
@@ -307,7 +327,9 @@ typedef enum ClosureType {
 	CLOSURE_BSDF_WESTIN_BACKSCATTER_ID,
 	CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID,
 	CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID,
-	CLOSURE_BSDF_GLASS_ID,
+	CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID,
+	CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID,
+	CLOSURE_BSDF_SHARP_GLASS_ID,
 
 	CLOSURE_BSDF_TRANSPARENT_ID,
 
@@ -317,6 +339,7 @@ typedef enum ClosureType {
 	CLOSURE_BACKGROUND_ID,
 	CLOSURE_HOLDOUT_ID,
 	CLOSURE_SUBSURFACE_ID,
+	CLOSURE_AMBIENT_OCCLUSION_ID,
 
 	CLOSURE_VOLUME_ID,
 	CLOSURE_VOLUME_TRANSPARENT_ID,
@@ -329,11 +352,12 @@ typedef enum ClosureType {
 #define CLOSURE_IS_BSDF(type) (type <= CLOSURE_BSDF_TRANSPARENT_ID)
 #define CLOSURE_IS_BSDF_DIFFUSE(type) (type >= CLOSURE_BSDF_DIFFUSE_ID && type <= CLOSURE_BSDF_OREN_NAYAR_ID)
 #define CLOSURE_IS_BSDF_GLOSSY(type) (type >= CLOSURE_BSDF_GLOSSY_ID && type <= CLOSURE_BSDF_WESTIN_SHEEN_ID)
-#define CLOSURE_IS_BSDF_TRANSMISSION(type) (type >= CLOSURE_BSDF_TRANSMISSION_ID && type <= CLOSURE_BSDF_GLASS_ID)
+#define CLOSURE_IS_BSDF_TRANSMISSION(type) (type >= CLOSURE_BSDF_TRANSMISSION_ID && type <= CLOSURE_BSDF_SHARP_GLASS_ID)
 #define CLOSURE_IS_VOLUME(type) (type >= CLOSURE_VOLUME_ID && type <= CLOSURE_VOLUME_ISOTROPIC_ID)
 #define CLOSURE_IS_EMISSION(type) (type == CLOSURE_EMISSION_ID)
 #define CLOSURE_IS_HOLDOUT(type) (type == CLOSURE_HOLDOUT_ID)
 #define CLOSURE_IS_BACKGROUND(type) (type == CLOSURE_BACKGROUND_ID)
+#define CLOSURE_IS_AMBIENT_OCCLUSION(type) (type == CLOSURE_AMBIENT_OCCLUSION_ID)
 
 CCL_NAMESPACE_END