use std::cell::RefCell;
use crate::cameras::RenderCamera;
use crate::materials::{render_output, OutputContext, ToneMapping};
use crate::math::Color;
use crate::nodes::node::Type;
use crate::nodes::tsl::{output_property, uniform_value};
use crate::nodes::NodeRef;
use crate::objects::{Background, Scene};
use super::Renderer;
type ContextKey = (usize, bool, ToneMapping);
pub struct DirectRenderPipeline {
pub output_node: Option<NodeRef>,
pub output_color_transform: bool,
context: RefCell<Option<(ContextKey, OutputContext)>>,
background_nodes: RefCell<Vec<(Color, NodeRef)>>,
}
impl Default for DirectRenderPipeline {
fn default() -> Self {
Self::new()
}
}
impl DirectRenderPipeline {
pub fn new() -> Self {
Self {
output_node: None,
output_color_transform: true,
context: RefCell::new(None),
background_nodes: RefCell::new(Vec::new()),
}
}
pub fn render(
&self,
renderer: &mut Renderer,
scene: &mut Scene,
camera: &mut dyn RenderCamera,
) {
let hook = self.context(renderer.tone_mapping);
let background = self
.background_node(scene)
.map(|node| scene.background.replace(Background::Node(node)));
let previous = renderer.set_output_hook(Some(hook));
renderer.with_neutral_output(|renderer| renderer.render(scene, camera));
renderer.set_output_hook(previous);
if let Some(background) = background {
scene.background = background;
}
}
fn context(&self, tone_mapping: ToneMapping) -> OutputContext {
let output_node = self.output_node.clone().unwrap_or_else(output_property);
let built_for = (output_node.key(), self.output_color_transform, tone_mapping);
let mut cell = self.context.borrow_mut();
if let Some((key, context)) = cell.as_ref() {
if *key == built_for {
return context.clone();
}
}
let node = if self.output_color_transform {
render_output(output_node, tone_mapping)
} else {
output_node
};
let context = OutputContext { node };
*cell = Some((built_for, context.clone()));
context
}
fn background_node(&self, scene: &Scene) -> Option<NodeRef> {
let color = match &scene.background {
Some(Background::Color(color)) => *color,
_ => return None,
};
let mut nodes = self.background_nodes.borrow_mut();
if let Some((_, node)) = nodes.iter().find(|(c, _)| *c == color) {
return Some(node.clone());
}
let node = uniform_value(Type::Vec3, vec![color.r, color.g, color.b]);
nodes.push((color, node.clone()));
Some(node)
}
}