Cycles:

* Revert r57203 (len() renaming)
There seems to be a problem with nVidia OpenCL after this and I haven't figured out the real cause yet. 
Better to selectively enable native length() later, after figuring out what's wrong. 

This fixes [#35612].

12 files changed, 35 insertions, 35 deletions

diff --git a/intern/cycles/kernel/kernel_bvh.h b/intern/cycles/kernel/kernel_bvh.h
index 1b02e486b40..aff9d586e7a 100644
--- a/intern/cycles/kernel/kernel_bvh.h
+++ b/intern/cycles/kernel/kernel_bvh.h
@@ -64,7 +64,7 @@ __device_inline void bvh_instance_push(KernelGlobals *kg, int object, const Ray
 	float3 dir = transform_direction(&tfm, ray->D);
 
 	float len;
-	dir = normalize_length(dir, &len);
+	dir = normalize_len(dir, &len);
 
 	*idir = bvh_inverse_direction(dir);
 
@@ -76,7 +76,7 @@ __device_inline void bvh_instance_pop(KernelGlobals *kg, int object, const Ray *
 {
 	if(*t != FLT_MAX) {
 		Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);
-		*t *= length(transform_direction(&tfm, 1.0f/(*idir)));
+		*t *= len(transform_direction(&tfm, 1.0f/(*idir)));
 	}
 
 	*P = ray->P;
@@ -94,7 +94,7 @@ __device_inline void bvh_instance_motion_push(KernelGlobals *kg, int object, con
 	float3 dir = transform_direction(&itfm, ray->D);
 
 	float len;
-	dir = normalize_length(dir, &len);
+	dir = normalize_len(dir, &len);
 
 	*idir = bvh_inverse_direction(dir);
 
@@ -105,7 +105,7 @@ __device_inline void bvh_instance_motion_push(KernelGlobals *kg, int object, con
 __device_inline void bvh_instance_motion_pop(KernelGlobals *kg, int object, const Ray *ray, float3 *P, float3 *idir, float *t, Transform *tfm, const float tmax)
 {
 	if(*t != FLT_MAX)
-		*t *= length(transform_direction(tfm, 1.0f/(*idir)));
+		*t *= len(transform_direction(tfm, 1.0f/(*idir)));
 
 	*P = ray->P;
 	*idir = bvh_inverse_direction(ray->D);
@@ -489,14 +489,14 @@ __device_inline void bvh_cardinal_curve_intersect(KernelGlobals *kg, Intersectio
 				t = p_curr.z;
 			}
 			else {
-				float l = length(p_en - p_st);
+				float l = len(p_en - p_st);
 				/*minimum width extension*/
 				float or1 = r1;
 				float or2 = r2;
 				if(difl != 0.0f) {
-					mw_extension = min(length(p_st - P) * difl, extmax);
+					mw_extension = min(len(p_st - P) * difl, extmax);
 					or1 = r1 < mw_extension ? mw_extension : r1;
-					mw_extension = min(length(p_en - P) * difl, extmax);
+					mw_extension = min(len(p_en - P) * difl, extmax);
 					or2 = r2 < mw_extension ? mw_extension : r2;
 				}
 				/* --- */
@@ -611,9 +611,9 @@ __device_inline void bvh_curve_intersect(KernelGlobals *kg, Intersection *isect,
 	float r1 = or1;
 	float r2 = or2;
 	if(difl != 0.0f) {
-		float pixelsize = min(length(p1 - P) * difl, extmax);
+		float pixelsize = min(len(p1 - P) * difl, extmax);
 		r1 = or1 < pixelsize ? pixelsize : or1;
-		pixelsize = min(length(p2 - P) * difl, extmax);
+		pixelsize = min(len(p2 - P) * difl, extmax);
 		r2 = or2 < pixelsize ? pixelsize : or2;
 	}
 	/* --- */
@@ -621,14 +621,14 @@ __device_inline void bvh_curve_intersect(KernelGlobals *kg, Intersection *isect,
 	float mr = max(r1,r2);
 	float3 dif = P - p1;
 	float3 dir = 1.0f/idir;
-	float l = length(p2 - p1);
+	float l = len(p2 - p1);
 
 	float sp_r = mr + 0.5f * l;
 	float3 sphere_dif = P - ((p1 + p2) * 0.5f);
 	float sphere_b = dot(dir,sphere_dif);
 	sphere_dif = sphere_dif - sphere_b * dir;
 	sphere_b = dot(dir,sphere_dif);
-	float sdisc = sphere_b * sphere_b - length_squared(sphere_dif) + sp_r * sp_r;
+	float sdisc = sphere_b * sphere_b - len_squared(sphere_dif) + sp_r * sp_r;
 	if(sdisc < 0.0f)
 		return;
 
@@ -652,8 +652,8 @@ __device_inline void bvh_curve_intersect(KernelGlobals *kg, Intersection *isect,
 	/* test minimum separation*/
 	float3 cprod = cross(tg, dir);
 	float3 cprod2 = cross(tg, dif);
-	float cprodsq = length_squared(cprod);
-	float cprod2sq = length_squared(cprod2);
+	float cprodsq = len_squared(cprod);
+	float cprod2sq = len_squared(cprod2);
 	float distscaled = dot(cprod,dif);
 
 	if(cprodsq == 0)
@@ -1010,7 +1010,7 @@ __device_inline float3 bvh_triangle_refine(KernelGlobals *kg, ShaderData *sd, co
 
 		P = transform_point(&tfm, P);
 		D = transform_direction(&tfm, D*t);
-		D = normalize_length(D, &t);
+		D = normalize_len(D, &t);
 	}
 
 	P = P + D*t;
@@ -1080,7 +1080,7 @@ __device_inline float3 bvh_curve_refine(KernelGlobals *kg, ShaderData *sd, const
 
 		P = transform_point(&tfm, P);
 		D = transform_direction(&tfm, D*t);
-		D = normalize_length(D, &t);
+		D = normalize_len(D, &t);
 	}
 
 	int prim = kernel_tex_fetch(__prim_index, isect->prim);
@@ -1092,7 +1092,7 @@ __device_inline float3 bvh_curve_refine(KernelGlobals *kg, ShaderData *sd, const
 	float4 P1 = kernel_tex_fetch(__curve_keys, k0);
 	float4 P2 = kernel_tex_fetch(__curve_keys, k1);
 	float l = 1.0f;
-	float3 tg = normalize_length(float4_to_float3(P2 - P1),&l);
+	float3 tg = normalize_len(float4_to_float3(P2 - P1),&l);
 	float r1 = P1.w;
 	float r2 = P2.w;
 	float gd = ((r2 - r1)/l);
diff --git a/intern/cycles/kernel/kernel_camera.h b/intern/cycles/kernel/kernel_camera.h
index 33456886990..a23586a53a4 100644
--- a/intern/cycles/kernel/kernel_camera.h
+++ b/intern/cycles/kernel/kernel_camera.h
@@ -255,7 +255,7 @@ __device_inline float camera_distance(KernelGlobals *kg, float3 P)
 		return fabsf(dot((P - camP), camD));
 	}
 	else
-		return length(P - camP);
+		return len(P - camP);
 }
 
 CCL_NAMESPACE_END
diff --git a/intern/cycles/kernel/kernel_curve.h b/intern/cycles/kernel/kernel_curve.h
index f1b9682f04f..e065717888c 100644
--- a/intern/cycles/kernel/kernel_curve.h
+++ b/intern/cycles/kernel/kernel_curve.h
@@ -122,7 +122,7 @@ __device float3 curve_tangent_normal(KernelGlobals *kg, ShaderData *sd)
 	if(sd->segment != ~0) {
 		float normalmix = kernel_data.curve_kernel_data.normalmix;
 
-		tgN = -(-sd->I - sd->dPdu * (dot(sd->dPdu,-sd->I) * normalmix / length_squared(sd->dPdu)));
+		tgN = -(-sd->I - sd->dPdu * (dot(sd->dPdu,-sd->I) * normalmix / len_squared(sd->dPdu)));
 		tgN = normalize(tgN);
 
 		/* need to find suitable scaled gd for corrected normal */
diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h
index 42e5f3961cd..74f768c899c 100644
--- a/intern/cycles/kernel/kernel_emission.h
+++ b/intern/cycles/kernel/kernel_emission.h
@@ -133,7 +133,7 @@ __device_noinline bool direct_emission(KernelGlobals *kg, ShaderData *sd, int li
 		else {
 			/* other lights, avoid self-intersection */
 			ray->D = ray_offset(ls.P, ls.Ng) - ray->P;
-			ray->D = normalize_length(ray->D, &ray->t);
+			ray->D = normalize_len(ray->D, &ray->t);
 		}
 
 		ray->dP = sd->dP;
diff --git a/intern/cycles/kernel/kernel_light.h b/intern/cycles/kernel/kernel_light.h
index f5899b90b26..d4d78e413d2 100644
--- a/intern/cycles/kernel/kernel_light.h
+++ b/intern/cycles/kernel/kernel_light.h
@@ -263,7 +263,7 @@ __device void lamp_light_sample(KernelGlobals *kg, int lamp,
 				/* sphere light */
 				ls->P += sphere_light_sample(P, ls->P, radius, randu, randv);
 
-			ls->D = normalize_length(ls->P - P, &ls->t);
+			ls->D = normalize_len(ls->P - P, &ls->t);
 			ls->Ng = -ls->D;
 
 			float invarea = data1.z;
@@ -287,7 +287,7 @@ __device void lamp_light_sample(KernelGlobals *kg, int lamp,
 
 			ls->P += area_light_sample(axisu, axisv, randu, randv);
 			ls->Ng = D;
-			ls->D = normalize_length(ls->P - P, &ls->t);
+			ls->D = normalize_len(ls->P - P, &ls->t);
 
 			float invarea = data2.x;
 
@@ -487,7 +487,7 @@ __device void curve_segment_light_sample(KernelGlobals *kg, int prim, int object
 	float4 P1 = kernel_tex_fetch(__curve_keys, k0);
 	float4 P2 = kernel_tex_fetch(__curve_keys, k1);
 
-	float l = length(float4_to_float3(P2) - float4_to_float3(P1));
+	float l = len(float4_to_float3(P2) - float4_to_float3(P1));
 
 	float r1 = P1.w;
 	float r2 = P2.w;
@@ -569,7 +569,7 @@ __device void light_sample(KernelGlobals *kg, float randt, float randu, float ra
 			triangle_light_sample(kg, prim, object, randu, randv, time, ls);
 
 		/* compute incoming direction, distance and pdf */
-		ls->D = normalize_length(ls->P - P, &ls->t);
+		ls->D = normalize_len(ls->P - P, &ls->t);
 		ls->pdf = triangle_light_pdf(kg, ls->Ng, -ls->D, ls->t);
 	}
 	else {
diff --git a/intern/cycles/kernel/kernel_path.h b/intern/cycles/kernel/kernel_path.h
index 5d02f059ec8..d2de9ba2b44 100644
--- a/intern/cycles/kernel/kernel_path.h
+++ b/intern/cycles/kernel/kernel_path.h
@@ -222,7 +222,7 @@ __device_inline bool shadow_blocked(KernelGlobals *kg, PathState *state, Ray *ra
 
 				ray->P = ray_offset(sd.P, -sd.Ng);
 				if(ray->t != FLT_MAX)
-					ray->D = normalize_length(Pend - ray->P, &ray->t);
+					ray->D = normalize_len(Pend - ray->P, &ray->t);
 
 				bounce++;
 			}
@@ -266,7 +266,7 @@ __device float4 kernel_path_progressive(KernelGlobals *kg, RNG *rng, int sample,
 			if((kernel_data.cam.resolution == 1) && (state.flag & PATH_RAY_CAMERA)) {	
 				float3 pixdiff = ray.dD.dx + ray.dD.dy;
 				/*pixdiff = pixdiff - dot(pixdiff, ray.D)*ray.D;*/
-				difl = kernel_data.curve_kernel_data.minimum_width * length(pixdiff) * 0.5f;
+				difl = kernel_data.curve_kernel_data.minimum_width * len(pixdiff) * 0.5f;
 			}
 
 			extmax = kernel_data.curve_kernel_data.maximum_width;
@@ -957,7 +957,7 @@ __device float4 kernel_path_non_progressive(KernelGlobals *kg, RNG *rng, int sam
 			if((kernel_data.cam.resolution == 1) && (state.flag & PATH_RAY_CAMERA)) {	
 				float3 pixdiff = ray.dD.dx + ray.dD.dy;
 				/*pixdiff = pixdiff - dot(pixdiff, ray.D)*ray.D;*/
-				difl = kernel_data.curve_kernel_data.minimum_width * length(pixdiff) * 0.5f;
+				difl = kernel_data.curve_kernel_data.minimum_width * len(pixdiff) * 0.5f;
 			}
 
 			extmax = kernel_data.curve_kernel_data.maximum_width;
diff --git a/intern/cycles/kernel/kernel_subsurface.h b/intern/cycles/kernel/kernel_subsurface.h
index f3b7c014d99..f7bccf71976 100644
--- a/intern/cycles/kernel/kernel_subsurface.h
+++ b/intern/cycles/kernel/kernel_subsurface.h
@@ -201,7 +201,7 @@ __device void subsurface_scatter_step(KernelGlobals *kg, ShaderData *sd, int sta
 		/* create ray */
 		Ray ray;
 		ray.P = p1;
-		ray.D = normalize_length(p2 - p1, &ray.t);
+		ray.D = normalize_len(p2 - p1, &ray.t);
 		ray.dP = sd->dP;
 		ray.dD = differential3_zero();
 		ray.time = sd->time;
diff --git a/intern/cycles/kernel/svm/svm_camera.h b/intern/cycles/kernel/svm/svm_camera.h
index 972d14d00e2..f13cefb7764 100644
--- a/intern/cycles/kernel/svm/svm_camera.h
+++ b/intern/cycles/kernel/svm/svm_camera.h
@@ -27,7 +27,7 @@ __device void svm_node_camera(KernelGlobals *kg, ShaderData *sd, float *stack, u
 	Transform tfm = kernel_data.cam.worldtocamera;
 	vector = transform_point(&tfm, sd->P);
 	zdepth = vector.z;
-	distance = length(vector);
+	distance = len(vector);
 
 	if (stack_valid(out_vector))
 		stack_store_float3(stack, out_vector, normalize(vector));
diff --git a/intern/cycles/kernel/svm/svm_math.h b/intern/cycles/kernel/svm/svm_math.h
index 93d432e5954..dbf477a0a96 100644
--- a/intern/cycles/kernel/svm/svm_math.h
+++ b/intern/cycles/kernel/svm/svm_math.h
@@ -82,7 +82,7 @@ __device void svm_vector_math(float *Fac, float3 *Vector, NodeVectorMath type, f
 		*Fac = average_fac(*Vector);
 	}
 	else if(type == NODE_VECTOR_MATH_AVERAGE) {
-		*Fac = length(Vector1 + Vector2);
+		*Fac = len(Vector1 + Vector2);
 		*Vector = normalize(Vector1 + Vector2);
 	}
 	else if(type == NODE_VECTOR_MATH_DOT_PRODUCT) {
@@ -91,11 +91,11 @@ __device void svm_vector_math(float *Fac, float3 *Vector, NodeVectorMath type, f
 	}
 	else if(type == NODE_VECTOR_MATH_CROSS_PRODUCT) {
 		float3 c = cross(Vector1, Vector2);
-		*Fac = length(c);
+		*Fac = len(c);
 		*Vector = normalize(c);
 	}
 	else if(type == NODE_VECTOR_MATH_NORMALIZE) {
-		*Fac = length(Vector1);
+		*Fac = len(Vector1);
 		*Vector = normalize(Vector1);
 	}
 	else {
diff --git a/intern/cycles/kernel/svm/svm_texture.h b/intern/cycles/kernel/svm/svm_texture.h
index 67e08bad7f8..a4f6691435c 100644
--- a/intern/cycles/kernel/svm/svm_texture.h
+++ b/intern/cycles/kernel/svm/svm_texture.h
@@ -25,7 +25,7 @@ __device float voronoi_distance(NodeDistanceMetric distance_metric, float3 d, fl
 	if(distance_metric == NODE_VORONOI_DISTANCE_SQUARED)
 		return dot(d, d);
 	if(distance_metric == NODE_VORONOI_ACTUAL_DISTANCE)
-		return length(d);
+		return len(d);
 	if(distance_metric == NODE_VORONOI_MANHATTAN)
 		return fabsf(d.x) + fabsf(d.y) + fabsf(d.z);
 	if(distance_metric == NODE_VORONOI_CHEBYCHEV)
diff --git a/intern/cycles/kernel/svm/svm_wave.h b/intern/cycles/kernel/svm/svm_wave.h
index e37b0788361..d2d808e4063 100644
--- a/intern/cycles/kernel/svm/svm_wave.h
+++ b/intern/cycles/kernel/svm/svm_wave.h
@@ -29,7 +29,7 @@ __device_noinline float svm_wave(NodeWaveType type, float3 p, float scale, float
 	if(type == NODE_WAVE_BANDS)
 		n = (p.x + p.y + p.z) * 10.0f;
 	else /* if(type == NODE_WAVE_RINGS) */
-		n = length(p) * 20.0f;
+		n = len(p) * 20.0f;
 	
 	if(distortion != 0.0f)
 		n += distortion * noise_turbulence(p*dscale, NODE_NOISE_PERLIN, detail, 0);
diff --git a/intern/cycles/kernel/svm/svm_wireframe.h b/intern/cycles/kernel/svm/svm_wireframe.h
index 24b29058440..9ecb81847d7 100644
--- a/intern/cycles/kernel/svm/svm_wireframe.h
+++ b/intern/cycles/kernel/svm/svm_wireframe.h
@@ -66,8 +66,8 @@ __device void svm_node_wireframe(KernelGlobals *kg, ShaderData *sd, float *stack
 		if(pixel_size) {
 			// Project the derivatives of P to the viewing plane defined
 			// by I so we have a measure of how big is a pixel at this point
-			float pixelwidth_x = length(sd->dP.dx - dot(sd->dP.dx, sd->I) * sd->I);
-			float pixelwidth_y = length(sd->dP.dy - dot(sd->dP.dy, sd->I) * sd->I);
+			float pixelwidth_x = len(sd->dP.dx - dot(sd->dP.dx, sd->I) * sd->I);
+			float pixelwidth_y = len(sd->dP.dy - dot(sd->dP.dy, sd->I) * sd->I);
 			// Take the average of both axis' length
 			pixelwidth = (pixelwidth_x + pixelwidth_y) * 0.5f;
 		}