use std::rc::Rc;
use super::dfg_lut::dfg_lut;
use super::phong::{self, LightDesc};
use super::transmission;
use crate::nodes::node::{FnDef, Type};
use crate::nodes::tsl::*;
use crate::nodes::NodeRef;
pub(crate) const RECIPROCAL_PI: f64 = std::f64::consts::FRAC_1_PI;
pub fn geometry_roughness(has_normal: bool) -> NodeRef {
if !has_normal {
return float(0.0);
}
let d = max(
abs(dpdx(normal_view_geometry())),
abs(dpdy(normal_view_geometry())),
);
max(max(d.x(), d.y()), d.z())
}
pub fn get_roughness(roughness: NodeRef, has_normal: bool) -> NodeRef {
max(roughness, float(0.045))
.add(geometry_roughness(has_normal))
.min(float(1.0))
}
fn v_ggx_smith_correlated() -> Rc<FnDef> {
thread_local! { static CELL: crate::nodes::node::Lazy<Rc<FnDef>> = const { crate::nodes::node::Lazy::new() }; }
CELL.with(|c| {
c.get(|| {
shader_fn(
Some("V_GGX_SmithCorrelated"),
vec![
("alpha", Type::F32),
("dotNL", Type::F32),
("dotNV", Type::F32),
],
Type::F32,
|args| {
let (alpha, dot_nl, dot_nv) =
(args[0].clone(), args[1].clone(), args[2].clone());
let a2 = alpha.clone().mul(alpha);
let gv = dot_nl.clone().mul(
a2.clone()
.add(
float(1.0)
.sub(a2.clone())
.mul(dot_nv.clone().mul(dot_nv.clone())),
)
.sqrt(),
);
let gl = dot_nv.mul(
a2.clone()
.add(float(1.0).sub(a2).mul(dot_nl.clone().mul(dot_nl)))
.sqrt(),
);
float(0.5).div(max(gv.add(gl), float(0.000001)))
},
)
})
})
}
fn d_ggx() -> Rc<FnDef> {
thread_local! { static CELL: crate::nodes::node::Lazy<Rc<FnDef>> = const { crate::nodes::node::Lazy::new() }; }
CELL.with(|c| {
c.get(|| {
shader_fn(
Some("D_GGX"),
vec![("alpha", Type::F32), ("dotNH", Type::F32)],
Type::F32,
|args| {
let (alpha, dot_nh) = (args[0].clone(), args[1].clone());
let a2 = alpha.clone().mul(alpha);
let denom =
float(1.0).sub(dot_nh.clone().mul(dot_nh).mul(float(1.0).sub(a2.clone())));
a2.div(denom.clone().mul(denom)).mul(RECIPROCAL_PI)
},
)
})
})
}
pub fn brdf_ggx(light_direction: NodeRef, f0: NodeRef, f90: NodeRef) -> NodeRef {
brdf_ggx_on(light_direction, f0, f90, roughness(), normal_view(), None)
}
pub(crate) fn brdf_ggx_on(
light_direction: NodeRef,
f0: NodeRef,
f90: NodeRef,
roughness_value: NodeRef,
normal: NodeRef,
iridescence_fresnel: Option<NodeRef>,
) -> NodeRef {
let floored = max(roughness_value, float(0.045));
let alpha = floored.clone().mul(floored);
let half_dir = light_direction
.clone()
.add(position_view_direction())
.normalize();
let dot_nl = normal.clone().dot(light_direction).clamp(0.0, 1.0);
let dot_nv = normal
.clone()
.dot(position_view_direction())
.clamp(0.0, 1.0);
let dot_nh = normal.dot(half_dir.clone()).clamp(0.0, 1.0);
let dot_vh = position_view_direction().dot(half_dir).clamp(0.0, 1.0);
let f = phong::f_schlick(f0, f90, dot_vh);
let f = match iridescence_fresnel {
Some(fresnel) => mix(f, fresnel, iridescence()),
None => f,
};
let v = call(
&v_ggx_smith_correlated(),
vec![alpha.clone(), dot_nl, dot_nv],
);
let d = call(&d_ggx(), vec![alpha, dot_nh]);
f.mul(v).mul(d)
}
fn d_charlie() -> Rc<FnDef> {
thread_local! { static CELL: crate::nodes::node::Lazy<Rc<FnDef>> = const { crate::nodes::node::Lazy::new() }; }
CELL.with(|c| {
c.get(|| {
shader_fn(
Some("D_Charlie"),
vec![("roughness", Type::F32), ("dotNH", Type::F32)],
Type::F32,
|args| {
let (roughness_value, dot_nh) = (args[0].clone(), args[1].clone());
let alpha = roughness_value.clone().mul(roughness_value);
let inv_alpha = float(1.0).div(alpha);
let cos2h = dot_nh.clone().mul(dot_nh);
let sin2h = max(cos2h.one_minus(), float(0.0078125));
float(2.0)
.add(inv_alpha.clone())
.mul(sin2h.pow(inv_alpha.mul(0.5)))
.div(2.0 * std::f64::consts::PI)
},
)
})
})
}
fn v_neubelt() -> Rc<FnDef> {
thread_local! { static CELL: crate::nodes::node::Lazy<Rc<FnDef>> = const { crate::nodes::node::Lazy::new() }; }
CELL.with(|c| {
c.get(|| {
shader_fn(
Some("V_Neubelt"),
vec![("dotNV", Type::F32), ("dotNL", Type::F32)],
Type::F32,
|args| {
let (dot_nv, dot_nl) = (args[0].clone(), args[1].clone());
float(1.0)
.div(
float(4.0)
.mul(dot_nl.clone().add(dot_nv.clone()).sub(dot_nl.mul(dot_nv))),
)
.saturate()
},
)
})
})
}
pub fn brdf_sheen(light_direction: NodeRef) -> NodeRef {
let half_dir = light_direction
.clone()
.add(position_view_direction())
.normalize();
let dot_nl = normal_view().dot(light_direction).saturate();
let dot_nv = normal_view().dot(position_view_direction()).saturate();
let dot_nh = normal_view().dot(half_dir).saturate();
let d = call(&d_charlie(), vec![sheen_roughness(), dot_nh]);
let v = call(&v_neubelt(), vec![dot_nv, dot_nl]);
sheen().mul(d).mul(v)
}
fn ibl_sheen_brdf(normal: NodeRef, view_dir: NodeRef, roughness_value: NodeRef) -> NodeRef {
let dot_nv = normal.dot(view_dir).saturate();
let r2 = roughness_value.clone().mul(roughness_value.clone());
let r_inv = roughness_value.clone().add(0.1).reciprocal();
let a = float(-1.9362)
.add(roughness_value.clone().mul(1.0678))
.add(r2.clone().mul(0.4573))
.sub(r_inv.clone().mul(0.8469));
let b = float(-0.6014)
.add(roughness_value.mul(0.5538))
.sub(r2.mul(0.4670))
.sub(r_inv.mul(0.1255));
exp(a.mul(dot_nv).add(b)).saturate()
}
fn sheen_albedo() -> NodeRef {
ibl_sheen_brdf(normal_view(), position_view_direction(), sheen_roughness())
}
fn sheen_energy_comp(albedo: NodeRef) -> NodeRef {
sheen()
.x()
.max(sheen().y())
.max(sheen().z())
.mul(albedo)
.one_minus()
}
const EON_EPSILON: f64 = 1e-7;
const FON_A_COEFFICIENT: f64 = 0.5 - 2.0 / (3.0 * std::f64::consts::PI);
const FON_AVERAGE_ALBEDO_COEFFICIENT: f64 = 2.0 / 3.0 - 28.0 / (15.0 * std::f64::consts::PI);
fn fon_directional_albedo(mu: NodeRef, roughness_value: NodeRef, a: NodeRef) -> NodeRef {
let mu_comp = mu.one_minus();
let g_over_pi = mu_comp.clone().mul(
mu_comp
.clone()
.mul(
mu_comp
.clone()
.mul(mu_comp.mul(0.0714429953).sub(0.332181442))
.add(0.491881867),
)
.add(0.0571085289),
);
a.mul(roughness_value.mul(g_over_pi).add(1.0))
}
fn fon_a(roughness_value: NodeRef) -> NodeRef {
roughness_value.mul(FON_A_COEFFICIENT).add(1.0).reciprocal()
}
fn eon_multi_scatter(rho: NodeRef, roughness_value: NodeRef, a: NodeRef) -> (NodeRef, NodeRef) {
let average_albedo = a.mul(roughness_value.mul(FON_AVERAGE_ALBEDO_COEFFICIENT).add(1.0));
let rho_multi_scatter = rho
.clone()
.mul(rho.clone())
.mul(average_albedo.clone())
.div(
rho.mul(average_albedo.clone().one_minus())
.one_minus()
.max(EON_EPSILON),
);
(average_albedo, rho_multi_scatter)
}
pub fn eon_directional_albedo(
diffuse_color_value: NodeRef,
roughness_value: NodeRef,
dot_nv: NodeRef,
) -> NodeRef {
let rho = diffuse_color_value.clamp(0.0, 1.0);
let a = fon_a(roughness_value.clone());
let directional_albedo =
fon_directional_albedo(dot_nv.clamp(0.0, 1.0), roughness_value.clone(), a.clone());
let (_, rho_multi_scatter) = eon_multi_scatter(rho.clone(), roughness_value.clone(), a);
let eon_albedo = rho
.clone()
.mul(directional_albedo.clone())
.add(rho_multi_scatter.mul(directional_albedo.one_minus()));
roughness_value
.less_than_equal(EON_EPSILON)
.select(rho, eon_albedo)
}
pub fn brdf_eon(
light_direction: NodeRef,
diffuse_color_value: NodeRef,
roughness_value: NodeRef,
) -> NodeRef {
let rho = diffuse_color_value.clamp(0.0, 1.0);
let dot_nl = normal_view().dot(light_direction.clone()).clamp(0.0, 1.0);
let dot_nv = normal_view().dot(position_view_direction()).clamp(0.0, 1.0);
let s = light_direction
.dot(position_view_direction())
.sub(dot_nl.clone().mul(dot_nv.clone()));
let s_over_t = s.greater_than(0.0).select(
s.clone()
.div(dot_nl.clone().max(dot_nv.clone()).max(EON_EPSILON)),
s,
);
let a = fon_a(roughness_value.clone());
let single_scatter = rho
.clone()
.mul(RECIPROCAL_PI)
.mul(a.clone())
.mul(roughness_value.clone().mul(s_over_t).add(1.0));
let albedo_v = fon_directional_albedo(dot_nv, roughness_value.clone(), a.clone());
let albedo_l = fon_directional_albedo(dot_nl, roughness_value.clone(), a.clone());
let (average_albedo, rho_multi_scatter) =
eon_multi_scatter(rho.clone(), roughness_value.clone(), a);
let multi_scatter = rho_multi_scatter
.mul(RECIPROCAL_PI)
.mul(albedo_v.one_minus().max(EON_EPSILON))
.mul(albedo_l.one_minus().max(EON_EPSILON))
.div(average_albedo.one_minus().max(EON_EPSILON));
let eon = single_scatter.add(multi_scatter);
roughness_value
.less_than_equal(EON_EPSILON)
.select(rho.mul(RECIPROCAL_PI), eon)
}
fn eon_diffuse_albedo() -> NodeRef {
eon_directional_albedo(
diffuse_color().rgb(),
diffuse_roughness(),
normal_view().dot(position_view_direction()).clamp(0.0, 1.0),
)
.mul(metalness().one_minus())
}
fn dfg_sample(roughness_value: NodeRef, dot_nv: NodeRef) -> NodeRef {
let lut = dfg_lut();
texture_uv(&lut, join(Type::Vec2, vec![roughness_value, dot_nv])).xy()
}
pub struct Physical {
pub dfg: NodeRef,
pub multi_scattering_compensation: NodeRef,
pub sheen: bool,
pub clearcoat: bool,
pub diffuse_roughness: bool,
pub iridescence_fresnel: Option<NodeRef>,
pub iridescence_f0_dielectric: Option<NodeRef>,
pub iridescence_f0_metallic: Option<NodeRef>,
pub backdrop: Option<NodeRef>,
}
impl Physical {
pub fn start(
sheen: bool,
clearcoat: bool,
diffuse_roughness: bool,
iridescence: bool,
opaque_frame: Option<&transmission::OpaqueFrame>,
out: &mut Vec<NodeRef>,
) -> Self {
if sheen {
out.push(sheen_specular_direct().assign(vec3(0.0, 0.0, 0.0)));
out.push(sheen_specular_indirect().assign(vec3(0.0, 0.0, 0.0)));
}
let (iridescence_fresnel, iridescence_f0_dielectric, iridescence_f0_metallic) =
if iridescence {
let (fresnel, f0_dielectric, f0_metallic) = iridescence_terms();
(Some(fresnel), Some(f0_dielectric), Some(f0_metallic))
} else {
(None, None, None)
};
let backdrop = opaque_frame.map(|frame| {
let v = transmission::world_view_vector();
let backdrop = to_var(
None,
transmission::ibl_volume_refraction(
&frame.texture,
normal_world(),
v,
position_world(),
Self::environment_brdf,
),
);
out.push(diffuse_color().w().assign(diffuse_color().w().mul(mix(
float(1.0),
backdrop.clone().w(),
transmission(),
))));
backdrop
});
let dot_nv = normal_view().dot(position_view_direction()).clamp(0.0, 1.0);
let dfg = dfg_sample(roughness(), dot_nv);
let ess = dfg.x().add(dfg.y());
let multi_scattering_compensation = specular_color_blended()
.mul(ess.reciprocal().sub(1.0))
.add(1.0);
if clearcoat {
out.push(clearcoat_radiance());
out.push(clearcoat_specular_direct());
out.push(clearcoat_specular_indirect());
}
Self {
dfg,
multi_scattering_compensation,
sheen,
clearcoat,
diffuse_roughness,
iridescence_fresnel,
iridescence_f0_dielectric,
iridescence_f0_metallic,
backdrop,
}
}
pub fn total_diffuse(&self, direct_plus_indirect: NodeRef) -> NodeRef {
match &self.backdrop {
Some(backdrop) => mix(
vec4_join(vec![direct_plus_indirect, float(1.0)]),
backdrop.clone(),
transmission(),
)
.xyz(),
None => direct_plus_indirect,
}
}
pub fn finish(&self, out: &mut Vec<NodeRef>) {
if self.sheen {
out.push(
outgoing_light().assign(
outgoing_light()
.add(sheen_specular_direct())
.add(sheen_specular_indirect()),
),
);
}
if self.clearcoat {
let dot_nvcc = clearcoat_normal_view()
.dot(position_view_direction())
.clamp(0.0, 1.0);
let fcc = phong::f_schlick(vec3(0.04, 0.04, 0.04), float(1.0), dot_nvcc);
let value = outgoing_light().mul(clearcoat().mul(fcc).one_minus()).add(
clearcoat_specular_direct()
.add(clearcoat_specular_indirect())
.mul(clearcoat()),
);
out.push(outgoing_light().assign(value));
}
}
pub(crate) fn environment_brdf(
dot_nv: NodeRef,
specular_color_value: NodeRef,
specular_f90_value: NodeRef,
roughness_value: NodeRef,
) -> NodeRef {
let fab = dfg_sample(roughness_value, dot_nv);
specular_color_value
.mul(fab.x())
.add(specular_f90_value.mul(fab.y()))
}
fn compute_multiscattering(
&self,
single_scatter: NodeRef,
multi_scatter: NodeRef,
f0: NodeRef,
iridescence_f0: Option<NodeRef>,
out: &mut Vec<NodeRef>,
) {
let fab = self.dfg.clone();
let f0 = match iridescence_f0 {
Some(iridescence_f0) => mix(f0, iridescence_f0, iridescence()),
None => f0,
};
let fss_ess = f0.clone().mul(fab.x()).add(specular_f90().mul(fab.y()));
let ess = fab.x().add(fab.y());
let ems = ess.one_minus();
let favg = f0.clone().add(f0.one_minus().mul(0.047619));
let fms = fss_ess
.clone()
.mul(favg.clone())
.div(ems.clone().mul(favg).one_minus());
out.push(single_scatter.clone().assign(single_scatter.add(fss_ess)));
out.push(
multi_scatter
.clone()
.assign(multi_scatter.add(fms.mul(ems))),
);
}
pub fn direct(&self, light_direction: NodeRef, light_color: NodeRef, out: &mut Vec<NodeRef>) {
let dot_nl = normal_view().dot(light_direction.clone()).clamp(0.0, 1.0);
let irradiance = if self.sheen || self.clearcoat {
to_var(None, dot_nl.mul(light_color.clone()))
} else {
dot_nl.mul(light_color.clone())
};
if self.sheen {
out.push(
sheen_specular_direct().assign(
sheen_specular_direct()
.add(irradiance.clone().mul(brdf_sheen(light_direction.clone()))),
),
);
let albedo_v = sheen_albedo();
let albedo_l =
ibl_sheen_brdf(normal_view(), light_direction.clone(), sheen_roughness());
out.push(
irradiance.clone().assign(
irradiance
.clone()
.mul(sheen_energy_comp(albedo_v.max(albedo_l))),
),
);
}
if self.clearcoat {
let dot_nlcc = clearcoat_normal_view()
.dot(light_direction.clone())
.clamp(0.0, 1.0);
let cc_irradiance = dot_nlcc.mul(light_color);
out.push(
clearcoat_specular_direct().assign(clearcoat_specular_direct().add(
cc_irradiance.mul(brdf_ggx_on(
light_direction.clone(),
vec3(0.04, 0.04, 0.04),
float(1.0),
clearcoat_roughness(),
clearcoat_normal_view(),
None,
)),
)),
);
}
let half_dir = light_direction
.clone()
.add(position_view_direction())
.normalize();
let dot_vh = position_view_direction().dot(half_dir).clamp(0.0, 1.0);
let f = phong::f_schlick(specular_color(), specular_f90(), dot_vh);
let diffuse_brdf = if self.diffuse_roughness {
brdf_eon(
light_direction.clone(),
diffuse_color().rgb(),
diffuse_roughness(),
)
.mul(metalness().one_minus())
} else {
brdf_lambert(diffuse_contribution())
};
let specular_brdf = brdf_ggx_on(
light_direction,
specular_color_blended(),
float(1.0),
roughness(),
normal_view(),
self.iridescence_fresnel.clone(),
);
out.push(
direct_diffuse().assign(
direct_diffuse().add(irradiance.clone().mul(diffuse_brdf).mul(f.one_minus())),
),
);
out.push(
direct_specular().assign(
direct_specular().add(
irradiance
.mul(specular_brdf)
.mul(self.multi_scattering_compensation.clone()),
),
),
);
}
pub fn indirect_diffuse(&self, out: &mut Vec<NodeRef>) {
out.push(single_scattering().assign(vec3(0.0, 0.0, 0.0)));
out.push(multi_scattering().assign(vec3(0.0, 0.0, 0.0)));
self.compute_multiscattering(
single_scattering(),
multi_scattering(),
specular_color(),
self.iridescence_f0_dielectric.clone(),
out,
);
let diffuse_brdf = if self.diffuse_roughness {
eon_diffuse_albedo().mul(RECIPROCAL_PI)
} else {
brdf_lambert(diffuse_contribution())
};
let diffuse = irradiance()
.mul(diffuse_brdf)
.mul(single_scattering().add(multi_scattering()).one_minus());
let diffuse = if self.sheen {
let diffuse = to_var(None, diffuse);
let albedo = sheen_albedo();
out.push(
sheen_specular_indirect().assign(
sheen_specular_indirect().add(
irradiance()
.mul(sheen())
.mul(albedo.clone())
.mul(RECIPROCAL_PI),
),
),
);
out.push(
diffuse
.clone()
.assign(diffuse.clone().mul(sheen_energy_comp(albedo))),
);
diffuse
} else {
diffuse
};
out.push(indirect_diffuse().assign(indirect_diffuse().add(diffuse)));
}
pub fn indirect_specular(
&self,
has_environment: bool,
environment_specular: bool,
out: &mut Vec<NodeRef>,
) {
if self.sheen {
out.push(
sheen_specular_indirect().assign(
sheen_specular_indirect().add(
ibl_irradiance()
.mul(sheen())
.mul(sheen_albedo())
.mul(RECIPROCAL_PI),
),
),
);
}
if self.clearcoat && !environment_specular {
out.push(clearcoat_radiance().assign(vec3(0.0, 0.0, 0.0)));
}
if self.clearcoat {
let dot_nvcc = clearcoat_normal_view()
.dot(position_view_direction())
.clamp(0.0, 1.0);
let clearcoat_env = Self::environment_brdf(
dot_nvcc,
vec3(0.04, 0.04, 0.04),
float(1.0),
clearcoat_roughness(),
);
out.push(clearcoat_specular_indirect().assign(
clearcoat_specular_indirect().add(clearcoat_radiance().mul(clearcoat_env)),
));
}
out.push(single_scattering_dielectric().assign(vec3(0.0, 0.0, 0.0)));
out.push(multi_scattering_dielectric().assign(vec3(0.0, 0.0, 0.0)));
out.push(single_scattering_metallic().assign(vec3(0.0, 0.0, 0.0)));
out.push(multi_scattering_metallic().assign(vec3(0.0, 0.0, 0.0)));
self.compute_multiscattering(
single_scattering_dielectric(),
multi_scattering_dielectric(),
specular_color(),
self.iridescence_f0_dielectric.clone(),
out,
);
self.compute_multiscattering(
single_scattering_metallic(),
multi_scattering_metallic(),
diffuse_color().rgb(),
self.iridescence_f0_metallic.clone(),
out,
);
if !has_environment {
if environment_specular {
out.push(radiance());
}
out.push(ibl_irradiance());
}
let single_scattering_mixed = mix(
single_scattering_dielectric(),
single_scattering_metallic(),
metalness(),
);
let multi_scattering_mixed = mix(
multi_scattering_dielectric(),
multi_scattering_metallic(),
metalness(),
);
let cosine_weighted_irradiance = ibl_irradiance().mul(RECIPROCAL_PI);
let radiance = if environment_specular {
radiance()
} else {
vec3(0.0, 0.0, 0.0)
};
let indirect_specular_value = radiance
.mul(single_scattering_mixed)
.add(multi_scattering_mixed.mul(cosine_weighted_irradiance.clone()));
let total_scattering_dielectric =
single_scattering_dielectric().add(multi_scattering_dielectric());
let diffuse_albedo = if self.diffuse_roughness {
eon_diffuse_albedo()
} else {
diffuse_contribution()
};
let diffuse = diffuse_albedo.mul(total_scattering_dielectric.one_minus());
let indirect_diffuse_value = diffuse.mul(cosine_weighted_irradiance);
let (indirect_specular_value, indirect_diffuse_value) = if self.sheen {
let specular = to_var(None, indirect_specular_value);
let diffuse = to_var(None, indirect_diffuse_value);
let comp = sheen_energy_comp(sheen_albedo());
out.push(specular.clone().assign(specular.clone().mul(comp.clone())));
out.push(diffuse.clone().assign(diffuse.clone().mul(comp)));
(specular, diffuse)
} else {
(indirect_specular_value, indirect_diffuse_value)
};
out.push(indirect_specular().assign(indirect_specular().add(indirect_specular_value)));
out.push(indirect_diffuse().assign(indirect_diffuse().add(indirect_diffuse_value)));
}
pub fn ambient_occlusion(&self, has_ao_node: bool, out: &mut Vec<NodeRef>) {
if !has_ao_node {
out.push(ambient_occlusion().assign(float(1.0)));
}
if self.sheen {
out.push(
sheen_specular_indirect()
.assign(sheen_specular_indirect().mul(ambient_occlusion())),
);
}
if self.clearcoat {
out.push(
clearcoat_specular_indirect()
.assign(clearcoat_specular_indirect().mul(ambient_occlusion())),
);
}
out.push(indirect_diffuse().assign(indirect_diffuse().mul(ambient_occlusion())));
let dot_nv = normal_view().dot(position_view_direction()).clamp(0.0, 1.0);
let ao_nv = dot_nv.add(ambient_occlusion());
let ao_exp = roughness().mul(-16.0).one_minus().negate().exp2();
let ao_node = ambient_occlusion()
.sub(ao_nv.pow(ao_exp).one_minus())
.clamp(0.0, 1.0);
out.push(indirect_specular().assign(indirect_specular().mul(ao_node)));
}
}
pub fn brdf_lambert(diffuse: NodeRef) -> NodeRef {
diffuse.mul(RECIPROCAL_PI)
}
pub(crate) fn direct_light(
model: &Physical,
light: &LightDesc,
received_shadow_position: Option<&NodeRef>,
out: &mut Vec<NodeRef>,
) {
if let Some((light_direction, light_color)) =
phong::setup_light(light, received_shadow_position, out)
{
model.direct(light_direction, light_color, out);
}
}
#[inline(never)]
fn iridescence_terms() -> (NodeRef, NodeRef, NodeRef) {
let dot_nvi = normal_view().dot(position_view_direction()).clamp(0.0, 1.0);
let eval = |base_f0: NodeRef| {
call(
&eval_iridescence(),
vec![
float(1.0),
iridescence_ior(),
dot_nvi.clone(),
iridescence_thickness(),
base_f0,
],
)
};
let dielectric = eval(specular_color());
let metallic = eval(diffuse_color().rgb());
let fresnel = mix(dielectric.clone(), metallic.clone(), metalness());
let f0_dielectric = schlick_to_f0(dielectric, float(1.0), dot_nvi.clone());
let f0_metallic = schlick_to_f0(metallic, float(1.0), dot_nvi);
(fresnel, f0_dielectric, f0_metallic)
}
fn xyz_to_rec709() -> NodeRef {
join(
Type::Mat3,
vec![
float(3.2404542),
float(-0.9692660),
float(0.0556434),
float(-1.5371385),
float(1.8760108),
float(-0.2040259),
float(-0.4985314),
float(0.0415560),
float(1.0572252),
],
)
}
fn fresnel0_to_ior(fresnel0: NodeRef) -> NodeRef {
let sqrt_f0 = sqrt(fresnel0);
vec3(1.0, 1.0, 1.0)
.add(sqrt_f0.clone())
.div(vec3(1.0, 1.0, 1.0).sub(sqrt_f0))
}
fn ior_to_fresnel0(transmitted_ior: NodeRef, incident_ior: NodeRef) -> NodeRef {
let r = transmitted_ior
.clone()
.sub(incident_ior.clone())
.div(transmitted_ior.add(incident_ior));
r.clone().mul(r)
}
#[inline(never)]
fn eval_sensitivity(opd: NodeRef, shift: NodeRef) -> NodeRef {
use std::f64::consts::PI;
let phase = opd.mul(2.0 * PI * 1.0e-9);
let val = vec3(5.4856e-13, 4.4201e-13, 5.2481e-13);
let pos = vec3(1.6810e+06, 1.7953e+06, 2.2084e+06);
let var = vec3(4.3278e+09, 9.3046e+09, 6.6121e+09);
let x = float(9.7470e-14 * (2.0 * PI * 4.5282e+09).sqrt())
.mul(phase.clone().mul(2.2399e+06).add(shift.x()).cos())
.mul(exp(phase.clone().mul(phase.clone()).mul(-4.5282e+09)));
let xyz = val
.mul(sqrt(var.clone().mul(2.0 * PI)))
.mul(pos.mul(phase.clone()).add(shift).cos())
.mul(exp(phase.clone().mul(phase).negate().mul(var)));
let xyz = join(
Type::Vec3,
vec![xyz.clone().x().add(x), xyz.clone().y(), xyz.z()],
)
.div(1.0685e-7);
xyz_to_rec709().mul(xyz)
}
fn eval_iridescence() -> Rc<FnDef> {
thread_local! { static CELL: crate::nodes::node::Lazy<Rc<FnDef>> = const { crate::nodes::node::Lazy::new() }; }
CELL.with(|c| {
c.get(|| {
shader_fn(
Some("evalIridescence"),
vec![
("outsideIOR", Type::F32),
("eta2", Type::F32),
("cosTheta1", Type::F32),
("thinFilmThickness", Type::F32),
("baseF0", Type::Vec3),
],
Type::Vec3,
eval_iridescence_body,
)
})
})
}
#[inline(never)]
fn eval_iridescence_body(args: &[NodeRef]) -> NodeRef {
use std::f64::consts::PI;
let (outside_ior, eta2, cos_theta1, thin_film_thickness, base_f0) = (
args[0].clone(),
args[1].clone(),
args[2].clone(),
args[3].clone(),
args[4].clone(),
);
let iridescence_ior_value = mix(
outside_ior.clone(),
eta2,
smoothstep(0.0, 0.03, thin_film_thickness.clone()),
);
let eta = outside_ior.clone().div(iridescence_ior_value.clone());
let sin_theta2_sq = eta
.clone()
.mul(eta)
.mul(cos_theta1.clone().mul(cos_theta1.clone()).one_minus());
let cos_theta2_sq = sin_theta2_sq.one_minus();
let tir = if_then(
cos_theta2_sq.clone().less_than(float(0.0)),
vec![return_statement(vec3(1.0, 1.0, 1.0))],
);
let cos_theta2 = sqrt(cos_theta2_sq);
let r0 = ior_to_fresnel0(iridescence_ior_value.clone(), outside_ior.clone());
let r12 = phong::f_schlick(r0, float(1.0), cos_theta1);
let t121 = r12.clone().one_minus();
let phi12 = iridescence_ior_value
.clone()
.less_than(outside_ior)
.select(float(PI), float(0.0));
let phi21 = float(PI).sub(phi12);
let base_ior = fresnel0_to_ior(base_f0.clamp(0.0, 0.9999));
let r1 = ior_to_fresnel0(
base_ior.clone(),
iridescence_ior_value.clone().to(Type::Vec3),
);
let r23 = phong::f_schlick(r1, float(1.0), cos_theta2.clone());
let pi_or_zero = |c: NodeRef| {
c.less_than(iridescence_ior_value.clone())
.select(float(PI), float(0.0))
};
let phi23 = join(
Type::Vec3,
vec![
pi_or_zero(base_ior.clone().x()),
pi_or_zero(base_ior.clone().y()),
pi_or_zero(base_ior.z()),
],
);
let opd = iridescence_ior_value
.mul(thin_film_thickness)
.mul(cos_theta2)
.mul(2.0);
let phi = phi21.to(Type::Vec3).add(phi23);
let r123 = r12.clone().mul(r23.clone()).clamp(1e-5, 0.9999);
let r123_sqrt = sqrt(r123.clone());
let rs = t121
.clone()
.mul(t121.clone())
.mul(r23)
.div(vec3(1.0, 1.0, 1.0).sub(r123));
let i = to_var(None, r12.add(rs.clone()));
let cm = to_var(None, rs.sub(t121));
let body = {
let (i, cm) = (i.clone(), cm.clone());
loop_options("m", Type::I32, int(1), int(2), "<=", move |m| {
let m = m.to(Type::F32);
let sm = eval_sensitivity(m.clone().mul(opd), m.mul(phi)).mul(2.0);
vec![
cm.clone().assign(cm.clone().mul(r123_sqrt)),
i.clone().assign(i.clone().add(cm.mul(sm))),
]
})
};
let declarations = vec![i.clone(), cm.clone()];
let mut statements = vec![tir];
statements.extend(declarations);
statements.push(body);
block(statements, max(i, vec3(0.0, 0.0, 0.0)))
}