use std::f64::consts::PI;
use std::rc::Rc;
use super::{
block, call, cross, dot, equirect_uv, float, if_then, log, max, mix, pi, reflect, shader_fn,
sqrt, struct_new, struct_type, to_var, vec3, vec3_join, StructLayout, StructMember,
};
use crate::nodes::node::{FnDef, Lazy, NodeRef, Type};
pub const ENV_RAY_LENGTH: f64 = 1e4;
pub const ENV_RAY_LENGTH_THRESHOLD: f64 = 1e3;
#[inline(never)]
fn sample_ggx_vndf(v: NodeRef, ax: NodeRef, ay: NodeRef, r1: NodeRef, r2: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
Some("SampleGGXVNDF"),
vec![
("V", Type::Vec3),
("ax", Type::F32),
("ay", Type::F32),
("r1", Type::F32),
("r2", Type::F32),
],
Type::Vec3,
sample_ggx_vndf_body,
)
})
});
call(&def, vec![v, ax, ay, r1, r2])
}
#[inline(never)]
fn sample_ggx_vndf_body(args: &[NodeRef]) -> NodeRef {
let (v, ax, ay, r1, r2) = (
args[0].clone(),
args[1].clone(),
args[2].clone(),
args[3].clone(),
args[4].clone(),
);
let wi_std = to_var(
None,
vec3_join(vec![ax.mul(v.x()), ay.mul(v.y()), v.z()]).normalize(),
);
let a = to_var(None, ax.min(ay.clone()));
let s = to_var(None, float(1.0).add(v.xy().length()));
let a2 = to_var(None, a.mul(a.clone()));
let s2 = to_var(None, s.mul(s.clone()));
let k = to_var(
None,
a2.one_minus()
.mul(s2.clone())
.div(s2.add(a2.mul(v.z()).mul(v.z()))),
);
let b = to_var(None, wi_std.z().mul(k.clone()));
let phi = to_var(None, float(std::f64::consts::TAU).mul(r1));
let z = to_var(
None,
r2.one_minus().mul(float(1.0).add(b.clone())).sub(b.clone()),
);
let sin_theta = to_var(
None,
sqrt(max(float(0.0), float(1.0).sub(z.mul(z.clone())))),
);
let c = to_var(
None,
vec3_join(vec![
sin_theta.mul(phi.cos()),
sin_theta.mul(phi.sin()),
z.clone(),
]),
);
let wm_std = to_var(None, c.add(wi_std.clone()));
let ne = to_var(
None,
vec3_join(vec![
ax.mul(wm_std.x()),
ay.mul(wm_std.y()),
max(float(0.0), wm_std.z()),
])
.normalize(),
);
block(
vec![
wi_std,
a,
s,
a2,
s2,
k,
b,
phi,
z,
sin_theta,
c,
wm_std,
ne.clone(),
],
ne,
)
}
pub fn d_gtr(roughness: NodeRef, no_h: NodeRef, k: NodeRef) -> NodeRef {
let a2 = to_var(None, roughness.mul(roughness.clone()));
let no_h2 = to_var(None, no_h.mul(no_h.clone()));
let base = to_var(None, no_h2.mul(a2.sub(float(1.0))).add(float(1.0)));
let d = to_var(None, a2.div(pi().mul(base.pow(k))));
block(vec![a2, no_h2, base, d.clone()], d)
}
pub fn smith_g(n_dot_x: NodeRef, alpha: NodeRef) -> NodeRef {
let a2 = to_var(None, alpha.mul(alpha.clone()));
let n_dot_x2 = to_var(None, n_dot_x.mul(n_dot_x.clone()));
let g = float(2.0)
.mul(n_dot_x.clone())
.div(n_dot_x.add(sqrt(a2.add(a2.one_minus().mul(n_dot_x2.clone())))));
block(vec![a2, n_dot_x2], g)
}
pub fn geometry_term(no_l: NodeRef, no_v: NodeRef, alpha_g: NodeRef) -> NodeRef {
let g1v = to_var(None, smith_g(no_v, alpha_g.clone()));
let g1l = to_var(None, smith_g(no_l, alpha_g));
let g = to_var(None, g1v.mul(g1l.clone()));
block(vec![g1v, g1l, g.clone()], g)
}
#[inline(never)]
fn ggx_vndf_pdf(no_h: NodeRef, no_v: NodeRef, roughness: NodeRef) -> NodeRef {
let d = to_var(None, d_gtr(roughness.clone(), no_h, float(2.0)));
let a2 = to_var(None, roughness.mul(roughness.clone()));
let sin_v2 = to_var(
None,
max(float(0.0), float(1.0).sub(no_v.mul(no_v.clone()))),
);
let s = to_var(None, float(1.0).add(sqrt(sin_v2.clone())));
let s2 = to_var(None, s.mul(s.clone()));
let k = to_var(
None,
float(1.0)
.sub(a2.clone())
.mul(s2.clone())
.div(s2.add(a2.mul(no_v.clone()).mul(no_v.clone()))),
);
let t = to_var(
None,
sqrt(a2.mul(sin_v2.clone()).add(no_v.mul(no_v.clone()))),
);
let pdf = to_var(
None,
d.div(max(float(1e-6), float(2.0).mul(k.mul(no_v).add(t.clone())))),
);
block(vec![d, a2, sin_v2, s, s2, k, t, pdf.clone()], pdf)
}
pub fn f_schlick(f0: NodeRef, theta: NodeRef) -> NodeRef {
let one_minus = to_var(None, float(1.0).sub(theta));
let one_minus2 = to_var(None, one_minus.mul(one_minus.clone()));
let one_minus5 = to_var(
None,
one_minus2.mul(one_minus2.clone()).mul(one_minus.clone()),
);
let f = to_var(
None,
f0.add(vec3(1.0, 1.0, 1.0).sub(f0.clone()).mul(one_minus5.clone())),
);
block(vec![one_minus, one_minus2, one_minus5, f.clone()], f)
}
pub fn get_specular_dominant_factor(no_v: NodeRef, roughness: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
Some("getSpecularDominantFactor"),
vec![("NoV", Type::F32), ("roughness", Type::F32)],
Type::F32,
|args| {
let (no_v, roughness) = (args[0].clone(), args[1].clone());
let a =
float(0.298475).mul(log(float(39.4115).sub(float(39.0029).mul(roughness))));
let f = float(1.0)
.sub(no_v)
.pow(float(10.8649))
.mul(float(1.0).sub(a.clone()))
.add(a);
f.clamp(float(0.0), float(1.0))
},
)
})
});
call(&def, vec![no_v, roughness])
}
pub fn ggx_reflection_struct() -> Rc<StructLayout> {
thread_local! { static CELL: Lazy<Rc<StructLayout>> = const { Lazy::new() }; }
CELL.with(|cell| {
cell.get(|| {
struct_type(
"StructType0",
vec![
StructMember::new("reflectDir", Type::Vec3),
StructMember::new("sampleWeight", Type::Vec3),
StructMember::new("pdf", Type::F32),
StructMember::new("NdotV", Type::F32),
StructMember::new("alpha", Type::F32),
StructMember::new("f0", Type::Vec3),
],
)
})
})
}
#[inline(never)]
pub fn ggx_reflection_sample(
n: NodeRef,
v: NodeRef,
roughness: NodeRef,
metalness: NodeRef,
albedo: NodeRef,
xi: NodeRef,
) -> NodeRef {
let mut statements = Vec::new();
let a = to_var(None, roughness.mul(roughness.clone()).max(float(0.001)));
let ax = to_var(None, a.clone());
let ay = to_var(None, a.clone());
statements.extend([a, ax.clone(), ay.clone()]);
let up = vec3(0.0, 0.0, 1.0);
let t0 = to_var(None, cross(up, n.clone()));
let t = to_var(None, t0.normalize());
let fallback = if_then(
t.length().less_than(float(1e-3)),
vec![t.assign(cross(vec3(0.0, 1.0, 0.0), n.clone()).normalize())],
);
let b = to_var(None, cross(n.clone(), t.clone()).normalize());
statements.extend([t0, t.clone(), fallback, b.clone()]);
let v_local = to_var(
None,
vec3_join(vec![
dot(t.clone(), v.clone()),
dot(b.clone(), v.clone()),
dot(n.clone(), v.clone()),
]),
);
let h_local = to_var(
None,
sample_ggx_vndf(v_local.clone(), ax.clone(), ay, xi.x(), xi.y()),
);
let flip = if_then(
h_local.z().less_than(float(0.0)),
vec![h_local.assign(h_local.negate())],
);
statements.extend([v_local, h_local.clone(), flip]);
let h = to_var(
None,
t.mul(h_local.x())
.add(b.mul(h_local.y()))
.add(n.mul(h_local.z()))
.normalize(),
);
let view_reflect_dir = to_var(None, reflect(v.negate(), h.clone()).normalize());
let l = to_var(None, view_reflect_dir.clone());
let hh = to_var(None, v.add(l.clone()).normalize());
statements.extend([h, view_reflect_dir.clone(), l.clone(), hh.clone()]);
let n_dot_v = to_var(None, max(float(0.0), dot(n.clone(), v.clone())));
let n_dot_l = to_var(None, max(float(0.0), dot(n.clone(), l)));
let n_dot_h = to_var(None, max(float(0.0), dot(n, hh.clone())));
let v_dot_h = to_var(None, max(float(0.0), dot(v, hh)));
let f0 = to_var(None, mix(vec3(0.04, 0.04, 0.04), albedo, metalness));
let fresnel_weight = to_var(None, f_schlick(f0.clone(), v_dot_h.clone()));
let pdf = to_var(
None,
ggx_vndf_pdf(n_dot_h.clone(), n_dot_v.clone(), ax.clone()),
);
statements.extend([
n_dot_v.clone(),
n_dot_l.clone(),
n_dot_h,
v_dot_h,
f0.clone(),
fresnel_weight.clone(),
pdf.clone(),
]);
let a2 = to_var(None, ax.mul(ax.clone()));
let sin_v2 = to_var(
None,
n_dot_v.mul(n_dot_v.clone()).one_minus().max(float(0.0)),
);
let s_b = to_var(None, float(1.0).add(sqrt(sin_v2.clone())));
let s2_b = to_var(None, s_b.mul(s_b.clone()));
let k_b = to_var(
None,
a2.one_minus()
.mul(s2_b.clone())
.div(s2_b.add(a2.mul(n_dot_v.clone()).mul(n_dot_v.clone()))),
);
let t_b = to_var(
None,
sqrt(a2.mul(sin_v2.clone()).add(n_dot_v.mul(n_dot_v.clone()))),
);
let glossy_weight = to_var(
None,
fresnel_weight
.mul(geometry_term(n_dot_l, n_dot_v.clone(), ax.clone()))
.mul(k_b.mul(n_dot_v.clone()).add(t_b.clone()))
.div(float(2.0).mul(n_dot_v.clone()).max(float(1e-4))),
);
statements.extend([a2, sin_v2, s_b, s2_b, k_b, t_b, glossy_weight.clone()]);
block(
statements,
struct_new(
&ggx_reflection_struct(),
vec![view_reflect_dir, glossy_weight, pdf, n_dot_v, ax, f0],
),
)
}
pub fn equirect_uv_to_dir(uv: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
Some("equirectUvToDir"),
vec![("uv", Type::Vec2)],
Type::Vec3,
|args| {
let uv = args[0].clone();
let phi = uv.x().mul(PI * 2.0).sub(PI);
let lat = uv.y().sub(0.5).mul(PI);
let cos_lat = lat.cos();
vec3_join(vec![
cos_lat.mul(phi.cos()),
lat.sin(),
cos_lat.mul(phi.sin()),
])
.normalize()
},
)
})
});
call(&def, vec![uv])
}
pub fn equirect_dir_pdf(direction: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
Some("equirectDirPdf"),
vec![("direction", Type::Vec3)],
Type::F32,
|args| {
let uv_dir = equirect_uv(args[0].clone());
let sin_theta = uv_dir.y().mul(PI).sin();
sin_theta.abs().less_than(float(1e-6)).select(
float(0.0),
float(1.0).div(float(2.0 * PI * PI).mul(sin_theta)),
)
},
)
})
});
call(&def, vec![direction])
}
pub fn mis_power_heuristic(pdf_a: NodeRef, pdf_b: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
Some("misPowerHeuristic"),
vec![("pdfA", Type::F32), ("pdfB", Type::F32)],
Type::F32,
|args| {
let (pdf_a, pdf_b) = (args[0].clone(), args[1].clone());
let pdf_a_sq = pdf_a.mul(pdf_a.clone());
let pdf_b_sq = pdf_b.mul(pdf_b.clone());
pdf_a_sq.div(pdf_a_sq.add(pdf_b_sq))
},
)
})
});
call(&def, vec![pdf_a, pdf_b])
}