use std::hash::{Hash, Hasher};
use std::rc::Rc;
use super::NodeRef;
#[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, crate::materials::Blending)>,
}
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,
blending: crate::materials::Blending,
) {
let name = name.into();
match self.blend_modes.iter_mut().find(|(n, _)| *n == name) {
Some(entry) => entry.1 = blending,
None => self.blend_modes.push((name, blending)),
}
}
pub fn blend_mode(&self, name: &str) -> Option<crate::materials::Blending> {
self.blend_modes
.iter()
.find(|(n, _)| n == name)
.map(|(_, b)| *b)
}
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());
}
for (name, blending) in &other.blend_modes {
merged.set_blend_mode(name.clone(), *blending);
}
merged
}
pub(crate) fn members(&self, attachments: &[String]) -> Vec<NodeRef> {
let mut members: Vec<Option<NodeRef>> = vec![None; attachments.len()];
for (name, value) in &self.outputs {
if let Some(index) = attachments.iter().position(|a| a == name) {
members[index] = Some(value.resolve());
}
}
while matches!(members.last(), Some(None)) {
members.pop();
}
members
.into_iter()
.map(|m| m.expect("three-rs: an MRT member index below the last is always filled"))
.collect()
}
}
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].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].key(), output_property().key());
assert_eq!(members[1].ty(), crate::nodes::Type::F32);
}
}