use std::cell::{Cell, RefCell};
use std::rc::Rc;
use crate::cameras::PerspectiveCamera;
use crate::core::ObjectRef;
use crate::lights::LightObject;
use crate::materials::MeshBasicNodeMaterial;
use crate::math::{Color, Matrix4};
use crate::nodes::frame::register_texture_update;
use crate::nodes::node::{SettableValue, Type, UniformGroup, UniformSource};
use crate::nodes::tsl::{
abs, block, break_loop, discard, float, fract, get_view_position, if_then,
interleaved_gradient_noise, loop_n, max, mix, pass_depth_texture_uv,
perspective_depth_to_view_z, rand, screen_coordinate, texture_uv, to_const, to_var,
transform_direction, uniform, uniform_settable, uv, vec2_join, vec4_join,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{DepthTexture, TextureFilter, TextureType};
const SPATIAL_OFFSETS: [f64; 4] = [0.0, 0.5, 0.25, 0.75];
pub fn sss(
depth: &DepthTexture,
camera: Rc<RefCell<PerspectiveCamera>>,
main_light: &ObjectRef,
) -> SssNode {
SssNode::new(depth, camera, main_light)
}
pub struct SssNode {
pub max_distance: SettableValue,
pub thickness: SettableValue,
pub shadow_intensity: SettableValue,
pub quality: SettableValue,
state: Rc<SssState>,
}
pub(crate) struct SssState {
depth: DepthTexture,
camera: Rc<RefCell<PerspectiveCamera>>,
main_light: ObjectRef,
target: RenderTarget,
quad: RefCell<Option<QuadMesh>>,
node: NodeRef,
resolution_scale: Cell<f64>,
use_temporal_filtering: Cell<bool>,
uniforms: Uniforms,
camera_view_matrix: SettableValue,
camera_projection_matrix: SettableValue,
camera_projection_matrix_inverse: SettableValue,
camera_near: SettableValue,
camera_far: SettableValue,
resolution: SettableValue,
temporal_offset: SettableValue,
light_position: SettableValue,
light_target_position: SettableValue,
}
struct Uniforms {
max_distance: NodeRef,
thickness: NodeRef,
shadow_intensity: NodeRef,
quality: NodeRef,
camera_view_matrix: NodeRef,
camera_projection_matrix: NodeRef,
camera_projection_matrix_inverse: NodeRef,
camera_near: NodeRef,
camera_far: NodeRef,
resolution: NodeRef,
temporal_offset: NodeRef,
light_position: NodeRef,
light_target_position: NodeRef,
}
fn mat4_values(m: &Matrix4) -> Vec<f64> {
m.elements.to_vec()
}
fn render_vec3() -> (NodeRef, SettableValue) {
let cell = SettableValue::new(vec![0.0, 0.0, 0.0]);
let node = uniform(
UniformSource::Settable(cell.clone()),
Type::Vec3,
UniformGroup::Render,
None,
);
(node, cell)
}
impl SssNode {
pub fn new(
depth: &DepthTexture,
camera: Rc<RefCell<PerspectiveCamera>>,
main_light: &ObjectRef,
) -> Self {
let target = RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type: TextureType::UnsignedByte,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: the SSS target is a colour type");
let (max_distance, max_distance_value) = uniform_settable(Type::F32, vec![0.1]);
let (thickness, thickness_value) = uniform_settable(Type::F32, vec![0.01]);
let (shadow_intensity, shadow_intensity_value) = uniform_settable(Type::F32, vec![1.0]);
let (quality, quality_value) = uniform_settable(Type::F32, vec![0.5]);
let identity = mat4_values(&Matrix4::identity());
let (camera_view_matrix, camera_view_matrix_value) =
uniform_settable(Type::Mat4, identity.clone());
let (camera_projection_matrix, camera_projection_matrix_value) =
uniform_settable(Type::Mat4, identity.clone());
let (camera_projection_matrix_inverse, camera_projection_matrix_inverse_value) =
uniform_settable(Type::Mat4, identity);
let (camera_near, camera_near_value) = uniform_settable(Type::F32, vec![0.0]);
let (camera_far, camera_far_value) = uniform_settable(Type::F32, vec![0.0]);
let (resolution, resolution_value) = uniform_settable(Type::Vec2, vec![0.0, 0.0]);
let (temporal_offset, temporal_offset_value) = uniform_settable(Type::F32, vec![0.0]);
let (light_position, light_position_value) = render_vec3();
let (light_target_position, light_target_position_value) = render_vec3();
let uniforms = Uniforms {
max_distance,
thickness,
shadow_intensity,
quality,
camera_view_matrix,
camera_projection_matrix,
camera_projection_matrix_inverse,
camera_near,
camera_far,
resolution,
temporal_offset,
light_position,
light_target_position,
};
let node = to_var(None, texture_uv(&target.texture(), uv()));
let state = Rc::new(SssState {
depth: depth.clone(),
camera,
main_light: main_light.clone(),
target,
quad: RefCell::new(None),
node,
resolution_scale: Cell::new(1.0),
use_temporal_filtering: Cell::new(false),
uniforms,
camera_view_matrix: camera_view_matrix_value,
camera_projection_matrix: camera_projection_matrix_value,
camera_projection_matrix_inverse: camera_projection_matrix_inverse_value,
camera_near: camera_near_value,
camera_far: camera_far_value,
resolution: resolution_value,
temporal_offset: temporal_offset_value,
light_position: light_position_value,
light_target_position: light_target_position_value,
});
register_texture_update(state.target.texture().id(), &state);
Self {
max_distance: max_distance_value,
thickness: thickness_value,
shadow_intensity: shadow_intensity_value,
quality: quality_value,
state,
}
}
pub fn node(&self) -> NodeRef {
self.state.node.clone()
}
pub fn sample(&self, coord: NodeRef) -> NodeRef {
texture_uv(&self.state.target.texture(), coord)
}
pub fn set_resolution_scale(&self, scale: f64) {
self.state.resolution_scale.set(scale);
}
pub fn set_use_temporal_filtering(&self, on: bool) {
self.state.use_temporal_filtering.set(on);
}
#[doc(hidden)]
pub fn quad_material(&self, frame_id: u64) -> MeshBasicNodeMaterial {
material(&self.state.depth, &self.state.uniforms, frame_id)
}
}
fn material(depth: &DepthTexture, uniforms: &Uniforms, frame_id: u64) -> MeshBasicNodeMaterial {
let mut material = MeshBasicNodeMaterial::new();
material.name = "SSS";
material.fragment_node = Some(sss_node(depth, uniforms, frame_id));
material
}
fn get_screen_position(view_position: NodeRef, projection_matrix: NodeRef) -> NodeRef {
let sample_clip_pos = projection_matrix.mul(vec4_join(vec![view_position, float(1.0)]));
let sample_uv = to_var(
None,
sample_clip_pos
.xy()
.div(sample_clip_pos.w())
.mul(0.5)
.add(0.5),
);
vec2_join(vec![sample_uv.x(), sample_uv.y().one_minus()])
}
fn sss_node(depth: &DepthTexture, u: &Uniforms, frame_id: u64) -> NodeRef {
let uv_node = uv();
let sample_depth = |coord: NodeRef| pass_depth_texture_uv(depth, coord);
let get_view_z = |depth: NodeRef| {
perspective_depth_to_view_z(depth, u.camera_near.clone(), u.camera_far.clone())
};
let depth_value = to_var(None, sample_depth(uv_node.clone()));
let discard_far = if_then(depth_value.greater_than_equal(1.0), vec![discard()]);
let ray_start_position = to_var(
Some("rayStartPosition"),
get_view_position(
uv_node.clone(),
depth_value.clone(),
u.camera_projection_matrix_inverse.clone(),
),
);
let ray_direction = to_const(
Some("rayDirection"),
transform_direction(
u.camera_view_matrix.clone(),
u.light_position.sub(u.light_target_position.clone()),
),
);
let ray_end_position = to_const(
Some("rayEndPosition"),
ray_start_position.add(ray_direction.mul(u.max_distance.clone())),
);
let d0 = to_var(None, screen_coordinate());
let d1 = to_var(
None,
get_screen_position(ray_end_position.clone(), u.camera_projection_matrix.clone())
.mul(u.resolution.clone()),
);
let total_len = to_var(None, d1.sub(d0.clone()).length());
let x_len = to_var(None, d1.x().sub(d0.x()));
let y_len = to_var(None, d1.y().sub(d0.y()));
let total_step = to_const(
None,
max(abs(x_len.clone()), abs(y_len.clone()))
.mul(u.quality.clamp(0.0, 1.0))
.to_int(),
);
let x_span = to_var(None, x_len.div(total_step.to_float()));
let y_span = to_var(None, y_len.div(total_step.to_float()));
let noise = interleaved_gradient_noise(screen_coordinate());
let offset = to_const(
Some("offset"),
fract(noise.add(u.temporal_offset.clone())).add(rand(uv_node.add(float(frame_id as f64)))),
);
let occlusion = to_var(None, float(0.0));
let march = loop_n("i", total_step.clone(), |i| {
let step = || i.to_float().add(offset.clone());
let xy = to_var(
None,
vec2_join(vec![
d0.x().add(x_span.mul(step())),
d0.y().add(y_span.mul(step())),
]),
);
let off_screen = if_then(
xy.x()
.less_than(0.0)
.or(xy.x().greater_than(u.resolution.x()))
.or(xy.y().less_than(0.0))
.or(xy.y().greater_than(u.resolution.y())),
vec![break_loop()],
);
let uv_node = xy.div(u.resolution.clone());
let fragment_depth = to_const(None, sample_depth(uv_node));
let fragment_view_z = to_const(Some("fragmentViewZ"), get_view_z(fragment_depth.clone()));
let s = to_var(None, xy.sub(d0.clone()).length().div(total_len.clone()));
let ray_position = mix(
ray_start_position.clone(),
ray_end_position.clone(),
s.clone(),
);
let depth_delta = to_const(None, ray_position.z().sub(fragment_view_z.clone()).negate());
let occluded = if_then(
depth_delta
.greater_than(0.0)
.and(depth_delta.less_than(u.thickness.clone())),
vec![
occlusion.assign(u.shadow_intensity.clone()),
break_loop(),
],
);
vec![
xy,
off_screen,
fragment_depth,
fragment_view_z,
s,
depth_delta,
occluded,
]
});
let statements = vec![
depth_value,
discard_far,
ray_start_position,
ray_direction,
ray_end_position,
d0,
d1,
total_len,
x_len,
y_len,
total_step,
x_span,
y_span,
offset,
occlusion.clone(),
march,
];
block(statements, occlusion.one_minus())
}
impl NodeUpdate for SssState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
if let Some(pass) = crate::nodes::frame::texture_update(self.depth.id()) {
let mut renderer = renderer.save_state();
renderer.context_shadow = None;
renderer.update_before_node(&pass);
}
let (width, height) = renderer.drawing_buffer_size();
let scale = self.resolution_scale.get();
let width = (scale * f64::from(width)).round() as u32;
let height = (scale * f64::from(height)).round() as u32;
self.resolution
.set(vec![f64::from(width), f64::from(height)]);
let (width, height) = (width.max(1), height.max(1));
if self.target.size() != (width, height) {
self.target.set_size(width, height);
}
let frame_id = if self.use_temporal_filtering.get() {
let frame_id = renderer.node_frame().frame_id;
self.temporal_offset
.set(vec![SPATIAL_OFFSETS[(frame_id % 4) as usize]]);
frame_id
} else {
self.temporal_offset.set(vec![0.0]);
0
};
{
let camera = self.camera.borrow();
self.camera_view_matrix
.set(mat4_values(&camera.matrix_world_inverse));
self.camera_projection_matrix
.set(mat4_values(&camera.projection_matrix));
self.camera_projection_matrix_inverse
.set(mat4_values(&camera.projection_matrix_inverse));
self.camera_near.set(vec![camera.near]);
self.camera_far.set(vec![camera.far]);
}
{
let object = self.main_light.borrow();
let position = LightObject::world_position(&object.matrix_world);
self.light_position
.set(vec![position.x, position.y, position.z]);
let target = object
.light()
.map_or_else(Default::default, LightObject::target_world_position);
self.light_target_position
.set(vec![target.x, target.y, target.z]);
}
let mut quad = self.quad.borrow_mut();
let quad = quad
.get_or_insert_with(|| QuadMesh::new(material(&self.depth, &self.uniforms, frame_id)));
let mut renderer = renderer.reset_state();
renderer.set_clear_color(Color::new(1.0, 1.0, 1.0), 1.0);
renderer.set_render_target(Some(self.target.clone()));
renderer.render_quad(quad);
drop(renderer);
true
}
}