ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / kernel / geom / geom_curve.h
index 9b60cf6..e0aacb4 100644 (file)
@@ -27,169 +27,199 @@ CCL_NAMESPACE_BEGIN
 
 ccl_device_inline float3 curvetangent(float t, float3 p0, float3 p1, float3 p2, float3 p3)
 {
-       float fc = 0.71f;
-       float data[4];
-       float t2 = t * t;
-       data[0] = -3.0f * fc          * t2  + 4.0f * fc * t                  - fc;
-       data[1] =  3.0f * (2.0f - fc) * t2  + 2.0f * (fc - 3.0f) * t;
-       data[2] =  3.0f * (fc - 2.0f) * t2  + 2.0f * (3.0f - 2.0f * fc) * t  + fc;
-       data[3] =  3.0f * fc          * t2  - 2.0f * fc * t;
-       return data[0] * p0 + data[1] * p1 + data[2] * p2 + data[3] * p3;
+  float fc = 0.71f;
+  float data[4];
+  float t2 = t * t;
+  data[0] = -3.0f * fc * t2 + 4.0f * fc * t - fc;
+  data[1] = 3.0f * (2.0f - fc) * t2 + 2.0f * (fc - 3.0f) * t;
+  data[2] = 3.0f * (fc - 2.0f) * t2 + 2.0f * (3.0f - 2.0f * fc) * t + fc;
+  data[3] = 3.0f * fc * t2 - 2.0f * fc * t;
+  return data[0] * p0 + data[1] * p1 + data[2] * p2 + data[3] * p3;
 }
 
 ccl_device_inline float3 curvepoint(float t, float3 p0, float3 p1, float3 p2, float3 p3)
 {
-       float data[4];
-       float fc = 0.71f;
-       float t2 = t * t;
-       float t3 = t2 * t;
-       data[0] = -fc          * t3  + 2.0f * fc          * t2 - fc * t;
-       data[1] =  (2.0f - fc) * t3  + (fc - 3.0f)        * t2 + 1.0f;
-       data[2] =  (fc - 2.0f) * t3  + (3.0f - 2.0f * fc) * t2 + fc * t;
-       data[3] =  fc          * t3  - fc * t2;
-       return data[0] * p0 + data[1] * p1 + data[2] * p2 + data[3] * p3;
+  float data[4];
+  float fc = 0.71f;
+  float t2 = t * t;
+  float t3 = t2 * t;
+  data[0] = -fc * t3 + 2.0f * fc * t2 - fc * t;
+  data[1] = (2.0f - fc) * t3 + (fc - 3.0f) * t2 + 1.0f;
+  data[2] = (fc - 2.0f) * t3 + (3.0f - 2.0f * fc) * t2 + fc * t;
+  data[3] = fc * t3 - fc * t2;
+  return data[0] * p0 + data[1] * p1 + data[2] * p2 + data[3] * p3;
 }
 
 /* Reading attributes on various curve elements */
 
-ccl_device float curve_attribute_float(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float *dx, float *dy)
+ccl_device float curve_attribute_float(
+    KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float *dx, float *dy)
 {
-       if(desc.element == ATTR_ELEMENT_CURVE) {
-#ifdef __RAY_DIFFERENTIALS__
-               if(dx) *dx = 0.0f;
-               if(dy) *dy = 0.0f;
-#endif
-
-               return kernel_tex_fetch(__attributes_float, 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;
-
-               float f0 = kernel_tex_fetch(__attributes_float, desc.offset + k0);
-               float f1 = kernel_tex_fetch(__attributes_float, desc.offset + k1);
-
-#ifdef __RAY_DIFFERENTIALS__
-               if(dx) *dx = sd->du.dx*(f1 - f0);
-               if(dy) *dy = 0.0f;
-#endif
-
-               return (1.0f - sd->u)*f0 + sd->u*f1;
-       }
-       else {
-#ifdef __RAY_DIFFERENTIALS__
-               if(dx) *dx = 0.0f;
-               if(dy) *dy = 0.0f;
-#endif
-
-               return 0.0f;
-       }
+  if (desc.element == ATTR_ELEMENT_CURVE) {
+#  ifdef __RAY_DIFFERENTIALS__
+    if (dx)
+      *dx = 0.0f;
+    if (dy)
+      *dy = 0.0f;
+#  endif
+
+    return kernel_tex_fetch(__attributes_float, 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;
+
+    float f0 = kernel_tex_fetch(__attributes_float, desc.offset + k0);
+    float f1 = kernel_tex_fetch(__attributes_float, desc.offset + k1);
+
+#  ifdef __RAY_DIFFERENTIALS__
+    if (dx)
+      *dx = sd->du.dx * (f1 - f0);
+    if (dy)
+      *dy = 0.0f;
+#  endif
+
+    return (1.0f - sd->u) * f0 + sd->u * f1;
+  }
+  else {
+#  ifdef __RAY_DIFFERENTIALS__
+    if (dx)
+      *dx = 0.0f;
+    if (dy)
+      *dy = 0.0f;
+#  endif
+
+    return 0.0f;
+  }
 }
 
-ccl_device float2 curve_attribute_float2(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float2 *dx, float2 *dy)
+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);
-       }
+  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)
+ccl_device float3 curve_attribute_float3(KernelGlobals *kg,
+                                         const ShaderData *sd,
+                                         const AttributeDescriptor desc,
+                                         float3 *dx,
+                                         float3 *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_float3(0.0f, 0.0f, 0.0f);
-               if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f);
-#endif
-
-               return float4_to_float3(kernel_tex_fetch(__attributes_float3, 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;
-
-               float3 f0 = float4_to_float3(kernel_tex_fetch(__attributes_float3, desc.offset + k0));
-               float3 f1 = float4_to_float3(kernel_tex_fetch(__attributes_float3, desc.offset + k1));
-
-#ifdef __RAY_DIFFERENTIALS__
-               if(dx) *dx = sd->du.dx*(f1 - f0);
-               if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f);
-#endif
-
-               return (1.0f - sd->u)*f0 + sd->u*f1;
-       }
-       else {
-#ifdef __RAY_DIFFERENTIALS__
-               if(dx) *dx = make_float3(0.0f, 0.0f, 0.0f);
-               if(dy) *dy = make_float3(0.0f, 0.0f, 0.0f);
-#endif
-
-               return make_float3(0.0f, 0.0f, 0.0f);
-       }
+  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_float3(0.0f, 0.0f, 0.0f);
+    if (dy)
+      *dy = make_float3(0.0f, 0.0f, 0.0f);
+#  endif
+
+    return float4_to_float3(kernel_tex_fetch(__attributes_float3, 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;
+
+    float3 f0 = float4_to_float3(kernel_tex_fetch(__attributes_float3, desc.offset + k0));
+    float3 f1 = float4_to_float3(kernel_tex_fetch(__attributes_float3, desc.offset + k1));
+
+#  ifdef __RAY_DIFFERENTIALS__
+    if (dx)
+      *dx = sd->du.dx * (f1 - f0);
+    if (dy)
+      *dy = make_float3(0.0f, 0.0f, 0.0f);
+#  endif
+
+    return (1.0f - sd->u) * f0 + sd->u * f1;
+  }
+  else {
+#  ifdef __RAY_DIFFERENTIALS__
+    if (dx)
+      *dx = make_float3(0.0f, 0.0f, 0.0f);
+    if (dy)
+      *dy = make_float3(0.0f, 0.0f, 0.0f);
+#  endif
+
+    return make_float3(0.0f, 0.0f, 0.0f);
+  }
 }
 
 /* Curve thickness */
 
 ccl_device float curve_thickness(KernelGlobals *kg, ShaderData *sd)
 {
-       float r = 0.0f;
+  float r = 0.0f;
 
-       if(sd->type & PRIMITIVE_ALL_CURVE) {
-               float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
-               int k0 = __float_as_int(curvedata.x) + PRIMITIVE_UNPACK_SEGMENT(sd->type);
-               int k1 = k0 + 1;
+  if (sd->type & PRIMITIVE_ALL_CURVE) {
+    float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
+    int k0 = __float_as_int(curvedata.x) + PRIMITIVE_UNPACK_SEGMENT(sd->type);
+    int k1 = k0 + 1;
 
-               float4 P_curve[2];
+    float4 P_curve[2];
 
-               if(sd->type & PRIMITIVE_CURVE) {
-                       P_curve[0]= kernel_tex_fetch(__curve_keys, k0);
-                       P_curve[1]= kernel_tex_fetch(__curve_keys, k1);
-               }
-               else {
-                       motion_curve_keys(kg, sd->object, sd->prim, sd->time, k0, k1, P_curve);
-               }
+    if (sd->type & PRIMITIVE_CURVE) {
+      P_curve[0] = kernel_tex_fetch(__curve_keys, k0);
+      P_curve[1] = kernel_tex_fetch(__curve_keys, k1);
+    }
+    else {
+      motion_curve_keys(kg, sd->object, sd->prim, sd->time, k0, k1, P_curve);
+    }
 
-               r = (P_curve[1].w - P_curve[0].w) * sd->u + P_curve[0].w;
-       }
+    r = (P_curve[1].w - P_curve[0].w) * sd->u + P_curve[0].w;
+  }
 
-       return r*2.0f;
+  return r * 2.0f;
 }
 
 /* Curve location for motion pass, linear interpolation between keys and
@@ -197,89 +227,98 @@ ccl_device float curve_thickness(KernelGlobals *kg, ShaderData *sd)
 
 ccl_device float3 curve_motion_center_location(KernelGlobals *kg, ShaderData *sd)
 {
-       float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
-       int k0 = __float_as_int(curvedata.x) + PRIMITIVE_UNPACK_SEGMENT(sd->type);
-       int k1 = k0 + 1;
+  float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
+  int k0 = __float_as_int(curvedata.x) + PRIMITIVE_UNPACK_SEGMENT(sd->type);
+  int k1 = k0 + 1;
 
-       float4 P_curve[2];
+  float4 P_curve[2];
 
-       P_curve[0]= kernel_tex_fetch(__curve_keys, k0);
-       P_curve[1]= kernel_tex_fetch(__curve_keys, k1);
+  P_curve[0] = kernel_tex_fetch(__curve_keys, k0);
+  P_curve[1] = kernel_tex_fetch(__curve_keys, k1);
 
-       return float4_to_float3(P_curve[1]) * sd->u + float4_to_float3(P_curve[0]) * (1.0f - sd->u);
+  return float4_to_float3(P_curve[1]) * sd->u + float4_to_float3(P_curve[0]) * (1.0f - sd->u);
 }
 
 /* Curve tangent normal */
 
 ccl_device float3 curve_tangent_normal(KernelGlobals *kg, ShaderData *sd)
 {
-       float3 tgN = make_float3(0.0f,0.0f,0.0f);
+  float3 tgN = make_float3(0.0f, 0.0f, 0.0f);
 
-       if(sd->type & PRIMITIVE_ALL_CURVE) {
+  if (sd->type & PRIMITIVE_ALL_CURVE) {
 
-               tgN = -(-sd->I - sd->dPdu * (dot(sd->dPdu,-sd->I) / len_squared(sd->dPdu)));
-               tgN = normalize(tgN);
+    tgN = -(-sd->I - sd->dPdu * (dot(sd->dPdu, -sd->I) / len_squared(sd->dPdu)));
+    tgN = normalize(tgN);
 
-               /* need to find suitable scaled gd for corrected normal */
-#if 0
-               tgN = normalize(tgN - gd * sd->dPdu);
-#endif
-       }
+    /* need to find suitable scaled gd for corrected normal */
+#  if 0
+    tgN = normalize(tgN - gd * sd->dPdu);
+#  endif
+  }
 
-       return tgN;
+  return tgN;
 }
 
 /* Curve bounds utility function */
 
-ccl_device_inline void curvebounds(float *lower, float *upper, float *extremta, float *extrema, float *extremtb, float *extremb, float p0, float p1, float p2, float p3)
+ccl_device_inline void curvebounds(float *lower,
+                                   float *upper,
+                                   float *extremta,
+                                   float *extrema,
+                                   float *extremtb,
+                                   float *extremb,
+                                   float p0,
+                                   float p1,
+                                   float p2,
+                                   float p3)
 {
-       float halfdiscroot = (p2 * p2 - 3 * p3 * p1);
-       float ta = -1.0f;
-       float tb = -1.0f;
-
-       *extremta = -1.0f;
-       *extremtb = -1.0f;
-       *upper = p0;
-       *lower = (p0 + p1) + (p2 + p3);
-       *extrema = *upper;
-       *extremb = *lower;
-
-       if(*lower >= *upper) {
-               *upper = *lower;
-               *lower = p0;
-       }
-
-       if(halfdiscroot >= 0) {
-               float inv3p3 = (1.0f/3.0f)/p3;
-               halfdiscroot = sqrtf(halfdiscroot);
-               ta = (-p2 - halfdiscroot) * inv3p3;
-               tb = (-p2 + halfdiscroot) * inv3p3;
-       }
-
-       float t2;
-       float t3;
-
-       if(ta > 0.0f && ta < 1.0f) {
-               t2 = ta * ta;
-               t3 = t2 * ta;
-               *extremta = ta;
-               *extrema = p3 * t3 + p2 * t2 + p1 * ta + p0;
-
-               *upper = fmaxf(*extrema, *upper);
-               *lower = fminf(*extrema, *lower);
-       }
-
-       if(tb > 0.0f && tb < 1.0f) {
-               t2 = tb * tb;
-               t3 = t2 * tb;
-               *extremtb = tb;
-               *extremb = p3 * t3 + p2 * t2 + p1 * tb + p0;
-
-               *upper = fmaxf(*extremb, *upper);
-               *lower = fminf(*extremb, *lower);
-       }
+  float halfdiscroot = (p2 * p2 - 3 * p3 * p1);
+  float ta = -1.0f;
+  float tb = -1.0f;
+
+  *extremta = -1.0f;
+  *extremtb = -1.0f;
+  *upper = p0;
+  *lower = (p0 + p1) + (p2 + p3);
+  *extrema = *upper;
+  *extremb = *lower;
+
+  if (*lower >= *upper) {
+    *upper = *lower;
+    *lower = p0;
+  }
+
+  if (halfdiscroot >= 0) {
+    float inv3p3 = (1.0f / 3.0f) / p3;
+    halfdiscroot = sqrtf(halfdiscroot);
+    ta = (-p2 - halfdiscroot) * inv3p3;
+    tb = (-p2 + halfdiscroot) * inv3p3;
+  }
+
+  float t2;
+  float t3;
+
+  if (ta > 0.0f && ta < 1.0f) {
+    t2 = ta * ta;
+    t3 = t2 * ta;
+    *extremta = ta;
+    *extrema = p3 * t3 + p2 * t2 + p1 * ta + p0;
+
+    *upper = fmaxf(*extrema, *upper);
+    *lower = fminf(*extrema, *lower);
+  }
+
+  if (tb > 0.0f && tb < 1.0f) {
+    t2 = tb * tb;
+    t3 = t2 * tb;
+    *extremtb = tb;
+    *extremb = p3 * t3 + p2 * t2 + p1 * tb + p0;
+
+    *upper = fmaxf(*extremb, *upper);
+    *lower = fminf(*extremb, *lower);
+  }
 }
 
-#endif  /* __HAIR__ */
+#endif /* __HAIR__ */
 
 CCL_NAMESPACE_END