Merge branch 'blender2.7'

10 files changed, 382 insertions, 10 deletions

diff --git a/intern/cycles/kernel/geom/geom_curve.h b/intern/cycles/kernel/geom/geom_curve.h
index dea0c742ed7..9b60cf6d56b 100644
--- a/intern/cycles/kernel/geom/geom_curve.h
+++ b/intern/cycles/kernel/geom/geom_curve.h
@@ -87,6 +87,45 @@ ccl_device float curve_attribute_float(KernelGlobals *kg, const ShaderData *sd,
 	}
 }
 
+ccl_device float2 curve_attribute_float2(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float2 *dx, float2 *dy)
+{
+	if(desc.element == ATTR_ELEMENT_CURVE) {
+		/* idea: we can't derive any useful differentials here, but for tiled
+		 * mipmap image caching it would be useful to avoid reading the highest
+		 * detail level always. maybe a derivative based on the hair density
+		 * could be computed somehow? */
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+#endif
+
+		return kernel_tex_fetch(__attributes_float2, desc.offset + sd->prim);
+	}
+	else if(desc.element == ATTR_ELEMENT_CURVE_KEY || desc.element == ATTR_ELEMENT_CURVE_KEY_MOTION) {
+		float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
+		int k0 = __float_as_int(curvedata.x) + PRIMITIVE_UNPACK_SEGMENT(sd->type);
+		int k1 = k0 + 1;
+
+		float2 f0 = kernel_tex_fetch(__attributes_float2, desc.offset + k0);
+		float2 f1 = kernel_tex_fetch(__attributes_float2, desc.offset + k1);
+
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx) *dx = sd->du.dx*(f1 - f0);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+#endif
+
+		return (1.0f - sd->u)*f0 + sd->u*f1;
+	}
+	else {
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+#endif
+
+		return make_float2(0.0f, 0.0f);
+	}
+}
+
 ccl_device float3 curve_attribute_float3(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float3 *dx, float3 *dy)
 {
 	if(desc.element == ATTR_ELEMENT_CURVE) {
diff --git a/intern/cycles/kernel/geom/geom_patch.h b/intern/cycles/kernel/geom/geom_patch.h
index 0143b384aa2..edb82172959 100644
--- a/intern/cycles/kernel/geom/geom_patch.h
+++ b/intern/cycles/kernel/geom/geom_patch.h
@@ -284,6 +284,33 @@ ccl_device float patch_eval_float(KernelGlobals *kg, const ShaderData *sd, int o
 	return val;
 }
 
+ccl_device float2 patch_eval_float2(KernelGlobals *kg, const ShaderData *sd, int offset,
+                                    int patch, float u, float v, int channel,
+                                    float2 *du, float2 *dv)
+{
+	int indices[PATCH_MAX_CONTROL_VERTS];
+	float weights[PATCH_MAX_CONTROL_VERTS];
+	float weights_du[PATCH_MAX_CONTROL_VERTS];
+	float weights_dv[PATCH_MAX_CONTROL_VERTS];
+
+	int num_control = patch_eval_control_verts(kg, sd->object, patch, u, v, channel,
+	                                           indices, weights, weights_du, weights_dv);
+
+	float2 val = make_float2(0.0f, 0.0f);
+	if(du) *du = make_float2(0.0f, 0.0f);
+	if(dv) *dv = make_float2(0.0f, 0.0f);
+
+	for(int i = 0; i < num_control; i++) {
+		float2 v = kernel_tex_fetch(__attributes_float2, offset + indices[i]);
+
+		val += v * weights[i];
+		if(du) *du += v * weights_du[i];
+		if(dv) *dv += v * weights_dv[i];
+	}
+
+	return val;
+}
+
 ccl_device float3 patch_eval_float3(KernelGlobals *kg, const ShaderData *sd, int offset,
                                     int patch, float u, float v, int channel,
                                     float3 *du, float3 *dv)
diff --git a/intern/cycles/kernel/geom/geom_primitive.h b/intern/cycles/kernel/geom/geom_primitive.h
index e3e2648e9ec..c9b1995ee05 100644
--- a/intern/cycles/kernel/geom/geom_primitive.h
+++ b/intern/cycles/kernel/geom/geom_primitive.h
@@ -89,6 +89,37 @@ ccl_device_inline float primitive_volume_attribute_float(KernelGlobals *kg,
 }
 #endif
 
+ccl_device_inline float2 primitive_attribute_float2(KernelGlobals *kg,
+                                                    const ShaderData *sd,
+                                                    const AttributeDescriptor desc,
+                                                    float2 *dx, float2 *dy)
+{
+	if(sd->type & PRIMITIVE_ALL_TRIANGLE) {
+		if(subd_triangle_patch(kg, sd) == ~0)
+			return triangle_attribute_float2(kg, sd, desc, dx, dy);
+		else
+			return subd_triangle_attribute_float2(kg, sd, desc, dx, dy);
+	}
+#ifdef __HAIR__
+	else if(sd->type & PRIMITIVE_ALL_CURVE) {
+		return curve_attribute_float2(kg, sd, desc, dx, dy);
+	}
+#endif
+#ifdef __VOLUME__
+	else if(sd->object != OBJECT_NONE && desc.element == ATTR_ELEMENT_VOXEL) {
+		kernel_assert(0);
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+		return make_float2(0.0f, 0.0f);
+	}
+#endif
+	else {
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+		return make_float2(0.0f, 0.0f);
+	}
+}
+
 ccl_device_inline float3 primitive_attribute_float3(KernelGlobals *kg,
                                                     const ShaderData *sd,
                                                     const AttributeDescriptor desc,
@@ -119,6 +150,29 @@ ccl_device_inline float3 primitive_attribute_float3(KernelGlobals *kg,
 	}
 }
 
+ccl_device_inline float2 primitive_surface_attribute_float2(KernelGlobals *kg,
+                                                            const ShaderData *sd,
+                                                            const AttributeDescriptor desc,
+                                                            float2 *dx, float2 *dy)
+{
+	if(sd->type & PRIMITIVE_ALL_TRIANGLE) {
+		if(subd_triangle_patch(kg, sd) == ~0)
+			return triangle_attribute_float2(kg, sd, desc, dx, dy);
+		else
+			return subd_triangle_attribute_float2(kg, sd, desc, dx, dy);
+	}
+#ifdef __HAIR__
+	else if(sd->type & PRIMITIVE_ALL_CURVE) {
+		return curve_attribute_float2(kg, sd, desc, dx, dy);
+	}
+#endif
+	else {
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+		return make_float2(0.0f, 0.0f);
+	}
+}
+
 ccl_device_inline float3 primitive_surface_attribute_float3(KernelGlobals *kg,
                                                             const ShaderData *sd,
                                                             const AttributeDescriptor desc,
diff --git a/intern/cycles/kernel/geom/geom_subd_triangle.h b/intern/cycles/kernel/geom/geom_subd_triangle.h
index 8c0d0a9770e..251e070c21f 100644
--- a/intern/cycles/kernel/geom/geom_subd_triangle.h
+++ b/intern/cycles/kernel/geom/geom_subd_triangle.h
@@ -216,6 +216,128 @@ ccl_device_noinline float subd_triangle_attribute_float(KernelGlobals *kg, const
 	}
 }
 
+ccl_device_noinline float2 subd_triangle_attribute_float2(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float2 *dx, float2 *dy)
+{
+	int patch = subd_triangle_patch(kg, sd);
+
+#ifdef __PATCH_EVAL__
+	if(desc.flags & ATTR_SUBDIVIDED) {
+		float2 uv[3];
+		subd_triangle_patch_uv(kg, sd, uv);
+
+		float2 dpdu = uv[0] - uv[2];
+		float2 dpdv = uv[1] - uv[2];
+
+		/* p is [s, t] */
+		float2 p = dpdu * sd->u + dpdv * sd->v + uv[2];
+
+		float2 a, dads, dadt;
+
+		a = patch_eval_float2(kg, sd, desc.offset, patch, p.x, p.y, 0, &dads, &dadt);
+
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx || dy) {
+			float dsdu = dpdu.x;
+			float dtdu = dpdu.y;
+			float dsdv = dpdv.x;
+			float dtdv = dpdv.y;
+
+			if(dx) {
+				float dudx = sd->du.dx;
+				float dvdx = sd->dv.dx;
+
+				float dsdx = dsdu*dudx + dsdv*dvdx;
+				float dtdx = dtdu*dudx + dtdv*dvdx;
+
+				*dx = dads*dsdx + dadt*dtdx;
+			}
+			if(dy) {
+				float dudy = sd->du.dy;
+				float dvdy = sd->dv.dy;
+
+				float dsdy = dsdu*dudy + dsdv*dvdy;
+				float dtdy = dtdu*dudy + dtdv*dvdy;
+
+				*dy = dads*dsdy + dadt*dtdy;
+			}
+		}
+#endif
+
+		return a;
+	}
+	else
+#endif  /* __PATCH_EVAL__ */
+		if(desc.element == ATTR_ELEMENT_FACE) {
+			if(dx) *dx = make_float2(0.0f, 0.0f);
+			if(dy) *dy = make_float2(0.0f, 0.0f);
+
+			return kernel_tex_fetch(__attributes_float2, desc.offset + subd_triangle_patch_face(kg, patch));
+		}
+		else if(desc.element == ATTR_ELEMENT_VERTEX || desc.element == ATTR_ELEMENT_VERTEX_MOTION) {
+			float2 uv[3];
+			subd_triangle_patch_uv(kg, sd, uv);
+
+			uint4 v = subd_triangle_patch_indices(kg, patch);
+
+			float2 f0 = kernel_tex_fetch(__attributes_float2, desc.offset + v.x);
+			float2 f1 = kernel_tex_fetch(__attributes_float2, desc.offset + v.y);
+			float2 f2 = kernel_tex_fetch(__attributes_float2, desc.offset + v.z);
+			float2 f3 = kernel_tex_fetch(__attributes_float2, desc.offset + v.w);
+
+			if(subd_triangle_patch_num_corners(kg, patch) != 4) {
+				f1 = (f1+f0)*0.5f;
+				f3 = (f3+f0)*0.5f;
+			}
+
+			float2 a = mix(mix(f0, f1, uv[0].x), mix(f3, f2, uv[0].x), uv[0].y);
+			float2 b = mix(mix(f0, f1, uv[1].x), mix(f3, f2, uv[1].x), uv[1].y);
+			float2 c = mix(mix(f0, f1, uv[2].x), mix(f3, f2, uv[2].x), uv[2].y);
+
+#ifdef __RAY_DIFFERENTIALS__
+			if(dx) *dx = sd->du.dx*a + sd->dv.dx*b - (sd->du.dx + sd->dv.dx)*c;
+			if(dy) *dy = sd->du.dy*a + sd->dv.dy*b - (sd->du.dy + sd->dv.dy)*c;
+#endif
+
+			return sd->u*a + sd->v*b + (1.0f - sd->u - sd->v)*c;
+		}
+		else if(desc.element == ATTR_ELEMENT_CORNER) {
+			float2 uv[3];
+			subd_triangle_patch_uv(kg, sd, uv);
+
+			int corners[4];
+			subd_triangle_patch_corners(kg, patch, corners);
+
+			float2 f0, f1, f2, f3;
+
+			f0 = kernel_tex_fetch(__attributes_float2, corners[0] + desc.offset);
+			f1 = kernel_tex_fetch(__attributes_float2, corners[1] + desc.offset);
+			f2 = kernel_tex_fetch(__attributes_float2, corners[2] + desc.offset);
+			f3 = kernel_tex_fetch(__attributes_float2, corners[3] + desc.offset);
+
+			if(subd_triangle_patch_num_corners(kg, patch) != 4) {
+				f1 = (f1+f0)*0.5f;
+				f3 = (f3+f0)*0.5f;
+			}
+
+			float2 a = mix(mix(f0, f1, uv[0].x), mix(f3, f2, uv[0].x), uv[0].y);
+			float2 b = mix(mix(f0, f1, uv[1].x), mix(f3, f2, uv[1].x), uv[1].y);
+			float2 c = mix(mix(f0, f1, uv[2].x), mix(f3, f2, uv[2].x), uv[2].y);
+
+#ifdef __RAY_DIFFERENTIALS__
+			if(dx) *dx = sd->du.dx*a + sd->dv.dx*b - (sd->du.dx + sd->dv.dx)*c;
+			if(dy) *dy = sd->du.dy*a + sd->dv.dy*b - (sd->du.dy + sd->dv.dy)*c;
+#endif
+
+			return sd->u*a + sd->v*b + (1.0f - sd->u - sd->v)*c;
+		}
+		else {
+			if(dx) *dx = make_float2(0.0f, 0.0f);
+			if(dy) *dy = make_float2(0.0f, 0.0f);
+
+			return make_float2(0.0f, 0.0f);
+		}
+}
+
 ccl_device_noinline float3 subd_triangle_attribute_float3(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float3 *dx, float3 *dy)
 {
 	int patch = subd_triangle_patch(kg, sd);
diff --git a/intern/cycles/kernel/geom/geom_triangle.h b/intern/cycles/kernel/geom/geom_triangle.h
index 105aee8da15..300227c38e6 100644
--- a/intern/cycles/kernel/geom/geom_triangle.h
+++ b/intern/cycles/kernel/geom/geom_triangle.h
@@ -149,6 +149,53 @@ ccl_device float triangle_attribute_float(KernelGlobals *kg, const ShaderData *s
 	}
 }
 
+ccl_device float2 triangle_attribute_float2(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float2 *dx, float2 *dy)
+{
+	if(desc.element == ATTR_ELEMENT_FACE) {
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+
+		return kernel_tex_fetch(__attributes_float2, desc.offset + sd->prim);
+	}
+	else if(desc.element == ATTR_ELEMENT_VERTEX || desc.element == ATTR_ELEMENT_VERTEX_MOTION) {
+		uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, sd->prim);
+
+		float2 f0 = kernel_tex_fetch(__attributes_float2, desc.offset + tri_vindex.x);
+		float2 f1 = kernel_tex_fetch(__attributes_float2, desc.offset + tri_vindex.y);
+		float2 f2 = kernel_tex_fetch(__attributes_float2, desc.offset + tri_vindex.z);
+
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2;
+		if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2;
+#endif
+
+		return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2;
+	}
+	else if(desc.element == ATTR_ELEMENT_CORNER) {
+		int tri = desc.offset + sd->prim*3;
+		float2 f0, f1, f2;
+
+		if(desc.element == ATTR_ELEMENT_CORNER) {
+			f0 = kernel_tex_fetch(__attributes_float2, tri + 0);
+			f1 = kernel_tex_fetch(__attributes_float2, tri + 1);
+			f2 = kernel_tex_fetch(__attributes_float2, tri + 2);
+		}
+
+#ifdef __RAY_DIFFERENTIALS__
+		if(dx) *dx = sd->du.dx*f0 + sd->dv.dx*f1 - (sd->du.dx + sd->dv.dx)*f2;
+		if(dy) *dy = sd->du.dy*f0 + sd->dv.dy*f1 - (sd->du.dy + sd->dv.dy)*f2;
+#endif
+
+		return sd->u*f0 + sd->v*f1 + (1.0f - sd->u - sd->v)*f2;
+	}
+	else {
+		if(dx) *dx = make_float2(0.0f, 0.0f);
+		if(dy) *dy = make_float2(0.0f, 0.0f);
+
+		return make_float2(0.0f, 0.0f);
+	}
+}
+
 ccl_device float3 triangle_attribute_float3(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float3 *dx, float3 *dy)
 {
 	if(desc.element == ATTR_ELEMENT_FACE) {
diff --git a/intern/cycles/kernel/kernel_textures.h b/intern/cycles/kernel/kernel_textures.h
index e83727ec64e..9eaa6b5516e 100644
--- a/intern/cycles/kernel/kernel_textures.h
+++ b/intern/cycles/kernel/kernel_textures.h
@@ -56,6 +56,7 @@ KERNEL_TEX(uint, __patches)
 /* attributes */
 KERNEL_TEX(uint4, __attributes_map)
 KERNEL_TEX(float, __attributes_float)
+KERNEL_TEX(float2, __attributes_float2)
 KERNEL_TEX(float4, __attributes_float3)
 KERNEL_TEX(uchar4, __attributes_uchar4)
 
diff --git a/intern/cycles/kernel/osl/osl_services.cpp b/intern/cycles/kernel/osl/osl_services.cpp
index 5436a66c9d4..6464d382634 100644
--- a/intern/cycles/kernel/osl/osl_services.cpp
+++ b/intern/cycles/kernel/osl/osl_services.cpp
@@ -392,6 +392,44 @@ bool OSLRenderServices::get_array_attribute(OSL::ShaderGlobals *sg, bool derivat
 	return false;
 }
 
+static bool set_attribute_float2(float2 f[3], TypeDesc type, bool derivatives, void *val)
+{
+	if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
+	   type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor)
+	{
+		float *fval = (float *)val;
+
+		fval[0] = f[0].x;
+		fval[1] = f[0].y;
+		fval[2] = 0.0f;
+
+		if(derivatives) {
+			fval[3] = f[1].x;
+			fval[4] = f[1].y;
+			fval[5] = 0.0f;
+
+			fval[6] = f[2].x;
+			fval[7] = f[2].y;
+			fval[8] = 0.0f;
+		}
+
+		return true;
+	}
+	else if(type == TypeDesc::TypeFloat) {
+		float *fval = (float *)val;
+		fval[0] = average(f[0]);
+
+		if(derivatives) {
+			fval[1] = average(f[1]);
+			fval[2] = average(f[2]);
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
 static bool set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, void *val)
 {
 	if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector ||
@@ -572,6 +610,12 @@ static bool get_primitive_attribute(KernelGlobals *kg, const ShaderData *sd, con
 		                                     (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
 		return set_attribute_float3(fval, type, derivatives, val);
 	}
+	else if(attr.type == TypeFloat2) {
+		float2 fval[2];
+		fval[0] = primitive_attribute_float2(kg, sd, attr.desc,
+		                                      (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL);
+		return set_attribute_float2(fval, type, derivatives, val);
+	}
 	else if(attr.type == TypeDesc::TypeFloat) {
 		float fval[3];
 		fval[0] = primitive_attribute_float(kg, sd, attr.desc,
diff --git a/intern/cycles/kernel/svm/svm_attribute.h b/intern/cycles/kernel/svm/svm_attribute.h
index ef6f7d7cbb5..c2366df71d0 100644
--- a/intern/cycles/kernel/svm/svm_attribute.h
+++ b/intern/cycles/kernel/svm/svm_attribute.h
@@ -52,18 +52,27 @@ ccl_device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, u
 	AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
 
 	/* fetch and store attribute */
-	if (desc.type == NODE_ATTR_FLOAT) {
+	if(desc.type == NODE_ATTR_FLOAT) {
 		float f = primitive_attribute_float(kg, sd, desc, NULL, NULL);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, f);
 		}
 		else {
 			stack_store_float3(stack, out_offset, make_float3(f, f, f));
 		}
 	}
+	else if(desc.type == NODE_ATTR_FLOAT2) {
+		float2 f = primitive_attribute_float2(kg, sd, desc, NULL, NULL);
+		if(type == NODE_ATTR_FLOAT) {
+			stack_store_float(stack, out_offset, f.x);
+		}
+		else {
+			stack_store_float3(stack, out_offset, make_float3(f.x, f.y, 0.0f));
+		}
+	}
 	else {
 		float3 f = primitive_attribute_float3(kg, sd, desc, NULL, NULL);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, average(f));
 		}
 		else {
@@ -84,20 +93,30 @@ void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint
 	AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
 
 	/* fetch and store attribute */
-	if (desc.type == NODE_ATTR_FLOAT) {
+	if(desc.type == NODE_ATTR_FLOAT) {
 		float dx;
 		float f = primitive_surface_attribute_float(kg, sd, desc, &dx, NULL);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, f+dx);
 		}
 		else {
 			stack_store_float3(stack, out_offset, make_float3(f+dx, f+dx, f+dx));
 		}
 	}
+	else if(desc.type == NODE_ATTR_FLOAT2) {
+		float2 dx;
+		float2 f = primitive_attribute_float2(kg, sd, desc, &dx, NULL);
+		if (type == NODE_ATTR_FLOAT) {
+			stack_store_float(stack, out_offset, f.x + dx.x);
+		}
+		else {
+			stack_store_float3(stack, out_offset, make_float3(f.x+dx.x, f.y+dx.y, 0.0f));
+		}
+	}
 	else {
 		float3 dx;
 		float3 f = primitive_surface_attribute_float3(kg, sd, desc, &dx, NULL);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, average(f+dx));
 		}
 		else {
@@ -121,20 +140,30 @@ void svm_node_attr_bump_dy(KernelGlobals *kg,
 	AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
 
 	/* fetch and store attribute */
-		if (desc.type == NODE_ATTR_FLOAT) {
+	if(desc.type == NODE_ATTR_FLOAT) {
 		float dy;
 		float f = primitive_surface_attribute_float(kg, sd, desc, NULL, &dy);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, f+dy);
 		}
 		else {
 			stack_store_float3(stack, out_offset, make_float3(f+dy, f+dy, f+dy));
 		}
 	}
+	else if(desc.type == NODE_ATTR_FLOAT2) {
+		float2 dy;
+		float2 f = primitive_attribute_float2(kg, sd, desc, NULL, &dy);
+		if(type == NODE_ATTR_FLOAT) {
+			stack_store_float(stack, out_offset, f.x + dy.x);
+		}
+		else {
+			stack_store_float3(stack, out_offset, make_float3(f.x+dy.x, f.y+dy.y, 0.0f));
+		}
+	}
 	else {
 		float3 dy;
 		float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, &dy);
-		if (type == NODE_ATTR_FLOAT) {
+		if(type == NODE_ATTR_FLOAT) {
 			stack_store_float(stack, out_offset, average(f+dy));
 		}
 		else {
diff --git a/intern/cycles/kernel/svm/svm_tex_coord.h b/intern/cycles/kernel/svm/svm_tex_coord.h
index 72871254f0d..fe61292d0b0 100644
--- a/intern/cycles/kernel/svm/svm_tex_coord.h
+++ b/intern/cycles/kernel/svm/svm_tex_coord.h
@@ -363,7 +363,15 @@ ccl_device void svm_node_tangent(KernelGlobals *kg, ShaderData *sd, float *stack
 	float3 attribute_value;
 	const AttributeDescriptor desc = find_attribute(kg, sd, node.z);
 	if (desc.offset != ATTR_STD_NOT_FOUND) {
-		attribute_value = primitive_surface_attribute_float3(kg, sd, desc, NULL, NULL);
+		if(desc.type == NODE_ATTR_FLOAT2) {
+			float2 value = primitive_surface_attribute_float2(kg, sd, desc, NULL, NULL);
+			attribute_value.x = value.x;
+			attribute_value.y = value.y;
+			attribute_value.z = 0.0f;
+		}
+		else {
+			attribute_value = primitive_surface_attribute_float3(kg, sd, desc, NULL, NULL);
+		}
 	}
 
 
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 0f1dfa4936b..8b15d7bf9f4 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -141,6 +141,7 @@ typedef enum ShaderNodeType {
 
 typedef enum NodeAttributeType {
 	NODE_ATTR_FLOAT = 0,
+	NODE_ATTR_FLOAT2,
 	NODE_ATTR_FLOAT3,
 	NODE_ATTR_MATRIX
 } NodeAttributeType;