use crate::core::ObjectRef;
use crate::geometries::box_geometry;
use crate::materials::{MeshBasicNodeMaterial, Side};
use crate::nodes::node::SettableValue;
use crate::nodes::tsl::{
block, camera_position, dot, exp, float, floor, fract, if_then, loop_n, max, min_of, mix,
model_view_projection, position_world, smoothstep, time, to_const, to_var, to_var_intent,
uniform_settable, varying_property, vec2, vec3, vec3s, vec4_join,
};
use crate::nodes::{NodeRef, Type};
use crate::objects::Mesh;
use std::rc::Rc;
pub struct SkyMesh {
pub mesh: ObjectRef,
pub turbidity: SettableValue,
pub rayleigh: SettableValue,
pub mie_coefficient: SettableValue,
pub mie_directional_g: SettableValue,
pub sun_position: SettableValue,
pub cloud_scale: SettableValue,
pub cloud_speed: SettableValue,
pub cloud_coverage: SettableValue,
pub cloud_density: SettableValue,
pub cloud_elevation: SettableValue,
pub show_sun_disc: SettableValue,
}
struct Uniforms {
turbidity: NodeRef,
rayleigh: NodeRef,
mie_coefficient: NodeRef,
mie_directional_g: NodeRef,
sun_position: NodeRef,
cloud_scale: NodeRef,
cloud_speed: NodeRef,
cloud_coverage: NodeRef,
cloud_density: NodeRef,
cloud_elevation: NodeRef,
show_sun_disc: NodeRef,
}
struct Varyings {
sun_direction: NodeRef,
sun_e: NodeRef,
beta_r: NodeRef,
beta_m: NodeRef,
}
impl Varyings {
fn new() -> Self {
Self {
sun_direction: varying_property("vSunDirection", Type::Vec3, false),
sun_e: varying_property("vSunE", Type::F32, false),
beta_r: varying_property("vBetaR", Type::Vec3, false),
beta_m: varying_property("vBetaM", Type::Vec3, false),
}
}
}
impl SkyMesh {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
let (turbidity, turbidity_cell) = uniform_settable(Type::F32, vec![2.0]);
let (rayleigh, rayleigh_cell) = uniform_settable(Type::F32, vec![1.0]);
let (mie_coefficient, mie_coefficient_cell) = uniform_settable(Type::F32, vec![0.005]);
let (mie_directional_g, mie_directional_g_cell) = uniform_settable(Type::F32, vec![0.8]);
let (sun_position, sun_position_cell) = uniform_settable(Type::Vec3, vec![0.0, 0.0, 0.0]);
let (cloud_scale, cloud_scale_cell) = uniform_settable(Type::F32, vec![0.0002]);
let (cloud_speed, cloud_speed_cell) = uniform_settable(Type::F32, vec![0.00002]);
let (cloud_coverage, cloud_coverage_cell) = uniform_settable(Type::F32, vec![0.4]);
let (cloud_density, cloud_density_cell) = uniform_settable(Type::F32, vec![0.4]);
let (cloud_elevation, cloud_elevation_cell) = uniform_settable(Type::F32, vec![0.5]);
let (show_sun_disc, show_sun_disc_cell) = uniform_settable(Type::Bool, vec![1.0]);
let uniforms = Uniforms {
turbidity,
rayleigh,
mie_coefficient,
mie_directional_g,
sun_position,
cloud_scale,
cloud_speed,
cloud_coverage,
cloud_density,
cloud_elevation,
show_sun_disc,
};
let mesh = Mesh::new(
Rc::new(box_geometry(1.0, 1.0, 1.0, 1, 1, 1)),
Self::material(&uniforms),
);
Self {
mesh,
turbidity: turbidity_cell,
rayleigh: rayleigh_cell,
mie_coefficient: mie_coefficient_cell,
mie_directional_g: mie_directional_g_cell,
sun_position: sun_position_cell,
cloud_scale: cloud_scale_cell,
cloud_speed: cloud_speed_cell,
cloud_coverage: cloud_coverage_cell,
cloud_density: cloud_density_cell,
cloud_elevation: cloud_elevation_cell,
show_sun_disc: show_sun_disc_cell,
}
}
fn material(uniforms: &Uniforms) -> MeshBasicNodeMaterial {
let varyings = Varyings::new();
let mut material = MeshBasicNodeMaterial::new();
material.side = Side::Back;
material.depth_write = false;
material.fog = false;
material.vertex_node = Some(vertex_node(uniforms, &varyings));
material.color_node = Some(color_node(uniforms, &varyings));
material
}
}
fn vertex_node(u: &Uniforms, v: &Varyings) -> NodeRef {
let e = float(std::f64::consts::E);
let total_rayleigh = vec3(
5.804542996261093E-6,
1.3562911419845635E-5,
3.0265902468824876E-5,
);
let mie_const = vec3(
1.8399918514433978E14,
2.7798023919660528E14,
4.0790479543861094E14,
);
let cutoff_angle = float(1.6110731556870734);
let steepness = float(1.5);
let ee = float(1000.0);
let sun_direction = to_const(None, u.sun_position.normalize());
let assign_sun_direction = v.sun_direction.assign(sun_direction.clone());
let angle = sun_direction.y();
let zenith_angle_cos = angle.clamp(-1.0, 1.0);
let sun_intensity = ee.mul(max(
0.0,
float(1.0).sub(
e.pow(
cutoff_angle
.sub(zenith_angle_cos.acos())
.div(steepness)
.negate(),
),
),
));
let assign_sun_e = v.sun_e.assign(sun_intensity);
let sunfade = float(1.0).sub(
float(1.0)
.sub(exp(u.sun_position.y().div(450000.0)))
.clamp(0.0, 1.0),
);
let rayleigh_coefficient = u.rayleigh.sub(float(1.0).mul(float(1.0).sub(sunfade)));
let assign_beta_r = v.beta_r.assign(total_rayleigh.mul(rayleigh_coefficient));
let c = float(0.2).mul(u.turbidity.clone()).mul(10E-18);
let total_mie = float(0.434).mul(c).mul(mie_const);
let assign_beta_m = v.beta_m.assign(total_mie.mul(u.mie_coefficient.clone()));
let position = model_view_projection();
let set_far = position.z().assign(position.w());
block(
vec![
assign_sun_direction,
assign_sun_e,
assign_beta_r,
assign_beta_m,
set_far,
],
position,
)
}
fn gradient(i: NodeRef) -> NodeRef {
let p = to_var(
None,
fract(i.swizzle("xyx").mul(vec3(0.1031, 0.1030, 0.0973))),
);
let add = p.add_assign(dot(p.clone(), p.swizzle("yzx").add(33.33)));
block(
vec![p.clone(), add],
fract(p.swizzle("xx").add(p.swizzle("yz")).mul(p.swizzle("zy")))
.mul(2.0)
.sub(1.0),
)
}
fn noise(p: NodeRef) -> NodeRef {
let i = to_const(None, floor(p.clone()));
let f = to_const(None, fract(p));
let u = to_const(
None,
f.mul(f.clone())
.mul(f.clone())
.mul(f.mul(f.mul(6.0).sub(15.0)).add(10.0)),
);
let a = dot(gradient(i.clone()), f.clone());
let b = dot(gradient(i.add(vec2(1.0, 0.0))), f.sub(vec2(1.0, 0.0)));
let c = dot(gradient(i.add(vec2(0.0, 1.0))), f.sub(vec2(0.0, 1.0)));
let d = dot(gradient(i.add(vec2(1.0, 1.0))), f.sub(vec2(1.0, 1.0)));
mix(mix(a, b, u.x()), mix(c, d, u.x()), u.y()).mul(1.6)
}
fn fbm(position: NodeRef, drift: NodeRef) -> NodeRef {
let p = to_var(None, position);
let result = to_var(None, float(0.0));
let amplitude = to_var(None, float(1.0));
let lp = loop_n("i", 4.into(), |_| {
vec![
result.add_assign(amplitude.mul(noise(p.clone()))),
amplitude.mul_assign(0.5),
p.mul_assign(2.0),
p.add_assign(drift),
]
});
block(vec![p, result.clone(), amplitude, lp], result)
}
fn color_node(u: &Uniforms, v: &Varyings) -> NodeRef {
let pi = float(std::f64::consts::PI);
let rayleigh_zenith_length = float(8.4E3);
let mie_zenith_length = float(1.25E3);
let sun_angular_diameter_cos = float(0.9999566769464484);
let three_over_sixteenpi = float(0.05968310365946075);
let one_over_fourpi = float(0.07957747154594767);
let direction = to_const(None, position_world().sub(camera_position()).normalize());
let zenith_angle = to_const(None, max(0.0, direction.y()).acos());
let inverse = to_const(
None,
float(1.0).div(
zenith_angle.cos().add(
float(0.15).mul(
float(93.885)
.sub(zenith_angle.mul(180.0).div(pi))
.pow(-1.253),
),
),
),
);
let s_r = rayleigh_zenith_length.mul(inverse.clone());
let s_m = mie_zenith_length.mul(inverse);
let fex = to_const(None, exp(v.beta_r.mul(s_r).add(v.beta_m.mul(s_m)).negate()));
let cos_theta = to_const(None, dot(direction.clone(), v.sun_direction.clone()));
let c = cos_theta.mul(0.5).add(0.5);
let r_phase = three_over_sixteenpi.mul(float(1.0).add(c.pow(2.0)));
let beta_r_theta = to_const(None, v.beta_r.mul(r_phase));
let g2 = to_const(None, u.mie_directional_g.pow(2.0));
let inv = float(1.0).div(
float(1.0)
.sub(
float(2.0)
.mul(u.mie_directional_g.clone())
.mul(cos_theta.clone()),
)
.add(g2.clone())
.pow(1.5),
);
let m_phase = one_over_fourpi.mul(float(1.0).sub(g2)).mul(inv);
let beta_m_theta = to_const(None, v.beta_m.mul(m_phase));
let scattering = || {
v.sun_e.mul(
beta_r_theta
.add(beta_m_theta.clone())
.div(v.beta_r.add(v.beta_m.clone())),
)
};
let lin = to_var_intent(
scattering()
.mul(float(1.0).sub(fex.clone()))
.pow(vec3s(1.5)),
);
let lin_mul = lin.mul_assign(mix(
vec3s(1.0),
scattering().mul(fex.clone()).pow(vec3s(1.0 / 2.0)),
float(1.0).sub(v.sun_direction.y()).pow(5.0).clamp(0.0, 1.0),
));
let l0 = to_const(None, vec3s(0.1).mul(fex.clone()));
let sundisc = cos_theta
.sub(sun_angular_diameter_cos)
.mul(50000.0)
.clamp(0.0, 1.0)
.mul(u.show_sun_disc.clone());
let sundisc_color = to_const(
None,
min_of(v.sun_e.mul(fex.clone()), 80.0)
.mul(760.0)
.mul(sundisc),
);
let tex_color = to_var(
None,
lin.add(l0.clone())
.mul(0.04)
.add(sundisc_color.clone())
.add(vec3(0.0, 0.0003, 0.00075)),
);
let clouds = {
let elevation = mix(1.0, 0.1, u.cloud_elevation.clone());
let cloud_uv = to_var(None, direction.xz().div(direction.y().mul(elevation)));
let scale = cloud_uv.mul_assign(u.cloud_scale.clone());
let drift = cloud_uv.add_assign(time().mul(u.cloud_speed.clone()));
let evolve = time().mul(u.cloud_speed.clone()).mul(300.0);
let cloud_noise = to_var(
None,
fbm(cloud_uv.mul(1000.0), evolve)
.mul(0.7)
.add(0.5)
.clamp(0.0, 1.0),
);
let region = noise(to_const(None, cloud_uv.mul(300.0)))
.mul(0.37)
.add(0.5);
let cov = u
.cloud_coverage
.add(region.sub(0.5).mul(0.6))
.clamp(0.0, 1.0);
let threshold = to_var(None, float(1.0).sub(cov));
let cloud_mask = to_var(
None,
smoothstep(threshold.clone(), threshold.add(0.3), cloud_noise.clone()),
);
let horizon_fade = to_const(
None,
smoothstep(
0.0,
float(0.03).add(float(0.06).mul(u.cloud_elevation.clone())),
direction.y(),
),
);
let fade = cloud_mask.mul_assign(horizon_fade.clone());
let day_factor = smoothstep(-0.08, 0.3, v.sun_direction.y());
let sun_color = to_var(None, v.sun_e.mul(fex.clone()).mul(0.22).mul(0.04));
let sky_ambient = lin.mul(0.04).add(vec3(0.0, 0.0003, 0.00075));
let depth = to_var(None, max(0.0, cloud_noise.sub(threshold.clone())));
let beer = to_var(None, exp(depth.mul(-4.0)));
let powder = float(1.0).sub(beer.mul(beer.clone())); let shade = mix(0.45, 1.0, beer.mul(powder).mul(2.6).clamp(0.0, 1.0));
let silver = float(0.51)
.div(float(1.49).sub(cos_theta.mul(1.4)).pow(1.5))
.clamp(0.0, 3.0);
let edge = cloud_mask.mul(float(1.0).sub(cloud_mask.clone())).mul(4.0);
let cloud_color = to_var(None, sky_ambient.add(sun_color.mul(shade)));
let rim = cloud_color.add_assign(sun_color.mul(silver).mul(edge).mul(0.6));
let day = cloud_color.mul_assign(day_factor.max(0.03));
let alpha = to_var(
None,
float(1.0)
.sub(exp(depth.mul(u.cloud_density.clone()).mul(-12.0)))
.mul(horizon_fade),
);
let occlude = tex_color.sub_assign(l0.mul(0.04).add(sundisc_color).mul(alpha.clone()));
let cloud_aerial = mix(tex_color.clone(), cloud_color.clone(), fex);
let composite = tex_color.assign(mix(tex_color.clone(), cloud_aerial, alpha.clone()));
if_then(
direction
.y()
.greater_than(0.0)
.and(u.cloud_coverage.greater_than(0.0)),
vec![
cloud_uv,
scale,
drift,
cloud_noise,
threshold,
cloud_mask,
fade,
sun_color,
depth,
beer,
cloud_color,
rim,
day,
alpha,
occlude,
composite,
],
)
};
block(
vec![lin_mul, tex_color.clone(), clouds],
vec4_join(vec![tex_color, float(1.0)]),
)
}