use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use crate::cameras::RenderCamera;
use crate::core::Layers;
use crate::nodes::node::SettableValue;
use crate::nodes::tsl::{
pass_depth_texture, perspective_depth_to_view_z, texture_uv, to_var, uniform_settable, uv,
};
use crate::nodes::{MrtNode, NodeRef, NodeUpdate, NodeUpdateType, Type};
use crate::objects::Scene;
use crate::textures::{DepthTexture, TextureFilter, TextureType};
pub const DEPTH_ATTACHMENT: &str = "depth";
use super::render_target::{RenderTarget, RenderTargetOptions, OUTPUT_ATTACHMENT};
use super::Renderer;
#[derive(Clone)]
pub struct PassNode(Rc<PassState>);
impl std::ops::Deref for PassNode {
type Target = PassState;
fn deref(&self) -> &PassState {
&self.0
}
}
pub type SceneRef = Rc<RefCell<Scene>>;
pub type CameraRef = Rc<RefCell<dyn RenderCamera>>;
pub struct PassState {
render_target: RenderTarget,
node: NodeRef,
previous_texture_nodes: RefCell<HashMap<String, NodeRef>>,
mrt: RefCell<Option<MrtNode>>,
texture_nodes: RefCell<HashMap<String, NodeRef>>,
view_z_nodes: RefCell<HashMap<String, NodeRef>>,
camera_near: (NodeRef, SettableValue),
camera_far: (NodeRef, SettableValue),
auto_clear_depth: bool,
owns_depth_texture: bool,
layers: RefCell<Option<Layers>>,
size_divisor: std::cell::Cell<u32>,
opaque: Cell<bool>,
transparent: Cell<bool>,
lighting_enabled: Cell<bool>,
scene: RefCell<Option<(SceneRef, CameraRef)>>,
}
pub fn pass(scene: SceneRef, camera: CameraRef) -> PassNode {
let node = PassNode::new();
node.set_scene(scene, camera);
node
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PassOptions {
pub min_filter: TextureFilter,
pub mag_filter: TextureFilter,
pub depth_texture: Option<DepthTexture>,
pub auto_clear_depth: bool,
}
impl Default for PassOptions {
fn default() -> Self {
Self {
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
depth_texture: None,
auto_clear_depth: true,
}
}
}
impl Default for PassNode {
fn default() -> Self {
Self::new()
}
}
impl PassNode {
pub fn new() -> Self {
Self::new_with_options(PassOptions::default())
}
pub fn new_with_options(options: PassOptions) -> Self {
let render_target = RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: true,
min_filter: options.min_filter,
mag_filter: options.mag_filter,
},
)
.expect("three-rs: PassNode's render target is a HalfFloat colour type");
render_target.set_depth_texture(options.depth_texture.clone().unwrap_or_default());
let texture_node = texture_uv(&render_target.texture(), uv());
let node = to_var(None, texture_node.clone());
let texture_nodes = HashMap::from([(OUTPUT_ATTACHMENT.to_string(), texture_node)]);
let camera_near = uniform_settable(Type::F32, vec![0.0]);
let camera_far = uniform_settable(Type::F32, vec![0.0]);
let pass = Self(Rc::new(PassState {
render_target,
node,
previous_texture_nodes: RefCell::new(HashMap::new()),
mrt: RefCell::new(None),
texture_nodes: RefCell::new(texture_nodes),
view_z_nodes: RefCell::new(HashMap::new()),
camera_near,
camera_far,
auto_clear_depth: options.auto_clear_depth,
owns_depth_texture: options.depth_texture.is_none(),
layers: RefCell::new(None),
size_divisor: std::cell::Cell::new(1),
opaque: Cell::new(true),
transparent: Cell::new(true),
lighting_enabled: Cell::new(true),
scene: RefCell::new(None),
}));
pass.link(pass.0.render_target.texture().id());
if pass.0.owns_depth_texture {
pass.link(pass.depth_texture().id());
}
pass
}
fn link(&self, texture_id: usize) {
crate::nodes::frame::register_texture_update(texture_id, &self.0);
}
pub fn set_scene(&self, scene: SceneRef, camera: CameraRef) {
*self.0.scene.borrow_mut() = Some((scene, camera));
}
pub(crate) fn set_size_divisor(&self, divisor: u32) {
self.size_divisor.set(divisor);
}
pub(crate) fn depth_texture_node_at(&self, coord: NodeRef) -> NodeRef {
crate::nodes::tsl::pass_depth_texture_uv(&self.depth_texture(), coord)
}
pub fn set_layers(&self, layers: Layers) {
*self.layers.borrow_mut() = Some(layers);
}
pub fn set_opaque(&mut self, opaque: bool) {
self.0.opaque.set(opaque);
}
pub fn set_transparent(&mut self, transparent: bool) {
self.0.transparent.set(transparent);
}
pub fn set_lighting_enabled(&mut self, enabled: bool) {
self.0.lighting_enabled.set(enabled);
}
pub fn depth_texture(&self) -> DepthTexture {
self.render_target
.depth_texture()
.expect("three-rs: a PassNode's render target always carries a DepthTexture")
}
pub fn view_z_node(&self, name: &str) -> NodeRef {
if let Some(node) = self.view_z_nodes.borrow().get(name) {
return node.clone();
}
assert_eq!(
name, DEPTH_ATTACHMENT,
"three-rs: PassNode::view_z_node only knows the 'depth' output"
);
let node = perspective_depth_to_view_z(
pass_depth_texture(&self.depth_texture()),
self.camera_near.0.clone(),
self.camera_far.0.clone(),
);
self.view_z_nodes
.borrow_mut()
.insert(name.to_string(), node.clone());
node
}
pub fn set_mrt(&self, mrt: MrtNode) {
*self.mrt.borrow_mut() = Some(mrt);
}
pub fn mrt(&self) -> Option<MrtNode> {
self.mrt.borrow().clone()
}
pub fn texture_node(&self, name: &str) -> NodeRef {
if let Some(node) = self.texture_nodes.borrow().get(name) {
return node.clone();
}
if name == DEPTH_ATTACHMENT {
let node = pass_depth_texture(&self.depth_texture());
self.texture_nodes
.borrow_mut()
.insert(name.to_string(), node.clone());
return node;
}
let texture = if name == crate::renderer::OUTPUT_ATTACHMENT {
self.render_target.texture()
} else {
self.render_target.add_texture(name)
};
self.link(texture.id());
let node = texture_uv(&texture, uv());
self.texture_nodes
.borrow_mut()
.insert(name.to_string(), node.clone());
node
}
pub fn previous_texture_node(&self, name: &str) -> NodeRef {
if let Some(node) = self.previous_texture_nodes.borrow().get(name) {
return node.clone();
}
let _ = self.texture_node(name);
let texture = self.render_target.add_previous_texture(name);
self.link(texture.id());
let node = texture_uv(&texture, uv());
self.previous_texture_nodes
.borrow_mut()
.insert(name.to_string(), node.clone());
node
}
pub fn texture_named(&self, name: &str) -> crate::textures::Texture {
self.render_target.add_texture(name)
}
pub fn node(&self) -> NodeRef {
self.node.clone()
}
pub fn a(&self) -> NodeRef {
self.node.a()
}
pub fn texture(&self) -> crate::textures::Texture {
self.render_target.texture()
}
pub(crate) fn render_target(&self) -> &RenderTarget {
&self.render_target
}
pub(crate) fn render_scene(
&self,
renderer: &mut Renderer,
scene: &mut Scene,
camera: &mut dyn RenderCamera,
) {
let (near, far) = (camera.near(), camera.far());
self.0.render_with(renderer, near, far, |renderer| {
renderer.render(scene, camera)
});
}
}
impl PassState {
fn render_with(
&self,
renderer: &mut Renderer,
near: f64,
far: f64,
render: impl FnOnce(&mut Renderer),
) {
let (width, height) = renderer.drawing_buffer_size();
let divisor = self.size_divisor.get().max(1);
let (width, height) = (width / divisor, height / divisor);
self.render_target
.set_size_keeping_depth(width, height, !self.owns_depth_texture);
self.render_target.set_samples(renderer.samples());
for name in self.previous_texture_nodes.borrow().keys() {
self.render_target.toggle_texture(name);
}
self.camera_near.1.set(vec![near]);
self.camera_far.1.set(vec![far]);
let previous = renderer.render_target();
let previous_mrt = renderer.mrt();
let previous_auto_clear_depth = renderer.auto_clear_depth;
let previous_opaque = renderer.opaque;
let previous_transparent = renderer.transparent;
let previous_lighting = renderer.lighting_enabled;
let previous_layers = renderer.camera_layers;
renderer.set_render_target(Some(self.render_target.clone()));
renderer.set_mrt(self.mrt.borrow().clone());
renderer.auto_clear_depth = self.auto_clear_depth;
renderer.opaque = self.opaque.get();
renderer.transparent = self.transparent.get();
renderer.lighting_enabled = self.lighting_enabled.get();
renderer.camera_layers = *self.layers.borrow();
render(renderer);
renderer.set_render_target(previous);
renderer.set_mrt(previous_mrt);
renderer.auto_clear_depth = previous_auto_clear_depth;
renderer.opaque = previous_opaque;
renderer.transparent = previous_transparent;
renderer.lighting_enabled = previous_lighting;
renderer.camera_layers = previous_layers;
}
}
impl NodeUpdate for PassState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
let Some((scene, camera)) = self.scene.borrow().clone() else {
return false;
};
let (near, far) = {
let camera = camera.borrow();
(camera.near(), camera.far())
};
self.render_with(renderer, near, far, |renderer| {
renderer.render_shared(&scene.borrow(), &camera)
});
true
}
fn sync_before_build(&self, samples: u32) {
self.render_target.set_samples(samples);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_previous_texture_is_never_a_colour_attachment() {
let pass = PassNode::new();
let current = pass.texture_node(OUTPUT_ATTACHMENT);
let previous = pass.previous_texture_node(OUTPUT_ATTACHMENT);
assert_ne!(current.key(), previous.key());
let attachments: Vec<usize> = pass
.render_target()
.textures()
.iter()
.map(|texture| texture.id())
.collect();
assert_eq!(attachments.len(), 1);
assert_eq!(attachments[0], pass.render_target().texture().id());
let shadow = pass.render_target().add_previous_texture(OUTPUT_ATTACHMENT);
assert!(!attachments.contains(&shadow.id()));
}
#[test]
fn the_texture_nodes_are_memoised() {
let pass = PassNode::new();
assert_eq!(
pass.texture_node(OUTPUT_ATTACHMENT).key(),
pass.texture_node(OUTPUT_ATTACHMENT).key()
);
assert_eq!(
pass.previous_texture_node(OUTPUT_ATTACHMENT).key(),
pass.previous_texture_node(OUTPUT_ATTACHMENT).key()
);
}
}