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

2 files changed, 108 insertions, 36 deletions

diff --git a/intern/cycles/blender/blender_mesh.cpp b/intern/cycles/blender/blender_mesh.cpp
index 0e13479a761..69b330db483 100644
--- a/intern/cycles/blender/blender_mesh.cpp
+++ b/intern/cycles/blender/blender_mesh.cpp
@@ -116,7 +116,7 @@ static void mikk_set_tangent_space(const SMikkTSpaceContext *context, const floa
 	userdata->tangent[face*4 + vert] = make_float4(T[0], T[1], T[2], sign);
 }
 
-static void mikk_compute_tangents(BL::Mesh b_mesh, BL::MeshTextureFaceLayer b_layer, Mesh *mesh, vector<int>& nverts)
+static void mikk_compute_tangents(BL::Mesh b_mesh, BL::MeshTextureFaceLayer b_layer, Mesh *mesh, vector<int>& nverts, bool need_sign, bool active_render)
 {
 	/* setup userdata */
 	MikkUserData userdata(b_mesh, b_layer, nverts.size());
@@ -140,22 +140,57 @@ static void mikk_compute_tangents(BL::Mesh b_mesh, BL::MeshTextureFaceLayer b_la
 	/* compute tangents */
 	genTangSpaceDefault(&context);
 
-	/* create attribute */
-	/* todo: create float4 attribute for sign */
-	Attribute *attr = mesh->attributes.add(ATTR_STD_TANGENT, ustring("tangent"));
+	/* create tangent attributes */
+	Attribute *attr;
+	ustring name = ustring((string(b_layer.name().c_str()) + ".tangent").c_str());
+
+	if(active_render)
+		attr = mesh->attributes.add(ATTR_STD_UV_TANGENT, name);
+	else
+		attr = mesh->attributes.add(name, TypeDesc::TypeVector, Attribute::CORNER);
+
 	float3 *tangent = attr->data_float3();
 
-	for (int i = 0; i < nverts.size(); i++) {
+	/* create bitangent sign attribute */
+	float *tangent_sign = NULL;
+
+	if(need_sign) {
+		Attribute *attr_sign;
+		ustring name_sign = ustring((string(b_layer.name().c_str()) + ".tangent_sign").c_str());
+
+		if(active_render)
+			attr_sign = mesh->attributes.add(ATTR_STD_UV_TANGENT_SIGN, name_sign);
+		else
+			attr_sign = mesh->attributes.add(name_sign, TypeDesc::TypeFloat, Attribute::CORNER);
+
+		tangent_sign = attr_sign->data_float();
+	}
+
+	for(int i = 0; i < nverts.size(); i++) {
 		tangent[0] = float4_to_float3(userdata.tangent[i*4 + 0]);
 		tangent[1] = float4_to_float3(userdata.tangent[i*4 + 1]);
 		tangent[2] = float4_to_float3(userdata.tangent[i*4 + 2]);
 		tangent += 3;
 
+		if(tangent_sign) {
+			tangent_sign[0] = userdata.tangent[i*4 + 0].w;
+			tangent_sign[1] = userdata.tangent[i*4 + 1].w;
+			tangent_sign[2] = userdata.tangent[i*4 + 2].w;
+			tangent_sign += 3;
+		}
+
 		if(nverts[i] == 4) {
 			tangent[0] = float4_to_float3(userdata.tangent[i*4 + 0]);
 			tangent[1] = float4_to_float3(userdata.tangent[i*4 + 2]);
 			tangent[2] = float4_to_float3(userdata.tangent[i*4 + 3]);
 			tangent += 3;
+
+			if(tangent_sign) {
+				tangent_sign[0] = userdata.tangent[i*4 + 0].w;
+				tangent_sign[1] = userdata.tangent[i*4 + 2].w;
+				tangent_sign[2] = userdata.tangent[i*4 + 3].w;
+				tangent_sign += 3;
+			}
 		}
 	}
 }
@@ -233,48 +268,49 @@ static void create_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, const vector<
 		BL::Mesh::tessface_uv_textures_iterator l;
 
 		for(b_mesh.tessface_uv_textures.begin(l); l != b_mesh.tessface_uv_textures.end(); ++l) {
-			AttributeStandard std = (l->active_render())? ATTR_STD_UV: ATTR_STD_NONE;
+			bool active_render = l->active_render();
+			AttributeStandard std = (active_render)? ATTR_STD_UV: ATTR_STD_NONE;
 			ustring name = ustring(l->name().c_str());
 
-			if(!(mesh->need_attribute(scene, name) || mesh->need_attribute(scene, std)))
-				continue;
+			/* UV map */
+			if(mesh->need_attribute(scene, name) || mesh->need_attribute(scene, std)) {
+				Attribute *attr;
 
-			Attribute *attr;
-
-			if(l->active_render())
-				attr = mesh->attributes.add(std, name);
-			else
-				attr = mesh->attributes.add(name, TypeDesc::TypePoint, Attribute::CORNER);
-
-			BL::MeshTextureFaceLayer::data_iterator t;
-			float3 *fdata = attr->data_float3();
-			size_t i = 0;
+				if(active_render)
+					attr = mesh->attributes.add(std, name);
+				else
+					attr = mesh->attributes.add(name, TypeDesc::TypePoint, Attribute::CORNER);
 
-			for(l->data.begin(t); t != l->data.end(); ++t, ++i) {
-				fdata[0] =  get_float3(t->uv1());
-				fdata[1] =  get_float3(t->uv2());
-				fdata[2] =  get_float3(t->uv3());
-				fdata += 3;
+				BL::MeshTextureFaceLayer::data_iterator t;
+				float3 *fdata = attr->data_float3();
+				size_t i = 0;
 
-				if(nverts[i] == 4) {
+				for(l->data.begin(t); t != l->data.end(); ++t, ++i) {
 					fdata[0] =  get_float3(t->uv1());
-					fdata[1] =  get_float3(t->uv3());
-					fdata[2] =  get_float3(t->uv4());
+					fdata[1] =  get_float3(t->uv2());
+					fdata[2] =  get_float3(t->uv3());
 					fdata += 3;
+
+					if(nverts[i] == 4) {
+						fdata[0] =  get_float3(t->uv1());
+						fdata[1] =  get_float3(t->uv3());
+						fdata[2] =  get_float3(t->uv4());
+						fdata += 3;
+					}
 				}
 			}
-		}
-	}
 
-	/* create texcoord-based tangent attributes */
-	if(mesh->need_attribute(scene, ATTR_STD_TANGENT)) {
-		BL::Mesh::tessface_uv_textures_iterator l;
+			/* UV tangent */
+			std = (active_render)? ATTR_STD_UV_TANGENT: ATTR_STD_NONE;
+			name = ustring((string(name.c_str()) + ".tangent").c_str());
 
-		for(b_mesh.tessface_uv_textures.begin(l); l != b_mesh.tessface_uv_textures.end(); ++l) {
-			if(!l->active_render())
-				continue;
+			if(mesh->need_attribute(scene, name) || mesh->need_attribute(scene, std)) {
+				std = (active_render)? ATTR_STD_UV_TANGENT_SIGN: ATTR_STD_NONE;
+				name = ustring((string(name.c_str()) + ".tangent_sign").c_str());
+				bool need_sign = (mesh->need_attribute(scene, name) || mesh->need_attribute(scene, std));
 
-			mikk_compute_tangents(b_mesh, *l, mesh, nverts);
+				mikk_compute_tangents(b_mesh, *l, mesh, nverts, need_sign, active_render);
+			}
 		}
 	}
 
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 1f8d86a7f70..6dc0bbdb90e 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -173,6 +173,7 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
 		case BL::ShaderNode::type_OUTPUT: break;
 		case BL::ShaderNode::type_SQUEEZE: break;
 		case BL::ShaderNode::type_TEXTURE: break;
+		case BL::ShaderNode::type_FRAME: break;
 		/* handled outside this function */
 		case BL::ShaderNode::type_GROUP: break;
 		/* existing blender nodes */
@@ -366,6 +367,23 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
 			node = glass;
 			break;
 		}
+		case BL::ShaderNode::type_BSDF_REFRACTION: {
+			BL::ShaderNodeBsdfRefraction b_refraction_node(b_node);
+			RefractionBsdfNode *refraction = new RefractionBsdfNode();
+			switch(b_refraction_node.distribution()) {
+				case BL::ShaderNodeBsdfRefraction::distribution_SHARP:
+					refraction->distribution = ustring("Sharp");
+					break;
+				case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN:
+					refraction->distribution = ustring("Beckmann");
+					break;
+				case BL::ShaderNodeBsdfRefraction::distribution_GGX:
+					refraction->distribution = ustring("GGX");
+					break;
+			}
+			node = refraction;
+			break;
+		}
 		case BL::ShaderNode::type_BSDF_TRANSLUCENT: {
 			node = new TranslucentBsdfNode();
 			break;
@@ -382,6 +400,10 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
 			node = new EmissionNode();
 			break;
 		}
+		case BL::ShaderNode::type_AMBIENT_OCCLUSION: {
+			node = new AmbientOcclusionNode();
+			break;
+		}
 		case BL::ShaderNode::type_VOLUME_ISOTROPIC: {
 			node = new IsotropicVolumeNode();
 			break;
@@ -573,7 +595,21 @@ static ShaderNode *add_node(Scene *scene, BL::BlendData b_data, BL::Scene b_scen
 			node = sky;
 			break;
 		}
-		case BL::ShaderNode::type_FRAME: {
+		case BL::ShaderNode::type_NORMAL_MAP: {
+			BL::ShaderNodeNormalMap b_normal_map_node(b_node);
+			NormalMapNode *nmap = new NormalMapNode();
+			nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()];
+			nmap->attribute = b_normal_map_node.uv_map();
+			node = nmap;
+			break;
+		}
+		case BL::ShaderNode::type_TANGENT: {
+			BL::ShaderNodeTangent b_tangent_node(b_node);
+			TangentNode *tangent = new TangentNode();
+			tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()];
+			tangent->axis = TangentNode::axis_enum[(int)b_tangent_node.axis()];
+			tangent->attribute = b_tangent_node.uv_map();
+			node = tangent;
 			break;
 		}
 	}