Cycles: Add new Sky Texture method including direct sunlight

This commit adds a new model to the Sky Texture node, which is based on a
method by Nishita et al. and works by basically simulating volumetric
scattering in the atmosphere.

By making some approximations (such as only considering single scattering),
we get a fairly simple and fast simulation code that takes into account
Rayleigh and Mie scattering as well as Ozone absorption.

This code is used to precompute a 512x128 texture which is then looked up
during render time, and is fast enough to allow real-time tweaking in the
viewport.

Due to the nature of the simulation, it exposes several parameters that
allow for lots of flexibility in choosing the look and matching real-world
conditions (such as Air/Dust/Ozone density and altitude).

Additionally, the same volumetric approach can be used to compute absorption
of the direct sunlight, so the model also supports adding direct sunlight.
This makes it significantly easier to set up Sun+Sky illumination where
the direction, intensity and color of the sun actually matches the sky.

In order to support properly sampling the direct sun component, the commit
also adds logic for sampling a specific area to the kernel light sampling
code. This is combined with portal and background map sampling using MIS.

This sampling logic works for the common case of having one Sky texture
going into the Background shader, but if a custom input to the Vector
node is used or if there are multiple Sky textures, it falls back to using
only background map sampling (while automatically setting the resolution to
4096x2048 if auto resolution is used).

More infos and preview can be found here:
https://docs.google.com/document/d/1gQta0ygFWXTrl5Pmvl_nZRgUw0mWg0FJeRuNKS36m08/view

Underlying model, implementation and documentation by Marco (@nacioss).
Improvements, cleanup and sun sampling by @lukasstockner.

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

10 files changed, 957 insertions, 619 deletions

diff --git a/intern/cycles/kernel/CMakeLists.txt b/intern/cycles/kernel/CMakeLists.txt
index 2e839a616e9..35339abff45 100644
--- a/intern/cycles/kernel/CMakeLists.txt
+++ b/intern/cycles/kernel/CMakeLists.txt
@@ -113,6 +113,8 @@ set(SRC_HEADERS
   kernel_id_passes.h
   kernel_jitter.h
   kernel_light.h
+  kernel_light_background.h
+  kernel_light_common.h
   kernel_math.h
   kernel_montecarlo.h
   kernel_passes.h
diff --git a/intern/cycles/kernel/kernel_emission.h b/intern/cycles/kernel/kernel_emission.h
index 71b176a0a8f..4ac07d86dda 100644
--- a/intern/cycles/kernel/kernel_emission.h
+++ b/intern/cycles/kernel/kernel_emission.h
@@ -326,9 +326,7 @@ ccl_device_noinline_cpu float3 indirect_background(KernelGlobals *kg,
   /* Background MIS weights. */
 #  ifdef __BACKGROUND_MIS__
   /* Check if background light exists or if we should skip pdf. */
-  int res_x = kernel_data.integrator.pdf_background_res_x;
-
-  if (!(state->flag & PATH_RAY_MIS_SKIP) && res_x) {
+  if (!(state->flag & PATH_RAY_MIS_SKIP) && kernel_data.background.use_mis) {
     /* multiple importance sampling, get background light pdf for ray
      * direction, and compute weight with respect to BSDF pdf */
     float pdf = background_light_pdf(kg, ray->P, ray->D);
diff --git a/intern/cycles/kernel/kernel_light.h b/intern/cycles/kernel/kernel_light.h
index 04472212d0c..0448d0165b9 100644
--- a/intern/cycles/kernel/kernel_light.h
+++ b/intern/cycles/kernel/kernel_light.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "kernel_light_background.h"
+
 CCL_NAMESPACE_BEGIN
 
 /* Light Sample result */
@@ -33,500 +35,6 @@ typedef struct LightSample {
   LightType type; /* type of light */
 } LightSample;
 
-/* Area light sampling */
-
-/* Uses the following paper:
- *
- * Carlos Urena et al.
- * An Area-Preserving Parametrization for Spherical Rectangles.
- *
- * https://www.solidangle.com/research/egsr2013_spherical_rectangle.pdf
- *
- * Note: light_p is modified when sample_coord is true.
- */
-ccl_device_inline float rect_light_sample(float3 P,
-                                          float3 *light_p,
-                                          float3 axisu,
-                                          float3 axisv,
-                                          float randu,
-                                          float randv,
-                                          bool sample_coord)
-{
-  /* In our name system we're using P for the center,
-   * which is o in the paper.
-   */
-
-  float3 corner = *light_p - axisu * 0.5f - axisv * 0.5f;
-  float axisu_len, axisv_len;
-  /* Compute local reference system R. */
-  float3 x = normalize_len(axisu, &axisu_len);
-  float3 y = normalize_len(axisv, &axisv_len);
-  float3 z = cross(x, y);
-  /* Compute rectangle coords in local reference system. */
-  float3 dir = corner - P;
-  float z0 = dot(dir, z);
-  /* Flip 'z' to make it point against Q. */
-  if (z0 > 0.0f) {
-    z *= -1.0f;
-    z0 *= -1.0f;
-  }
-  float x0 = dot(dir, x);
-  float y0 = dot(dir, y);
-  float x1 = x0 + axisu_len;
-  float y1 = y0 + axisv_len;
-  /* Compute internal angles (gamma_i). */
-  float4 diff = make_float4(x0, y1, x1, y0) - make_float4(x1, y0, x0, y1);
-  float4 nz = make_float4(y0, x1, y1, x0) * diff;
-  nz = nz / sqrt(z0 * z0 * diff * diff + nz * nz);
-  float g0 = safe_acosf(-nz.x * nz.y);
-  float g1 = safe_acosf(-nz.y * nz.z);
-  float g2 = safe_acosf(-nz.z * nz.w);
-  float g3 = safe_acosf(-nz.w * nz.x);
-  /* Compute predefined constants. */
-  float b0 = nz.x;
-  float b1 = nz.z;
-  float b0sq = b0 * b0;
-  float k = M_2PI_F - g2 - g3;
-  /* Compute solid angle from internal angles. */
-  float S = g0 + g1 - k;
-
-  if (sample_coord) {
-    /* Compute cu. */
-    float au = randu * S + k;
-    float fu = (cosf(au) * b0 - b1) / sinf(au);
-    float cu = 1.0f / sqrtf(fu * fu + b0sq) * (fu > 0.0f ? 1.0f : -1.0f);
-    cu = clamp(cu, -1.0f, 1.0f);
-    /* Compute xu. */
-    float xu = -(cu * z0) / max(sqrtf(1.0f - cu * cu), 1e-7f);
-    xu = clamp(xu, x0, x1);
-    /* Compute yv. */
-    float z0sq = z0 * z0;
-    float y0sq = y0 * y0;
-    float y1sq = y1 * y1;
-    float d = sqrtf(xu * xu + z0sq);
-    float h0 = y0 / sqrtf(d * d + y0sq);
-    float h1 = y1 / sqrtf(d * d + y1sq);
-    float hv = h0 + randv * (h1 - h0), hv2 = hv * hv;
-    float yv = (hv2 < 1.0f - 1e-6f) ? (hv * d) / sqrtf(1.0f - hv2) : y1;
-
-    /* Transform (xu, yv, z0) to world coords. */
-    *light_p = P + xu * x + yv * y + z0 * z;
-  }
-
-  /* return pdf */
-  if (S != 0.0f)
-    return 1.0f / S;
-  else
-    return 0.0f;
-}
-
-ccl_device_inline float3 ellipse_sample(float3 ru, float3 rv, float randu, float randv)
-{
-  to_unit_disk(&randu, &randv);
-  return ru * randu + rv * randv;
-}
-
-ccl_device float3 disk_light_sample(float3 v, float randu, float randv)
-{
-  float3 ru, rv;
-
-  make_orthonormals(v, &ru, &rv);
-
-  return ellipse_sample(ru, rv, randu, randv);
-}
-
-ccl_device float3 distant_light_sample(float3 D, float radius, float randu, float randv)
-{
-  return normalize(D + disk_light_sample(D, randu, randv) * radius);
-}
-
-ccl_device float3
-sphere_light_sample(float3 P, float3 center, float radius, float randu, float randv)
-{
-  return disk_light_sample(normalize(P - center), randu, randv) * radius;
-}
-
-ccl_device float spot_light_attenuation(float3 dir,
-                                        float spot_angle,
-                                        float spot_smooth,
-                                        LightSample *ls)
-{
-  float3 I = ls->Ng;
-
-  float attenuation = dot(dir, I);
-
-  if (attenuation <= spot_angle) {
-    attenuation = 0.0f;
-  }
-  else {
-    float t = attenuation - spot_angle;
-
-    if (t < spot_smooth && spot_smooth != 0.0f)
-      attenuation *= smoothstepf(t / spot_smooth);
-  }
-
-  return attenuation;
-}
-
-ccl_device float lamp_light_pdf(KernelGlobals *kg, const float3 Ng, const float3 I, float t)
-{
-  float cos_pi = dot(Ng, I);
-
-  if (cos_pi <= 0.0f)
-    return 0.0f;
-
-  return t * t / cos_pi;
-}
-
-/* Background Light */
-
-#ifdef __BACKGROUND_MIS__
-
-ccl_device float3 background_map_sample(KernelGlobals *kg, float randu, float randv, float *pdf)
-{
-  /* for the following, the CDF values are actually a pair of floats, with the
-   * function value as X and the actual CDF as Y.  The last entry's function
-   * value is the CDF total. */
-  int res_x = kernel_data.integrator.pdf_background_res_x;
-  int res_y = kernel_data.integrator.pdf_background_res_y;
-  int cdf_width = res_x + 1;
-
-  /* this is basically std::lower_bound as used by pbrt */
-  int first = 0;
-  int count = res_y;
-
-  while (count > 0) {
-    int step = count >> 1;
-    int middle = first + step;
-
-    if (kernel_tex_fetch(__light_background_marginal_cdf, middle).y < randv) {
-      first = middle + 1;
-      count -= step + 1;
-    }
-    else
-      count = step;
-  }
-
-  int index_v = max(0, first - 1);
-  kernel_assert(index_v >= 0 && index_v < res_y);
-
-  float2 cdf_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v);
-  float2 cdf_next_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v + 1);
-  float2 cdf_last_v = kernel_tex_fetch(__light_background_marginal_cdf, res_y);
-
-  /* importance-sampled V direction */
-  float dv = inverse_lerp(cdf_v.y, cdf_next_v.y, randv);
-  float v = (index_v + dv) / res_y;
-
-  /* this is basically std::lower_bound as used by pbrt */
-  first = 0;
-  count = res_x;
-  while (count > 0) {
-    int step = count >> 1;
-    int middle = first + step;
-
-    if (kernel_tex_fetch(__light_background_conditional_cdf, index_v * cdf_width + middle).y <
-        randu) {
-      first = middle + 1;
-      count -= step + 1;
-    }
-    else
-      count = step;
-  }
-
-  int index_u = max(0, first - 1);
-  kernel_assert(index_u >= 0 && index_u < res_x);
-
-  float2 cdf_u = kernel_tex_fetch(__light_background_conditional_cdf,
-                                  index_v * cdf_width + index_u);
-  float2 cdf_next_u = kernel_tex_fetch(__light_background_conditional_cdf,
-                                       index_v * cdf_width + index_u + 1);
-  float2 cdf_last_u = kernel_tex_fetch(__light_background_conditional_cdf,
-                                       index_v * cdf_width + res_x);
-
-  /* importance-sampled U direction */
-  float du = inverse_lerp(cdf_u.y, cdf_next_u.y, randu);
-  float u = (index_u + du) / res_x;
-
-  /* compute pdf */
-  float sin_theta = sinf(M_PI_F * v);
-  float denom = (M_2PI_F * M_PI_F * sin_theta) * cdf_last_u.x * cdf_last_v.x;
-
-  if (sin_theta == 0.0f || denom == 0.0f)
-    *pdf = 0.0f;
-  else
-    *pdf = (cdf_u.x * cdf_v.x) / denom;
-
-  /* compute direction */
-  return equirectangular_to_direction(u, v);
-}
-
-/* TODO(sergey): Same as above, after the release we should consider using
- * 'noinline' for all devices.
- */
-ccl_device float background_map_pdf(KernelGlobals *kg, float3 direction)
-{
-  float2 uv = direction_to_equirectangular(direction);
-  int res_x = kernel_data.integrator.pdf_background_res_x;
-  int res_y = kernel_data.integrator.pdf_background_res_y;
-  int cdf_width = res_x + 1;
-
-  float sin_theta = sinf(uv.y * M_PI_F);
-
-  if (sin_theta == 0.0f)
-    return 0.0f;
-
-  int index_u = clamp(float_to_int(uv.x * res_x), 0, res_x - 1);
-  int index_v = clamp(float_to_int(uv.y * res_y), 0, res_y - 1);
-
-  /* pdfs in V direction */
-  float2 cdf_last_u = kernel_tex_fetch(__light_background_conditional_cdf,
-                                       index_v * cdf_width + res_x);
-  float2 cdf_last_v = kernel_tex_fetch(__light_background_marginal_cdf, res_y);
-
-  float denom = (M_2PI_F * M_PI_F * sin_theta) * cdf_last_u.x * cdf_last_v.x;
-
-  if (denom == 0.0f)
-    return 0.0f;
-
-  /* pdfs in U direction */
-  float2 cdf_u = kernel_tex_fetch(__light_background_conditional_cdf,
-                                  index_v * cdf_width + index_u);
-  float2 cdf_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v);
-
-  return (cdf_u.x * cdf_v.x) / denom;
-}
-
-ccl_device_inline bool background_portal_data_fetch_and_check_side(
-    KernelGlobals *kg, float3 P, int index, float3 *lightpos, float3 *dir)
-{
-  int portal = kernel_data.integrator.portal_offset + index;
-  const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
-
-  *lightpos = make_float3(klight->co[0], klight->co[1], klight->co[2]);
-  *dir = make_float3(klight->area.dir[0], klight->area.dir[1], klight->area.dir[2]);
-
-  /* Check whether portal is on the right side. */
-  if (dot(*dir, P - *lightpos) > 1e-4f)
-    return true;
-
-  return false;
-}
-
-ccl_device_inline float background_portal_pdf(
-    KernelGlobals *kg, float3 P, float3 direction, int ignore_portal, bool *is_possible)
-{
-  float portal_pdf = 0.0f;
-
-  int num_possible = 0;
-  for (int p = 0; p < kernel_data.integrator.num_portals; p++) {
-    if (p == ignore_portal)
-      continue;
-
-    float3 lightpos, dir;
-    if (!background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
-      continue;
-
-    /* There's a portal that could be sampled from this position. */
-    if (is_possible) {
-      *is_possible = true;
-    }
-    num_possible++;
-
-    int portal = kernel_data.integrator.portal_offset + p;
-    const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
-    float3 axisu = make_float3(
-        klight->area.axisu[0], klight->area.axisu[1], klight->area.axisu[2]);
-    float3 axisv = make_float3(
-        klight->area.axisv[0], klight->area.axisv[1], klight->area.axisv[2]);
-    bool is_round = (klight->area.invarea < 0.0f);
-
-    if (!ray_quad_intersect(P,
-                            direction,
-                            1e-4f,
-                            FLT_MAX,
-                            lightpos,
-                            axisu,
-                            axisv,
-                            dir,
-                            NULL,
-                            NULL,
-                            NULL,
-                            NULL,
-                            is_round))
-      continue;
-
-    if (is_round) {
-      float t;
-      float3 D = normalize_len(lightpos - P, &t);
-      portal_pdf += fabsf(klight->area.invarea) * lamp_light_pdf(kg, dir, -D, t);
-    }
-    else {
-      portal_pdf += rect_light_sample(P, &lightpos, axisu, axisv, 0.0f, 0.0f, false);
-    }
-  }
-
-  if (ignore_portal >= 0) {
-    /* We have skipped a portal that could be sampled as well. */
-    num_possible++;
-  }
-
-  return (num_possible > 0) ? portal_pdf / num_possible : 0.0f;
-}
-
-ccl_device int background_num_possible_portals(KernelGlobals *kg, float3 P)
-{
-  int num_possible_portals = 0;
-  for (int p = 0; p < kernel_data.integrator.num_portals; p++) {
-    float3 lightpos, dir;
-    if (background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
-      num_possible_portals++;
-  }
-  return num_possible_portals;
-}
-
-ccl_device float3 background_portal_sample(KernelGlobals *kg,
-                                           float3 P,
-                                           float randu,
-                                           float randv,
-                                           int num_possible,
-                                           int *sampled_portal,
-                                           float *pdf)
-{
-  /* Pick a portal, then re-normalize randv. */
-  randv *= num_possible;
-  int portal = (int)randv;
-  randv -= portal;
-
-  /* TODO(sergey): Some smarter way of finding portal to sample
-   * is welcome.
-   */
-  for (int p = 0; p < kernel_data.integrator.num_portals; p++) {
-    /* Search for the sampled portal. */
-    float3 lightpos, dir;
-    if (!background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
-      continue;
-
-    if (portal == 0) {
-      /* p is the portal to be sampled. */
-      int portal = kernel_data.integrator.portal_offset + p;
-      const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
-      float3 axisu = make_float3(
-          klight->area.axisu[0], klight->area.axisu[1], klight->area.axisu[2]);
-      float3 axisv = make_float3(
-          klight->area.axisv[0], klight->area.axisv[1], klight->area.axisv[2]);
-      bool is_round = (klight->area.invarea < 0.0f);
-
-      float3 D;
-      if (is_round) {
-        lightpos += ellipse_sample(axisu * 0.5f, axisv * 0.5f, randu, randv);
-        float t;
-        D = normalize_len(lightpos - P, &t);
-        *pdf = fabsf(klight->area.invarea) * lamp_light_pdf(kg, dir, -D, t);
-      }
-      else {
-        *pdf = rect_light_sample(P, &lightpos, axisu, axisv, randu, randv, true);
-        D = normalize(lightpos - P);
-      }
-
-      *pdf /= num_possible;
-      *sampled_portal = p;
-      return D;
-    }
-
-    portal--;
-  }
-
-  return make_float3(0.0f, 0.0f, 0.0f);
-}
-
-ccl_device_inline float3
-background_light_sample(KernelGlobals *kg, float3 P, float randu, float randv, float *pdf)
-{
-  /* Probability of sampling portals instead of the map. */
-  float portal_sampling_pdf = kernel_data.integrator.portal_pdf;
-
-  /* Check if there are portals in the scene which we can sample. */
-  if (portal_sampling_pdf > 0.0f) {
-    int num_portals = background_num_possible_portals(kg, P);
-    if (num_portals > 0) {
-      if (portal_sampling_pdf == 1.0f || randu < portal_sampling_pdf) {
-        if (portal_sampling_pdf < 1.0f) {
-          randu /= portal_sampling_pdf;
-        }
-        int portal;
-        float3 D = background_portal_sample(kg, P, randu, randv, num_portals, &portal, pdf);
-        if (num_portals > 1) {
-          /* Ignore the chosen portal, its pdf is already included. */
-          *pdf += background_portal_pdf(kg, P, D, portal, NULL);
-        }
-        /* We could also have sampled the map, so combine with MIS. */
-        if (portal_sampling_pdf < 1.0f) {
-          float cdf_pdf = background_map_pdf(kg, D);
-          *pdf = (portal_sampling_pdf * (*pdf) + (1.0f - portal_sampling_pdf) * cdf_pdf);
-        }
-        return D;
-      }
-      else {
-        /* Sample map, but with nonzero portal_sampling_pdf for MIS. */
-        randu = (randu - portal_sampling_pdf) / (1.0f - portal_sampling_pdf);
-      }
-    }
-    else {
-      /* We can't sample a portal.
-       * Check if we can sample the map instead.
-       */
-      if (portal_sampling_pdf == 1.0f) {
-        /* Use uniform as a fallback if we can't sample the map. */
-        *pdf = 1.0f / M_4PI_F;
-        return sample_uniform_sphere(randu, randv);
-      }
-      else {
-        portal_sampling_pdf = 0.0f;
-      }
-    }
-  }
-
-  float3 D = background_map_sample(kg, randu, randv, pdf);
-  /* Use MIS if portals could be sampled as well. */
-  if (portal_sampling_pdf > 0.0f) {
-    float portal_pdf = background_portal_pdf(kg, P, D, -1, NULL);
-    *pdf = (portal_sampling_pdf * portal_pdf + (1.0f - portal_sampling_pdf) * (*pdf));
-  }
-  return D;
-}
-
-ccl_device float background_light_pdf(KernelGlobals *kg, float3 P, float3 direction)
-{
-  /* Probability of sampling portals instead of the map. */
-  float portal_sampling_pdf = kernel_data.integrator.portal_pdf;
-
-  float portal_pdf = 0.0f, map_pdf = 0.0f;
-  if (portal_sampling_pdf > 0.0f) {
-    /* Evaluate PDF of sampling this direction by portal sampling. */
-    bool is_possible = false;
-    portal_pdf = background_portal_pdf(kg, P, direction, -1, &is_possible) * portal_sampling_pdf;
-    if (!is_possible) {
-      /* Portal sampling is not possible here because all portals point to the wrong side.
-       * If map sampling is possible, it would be used instead,
-       * otherwise fallback sampling is used. */
-      if (portal_sampling_pdf == 1.0f) {
-        return kernel_data.integrator.pdf_lights / M_4PI_F;
-      }
-      else {
-        /* Force map sampling. */
-        portal_sampling_pdf = 0.0f;
-      }
-    }
-  }
-  if (portal_sampling_pdf < 1.0f) {
-    /* Evaluate PDF of sampling this direction by map sampling. */
-    map_pdf = background_map_pdf(kg, direction) * (1.0f - portal_sampling_pdf);
-  }
-  return (portal_pdf + map_pdf) * kernel_data.integrator.pdf_lights;
-}
-#endif
-
 /* Regular Light */
 
 ccl_device_inline bool lamp_light_sample(
@@ -594,7 +102,7 @@ ccl_device_inline bool lamp_light_sample(
         /* spot light attenuation */
         float3 dir = make_float3(klight->spot.dir[0], klight->spot.dir[1], klight->spot.dir[2]);
         ls->eval_fac *= spot_light_attenuation(
-            dir, klight->spot.spot_angle, klight->spot.spot_smooth, ls);
+            dir, klight->spot.spot_angle, klight->spot.spot_smooth, ls->Ng);
         if (ls->eval_fac == 0.0f) {
           return false;
         }
@@ -732,7 +240,7 @@ ccl_device bool lamp_light_eval(
       /* spot light attenuation */
       float3 dir = make_float3(klight->spot.dir[0], klight->spot.dir[1], klight->spot.dir[2]);
       ls->eval_fac *= spot_light_attenuation(
-          dir, klight->spot.spot_angle, klight->spot.spot_smooth, ls);
+          dir, klight->spot.spot_angle, klight->spot.spot_smooth, ls->Ng);
 
       if (ls->eval_fac == 0.0f)
         return false;
diff --git a/intern/cycles/kernel/kernel_light_background.h b/intern/cycles/kernel/kernel_light_background.h
new file mode 100644
index 00000000000..30e336f0f80
--- /dev/null
+++ b/intern/cycles/kernel/kernel_light_background.h
@@ -0,0 +1,448 @@
+/*
+ * Copyright 2011-2020 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kernel_light_common.h"
+
+CCL_NAMESPACE_BEGIN
+
+/* Background Light */
+
+#ifdef __BACKGROUND_MIS__
+
+ccl_device float3 background_map_sample(KernelGlobals *kg, float randu, float randv, float *pdf)
+{
+  /* for the following, the CDF values are actually a pair of floats, with the
+   * function value as X and the actual CDF as Y.  The last entry's function
+   * value is the CDF total. */
+  int res_x = kernel_data.background.map_res_x;
+  int res_y = kernel_data.background.map_res_y;
+  int cdf_width = res_x + 1;
+
+  /* this is basically std::lower_bound as used by pbrt */
+  int first = 0;
+  int count = res_y;
+
+  while (count > 0) {
+    int step = count >> 1;
+    int middle = first + step;
+
+    if (kernel_tex_fetch(__light_background_marginal_cdf, middle).y < randv) {
+      first = middle + 1;
+      count -= step + 1;
+    }
+    else
+      count = step;
+  }
+
+  int index_v = max(0, first - 1);
+  kernel_assert(index_v >= 0 && index_v < res_y);
+
+  float2 cdf_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v);
+  float2 cdf_next_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v + 1);
+  float2 cdf_last_v = kernel_tex_fetch(__light_background_marginal_cdf, res_y);
+
+  /* importance-sampled V direction */
+  float dv = inverse_lerp(cdf_v.y, cdf_next_v.y, randv);
+  float v = (index_v + dv) / res_y;
+
+  /* this is basically std::lower_bound as used by pbrt */
+  first = 0;
+  count = res_x;
+  while (count > 0) {
+    int step = count >> 1;
+    int middle = first + step;
+
+    if (kernel_tex_fetch(__light_background_conditional_cdf, index_v * cdf_width + middle).y <
+        randu) {
+      first = middle + 1;
+      count -= step + 1;
+    }
+    else
+      count = step;
+  }
+
+  int index_u = max(0, first - 1);
+  kernel_assert(index_u >= 0 && index_u < res_x);
+
+  float2 cdf_u = kernel_tex_fetch(__light_background_conditional_cdf,
+                                  index_v * cdf_width + index_u);
+  float2 cdf_next_u = kernel_tex_fetch(__light_background_conditional_cdf,
+                                       index_v * cdf_width + index_u + 1);
+  float2 cdf_last_u = kernel_tex_fetch(__light_background_conditional_cdf,
+                                       index_v * cdf_width + res_x);
+
+  /* importance-sampled U direction */
+  float du = inverse_lerp(cdf_u.y, cdf_next_u.y, randu);
+  float u = (index_u + du) / res_x;
+
+  /* compute pdf */
+  float sin_theta = sinf(M_PI_F * v);
+  float denom = (M_2PI_F * M_PI_F * sin_theta) * cdf_last_u.x * cdf_last_v.x;
+
+  if (sin_theta == 0.0f || denom == 0.0f)
+    *pdf = 0.0f;
+  else
+    *pdf = (cdf_u.x * cdf_v.x) / denom;
+
+  /* compute direction */
+  return equirectangular_to_direction(u, v);
+}
+
+/* TODO(sergey): Same as above, after the release we should consider using
+ * 'noinline' for all devices.
+ */
+ccl_device float background_map_pdf(KernelGlobals *kg, float3 direction)
+{
+  float2 uv = direction_to_equirectangular(direction);
+  int res_x = kernel_data.background.map_res_x;
+  int res_y = kernel_data.background.map_res_y;
+  int cdf_width = res_x + 1;
+
+  float sin_theta = sinf(uv.y * M_PI_F);
+
+  if (sin_theta == 0.0f)
+    return 0.0f;
+
+  int index_u = clamp(float_to_int(uv.x * res_x), 0, res_x - 1);
+  int index_v = clamp(float_to_int(uv.y * res_y), 0, res_y - 1);
+
+  /* pdfs in V direction */
+  float2 cdf_last_u = kernel_tex_fetch(__light_background_conditional_cdf,
+                                       index_v * cdf_width + res_x);
+  float2 cdf_last_v = kernel_tex_fetch(__light_background_marginal_cdf, res_y);
+
+  float denom = (M_2PI_F * M_PI_F * sin_theta) * cdf_last_u.x * cdf_last_v.x;
+
+  if (denom == 0.0f)
+    return 0.0f;
+
+  /* pdfs in U direction */
+  float2 cdf_u = kernel_tex_fetch(__light_background_conditional_cdf,
+                                  index_v * cdf_width + index_u);
+  float2 cdf_v = kernel_tex_fetch(__light_background_marginal_cdf, index_v);
+
+  return (cdf_u.x * cdf_v.x) / denom;
+}
+
+ccl_device_inline bool background_portal_data_fetch_and_check_side(
+    KernelGlobals *kg, float3 P, int index, float3 *lightpos, float3 *dir)
+{
+  int portal = kernel_data.background.portal_offset + index;
+  const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
+
+  *lightpos = make_float3(klight->co[0], klight->co[1], klight->co[2]);
+  *dir = make_float3(klight->area.dir[0], klight->area.dir[1], klight->area.dir[2]);
+
+  /* Check whether portal is on the right side. */
+  if (dot(*dir, P - *lightpos) > 1e-4f)
+    return true;
+
+  return false;
+}
+
+ccl_device_inline float background_portal_pdf(
+    KernelGlobals *kg, float3 P, float3 direction, int ignore_portal, bool *is_possible)
+{
+  float portal_pdf = 0.0f;
+
+  int num_possible = 0;
+  for (int p = 0; p < kernel_data.background.num_portals; p++) {
+    if (p == ignore_portal)
+      continue;
+
+    float3 lightpos, dir;
+    if (!background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
+      continue;
+
+    /* There's a portal that could be sampled from this position. */
+    if (is_possible) {
+      *is_possible = true;
+    }
+    num_possible++;
+
+    int portal = kernel_data.background.portal_offset + p;
+    const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
+    float3 axisu = make_float3(
+        klight->area.axisu[0], klight->area.axisu[1], klight->area.axisu[2]);
+    float3 axisv = make_float3(
+        klight->area.axisv[0], klight->area.axisv[1], klight->area.axisv[2]);
+    bool is_round = (klight->area.invarea < 0.0f);
+
+    if (!ray_quad_intersect(P,
+                            direction,
+                            1e-4f,
+                            FLT_MAX,
+                            lightpos,
+                            axisu,
+                            axisv,
+                            dir,
+                            NULL,
+                            NULL,
+                            NULL,
+                            NULL,
+                            is_round))
+      continue;
+
+    if (is_round) {
+      float t;
+      float3 D = normalize_len(lightpos - P, &t);
+      portal_pdf += fabsf(klight->area.invarea) * lamp_light_pdf(kg, dir, -D, t);
+    }
+    else {
+      portal_pdf += rect_light_sample(P, &lightpos, axisu, axisv, 0.0f, 0.0f, false);
+    }
+  }
+
+  if (ignore_portal >= 0) {
+    /* We have skipped a portal that could be sampled as well. */
+    num_possible++;
+  }
+
+  return (num_possible > 0) ? portal_pdf / num_possible : 0.0f;
+}
+
+ccl_device int background_num_possible_portals(KernelGlobals *kg, float3 P)
+{
+  int num_possible_portals = 0;
+  for (int p = 0; p < kernel_data.background.num_portals; p++) {
+    float3 lightpos, dir;
+    if (background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
+      num_possible_portals++;
+  }
+  return num_possible_portals;
+}
+
+ccl_device float3 background_portal_sample(KernelGlobals *kg,
+                                           float3 P,
+                                           float randu,
+                                           float randv,
+                                           int num_possible,
+                                           int *sampled_portal,
+                                           float *pdf)
+{
+  /* Pick a portal, then re-normalize randv. */
+  randv *= num_possible;
+  int portal = (int)randv;
+  randv -= portal;
+
+  /* TODO(sergey): Some smarter way of finding portal to sample
+   * is welcome.
+   */
+  for (int p = 0; p < kernel_data.background.num_portals; p++) {
+    /* Search for the sampled portal. */
+    float3 lightpos, dir;
+    if (!background_portal_data_fetch_and_check_side(kg, P, p, &lightpos, &dir))
+      continue;
+
+    if (portal == 0) {
+      /* p is the portal to be sampled. */
+      int portal = kernel_data.background.portal_offset + p;
+      const ccl_global KernelLight *klight = &kernel_tex_fetch(__lights, portal);
+      float3 axisu = make_float3(
+          klight->area.axisu[0], klight->area.axisu[1], klight->area.axisu[2]);
+      float3 axisv = make_float3(
+          klight->area.axisv[0], klight->area.axisv[1], klight->area.axisv[2]);
+      bool is_round = (klight->area.invarea < 0.0f);
+
+      float3 D;
+      if (is_round) {
+        lightpos += ellipse_sample(axisu * 0.5f, axisv * 0.5f, randu, randv);
+        float t;
+        D = normalize_len(lightpos - P, &t);
+        *pdf = fabsf(klight->area.invarea) * lamp_light_pdf(kg, dir, -D, t);
+      }
+      else {
+        *pdf = rect_light_sample(P, &lightpos, axisu, axisv, randu, randv, true);
+        D = normalize(lightpos - P);
+      }
+
+      *pdf /= num_possible;
+      *sampled_portal = p;
+      return D;
+    }
+
+    portal--;
+  }
+
+  return make_float3(0.0f, 0.0f, 0.0f);
+}
+
+ccl_device_inline float3 background_sun_sample(KernelGlobals *kg,
+                                               float randu,
+                                               float randv,
+                                               float *pdf)
+{
+  float3 D;
+  const float3 N = float4_to_float3(kernel_data.background.sun);
+  const float angle = kernel_data.background.sun.w;
+  sample_uniform_cone(N, angle, randu, randv, &D, pdf);
+  return D;
+}
+
+ccl_device_inline float background_sun_pdf(KernelGlobals *kg, float3 D)
+{
+  const float3 N = float4_to_float3(kernel_data.background.sun);
+  const float angle = kernel_data.background.sun.w;
+  return pdf_uniform_cone(N, D, angle);
+}
+
+ccl_device_inline float3
+background_light_sample(KernelGlobals *kg, float3 P, float randu, float randv, float *pdf)
+{
+  float portal_method_pdf = kernel_data.background.portal_weight;
+  float sun_method_pdf = kernel_data.background.sun_weight;
+  float map_method_pdf = kernel_data.background.map_weight;
+
+  int num_portals = 0;
+  if (portal_method_pdf > 0.0f) {
+    /* Check if there are portals in the scene which we can sample. */
+    num_portals = background_num_possible_portals(kg, P);
+    if (num_portals == 0) {
+      portal_method_pdf = 0.0f;
+    }
+  }
+
+  float pdf_fac = (portal_method_pdf + sun_method_pdf + map_method_pdf);
+  if (pdf_fac == 0.0f) {
+    /* Use uniform as a fallback if we can't use any strategy. */
+    *pdf = 1.0f / M_4PI_F;
+    return sample_uniform_sphere(randu, randv);
+  }
+
+  pdf_fac = 1.0f / pdf_fac;
+  portal_method_pdf *= pdf_fac;
+  sun_method_pdf *= pdf_fac;
+  map_method_pdf *= pdf_fac;
+
+  /* We have 100% in total and split it between the three categories.
+   * Therefore, we pick portals if randu is between 0 and portal_method_pdf,
+   * sun if randu is between portal_method_pdf and (portal_method_pdf + sun_method_pdf)
+   * and map if randu is between (portal_method_pdf + sun_method_pdf) and 1. */
+  float sun_method_cdf = portal_method_pdf + sun_method_pdf;
+
+  int method = 0;
+  float3 D;
+  if (randu < portal_method_pdf) {
+    method = 0;
+    /* Rescale randu. */
+    if (portal_method_pdf != 1.0f) {
+      randu /= portal_method_pdf;
+    }
+
+    /* Sample a portal. */
+    int portal;
+    D = background_portal_sample(kg, P, randu, randv, num_portals, &portal, pdf);
+    if (num_portals > 1) {
+      /* Ignore the chosen portal, its pdf is already included. */
+      *pdf += background_portal_pdf(kg, P, D, portal, NULL);
+    }
+
+    /* Skip MIS if this is the only method. */
+    if (portal_method_pdf == 1.0f) {
+      return D;
+    }
+    *pdf *= portal_method_pdf;
+  }
+  else if (randu < sun_method_cdf) {
+    method = 1;
+    /* Rescale randu. */
+    if (sun_method_pdf != 1.0f) {
+      randu = (randu - portal_method_pdf) / sun_method_pdf;
+    }
+
+    D = background_sun_sample(kg, randu, randv, pdf);
+
+    /* Skip MIS if this is the only method. */
+    if (sun_method_pdf == 1.0f) {
+      return D;
+    }
+    *pdf *= sun_method_pdf;
+  }
+  else {
+    method = 2;
+    /* Rescale randu. */
+    if (map_method_pdf != 1.0f) {
+      randu = (randu - sun_method_cdf) / map_method_pdf;
+    }
+
+    D = background_map_sample(kg, randu, randv, pdf);
+
+    /* Skip MIS if this is the only method. */
+    if (map_method_pdf == 1.0f) {
+      return D;
+    }
+    *pdf *= map_method_pdf;
+  }
+
+  /* MIS weighting. */
+  if (method != 0 && portal_method_pdf != 0.0f) {
+    *pdf += portal_method_pdf * background_portal_pdf(kg, P, D, -1, NULL);
+  }
+  if (method != 1 && sun_method_pdf != 0.0f) {
+    *pdf += sun_method_pdf * background_sun_pdf(kg, D);
+  }
+  if (method != 2 && map_method_pdf != 0.0f) {
+    *pdf += map_method_pdf * background_map_pdf(kg, D);
+  }
+  return D;
+}
+
+ccl_device float background_light_pdf(KernelGlobals *kg, float3 P, float3 direction)
+{
+  float portal_method_pdf = kernel_data.background.portal_weight;
+  float sun_method_pdf = kernel_data.background.sun_weight;
+  float map_method_pdf = kernel_data.background.map_weight;
+
+  float portal_pdf = 0.0f;
+  /* Portals are a special case here since we need to compute their pdf in order
+   * to find out if we can sample them. */
+  if (portal_method_pdf > 0.0f) {
+    /* Evaluate PDF of sampling this direction by portal sampling. */
+    bool is_possible = false;
+    portal_pdf = background_portal_pdf(kg, P, direction, -1, &is_possible);
+    if (!is_possible) {
+      /* Portal sampling is not possible here because all portals point to the wrong side.
+       * If other methods can be used instead, do so, otherwise uniform sampling is used as a
+       * fallback. */
+      portal_method_pdf = 0.0f;
+    }
+  }
+
+  float pdf_fac = (portal_method_pdf + sun_method_pdf + map_method_pdf);
+  if (pdf_fac == 0.0f) {
+    /* Use uniform as a fallback if we can't use any strategy. */
+    return kernel_data.integrator.pdf_lights / M_4PI_F;
+  }
+
+  pdf_fac = 1.0f / pdf_fac;
+  portal_method_pdf *= pdf_fac;
+  sun_method_pdf *= pdf_fac;
+  map_method_pdf *= pdf_fac;
+
+  float pdf = portal_pdf * portal_method_pdf;
+  if (sun_method_pdf != 0.0f) {
+    pdf += background_sun_pdf(kg, direction) * sun_method_pdf;
+  }
+  if (map_method_pdf != 0.0f) {
+    pdf += background_map_pdf(kg, direction) * map_method_pdf;
+  }
+
+  return pdf * kernel_data.integrator.pdf_lights;
+}
+
+#endif
+
+CCL_NAMESPACE_END
\ No newline at end of file
diff --git a/intern/cycles/kernel/kernel_light_common.h b/intern/cycles/kernel/kernel_light_common.h
new file mode 100644
index 00000000000..39503a4b479
--- /dev/null
+++ b/intern/cycles/kernel/kernel_light_common.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2011-2020 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+CCL_NAMESPACE_BEGIN
+
+/* Area light sampling */
+
+/* Uses the following paper:
+ *
+ * Carlos Urena et al.
+ * An Area-Preserving Parametrization for Spherical Rectangles.
+ *
+ * https://www.solidangle.com/research/egsr2013_spherical_rectangle.pdf
+ *
+ * Note: light_p is modified when sample_coord is true.
+ */
+ccl_device_inline float rect_light_sample(float3 P,
+                                          float3 *light_p,
+                                          float3 axisu,
+                                          float3 axisv,
+                                          float randu,
+                                          float randv,
+                                          bool sample_coord)
+{
+  /* In our name system we're using P for the center,
+   * which is o in the paper.
+   */
+
+  float3 corner = *light_p - axisu * 0.5f - axisv * 0.5f;
+  float axisu_len, axisv_len;
+  /* Compute local reference system R. */
+  float3 x = normalize_len(axisu, &axisu_len);
+  float3 y = normalize_len(axisv, &axisv_len);
+  float3 z = cross(x, y);
+  /* Compute rectangle coords in local reference system. */
+  float3 dir = corner - P;
+  float z0 = dot(dir, z);
+  /* Flip 'z' to make it point against Q. */
+  if (z0 > 0.0f) {
+    z *= -1.0f;
+    z0 *= -1.0f;
+  }
+  float x0 = dot(dir, x);
+  float y0 = dot(dir, y);
+  float x1 = x0 + axisu_len;
+  float y1 = y0 + axisv_len;
+  /* Compute internal angles (gamma_i). */
+  float4 diff = make_float4(x0, y1, x1, y0) - make_float4(x1, y0, x0, y1);
+  float4 nz = make_float4(y0, x1, y1, x0) * diff;
+  nz = nz / sqrt(z0 * z0 * diff * diff + nz * nz);
+  float g0 = safe_acosf(-nz.x * nz.y);
+  float g1 = safe_acosf(-nz.y * nz.z);
+  float g2 = safe_acosf(-nz.z * nz.w);
+  float g3 = safe_acosf(-nz.w * nz.x);
+  /* Compute predefined constants. */
+  float b0 = nz.x;
+  float b1 = nz.z;
+  float b0sq = b0 * b0;
+  float k = M_2PI_F - g2 - g3;
+  /* Compute solid angle from internal angles. */
+  float S = g0 + g1 - k;
+
+  if (sample_coord) {
+    /* Compute cu. */
+    float au = randu * S + k;
+    float fu = (cosf(au) * b0 - b1) / sinf(au);
+    float cu = 1.0f / sqrtf(fu * fu + b0sq) * (fu > 0.0f ? 1.0f : -1.0f);
+    cu = clamp(cu, -1.0f, 1.0f);
+    /* Compute xu. */
+    float xu = -(cu * z0) / max(sqrtf(1.0f - cu * cu), 1e-7f);
+    xu = clamp(xu, x0, x1);
+    /* Compute yv. */
+    float z0sq = z0 * z0;
+    float y0sq = y0 * y0;
+    float y1sq = y1 * y1;
+    float d = sqrtf(xu * xu + z0sq);
+    float h0 = y0 / sqrtf(d * d + y0sq);
+    float h1 = y1 / sqrtf(d * d + y1sq);
+    float hv = h0 + randv * (h1 - h0), hv2 = hv * hv;
+    float yv = (hv2 < 1.0f - 1e-6f) ? (hv * d) / sqrtf(1.0f - hv2) : y1;
+
+    /* Transform (xu, yv, z0) to world coords. */
+    *light_p = P + xu * x + yv * y + z0 * z;
+  }
+
+  /* return pdf */
+  if (S != 0.0f)
+    return 1.0f / S;
+  else
+    return 0.0f;
+}
+
+ccl_device_inline float3 ellipse_sample(float3 ru, float3 rv, float randu, float randv)
+{
+  to_unit_disk(&randu, &randv);
+  return ru * randu + rv * randv;
+}
+
+ccl_device float3 disk_light_sample(float3 v, float randu, float randv)
+{
+  float3 ru, rv;
+
+  make_orthonormals(v, &ru, &rv);
+
+  return ellipse_sample(ru, rv, randu, randv);
+}
+
+ccl_device float3 distant_light_sample(float3 D, float radius, float randu, float randv)
+{
+  return normalize(D + disk_light_sample(D, randu, randv) * radius);
+}
+
+ccl_device float3
+sphere_light_sample(float3 P, float3 center, float radius, float randu, float randv)
+{
+  return disk_light_sample(normalize(P - center), randu, randv) * radius;
+}
+
+ccl_device float spot_light_attenuation(float3 dir, float spot_angle, float spot_smooth, float3 N)
+{
+  float attenuation = dot(dir, N);
+
+  if (attenuation <= spot_angle) {
+    attenuation = 0.0f;
+  }
+  else {
+    float t = attenuation - spot_angle;
+
+    if (t < spot_smooth && spot_smooth != 0.0f)
+      attenuation *= smoothstepf(t / spot_smooth);
+  }
+
+  return attenuation;
+}
+
+ccl_device float lamp_light_pdf(KernelGlobals *kg, const float3 Ng, const float3 I, float t)
+{
+  float cos_pi = dot(Ng, I);
+
+  if (cos_pi <= 0.0f)
+    return 0.0f;
+
+  return t * t / cos_pi;
+}
+
+CCL_NAMESPACE_END
diff --git a/intern/cycles/kernel/kernel_montecarlo.h b/intern/cycles/kernel/kernel_montecarlo.h
index 5c776e06547..0edcc1a5a14 100644
--- a/intern/cycles/kernel/kernel_montecarlo.h
+++ b/intern/cycles/kernel/kernel_montecarlo.h
@@ -98,6 +98,16 @@ ccl_device_inline void sample_uniform_cone(
   *pdf = M_1_2PI_F / (1.0f - zMin);
 }
 
+ccl_device_inline float pdf_uniform_cone(const float3 N, float3 D, float angle)
+{
+  float zMin = cosf(angle);
+  float z = dot(N, D);
+  if (z > zMin) {
+    return M_1_2PI_F / (1.0f - zMin);
+  }
+  return 0.0f;
+}
+
 /* sample uniform point on the surface of a sphere */
 ccl_device float3 sample_uniform_sphere(float u1, float u2)
 {
diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index 0a0cf1bd6c0..a692d7a844f 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -1291,6 +1291,24 @@ typedef struct KernelBackground {
   float ao_factor;
   float ao_distance;
   float ao_bounces_factor;
+
+  /* portal sampling */
+  float portal_weight;
+  int num_portals;
+  int portal_offset;
+
+  /* sun sampling */
+  float sun_weight;
+  /* xyz store direction, w the angle. float4 instead of float3 is used
+   * to ensure consistent padding/alignment across devices. */
+  float4 sun;
+
+  /* map sampling */
+  float map_weight;
+  int map_res_x;
+  int map_res_y;
+
+  int use_mis;
 } KernelBackground;
 static_assert_align(KernelBackground, 16);
 
@@ -1302,15 +1320,8 @@ typedef struct KernelIntegrator {
   int num_all_lights;
   float pdf_triangles;
   float pdf_lights;
-  int pdf_background_res_x;
-  int pdf_background_res_y;
   float light_inv_rr_threshold;
 
-  /* light portals */
-  float portal_pdf;
-  int num_portals;
-  int portal_offset;
-
   /* bounces */
   int min_bounce;
   int max_bounce;
@@ -1372,7 +1383,7 @@ typedef struct KernelIntegrator {
 
   int max_closures;
 
-  int pad1;
+  int pad1, pad2;
 } KernelIntegrator;
 static_assert_align(KernelIntegrator, 16);
 
diff --git a/intern/cycles/kernel/shaders/node_sky_texture.osl b/intern/cycles/kernel/shaders/node_sky_texture.osl
index 4def237a2e0..08bc8f85120 100644
--- a/intern/cycles/kernel/shaders/node_sky_texture.osl
+++ b/intern/cycles/kernel/shaders/node_sky_texture.osl
@@ -44,13 +44,13 @@ float sky_perez_function(float lam[9], float theta, float gamma)
          (1.0 + lam[2] * exp(lam[3] * gamma) + lam[4] * cgamma * cgamma);
 }
 
-color sky_radiance_old(normal dir,
-                       float sunphi,
-                       float suntheta,
-                       color radiance,
-                       float config_x[9],
-                       float config_y[9],
-                       float config_z[9])
+color sky_radiance_preetham(normal dir,
+                            float sunphi,
+                            float suntheta,
+                            color radiance,
+                            float config_x[9],
+                            float config_y[9],
+                            float config_z[9])
 {
   /* convert vector to spherical coordinates */
   vector spherical = sky_spherical_coordinates(dir);
@@ -88,13 +88,13 @@ float sky_radiance_internal(float config[9], float theta, float gamma)
          (config[2] + config[3] * expM + config[5] * rayM + config[6] * mieM + config[7] * zenith);
 }
 
-color sky_radiance_new(normal dir,
-                       float sunphi,
-                       float suntheta,
-                       color radiance,
-                       float config_x[9],
-                       float config_y[9],
-                       float config_z[9])
+color sky_radiance_hosek(normal dir,
+                         float sunphi,
+                         float suntheta,
+                         color radiance,
+                         float config_x[9],
+                         float config_y[9],
+                         float config_z[9])
 {
   /* convert vector to spherical coordinates */
   vector spherical = sky_spherical_coordinates(dir);
@@ -116,16 +116,103 @@ color sky_radiance_new(normal dir,
   return xyz_to_rgb(x, y, z) * (M_2PI / 683);
 }
 
+/* Nishita improved */
+vector geographical_to_direction(float lat, float lon)
+{
+  return vector(cos(lat) * cos(lon), cos(lat) * sin(lon), sin(lat));
+}
+
+color sky_radiance_nishita(vector dir, float nishita_data[9], string filename)
+{
+  /* definitions */
+  float sun_elevation = nishita_data[6];
+  float sun_rotation = nishita_data[7];
+  float angular_diameter = nishita_data[8];
+  int sun_disc = angular_diameter > 0;
+  float alpha = 1.0;
+  color xyz;
+  /* convert dir to spherical coordinates */
+  vector direction = sky_spherical_coordinates(dir);
+
+  /* render above the horizon */
+  if (dir[2] >= 0.0) {
+    /* definitions */
+    vector sun_dir = geographical_to_direction(sun_elevation, sun_rotation + M_PI_2);
+    float sun_dir_angle = acos(dot(dir, sun_dir));
+    float half_angular = angular_diameter / 2.0;
+    float dir_elevation = M_PI_2 - direction[0];
+
+    /* if ray inside sun disc render it, otherwise render sky */
+    if (sun_dir_angle < half_angular && sun_disc == 1) {
+      /* get 3 pixels data */
+      color pixel_bottom = color(nishita_data[0], nishita_data[1], nishita_data[2]);
+      color pixel_top = color(nishita_data[3], nishita_data[4], nishita_data[5]);
+      float y;
+
+      /* sun interpolation */
+      if (sun_elevation - half_angular > 0.0) {
+        if ((sun_elevation + half_angular) > 0.0) {
+          y = ((dir_elevation - sun_elevation) / angular_diameter) + 0.5;
+          xyz = mix(pixel_bottom, pixel_top, y);
+        }
+      }
+      else {
+        if (sun_elevation + half_angular > 0.0) {
+          y = dir_elevation / (sun_elevation + half_angular);
+          xyz = mix(pixel_bottom, pixel_top, y);
+        }
+      }
+      /* limb darkening, coefficient is 0.6f */
+      float angle_fraction = sun_dir_angle / half_angular;
+      float limb_darkening = (1.0 - 0.6 * (1.0 - sqrt(1.0 - angle_fraction * angle_fraction)));
+      xyz *= limb_darkening;
+    }
+    /* sky */
+    else {
+      /* sky interpolation */
+      float x = (direction[1] + M_PI + sun_rotation) / M_2PI;
+      float y = 1.0 - (dir_elevation / M_PI_2);
+      if (x > 1.0) {
+        x = x - 1.0;
+      }
+      xyz = (color)texture(filename, x, y, "wrap", "clamp", "interp", "linear", "alpha", alpha);
+    }
+  }
+  /* ground */
+  else {
+    if (dir[2] < -0.4) {
+      xyz = color(0, 0, 0);
+    }
+    else {
+      /* black ground fade */
+      float mul = pow(1.0 + dir[2] * 2.5, 3.0);
+      /* interpolation */
+      float x = (direction[1] + M_PI + sun_rotation) / M_2PI;
+      float y = 1.5;
+      if (x > 1.0) {
+        x = x - 1.0;
+      }
+      xyz = (color)texture(
+                filename, x, y, "wrap", "periodic", "interp", "linear", "alpha", alpha) *
+            mul;
+    }
+  }
+  /* convert to RGB and adjust strength */
+  return xyz_to_rgb(xyz[0], xyz[1], xyz[2]) * 120000.0;
+}
+
 shader node_sky_texture(int use_mapping = 0,
                         matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
                         vector Vector = P,
                         string type = "hosek_wilkie",
                         float theta = 0.0,
                         float phi = 0.0,
+                        string filename = "",
                         color radiance = color(0.0, 0.0, 0.0),
                         float config_x[9] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                         float config_y[9] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                         float config_z[9] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                        float nishita_data[9] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                         output color Color = color(0.0, 0.0, 0.0))
 {
   vector p = Vector;
@@ -133,8 +220,10 @@ shader node_sky_texture(int use_mapping = 0,
   if (use_mapping)
     p = transform(mapping, p);
 
+  if (type == "nishita_improved")
+    Color = sky_radiance_nishita(p, nishita_data, filename);
   if (type == "hosek_wilkie")
-    Color = sky_radiance_new(p, phi, theta, radiance, config_x, config_y, config_z);
-  else
-    Color = sky_radiance_old(p, phi, theta, radiance, config_x, config_y, config_z);
+    Color = sky_radiance_hosek(p, phi, theta, radiance, config_x, config_y, config_z);
+  if (type == "preetham")
+    Color = sky_radiance_preetham(p, phi, theta, radiance, config_x, config_y, config_z);
 }
diff --git a/intern/cycles/kernel/svm/svm_sky.h b/intern/cycles/kernel/svm/svm_sky.h
index 50fe0c8232f..e877bd9a5c8 100644
--- a/intern/cycles/kernel/svm/svm_sky.h
+++ b/intern/cycles/kernel/svm/svm_sky.h
@@ -37,16 +37,16 @@ ccl_device float sky_perez_function(float *lam, float theta, float gamma)
          (1.0f + lam[2] * expf(lam[3] * gamma) + lam[4] * cgamma * cgamma);
 }
 
-ccl_device float3 sky_radiance_old(KernelGlobals *kg,
-                                   float3 dir,
-                                   float sunphi,
-                                   float suntheta,
-                                   float radiance_x,
-                                   float radiance_y,
-                                   float radiance_z,
-                                   float *config_x,
-                                   float *config_y,
-                                   float *config_z)
+ccl_device float3 sky_radiance_preetham(KernelGlobals *kg,
+                                        float3 dir,
+                                        float sunphi,
+                                        float suntheta,
+                                        float radiance_x,
+                                        float radiance_y,
+                                        float radiance_z,
+                                        float *config_x,
+                                        float *config_y,
+                                        float *config_z)
 {
   /* convert vector to spherical coordinates */
   float2 spherical = direction_to_spherical(dir);
@@ -90,16 +90,16 @@ ccl_device float sky_radiance_internal(float *configuration, float theta, float
           configuration[6] * mieM + configuration[7] * zenith);
 }
 
-ccl_device float3 sky_radiance_new(KernelGlobals *kg,
-                                   float3 dir,
-                                   float sunphi,
-                                   float suntheta,
-                                   float radiance_x,
-                                   float radiance_y,
-                                   float radiance_z,
-                                   float *config_x,
-                                   float *config_y,
-                                   float *config_z)
+ccl_device float3 sky_radiance_hosek(KernelGlobals *kg,
+                                     float3 dir,
+                                     float sunphi,
+                                     float suntheta,
+                                     float radiance_x,
+                                     float radiance_y,
+                                     float radiance_z,
+                                     float *config_x,
+                                     float *config_y,
+                                     float *config_z)
 {
   /* convert vector to spherical coordinates */
   float2 spherical = direction_to_spherical(dir);
@@ -121,93 +121,206 @@ ccl_device float3 sky_radiance_new(KernelGlobals *kg,
   return xyz_to_rgb(kg, make_float3(x, y, z)) * (M_2PI_F / 683);
 }
 
+/* Nishita improved sky model */
+ccl_device float3 geographical_to_direction(float lat, float lon)
+{
+  return make_float3(cos(lat) * cos(lon), cos(lat) * sin(lon), sin(lat));
+}
+
+ccl_device float3 sky_radiance_nishita(KernelGlobals *kg,
+                                       float3 dir,
+                                       float *nishita_data,
+                                       uint texture_id)
+{
+  /* definitions */
+  float sun_elevation = nishita_data[6];
+  float sun_rotation = nishita_data[7];
+  float angular_diameter = nishita_data[8];
+  bool sun_disc = (angular_diameter > 0.0f);
+  float3 xyz;
+  /* convert dir to spherical coordinates */
+  float2 direction = direction_to_spherical(dir);
+
+  /* render above the horizon */
+  if (dir.z >= 0.0f) {
+    /* definitions */
+    float3 sun_dir = geographical_to_direction(sun_elevation, sun_rotation + M_PI_2_F);
+    float sun_dir_angle = acos(dot(dir, sun_dir));
+    float half_angular = angular_diameter / 2.0f;
+    float dir_elevation = M_PI_2_F - direction.x;
+
+    /* if ray inside sun disc render it, otherwise render sky */
+    if (sun_disc && sun_dir_angle < half_angular) {
+      /* get 3 pixels data */
+      float3 pixel_bottom = make_float3(nishita_data[0], nishita_data[1], nishita_data[2]);
+      float3 pixel_top = make_float3(nishita_data[3], nishita_data[4], nishita_data[5]);
+      float y;
+
+      /* sun interpolation */
+      if (sun_elevation - half_angular > 0.0f) {
+        if (sun_elevation + half_angular > 0.0f) {
+          y = ((dir_elevation - sun_elevation) / angular_diameter) + 0.5f;
+          xyz = interp(pixel_bottom, pixel_top, y);
+        }
+      }
+      else {
+        if (sun_elevation + half_angular > 0.0f) {
+          y = dir_elevation / (sun_elevation + half_angular);
+          xyz = interp(pixel_bottom, pixel_top, y);
+        }
+      }
+      /* limb darkening, coefficient is 0.6f */
+      float limb_darkening = (1.0f -
+                              0.6f * (1.0f - sqrtf(1.0f - sqr(sun_dir_angle / half_angular))));
+      xyz *= limb_darkening;
+    }
+    /* sky */
+    else {
+      /* sky interpolation */
+      float x = (direction.y + M_PI_F + sun_rotation) / M_2PI_F;
+      float y = dir_elevation / M_PI_2_F;
+      if (x > 1.0f) {
+        x -= 1.0f;
+      }
+      xyz = float4_to_float3(kernel_tex_image_interp(kg, texture_id, x, y));
+    }
+  }
+  /* ground */
+  else {
+    if (dir.z < -0.4f) {
+      xyz = make_float3(0.0f, 0.0f, 0.0f);
+    }
+    else {
+      /* black ground fade */
+      float fade = 1.0f + dir.z * 2.5f;
+      fade = sqr(fade) * fade;
+      /* interpolation */
+      float x = (direction.y + M_PI_F + sun_rotation) / M_2PI_F;
+      if (x > 1.0f) {
+        x -= 1.0f;
+      }
+      xyz = float4_to_float3(kernel_tex_image_interp(kg, texture_id, x, -0.5)) * fade;
+    }
+  }
+
+  /* convert to rgb and adjust strength */
+  return xyz_to_rgb(kg, xyz) * 120000.0f;
+}
+
 ccl_device void svm_node_tex_sky(
     KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int *offset)
 {
-  /* Define variables */
-  float sunphi, suntheta, radiance_x, radiance_y, radiance_z;
-  float config_x[9], config_y[9], config_z[9];
-
   /* Load data */
   uint dir_offset = node.y;
   uint out_offset = node.z;
   int sky_model = node.w;
 
-  float4 data = read_node_float(kg, offset);
-  sunphi = data.x;
-  suntheta = data.y;
-  radiance_x = data.z;
-  radiance_y = data.w;
-
-  data = read_node_float(kg, offset);
-  radiance_z = data.x;
-  config_x[0] = data.y;
-  config_x[1] = data.z;
-  config_x[2] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_x[3] = data.x;
-  config_x[4] = data.y;
-  config_x[5] = data.z;
-  config_x[6] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_x[7] = data.x;
-  config_x[8] = data.y;
-  config_y[0] = data.z;
-  config_y[1] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_y[2] = data.x;
-  config_y[3] = data.y;
-  config_y[4] = data.z;
-  config_y[5] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_y[6] = data.x;
-  config_y[7] = data.y;
-  config_y[8] = data.z;
-  config_z[0] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_z[1] = data.x;
-  config_z[2] = data.y;
-  config_z[3] = data.z;
-  config_z[4] = data.w;
-
-  data = read_node_float(kg, offset);
-  config_z[5] = data.x;
-  config_z[6] = data.y;
-  config_z[7] = data.z;
-  config_z[8] = data.w;
-
   float3 dir = stack_load_float3(stack, dir_offset);
   float3 f;
 
-  /* Compute Sky */
-  if (sky_model == 0) {
-    f = sky_radiance_old(kg,
-                         dir,
-                         sunphi,
-                         suntheta,
-                         radiance_x,
-                         radiance_y,
-                         radiance_z,
-                         config_x,
-                         config_y,
-                         config_z);
+  /* Preetham and Hosek share the same data */
+  if (sky_model == 0 || sky_model == 1) {
+    /* Define variables */
+    float sunphi, suntheta, radiance_x, radiance_y, radiance_z;
+    float config_x[9], config_y[9], config_z[9];
+
+    float4 data = read_node_float(kg, offset);
+    sunphi = data.x;
+    suntheta = data.y;
+    radiance_x = data.z;
+    radiance_y = data.w;
+
+    data = read_node_float(kg, offset);
+    radiance_z = data.x;
+    config_x[0] = data.y;
+    config_x[1] = data.z;
+    config_x[2] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_x[3] = data.x;
+    config_x[4] = data.y;
+    config_x[5] = data.z;
+    config_x[6] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_x[7] = data.x;
+    config_x[8] = data.y;
+    config_y[0] = data.z;
+    config_y[1] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_y[2] = data.x;
+    config_y[3] = data.y;
+    config_y[4] = data.z;
+    config_y[5] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_y[6] = data.x;
+    config_y[7] = data.y;
+    config_y[8] = data.z;
+    config_z[0] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_z[1] = data.x;
+    config_z[2] = data.y;
+    config_z[3] = data.z;
+    config_z[4] = data.w;
+
+    data = read_node_float(kg, offset);
+    config_z[5] = data.x;
+    config_z[6] = data.y;
+    config_z[7] = data.z;
+    config_z[8] = data.w;
+
+    /* Compute Sky */
+    if (sky_model == 0) {
+      f = sky_radiance_preetham(kg,
+                                dir,
+                                sunphi,
+                                suntheta,
+                                radiance_x,
+                                radiance_y,
+                                radiance_z,
+                                config_x,
+                                config_y,
+                                config_z);
+    }
+    else {
+      f = sky_radiance_hosek(kg,
+                             dir,
+                             sunphi,
+                             suntheta,
+                             radiance_x,
+                             radiance_y,
+                             radiance_z,
+                             config_x,
+                             config_y,
+                             config_z);
+    }
   }
+  /* Nishita */
   else {
-    f = sky_radiance_new(kg,
-                         dir,
-                         sunphi,
-                         suntheta,
-                         radiance_x,
-                         radiance_y,
-                         radiance_z,
-                         config_x,
-                         config_y,
-                         config_z);
+    /* Define variables */
+    float nishita_data[9];
+
+    float4 data = read_node_float(kg, offset);
+    nishita_data[0] = data.x;
+    nishita_data[1] = data.y;
+    nishita_data[2] = data.z;
+    nishita_data[3] = data.w;
+
+    data = read_node_float(kg, offset);
+    nishita_data[4] = data.x;
+    nishita_data[5] = data.y;
+    nishita_data[6] = data.z;
+    nishita_data[7] = data.w;
+
+    data = read_node_float(kg, offset);
+    nishita_data[8] = data.x;
+    uint texture_id = __float_as_uint(data.y);
+
+    /* Compute Sky */
+    f = sky_radiance_nishita(kg, dir, nishita_data, texture_id);
   }
 
   stack_store_float3(stack, out_offset, f);
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index e913d9e0489..f1ebb37e23e 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -414,7 +414,7 @@ typedef enum NodeWaveProfile {
   NODE_WAVE_PROFILE_TRI,
 } NodeWaveProfile;
 
-typedef enum NodeSkyType { NODE_SKY_OLD, NODE_SKY_NEW } NodeSkyType;
+typedef enum NodeSkyType { NODE_SKY_PREETHAM, NODE_SKY_HOSEK, NODE_SKY_NISHITA } NodeSkyType;
 
 typedef enum NodeGradientType {
   NODE_BLEND_LINEAR,