Cycles: Added Float2 attribute type.

Float2 are now a new type for attributes in Cycles. Before, the choices
for attribute storage were float and float3, the latter padded to
float4. This meant that UV maps were inflated to twice the size
necessary.

Reviewers: brecht, sergey

Reviewed By: brecht

Subscribers: #cycles

Tags: #cycles

Differential Revision: https://developer.blender.org/D4409

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;