Cycles: add new Spectrum and PackedSpectrum types

These replace float3 and packed_float3 in various places in the kernel where a
spectral color representation will be used in the future. That representation
will require more than 3 channels and conversion to from/RGB. The kernel code
was refactored to remove the assumption that Spectrum and RGB colors are the
same thing.

There are no functional changes, Spectrum is still a float3 and the conversion
functions are no-ops.

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

1 files changed, 72 insertions, 59 deletions

diff --git a/intern/cycles/kernel/closure/bsdf_hair_principled.h b/intern/cycles/kernel/closure/bsdf_hair_principled.h
index e7f24b89458..f78a05ea212 100644
--- a/intern/cycles/kernel/closure/bsdf_hair_principled.h
+++ b/intern/cycles/kernel/closure/bsdf_hair_principled.h
@@ -20,7 +20,7 @@ typedef struct PrincipledHairBSDF {
   SHADER_CLOSURE_BASE;
 
   /* Absorption coefficient. */
-  float3 sigma;
+  Spectrum sigma;
   /* Variance of the underlying logistic distribution. */
   float v;
   /* Scale factor of the underlying logistic distribution. */
@@ -166,12 +166,6 @@ ccl_device_inline float longitudinal_scattering(
   }
 }
 
-/* Combine the three values using their luminances. */
-ccl_device_inline float4 combine_with_energy(KernelGlobals kg, float3 c)
-{
-  return make_float4(c.x, c.y, c.z, linear_rgb_to_gray(kg, c));
-}
-
 #ifdef __HAIR__
 /* Set up the hair closure. */
 ccl_device int bsdf_principled_hair_setup(ccl_private ShaderData *sd,
@@ -214,34 +208,36 @@ ccl_device int bsdf_principled_hair_setup(ccl_private ShaderData *sd,
 #endif /* __HAIR__ */
 
 /* Given the Fresnel term and transmittance, generate the attenuation terms for each bounce. */
-ccl_device_inline void hair_attenuation(KernelGlobals kg,
-                                        float f,
-                                        float3 T,
-                                        ccl_private float4 *Ap)
+ccl_device_inline void hair_attenuation(
+    KernelGlobals kg, float f, Spectrum T, ccl_private Spectrum *Ap, ccl_private float *Ap_energy)
 {
   /* Primary specular (R). */
-  Ap[0] = make_float4(f, f, f, f);
+  Ap[0] = make_spectrum(f);
+  Ap_energy[0] = f;
 
   /* Transmission (TT). */
-  float3 col = sqr(1.0f - f) * T;
-  Ap[1] = combine_with_energy(kg, col);
+  Spectrum col = sqr(1.0f - f) * T;
+  Ap[1] = col;
+  Ap_energy[1] = spectrum_to_gray(kg, col);
 
   /* Secondary specular (TRT). */
   col *= T * f;
-  Ap[2] = combine_with_energy(kg, col);
+  Ap[2] = col;
+  Ap_energy[2] = spectrum_to_gray(kg, col);
 
   /* Residual component (TRRT+). */
-  col *= safe_divide_color(T * f, make_float3(1.0f, 1.0f, 1.0f) - T * f);
-  Ap[3] = combine_with_energy(kg, col);
+  col *= safe_divide(T * f, one_spectrum() - T * f);
+  Ap[3] = col;
+  Ap_energy[3] = spectrum_to_gray(kg, col);
 
   /* Normalize sampling weights. */
-  float totweight = Ap[0].w + Ap[1].w + Ap[2].w + Ap[3].w;
+  float totweight = Ap_energy[0] + Ap_energy[1] + Ap_energy[2] + Ap_energy[3];
   float fac = safe_divide(1.0f, totweight);
 
-  Ap[0].w *= fac;
-  Ap[1].w *= fac;
-  Ap[2].w *= fac;
-  Ap[3].w *= fac;
+  Ap_energy[0] *= fac;
+  Ap_energy[1] *= fac;
+  Ap_energy[2] *= fac;
+  Ap_energy[3] *= fac;
 }
 
 /* Given the tilt angle, generate the rotated theta_i for the different bounces. */
@@ -266,11 +262,11 @@ ccl_device_inline void hair_alpha_angles(float sin_theta_i,
 }
 
 /* Evaluation function for our shader. */
-ccl_device float3 bsdf_principled_hair_eval(KernelGlobals kg,
-                                            ccl_private const ShaderData *sd,
-                                            ccl_private const ShaderClosure *sc,
-                                            const float3 omega_in,
-                                            ccl_private float *pdf)
+ccl_device Spectrum bsdf_principled_hair_eval(KernelGlobals kg,
+                                              ccl_private const ShaderData *sd,
+                                              ccl_private const ShaderClosure *sc,
+                                              const float3 omega_in,
+                                              ccl_private float *pdf)
 {
   kernel_assert(isfinite_safe(sd->P) && isfinite_safe(sd->ray_length));
 
@@ -299,9 +295,11 @@ ccl_device float3 bsdf_principled_hair_eval(KernelGlobals kg,
   float cos_gamma_t = cos_from_sin(sin_gamma_t);
   float gamma_t = safe_asinf(sin_gamma_t);
 
-  float3 T = exp(-bsdf->sigma * (2.0f * cos_gamma_t / cos_theta_t));
-  float4 Ap[4];
-  hair_attenuation(kg, fresnel_dielectric_cos(cos_theta_o * cos_gamma_o, bsdf->eta), T, Ap);
+  Spectrum T = exp(-bsdf->sigma * (2.0f * cos_gamma_t / cos_theta_t));
+  Spectrum Ap[4];
+  float Ap_energy[4];
+  hair_attenuation(
+      kg, fresnel_dielectric_cos(cos_theta_o * cos_gamma_o, bsdf->eta), T, Ap, Ap_energy);
 
   float sin_theta_i = wi.x;
   float cos_theta_i = cos_from_sin(sin_theta_i);
@@ -312,35 +310,40 @@ ccl_device float3 bsdf_principled_hair_eval(KernelGlobals kg,
   float angles[6];
   hair_alpha_angles(sin_theta_i, cos_theta_i, bsdf->alpha, angles);
 
-  float4 F;
+  Spectrum F;
+  float F_energy;
   float Mp, Np;
 
   /* Primary specular (R). */
   Mp = longitudinal_scattering(angles[0], angles[1], sin_theta_o, cos_theta_o, bsdf->m0_roughness);
   Np = azimuthal_scattering(phi, 0, bsdf->s, gamma_o, gamma_t);
   F = Ap[0] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy = Ap_energy[0] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Transmission (TT). */
   Mp = longitudinal_scattering(angles[2], angles[3], sin_theta_o, cos_theta_o, 0.25f * bsdf->v);
   Np = azimuthal_scattering(phi, 1, bsdf->s, gamma_o, gamma_t);
   F += Ap[1] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[1] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Secondary specular (TRT). */
   Mp = longitudinal_scattering(angles[4], angles[5], sin_theta_o, cos_theta_o, 4.0f * bsdf->v);
   Np = azimuthal_scattering(phi, 2, bsdf->s, gamma_o, gamma_t);
   F += Ap[2] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[2] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Residual component (TRRT+). */
   Mp = longitudinal_scattering(sin_theta_i, cos_theta_i, sin_theta_o, cos_theta_o, 4.0f * bsdf->v);
   Np = M_1_2PI_F;
   F += Ap[3] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[3] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
-  *pdf = F.w;
-  return float4_to_float3(F);
+  *pdf = F_energy;
+  return F;
 }
 
 /* Sampling function for the hair shader. */
@@ -349,7 +352,7 @@ ccl_device int bsdf_principled_hair_sample(KernelGlobals kg,
                                            ccl_private ShaderData *sd,
                                            float randu,
                                            float randv,
-                                           ccl_private float3 *eval,
+                                           ccl_private Spectrum *eval,
                                            ccl_private float3 *omega_in,
                                            ccl_private float3 *domega_in_dx,
                                            ccl_private float3 *domega_in_dy,
@@ -385,16 +388,18 @@ ccl_device int bsdf_principled_hair_sample(KernelGlobals kg,
   float cos_gamma_t = cos_from_sin(sin_gamma_t);
   float gamma_t = safe_asinf(sin_gamma_t);
 
-  float3 T = exp(-bsdf->sigma * (2.0f * cos_gamma_t / cos_theta_t));
-  float4 Ap[4];
-  hair_attenuation(kg, fresnel_dielectric_cos(cos_theta_o * cos_gamma_o, bsdf->eta), T, Ap);
+  Spectrum T = exp(-bsdf->sigma * (2.0f * cos_gamma_t / cos_theta_t));
+  Spectrum Ap[4];
+  float Ap_energy[4];
+  hair_attenuation(
+      kg, fresnel_dielectric_cos(cos_theta_o * cos_gamma_o, bsdf->eta), T, Ap, Ap_energy);
 
   int p = 0;
   for (; p < 3; p++) {
-    if (u[0].x < Ap[p].w) {
+    if (u[0].x < Ap_energy[p]) {
       break;
     }
-    u[0].x -= Ap[p].w;
+    u[0].x -= Ap_energy[p];
   }
 
   float v = bsdf->v;
@@ -429,35 +434,40 @@ ccl_device int bsdf_principled_hair_sample(KernelGlobals kg,
 
   hair_alpha_angles(sin_theta_i, cos_theta_i, bsdf->alpha, angles);
 
-  float4 F;
+  Spectrum F;
+  float F_energy;
   float Mp, Np;
 
   /* Primary specular (R). */
   Mp = longitudinal_scattering(angles[0], angles[1], sin_theta_o, cos_theta_o, bsdf->m0_roughness);
   Np = azimuthal_scattering(phi, 0, bsdf->s, gamma_o, gamma_t);
   F = Ap[0] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy = Ap_energy[0] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Transmission (TT). */
   Mp = longitudinal_scattering(angles[2], angles[3], sin_theta_o, cos_theta_o, 0.25f * bsdf->v);
   Np = azimuthal_scattering(phi, 1, bsdf->s, gamma_o, gamma_t);
   F += Ap[1] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[1] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Secondary specular (TRT). */
   Mp = longitudinal_scattering(angles[4], angles[5], sin_theta_o, cos_theta_o, 4.0f * bsdf->v);
   Np = azimuthal_scattering(phi, 2, bsdf->s, gamma_o, gamma_t);
   F += Ap[2] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[2] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
   /* Residual component (TRRT+). */
   Mp = longitudinal_scattering(sin_theta_i, cos_theta_i, sin_theta_o, cos_theta_o, 4.0f * bsdf->v);
   Np = M_1_2PI_F;
   F += Ap[3] * Mp * Np;
-  kernel_assert(isfinite_safe(float4_to_float3(F)));
+  F_energy += Ap_energy[3] * Mp * Np;
+  kernel_assert(isfinite_safe(F) && isfinite_safe(F_energy));
 
-  *eval = float4_to_float3(F);
-  *pdf = F.w;
+  *eval = F;
+  *pdf = F_energy;
 
   *omega_in = X * sin_theta_i + Y * cos_theta_i * cosf(phi_i) + Z * cos_theta_i * sinf(phi_i);
 
@@ -489,25 +499,28 @@ ccl_device_inline float bsdf_principled_hair_albedo_roughness_scale(
   return (((((0.245f * x) + 5.574f) * x - 10.73f) * x + 2.532f) * x - 0.215f) * x + 5.969f;
 }
 
-ccl_device float3 bsdf_principled_hair_albedo(ccl_private const ShaderClosure *sc)
+ccl_device Spectrum bsdf_principled_hair_albedo(ccl_private const ShaderClosure *sc)
 {
   ccl_private PrincipledHairBSDF *bsdf = (ccl_private PrincipledHairBSDF *)sc;
   return exp(-sqrt(bsdf->sigma) * bsdf_principled_hair_albedo_roughness_scale(bsdf->v));
 }
 
-ccl_device_inline float3
-bsdf_principled_hair_sigma_from_reflectance(const float3 color, const float azimuthal_roughness)
+ccl_device_inline Spectrum
+bsdf_principled_hair_sigma_from_reflectance(const Spectrum color, const float azimuthal_roughness)
 {
-  const float3 sigma = log(color) /
-                       bsdf_principled_hair_albedo_roughness_scale(azimuthal_roughness);
+  const Spectrum sigma = log(color) /
+                         bsdf_principled_hair_albedo_roughness_scale(azimuthal_roughness);
   return sigma * sigma;
 }
 
-ccl_device_inline float3 bsdf_principled_hair_sigma_from_concentration(const float eumelanin,
-                                                                       const float pheomelanin)
+ccl_device_inline Spectrum bsdf_principled_hair_sigma_from_concentration(const float eumelanin,
+                                                                         const float pheomelanin)
 {
-  return eumelanin * make_float3(0.506f, 0.841f, 1.653f) +
-         pheomelanin * make_float3(0.343f, 0.733f, 1.924f);
+  const float3 eumelanin_color = make_float3(0.506f, 0.841f, 1.653f);
+  const float3 pheomelanin_color = make_float3(0.343f, 0.733f, 1.924f);
+
+  return eumelanin * rgb_to_spectrum(eumelanin_color) +
+         pheomelanin * rgb_to_spectrum(pheomelanin_color);
 }
 
 CCL_NAMESPACE_END