use crate::materials::{render_output, MeshBasicNodeMaterial, ToneMapping};
use crate::nodes::NodeRef;
use crate::objects::QuadMesh;
use super::Renderer;
type RenderPipelineHook = Box<dyn FnMut(&mut Renderer)>;
pub struct RenderPipeline {
pub output_node: Option<NodeRef>,
pub output_color_transform: bool,
quad_mesh: QuadMesh,
built_for: Option<(usize, bool, ToneMapping)>,
before_render: Vec<RenderPipelineHook>,
after_render: Vec<RenderPipelineHook>,
}
impl Default for RenderPipeline {
fn default() -> Self {
Self::new()
}
}
impl RenderPipeline {
pub fn new() -> Self {
let mut material = MeshBasicNodeMaterial::new();
material.name = "RenderPipeline";
Self {
output_node: None,
output_color_transform: true,
quad_mesh: QuadMesh::new(material),
built_for: None,
before_render: Vec::new(),
after_render: Vec::new(),
}
}
pub fn on_before_render(&mut self, hook: RenderPipelineHook) {
self.before_render.push(hook);
}
pub fn on_after_render(&mut self, hook: RenderPipelineHook) {
self.after_render.push(hook);
}
pub fn render(&mut self, renderer: &mut Renderer) {
let output_node = self
.output_node
.clone()
.expect("three-rs: RenderPipeline.outputNode is not set");
let tone_mapping = renderer.tone_mapping;
let built_for = (output_node.key(), self.output_color_transform, tone_mapping);
if self.built_for != Some(built_for) {
self.quad_mesh.material.fragment_node = Some(if self.output_color_transform {
render_output(output_node, tone_mapping)
} else {
output_node
});
self.quad_mesh.material.set_needs_update();
self.built_for = Some(built_for);
}
for hook in &mut self.before_render {
hook(renderer);
}
let quad = &self.quad_mesh;
renderer.with_neutral_output(|renderer| renderer.render_quad(quad));
for hook in &mut self.after_render {
hook(renderer);
}
}
}