use std::hash::{Hash, Hasher};
use std::rc::Rc;
use super::{NodeRef, Type};
use crate::materials::BlendMode;
#[derive(Clone)]
pub(crate) enum MrtValue {
Node(NodeRef),
Deferred(Rc<dyn Fn() -> NodeRef>),
}
impl MrtValue {
fn resolve(&self) -> NodeRef {
match self {
MrtValue::Node(node) => node.clone(),
MrtValue::Deferred(build) => build(),
}
}
}
impl std::fmt::Debug for MrtValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
MrtValue::Node(node) => node.fmt(f),
MrtValue::Deferred(_) => f.write_str("Deferred"),
}
}
}
#[derive(Clone, Debug, Default)]
pub struct MrtNode {
outputs: Vec<(String, MrtValue)>,
blend_modes: Vec<(String, BlendMode)>,
clear_colors: Vec<(String, [f64; 4])>,
}
pub fn mrt<N: Into<String>>(outputs: Vec<(N, NodeRef)>) -> MrtNode {
let mut node = MrtNode::default();
for (name, value) in outputs {
node.set(name, value);
}
node
}
impl MrtNode {
pub fn set<N: Into<String>>(&mut self, name: N, value: NodeRef) {
self.set_value(name, MrtValue::Node(value));
}
pub fn set_deferred<N: Into<String>>(
&mut self,
name: N,
build: impl Fn() -> NodeRef + 'static,
) {
self.set_value(name, MrtValue::Deferred(Rc::new(build)));
}
fn set_value<N: Into<String>>(&mut self, name: N, value: MrtValue) {
let name = name.into();
match self.outputs.iter_mut().find(|(n, _)| *n == name) {
Some(entry) => entry.1 = value,
None => self.outputs.push((name, value)),
}
}
pub fn set_blend_mode<N: Into<String>>(
&mut self,
name: N,
blend_mode: impl Into<BlendMode>,
) -> &mut Self {
let name = name.into();
let blend_mode = blend_mode.into();
match self.blend_modes.iter_mut().find(|(n, _)| *n == name) {
Some(entry) => entry.1 = blend_mode,
None => self.blend_modes.push((name, blend_mode)),
}
self
}
pub fn blend_mode(&self, name: &str) -> Option<BlendMode> {
self.blend_modes
.iter()
.find(|(n, _)| n == name)
.map(|(_, b)| *b)
}
pub fn set_clear_color<N: Into<String>>(
&mut self,
name: N,
color: crate::math::Color,
alpha: f64,
) -> &mut Self {
let name = name.into();
let value = [color.r, color.g, color.b, alpha];
match self.clear_colors.iter_mut().find(|(n, _)| *n == name) {
Some(entry) => entry.1 = value,
None => self.clear_colors.push((name, value)),
}
self
}
pub fn clear_color(&self, name: &str) -> Option<[f64; 4]> {
self.clear_colors
.iter()
.find(|(n, _)| n == name)
.map(|(_, c)| *c)
}
pub fn has(&self, name: &str) -> bool {
self.outputs.iter().any(|(n, _)| n == name)
}
pub fn get(&self, name: &str) -> Option<NodeRef> {
self.outputs
.iter()
.find(|(n, _)| n == name)
.map(|(_, v)| v.resolve())
}
#[cfg(test)]
fn names(&self) -> impl Iterator<Item = &str> {
self.outputs.iter().map(|(n, _)| n.as_str())
}
pub fn merge(&self, other: &MrtNode) -> MrtNode {
let mut merged = self.clone();
for (name, value) in &other.outputs {
merged.set_value(name.clone(), value.clone());
}
merged.blend_modes.retain(|(name, _)| name != "output");
for (name, blend_mode) in &other.blend_modes {
merged.set_blend_mode(name.clone(), *blend_mode);
}
for (name, color) in &other.clear_colors {
let [r, g, b, a] = *color;
merged.set_clear_color(name.clone(), crate::math::Color::new(r, g, b), a);
}
merged
}
pub(crate) fn members(&self, attachments: &[String], types: &[Type]) -> Vec<(NodeRef, Type)> {
let mut members: Vec<Option<NodeRef>> = vec![None; attachments.len()];
for (name, value) in &self.outputs {
if let Some(index) = get_texture_index(attachments, name) {
members[index] = Some(value.resolve());
}
}
while matches!(members.last(), Some(None)) {
members.pop();
}
members
.into_iter()
.enumerate()
.map(|(index, m)| {
(
m.expect("three-rs: an MRT member index below the last is always filled"),
types.get(index).copied().unwrap_or(Type::Vec4),
)
})
.collect()
}
}
pub fn get_texture_index<S: AsRef<str>>(names: &[S], name: &str) -> Option<usize> {
names.iter().position(|n| n.as_ref() == name)
}
impl Hash for MrtNode {
fn hash<H: Hasher>(&self, state: &mut H) {
for (name, value) in &self.outputs {
name.hash(state);
match value {
MrtValue::Node(node) => node.key().hash(state),
MrtValue::Deferred(build) => Rc::as_ptr(build).cast::<()>().hash(state),
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::nodes::tsl::{float, output_property};
#[test]
fn merge_keeps_the_pass_order_and_takes_the_material_value() {
let pass = mrt(vec![
("output", output_property()),
("bloomIntensity", float(0.0)),
]);
let material = mrt(vec![("bloomIntensity", float(1.0))]);
let merged = pass.merge(&material);
assert_eq!(
merged.names().collect::<Vec<_>>(),
["output", "bloomIntensity"]
);
assert_eq!(
merged.get("bloomIntensity").map(|n| n.key()),
material.get("bloomIntensity").map(|n| n.key())
);
}
#[test]
fn an_output_with_no_attachment_is_dropped() {
let node = mrt(vec![
("output", output_property()),
("velocity", float(2.0)),
("bloomIntensity", float(1.0)),
]);
let attachments = ["output".to_string(), "bloomIntensity".to_string()];
let members = node.members(&attachments, &[]);
assert_eq!(members.len(), 2);
assert_eq!(members[0].0.key(), output_property().key());
}
#[test]
fn members_are_laid_out_by_attachment_index_not_dictionary_order() {
let node = mrt(vec![
("bloomIntensity", float(1.0)),
("output", output_property()),
]);
let attachments = ["output".to_string(), "bloomIntensity".to_string()];
let members = node.members(&attachments, &[]);
assert_eq!(members[0].0.key(), output_property().key());
assert_eq!(members[1].0.ty(), crate::nodes::Type::F32);
assert_eq!(members[1].1, crate::nodes::Type::Vec4);
}
#[test]
fn blend_modes_and_clear_colors_are_per_output() {
use crate::materials::{BlendFactor, Blending};
use crate::math::Color;
let accum = BlendMode {
blend_src: BlendFactor::One,
blend_dst: BlendFactor::One,
..BlendMode::new(Blending::Custom)
};
let mut node = mrt(vec![("accum", float(1.0)), ("revealage", float(1.0))]);
node.set_blend_mode("accum", Blending::Normal)
.set_blend_mode("accum", accum)
.set_blend_mode("revealage", Blending::Additive)
.set_clear_color("accum", Color::from_hex(0x000000), 0.0)
.set_clear_color("revealage", Color::from_hex(0xffffff), 1.0);
assert_eq!(node.blend_mode("accum"), Some(accum));
assert_eq!(
node.blend_mode("revealage"),
Some(BlendMode::new(Blending::Additive))
);
assert_eq!(node.blend_mode("output"), None);
assert_eq!(node.clear_color("accum"), Some([0.0, 0.0, 0.0, 0.0]));
assert_eq!(node.clear_color("revealage"), Some([1.0, 1.0, 1.0, 1.0]));
assert_eq!(node.clear_color("output"), None);
let state = crate::materials::blending::blending(&accum).expect("custom blends");
assert_eq!(state.color.src_factor, wgpu::BlendFactor::One);
assert_eq!(state.color.dst_factor, wgpu::BlendFactor::One);
assert_eq!(state.alpha, state.color);
}
#[test]
fn merge_keeps_blend_modes_and_clear_colors() {
use crate::materials::Blending;
use crate::math::Color;
let mut pass = mrt(vec![("output", output_property())]);
pass.set_clear_color("output", Color::from_hex(0x000000), 1.0)
.set_clear_color("emissive", Color::from_hex(0x000000), 1.0)
.set_blend_mode("output", Blending::No)
.set_blend_mode("bloom", Blending::Additive);
let mut material = mrt(vec![("emissive", float(0.0))]);
material
.set_clear_color("output", Color::from_hex(0xffffff), 0.5)
.set_blend_mode("emissive", Blending::Normal);
let merged = pass.merge(&material);
assert_eq!(merged.clear_color("output"), Some([1.0, 1.0, 1.0, 0.5]));
assert_eq!(merged.clear_color("emissive"), Some([0.0, 0.0, 0.0, 1.0]));
assert_eq!(merged.blend_mode("output"), None);
assert_eq!(
merged.blend_mode("bloom"),
Some(BlendMode::new(Blending::Additive))
);
assert_eq!(
merged.blend_mode("emissive"),
Some(BlendMode::new(Blending::Normal))
);
material.set_blend_mode("output", Blending::Additive);
assert_eq!(
pass.merge(&material).blend_mode("output"),
Some(BlendMode::new(Blending::Additive))
);
}
#[test]
fn members_take_the_attachment_types() {
let node = mrt(vec![
("accum", output_property()),
("revealage", float(1.0)),
]);
let attachments = ["accum".to_string(), "revealage".to_string()];
let members = node.members(&attachments, &[Type::Vec4, Type::F32]);
assert_eq!(members[0].1, Type::Vec4);
assert_eq!(members[1].1, Type::F32);
}
}