use std::cell::RefCell;
use std::rc::Rc;
use crate::materials::{BlendFactor, BlendMode, Blending, MeshBasicNodeMaterial};
use crate::math::Color;
use crate::nodes::frame::register_texture_update;
use crate::nodes::tsl::{custom, float, mix, output_property, position_view, texture, vec4_join};
use crate::nodes::{
mrt, CustomNode, MrtNode, NodeBuilder, NodeRef, NodeUpdate, NodeUpdateType, Type,
};
use crate::renderer::{CameraRef, PassNode, RenderTarget, Renderer, SceneRef};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OitRenderObjects {
Default,
Accumulate,
}
impl OitRenderObjects {
pub(crate) fn draws(&self, material: &MeshBasicNodeMaterial) -> bool {
match self {
Self::Default => !is_oit_capable(material),
Self::Accumulate => is_oit_capable(material),
}
}
}
pub fn is_oit_capable(material: &MeshBasicNodeMaterial) -> bool {
material.transparent
&& material.blending == Blending::Normal
&& material.transmission.partial_cmp(&0.0) != Some(std::cmp::Ordering::Greater)
&& material.backdrop_node.is_none()
}
#[derive(Clone)]
pub struct OitPassNode(Rc<OitState>);
struct OitState {
pass: PassNode,
oit_render_target: RenderTarget,
weight_node: RefCell<Option<NodeRef>>,
oit_mrt_node: RefCell<Option<MrtNode>>,
scene: SceneRef,
camera: CameraRef,
node: NodeRef,
}
pub fn oit_pass(scene: SceneRef, camera: CameraRef) -> OitPassNode {
OitPassNode::new(scene, camera)
}
impl OitPassNode {
pub fn new(scene: SceneRef, camera: CameraRef) -> Self {
let pass = PassNode::new();
let oit_render_target = RenderTarget::new(1, 1);
oit_render_target.set_count(2);
oit_render_target.set_depth_texture(pass.depth_texture());
let textures = oit_render_target.textures();
oit_render_target.set_texture_name(0, "accum");
textures[0].set_format(wgpu::TextureFormat::Rgba16Float);
oit_render_target.set_texture_name(1, "revealage");
textures[1].set_format(wgpu::TextureFormat::R8Unorm);
let beauty_node = pass.node();
let accum_node = texture(&textures[0]);
let revealage_node = texture(&textures[1]).x();
let accum_color = accum_node.rgb().div(accum_node.a().max(float(1e-5)));
let composite = vec4_join(vec![
mix(accum_color, beauty_node.rgb(), revealage_node),
beauty_node.a(),
]);
let node = custom(Composite(composite));
let state = Rc::new(OitState {
pass,
oit_render_target,
weight_node: RefCell::new(None),
oit_mrt_node: RefCell::new(None),
scene,
camera,
node,
});
register_texture_update(state.pass.texture().id(), &state);
register_texture_update(state.pass.depth_texture().id(), &state);
for texture in &textures {
register_texture_update(texture.id(), &state);
}
Self(state)
}
pub fn set_weight_node(&self, weight_node: Option<NodeRef>) {
*self.0.weight_node.borrow_mut() = weight_node;
}
pub fn node(&self) -> NodeRef {
self.0.node.clone()
}
pub fn pass(&self) -> &PassNode {
&self.0.pass
}
#[doc(hidden)]
pub fn mrt_node(&self) -> MrtNode {
self.0.mrt_node()
}
#[doc(hidden)]
pub fn mrt_context(&self) -> crate::materials::MrtContext {
crate::materials::MrtContext::for_target(self.mrt_node(), &self.0.oit_render_target)
}
#[doc(hidden)]
pub fn accumulation_textures(&self) -> Vec<crate::textures::Texture> {
self.0.oit_render_target.textures()
}
}
struct Composite(NodeRef);
impl CustomNode for Composite {
fn type_name(&self) -> &'static str {
"OITPassNode"
}
fn node_type(&self) -> Type {
Type::Vec4
}
fn is_cacheable(&self) -> bool {
false
}
fn setup(&self, _builder: &NodeBuilder) -> NodeRef {
self.0.clone()
}
}
impl OitState {
fn mrt_node(&self) -> MrtNode {
if let Some(node) = self.oit_mrt_node.borrow().as_ref() {
return node.clone();
}
let alpha = output_property().a();
let weight = match self.weight_node.borrow().clone() {
Some(weight) => weight,
None => {
let z = position_view().z().negate();
alpha.mul(
float(0.03)
.div(z.div(float(200.0)).pow(float(4.0)).add(float(1e-5)))
.clamp(float(1e-2), float(3e3)),
)
}
};
let accum_blending = BlendMode {
blend_src: BlendFactor::One,
blend_dst: BlendFactor::One,
..BlendMode::new(Blending::Custom)
};
let revealage_blending = BlendMode {
blend_src: BlendFactor::Zero,
blend_dst: BlendFactor::OneMinusSrcColor,
..BlendMode::new(Blending::Custom)
};
let mut node = mrt(vec![
(
"accum",
vec4_join(vec![
output_property().rgb().mul(alpha.clone()),
alpha.clone(),
])
.mul(weight),
),
("revealage", alpha),
]);
node.set_blend_mode("accum", accum_blending)
.set_blend_mode("revealage", revealage_blending)
.set_clear_color("accum", Color::from_hex(0x000000), 0.0)
.set_clear_color("revealage", Color::from_hex(0xffffff), 1.0);
*self.oit_mrt_node.borrow_mut() = Some(node.clone());
node
}
}
impl NodeUpdate for OitState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
let (near, far) = {
let camera = self.camera.borrow();
(camera.near(), camera.far())
};
let pass_target = self.pass.render_target().clone();
self.pass.render_with(renderer, near, far, |renderer| {
let (width, height) = pass_target.size();
self.oit_render_target
.set_size_keeping_depth(width, height, true);
self.oit_render_target.set_samples(pass_target.samples());
renderer.oit = Some(OitRenderObjects::Default);
renderer.render_shared(&self.scene.borrow(), &self.camera);
let (background, override_material) = {
let mut scene = self.scene.borrow_mut();
(scene.background.take(), scene.override_material.take())
};
renderer.set_render_target(Some(self.oit_render_target.clone()));
renderer.set_mrt(Some(self.mrt_node()));
renderer.oit = Some(OitRenderObjects::Accumulate);
renderer.auto_clear_depth = false;
renderer.opaque = false;
renderer.transparent = true;
renderer.render_shared(&self.scene.borrow(), &self.camera);
{
let mut scene = self.scene.borrow_mut();
scene.background = background;
scene.override_material = override_material;
}
});
true
}
fn sync_before_build(&self, samples: u32) {
self.pass.render_target().set_samples(samples);
self.oit_render_target.set_samples(samples);
}
}