use std::rc::Rc;
use std::sync::atomic::{AtomicUsize, Ordering};
use super::{block, context, custom, dot, float, pack_normal_to_rgb, sqrt, to_varying, uv};
use crate::nodes::code::CodeDef;
use crate::nodes::node::{ContextValue, CustomNode, DebugCallback, Node, NodeRef, Type};
use crate::nodes::{NodeBuilder, NodeUpdateType};
use crate::renderer::Renderer;
pub fn uniform_flow(node: impl Into<NodeRef>) -> NodeRef {
context(node, ContextValue::default().uniform_flow(true))
}
pub fn set_name(node: impl Into<NodeRef>, name: &'static str) -> NodeRef {
context(node, ContextValue::default().node_name(name))
}
#[deprecated(note = "three.js r179 renamed `label()` to `setName()`; use `set_name`")]
pub fn label(node: impl Into<NodeRef>, name: &'static str) -> NodeRef {
set_name(node, name)
}
pub fn bypass(output: impl Into<NodeRef>, call: impl Into<NodeRef>) -> NodeRef {
block(vec![call.into()], output.into())
}
pub fn vertex_stage(node: impl Into<NodeRef>) -> NodeRef {
to_varying(None, node.into())
}
pub fn unpack_normal(xy: impl Into<NodeRef>) -> NodeRef {
let xy = xy.into();
let z = sqrt(float(1.0).sub(dot(xy.clone(), xy.clone())).saturate());
super::vec3_join(vec![xy, z])
}
#[deprecated(note = "three.js r185 renamed `directionToColor()` to `packNormalToRGB()`")]
pub fn direction_to_color(node: impl Into<NodeRef>) -> NodeRef {
pack_normal_to_rgb(node.into())
}
pub fn unpack_rgb_to_normal(node: impl Into<NodeRef>) -> NodeRef {
node.into().mul(2.0).sub(1.0)
}
#[deprecated(note = "three.js r185 renamed `colorToDirection()` to `unpackRGBToNormal()`")]
pub fn color_to_direction(node: impl Into<NodeRef>) -> NodeRef {
unpack_rgb_to_normal(node)
}
pub fn expression(snippet: &str, ty: Type) -> NodeRef {
NodeRef::new(Node::Expression {
snippet: snippet.into(),
ty,
})
}
pub fn debug(node: impl Into<NodeRef>, callback: Option<DebugCallback>) -> NodeRef {
NodeRef::new(Node::Debug {
node: node.into(),
callback,
})
}
type SampleCallback = Rc<dyn Fn(NodeRef) -> NodeRef>;
#[derive(Clone)]
pub struct SampleNode {
callback: SampleCallback,
node: NodeRef,
}
impl std::fmt::Debug for SampleNode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SampleNode").finish_non_exhaustive()
}
}
struct SampleSetup {
callback: SampleCallback,
ty: Type,
}
impl CustomNode for SampleSetup {
fn type_name(&self) -> &'static str {
"SampleNode"
}
fn node_type(&self) -> Type {
self.ty
}
fn is_cacheable(&self) -> bool {
false
}
fn setup(&self, _builder: &NodeBuilder) -> NodeRef {
(self.callback)(uv())
}
}
impl SampleNode {
pub fn sample(&self, uv: impl Into<NodeRef>) -> NodeRef {
(self.callback)(uv.into())
}
pub fn node(&self) -> NodeRef {
self.node.clone()
}
}
impl From<&SampleNode> for NodeRef {
fn from(node: &SampleNode) -> Self {
node.node()
}
}
impl From<SampleNode> for NodeRef {
fn from(node: SampleNode) -> Self {
node.node
}
}
pub fn sample(callback: impl Fn(NodeRef) -> NodeRef + 'static) -> SampleNode {
let callback: SampleCallback = Rc::new(callback);
let ty = callback(uv()).ty();
let node = custom(SampleSetup {
callback: callback.clone(),
ty,
});
SampleNode { callback, node }
}
pub fn wgsl(code: &str, includes: Vec<NodeRef>) -> NodeRef {
static NEXT: AtomicUsize = AtomicUsize::new(0);
let name = format!("#wgsl{}", NEXT.fetch_add(1, Ordering::Relaxed));
super::code(&Rc::new(CodeDef {
name,
code: code.to_string(),
params: Vec::new(),
ret: Type::Void,
includes,
}))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EventType {
Object,
Material,
Frame,
AfterObject,
BeforeObject,
BeforeMaterial,
BeforeFrame,
}
struct EventNode {
event: EventType,
callback: Box<dyn Fn(&mut Renderer)>,
}
impl EventNode {
fn phase(&self, before: bool, after: bool) -> NodeUpdateType {
use EventType::*;
match (self.event, before, after) {
(Object, false, false) | (AfterObject, false, true) | (BeforeObject, true, false) => {
NodeUpdateType::Object
}
(Material, false, false) | (BeforeMaterial, true, false) => NodeUpdateType::Render,
(Frame, false, false) | (BeforeFrame, true, false) => NodeUpdateType::Frame,
_ => NodeUpdateType::None,
}
}
}
impl CustomNode for EventNode {
fn type_name(&self) -> &'static str {
"EventNode"
}
fn node_type(&self) -> Type {
Type::Void
}
fn is_cacheable(&self) -> bool {
false
}
fn setup(&self, _builder: &NodeBuilder) -> NodeRef {
expression("", Type::Void)
}
fn update_before_type(&self) -> NodeUpdateType {
self.phase(true, false)
}
fn update_type(&self) -> NodeUpdateType {
self.phase(false, false)
}
fn update_after_type(&self) -> NodeUpdateType {
self.phase(false, true)
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
(self.callback)(renderer);
true
}
fn update(&self, renderer: &mut Renderer) -> bool {
(self.callback)(renderer);
true
}
fn update_after(&self, renderer: &mut Renderer) -> bool {
(self.callback)(renderer);
true
}
}
fn event(event: EventType, callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
custom(EventNode {
event,
callback: Box::new(callback),
})
}
pub fn on_object_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::Object, callback)
}
pub fn on_material_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::Material, callback)
}
pub fn on_frame_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::Frame, callback)
}
pub fn on_after_object_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::AfterObject, callback)
}
pub fn on_before_object_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::BeforeObject, callback)
}
pub fn on_before_material_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::BeforeMaterial, callback)
}
pub fn on_before_frame_update(callback: impl Fn(&mut Renderer) + 'static) -> NodeRef {
event(EventType::BeforeFrame, callback)
}
fn rename_or_set_name(node: &NodeRef, name: &'static str) -> NodeRef {
if let Node::Uniform(u) = node.node() {
u.name.set(Some(name));
return node.clone();
}
set_name(node, name)
}
impl NodeRef {
pub fn bypass(&self, call: impl Into<NodeRef>) -> NodeRef {
bypass(self, call)
}
pub fn uniform_flow(&self) -> NodeRef {
uniform_flow(self)
}
pub fn set_name(&self, name: &'static str) -> NodeRef {
rename_or_set_name(self, name)
}
#[deprecated(note = "three.js r179 renamed `label()` to `setName()`; use `set_name`")]
pub fn label(&self, name: &'static str) -> NodeRef {
rename_or_set_name(self, name)
}
pub fn to_vertex_stage(&self) -> NodeRef {
vertex_stage(self)
}
pub fn debug(&self, callback: Option<DebugCallback>) -> NodeRef {
debug(self, callback)
}
}