311 lines
12 KiB
C
311 lines
12 KiB
C
/* SPDX-FileCopyrightText: 2011-2024 Blender Foundation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 */
|
|
|
|
#pragma once
|
|
|
|
#include "util/math_fast.h"
|
|
#include "util/projection.h"
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
/* Given a random number, sample a direction that makes an angle of theta with direction D. */
|
|
ccl_device float3 phase_sample_direction(const float3 D, const float cos_theta, const float rand)
|
|
{
|
|
const float phi = M_2PI_F * rand;
|
|
const float3 dir = spherical_cos_to_direction(cos_theta, phi);
|
|
|
|
float3 T;
|
|
float3 B;
|
|
make_orthonormals(D, &T, &B);
|
|
return to_global(dir, T, B, D);
|
|
}
|
|
|
|
/* Given cosine between rays, return probability density that a photon bounces
|
|
* to that direction. The g parameter controls how different it is from the
|
|
* uniform sphere. g=0 uniform diffuse-like, g=1 close to sharp single ray. */
|
|
ccl_device float phase_henyey_greenstein(const float cos_theta, const float g)
|
|
{
|
|
if (fabsf(g) < 1e-3f) {
|
|
return M_1_4PI_F;
|
|
}
|
|
const float fac = 1 + g * (g - 2 * cos_theta);
|
|
return (1 - sqr(g)) / (M_4PI_F * fac * safe_sqrtf(fac));
|
|
}
|
|
|
|
ccl_device float3 phase_henyey_greenstein_sample(const float3 D,
|
|
const float g,
|
|
const float2 rand,
|
|
ccl_private float *pdf)
|
|
{
|
|
float cos_theta = 1 - 2 * rand.x;
|
|
if (fabsf(g) >= 1e-3f) {
|
|
const float k = (1 - sqr(g)) / (1 - g * cos_theta);
|
|
cos_theta = (1 + sqr(g) - sqr(k)) / (2 * g);
|
|
}
|
|
|
|
*pdf = phase_henyey_greenstein(cos_theta, g);
|
|
|
|
return phase_sample_direction(D, cos_theta, rand.y);
|
|
}
|
|
|
|
/* Given cosine between rays, return probability density that a photon bounces to that direction
|
|
* according to the constant Rayleigh phase function.
|
|
* See https://doi.org/10.1364/JOSAA.28.002436 for details. */
|
|
ccl_device float phase_rayleigh(const float cos_theta)
|
|
{
|
|
return (0.1875f * M_1_PI_F) * (1.0f + sqr(cos_theta));
|
|
}
|
|
|
|
ccl_device float3 phase_rayleigh_sample(const float3 D, const float2 rand, ccl_private float *pdf)
|
|
{
|
|
const float a = 2 - 4 * rand.x;
|
|
/* Metal doesn't have cbrtf, but since we compute u - 1/u anyways, we can just as well
|
|
* use the inverse cube root for which there is a simple Quake-style fast implementation.*/
|
|
const float inv_u = -fast_inv_cbrtf(sqrtf(1 + sqr(a)) + a);
|
|
const float cos_theta = 1 / inv_u - inv_u;
|
|
*pdf = phase_rayleigh(cos_theta);
|
|
|
|
return phase_sample_direction(D, cos_theta, rand.y);
|
|
}
|
|
|
|
/* Given cosine between rays, return probability density that a photon bounces to that direction
|
|
* according to the Draine phase function. This is a generalization of the Henyey-Greenstein
|
|
* function which bridges the cases of HG and Rayleigh scattering. The parameter g mainly controls
|
|
* the first moment <cos theta>, and alpha the second moment <cos2 theta> of the exact phase
|
|
* function. alpha=0 reduces to HG function, g=0, alpha=1 reduces to Rayleigh function, alpha=1
|
|
* reduces to Cornette-Shanks function.
|
|
* See https://doi.org/10.1086/379118 for details. */
|
|
ccl_device float phase_draine(const float cos_theta, const float g, float alpha)
|
|
{
|
|
/* Check special cases. */
|
|
if (fabsf(g) < 1e-3f && alpha > 0.999f) {
|
|
return phase_rayleigh(cos_theta);
|
|
}
|
|
if (fabsf(alpha) < 1e-3f) {
|
|
return phase_henyey_greenstein(cos_theta, g);
|
|
}
|
|
|
|
const float g2 = sqr(g);
|
|
const float fac = 1 + g2 - 2 * g * cos_theta;
|
|
return ((1 - g2) * (1 + alpha * sqr(cos_theta))) /
|
|
((1 + (alpha * (1 + 2 * g2)) * (1 / 3.0f)) * M_4PI_F * fac * sqrtf(fac));
|
|
}
|
|
|
|
/* Adapted from the HLSL code provided in https://research.nvidia.com/labs/rtr/approximate-mie/ */
|
|
ccl_device float phase_draine_sample_cos(const float g, const float alpha, const float rand)
|
|
{
|
|
if (fabsf(g) < 1e-2f) {
|
|
/* Special case to prevent division by zero.
|
|
* The sample technique is similar as in https://doi.org/10.1364/JOSAA.28.002436. */
|
|
const float inv_alpha = 1.0f / alpha;
|
|
const float b_2 = (3 + alpha) * inv_alpha * (0.5f - rand);
|
|
const float inv_u = -fast_inv_cbrtf(b_2 + sqrtf(sqr(b_2) + sqr(inv_alpha) * inv_alpha));
|
|
return 1 / inv_u - inv_u / alpha;
|
|
}
|
|
const float g2 = sqr(g);
|
|
const float g3 = g * g2;
|
|
const float g4 = sqr(g2);
|
|
const float g6 = g2 * g4;
|
|
const float pgp1_2 = sqr(1 + g2);
|
|
const float T1a = alpha * (g4 - 1);
|
|
const float T1a3 = sqr(T1a) * T1a;
|
|
const float T2 = -1296 * (g2 - 1) * (alpha - alpha * g2) * T1a * (4 * g2 + alpha * pgp1_2);
|
|
const float T9 = 2 + g2 + g3 * (1 + 2 * g2) * (2 * rand - 1);
|
|
const float T3 = 3 * g2 * (1 + g * (2 * rand - 1)) + alpha * T9;
|
|
const float T4a = 432 * T1a3 + T2 + 432 * (alpha * (1 - g2)) * sqr(T3);
|
|
const float T10 = alpha * (2 * g4 - g2 - g6);
|
|
const float T4b = 144 * T10;
|
|
const float T4b3 = sqr(T4b) * T4b;
|
|
const float T4 = T4a + sqrtf(-4 * T4b3 + sqr(T4a));
|
|
const float inv_T4p3 = fast_inv_cbrtf(T4);
|
|
const float T8 = 48 * M_CBRT2_F * T10;
|
|
const float T6 = (2 * T1a + T8 * inv_T4p3 + 1 / (3 * M_CBRT2_F * inv_T4p3)) / (alpha * (1 - g2));
|
|
const float T5 = 6 * (1 + g2) + T6;
|
|
const float T7 = 6 * (1 + g2) - (8 * T3) / (alpha * (g2 - 1) * sqrtf(T5)) - T6;
|
|
return (1 + g2 - 0.25f * sqr(sqrtf(T7) - sqrtf(T5))) / (2 * g);
|
|
}
|
|
|
|
ccl_device float3 phase_draine_sample(
|
|
const float3 D, const float g, float alpha, const float2 rand, ccl_private float *pdf)
|
|
{
|
|
/* Check special cases. */
|
|
if (fabsf(g) < 1e-3f && alpha > 0.999f) {
|
|
return phase_rayleigh_sample(D, rand, pdf);
|
|
}
|
|
if (fabsf(alpha) < 1e-3f) {
|
|
return phase_henyey_greenstein_sample(D, g, rand, pdf);
|
|
}
|
|
|
|
const float cos_theta = phase_draine_sample_cos(g, alpha, rand.x);
|
|
*pdf = phase_draine(cos_theta, g, alpha);
|
|
|
|
return phase_sample_direction(D, cos_theta, rand.y);
|
|
}
|
|
|
|
ccl_device float phase_fournier_forand_delta(const float n, const float sin_htheta_sqr)
|
|
{
|
|
const float u = 4 * sin_htheta_sqr;
|
|
return u / (3 * sqr(n - 1));
|
|
}
|
|
|
|
ccl_device_inline float3 phase_fournier_forand_coeffs(const float B, const float IOR)
|
|
{
|
|
const float d90 = phase_fournier_forand_delta(IOR, 0.5f);
|
|
const float d180 = phase_fournier_forand_delta(IOR, 1.0f);
|
|
const float v = -logf(2 * B * (d90 - 1) + 1) / logf(d90);
|
|
return make_float3(IOR, v, (powf(d180, -v) - 1) / (d180 - 1));
|
|
}
|
|
|
|
/* Given cosine between rays, return probability density that a photon bounces to that direction
|
|
* according to the Fournier-Forand phase function. The n parameter is the particle index of
|
|
* refraction and controls how much of the light is refracted. B is the particle backscatter
|
|
* fraction, B = b_b / b.
|
|
* See https://doi.org/10.1117/12.366488 for details. */
|
|
ccl_device_inline float phase_fournier_forand_impl(float cos_theta,
|
|
const float delta,
|
|
const float pow_delta_v,
|
|
const float v,
|
|
float sin_htheta_sqr,
|
|
const float pf_coeff)
|
|
{
|
|
const float m_delta = 1 - delta;
|
|
const float m_pow_delta_v = 1 - pow_delta_v;
|
|
|
|
float pf;
|
|
if (fabsf(m_delta) < 1e-3f) {
|
|
/* Special case (first-order Taylor expansion) to avoid singularity at delta near 1.0 */
|
|
pf = v * ((v - 1) - (v + 1) / sin_htheta_sqr) * (1 / (8 * M_PI_F));
|
|
pf += v * (v + 1) * m_delta * (2 * (v - 1) - (2 * v + 1) / sin_htheta_sqr) *
|
|
(1 / (24 * M_PI_F));
|
|
}
|
|
else {
|
|
pf = (v * m_delta - m_pow_delta_v + (delta * m_pow_delta_v - v * m_delta) / sin_htheta_sqr) /
|
|
(M_4PI_F * sqr(m_delta) * pow_delta_v);
|
|
}
|
|
pf += pf_coeff * (3 * sqr(cos_theta) - 1);
|
|
return pf;
|
|
}
|
|
|
|
ccl_device float phase_fournier_forand(const float cos_theta, const float3 coeffs)
|
|
{
|
|
if (fabsf(cos_theta) >= 1.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
const float n = coeffs.x;
|
|
const float v = coeffs.y;
|
|
const float pf_coeff = coeffs.z * (1.0f / (16.0f * M_PI_F));
|
|
const float sin_htheta_sqr = 0.5f * (1 - cos_theta); /* sin^2(theta / 2)*/
|
|
const float delta = phase_fournier_forand_delta(n, sin_htheta_sqr);
|
|
|
|
return phase_fournier_forand_impl(cos_theta, delta, powf(delta, v), v, sin_htheta_sqr, pf_coeff);
|
|
}
|
|
|
|
ccl_device float phase_fournier_forand_newton(const float rand, const float3 coeffs)
|
|
{
|
|
const float n = coeffs.x;
|
|
const float v = coeffs.y;
|
|
const float cdf_coeff = coeffs.z * (1.0f / 8.0f);
|
|
const float pf_coeff = coeffs.z * (1.0f / (16.0f * M_PI_F));
|
|
|
|
float cos_theta = 0.64278760968f; /* Initial guess: 50 degrees */
|
|
for (int it = 0; it < 20; it++) {
|
|
const float sin_htheta_sqr = 0.5f * (1 - cos_theta); /* sin^2(theta / 2)*/
|
|
const float delta = phase_fournier_forand_delta(n, sin_htheta_sqr);
|
|
const float pow_delta_v = powf(delta, v);
|
|
const float m_delta = 1 - delta;
|
|
const float m_pow_delta_v = 1 - pow_delta_v;
|
|
|
|
/* Evaluate CDF and phase functions */
|
|
float cdf;
|
|
if (fabsf(m_delta) < 1e-3f) {
|
|
/* Special case (first-order Taylor expansion) to avoid singularity at delta near 1.0 */
|
|
cdf = 1 + v * (1 - sin_htheta_sqr) * (1 - 0.5f * (v + 1) * m_delta);
|
|
}
|
|
else {
|
|
cdf = (1 - pow_delta_v * delta - m_pow_delta_v * sin_htheta_sqr) / (m_delta * pow_delta_v);
|
|
}
|
|
cdf += cdf_coeff * cos_theta * (1 - sqr(cos_theta));
|
|
const float pf = phase_fournier_forand_impl(
|
|
cos_theta, delta, pow_delta_v, v, sin_htheta_sqr, pf_coeff);
|
|
|
|
/* Perform Newton iteration step */
|
|
float new_cos_theta = cos_theta + M_1_2PI_F * (cdf - rand) / pf;
|
|
|
|
/* Don't step off past 1.0, approach the peak slowly */
|
|
if (new_cos_theta >= 1.0f) {
|
|
new_cos_theta = max(mix(cos_theta, 1.0f, 0.5f), 0.99f);
|
|
}
|
|
if (fabsf(cos_theta - new_cos_theta) < 1e-6f || new_cos_theta == 1.0f) {
|
|
return new_cos_theta;
|
|
}
|
|
cos_theta = new_cos_theta;
|
|
}
|
|
/* Reached iteration limit, so give up and use what we have. */
|
|
return cos_theta;
|
|
}
|
|
|
|
ccl_device float3 phase_fournier_forand_sample(const float3 D,
|
|
const float3 coeffs,
|
|
const float2 rand,
|
|
ccl_private float *pdf)
|
|
{
|
|
const float cos_theta = phase_fournier_forand_newton(rand.x, coeffs);
|
|
*pdf = phase_fournier_forand(cos_theta, coeffs);
|
|
|
|
return phase_sample_direction(D, cos_theta, rand.y);
|
|
}
|
|
|
|
/* We approximate the Mie phase function for water droplets with diameters 0 < d < 50 um using a
|
|
* mixture of Draine and Henyey-Greenstein, following
|
|
* "An Approximate Mie Scattering Function for Fog and Cloud Rendering (Supplemental)"
|
|
* https://research.nvidia.com/labs/rtr/approximate-mie/publications/approximate-mie-supplemental.pdf
|
|
* For d > 1, the phase function is strong forward-scattering. For d very close to 0, the phase
|
|
* function is a mixture of Henyey-Greenstein and Rayleigh.
|
|
*/
|
|
ccl_device void phase_mie_fitted_parameters(float d,
|
|
ccl_private float *g_HG,
|
|
ccl_private float *g_D,
|
|
ccl_private float *alpha,
|
|
ccl_private float *w)
|
|
{
|
|
d = fmaxf(d, 0.0f);
|
|
if (d <= 0.1f) {
|
|
/* Eq (11 - 14). */
|
|
*g_HG = 13.8f * sqr(d);
|
|
*g_D = 1.1456f * d * fast_sinf(9.29044f * d);
|
|
*alpha = 250.0f;
|
|
*w = 0.252977f - 312.983f * powf(d, 4.3f);
|
|
}
|
|
else if (d < 1.5f) {
|
|
/* Eq (15 - 18). */
|
|
const float log_d = fast_logf(d);
|
|
*g_HG = 0.862f - 0.143f * sqr(log_d);
|
|
const float a = (log_d - 0.238604f) * (log_d + 1.00667f);
|
|
const float b = 0.507522f - 0.15677f * log_d;
|
|
const float c = 1.19692f * fast_cosf(a / b) + 1.37932f * log_d + 0.0625835f;
|
|
*g_D = 0.379685f * fast_cosf(c) + 0.344213f;
|
|
*alpha = 250.0f;
|
|
*w = 0.146209f * fast_cosf(3.38707f * log_d + 2.11193f) + 0.316072f + 0.0778917f * log_d;
|
|
}
|
|
else if (d < 5.0f) {
|
|
/* Eq (19 - 22). */
|
|
const float log_d = fast_logf(d);
|
|
*g_HG = 0.0604931f * fast_logf(log_d) + 0.940256f;
|
|
*g_D = 0.500411f - (0.081287f / (-2.0f * log_d + fast_tanf(log_d) + 1.27551f));
|
|
*alpha = 7.30354f * log_d + 6.31675f;
|
|
const float temp = fast_cosf(5.68947f * (fast_logf(log_d) - 0.0292149f));
|
|
*w = 0.026914f * (log_d - temp) + 0.3764f;
|
|
}
|
|
else {
|
|
/* Eq (7 - 10). */
|
|
*g_HG = fast_expf(-0.0990567f / (d - 1.67154f));
|
|
*g_D = fast_expf(-2.20679f / (d + 3.91029f) - 0.428934f);
|
|
*alpha = fast_expf(3.62489f - 8.29288f / (d + 5.52825f));
|
|
*w = fast_expf(-0.599085f / (d - 0.641583f) - 0.665888f);
|
|
}
|
|
}
|
|
|
|
CCL_NAMESPACE_END
|