use crate::{OwnedArgument, OwnedData};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EdgeKind {
SceneMember,
AttributeBinding,
SurfaceShader,
DisplacementShader,
VolumeShader,
LensShader,
BackgroundLayer,
Bounds,
SubsurfaceSet,
ExclusiveShading,
FaceSet,
Other {
to_attribute: String,
},
InstanceSource,
SetMember,
LightSet,
ShaderAttributes,
Screen,
OutputLayer,
OutputDriver,
ShaderNetwork {
from_port: String,
to_port: String,
},
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Edge {
pub(crate) from: crate::handle::Handle,
pub(crate) to: crate::handle::Handle,
pub kind: EdgeKind,
pub args: Vec<OwnedArgument>,
}
impl EdgeKind {
pub fn to_attribute(&self) -> &str {
match self {
Self::SceneMember => "objects",
Self::AttributeBinding => "geometryattributes",
Self::SurfaceShader => "surfaceshader",
Self::DisplacementShader => "displacementshader",
Self::VolumeShader => "volumeshader",
Self::LensShader => "lensshader",
Self::BackgroundLayer => "backgroundlayer",
Self::Bounds => "bounds",
Self::SubsurfaceSet => "visibility.set.subsurface",
Self::ExclusiveShading => "exclusiveshading",
Self::FaceSet => "facesets",
Self::Other { to_attribute } => to_attribute,
Self::InstanceSource => "sourcemodels",
Self::SetMember => "members",
Self::LightSet => "lightset",
Self::ShaderAttributes => "shaderattributes",
Self::Screen => "screens",
Self::OutputLayer => "outputlayers",
Self::OutputDriver => "outputdrivers",
Self::ShaderNetwork { to_port, .. } => to_port,
}
}
}
impl Edge {
pub fn priority(&self) -> i32 {
self.integer_argument("priority")
}
pub fn index(&self) -> i32 {
self.integer_argument("index")
}
pub fn strength(&self) -> i32 {
self.integer_argument("strength")
}
fn integer_argument(&self, name: &str) -> i32 {
self.args
.iter()
.find(|arg| arg.name == name)
.and_then(|arg| match &arg.data {
OwnedData::I32(values) => values.first().copied(),
OwnedData::I64(values) => values.first().map(|v| *v as i32),
_ => None,
})
.unwrap_or(0)
}
}
pub fn classify(from_attribute: Option<&str>, to_attribute: &str) -> EdgeKind {
if let Some(from_port) = from_attribute.filter(|port| !port.is_empty()) {
return EdgeKind::ShaderNetwork {
from_port: from_port.to_string(),
to_port: to_attribute.to_string(),
};
}
match to_attribute {
"objects" => EdgeKind::SceneMember,
"geometryattributes" => EdgeKind::AttributeBinding,
"surfaceshader" => EdgeKind::SurfaceShader,
"displacementshader" => EdgeKind::DisplacementShader,
"volumeshader" => EdgeKind::VolumeShader,
"lensshader" => EdgeKind::LensShader,
"backgroundlayer" => EdgeKind::BackgroundLayer,
"bounds" => EdgeKind::Bounds,
"visibility.set.subsurface" => EdgeKind::SubsurfaceSet,
"exclusiveshading" => EdgeKind::ExclusiveShading,
"sourcemodels" => EdgeKind::InstanceSource,
"members" => EdgeKind::SetMember,
"lightset" => EdgeKind::LightSet,
"shaderattributes" => EdgeKind::ShaderAttributes,
"screens" => EdgeKind::Screen,
"outputlayers" => EdgeKind::OutputLayer,
"outputdrivers" => EdgeKind::OutputDriver,
"facesets" => EdgeKind::FaceSet,
other => EdgeKind::Other {
to_attribute: other.to_string(),
},
}
}
impl Edge {
pub fn from(&self) -> &str {
&self.from
}
pub fn to(&self) -> &str {
&self.to
}
}