use std::fmt::Debug;
use super::phong::{self, LightDesc};
use crate::nodes::tsl::*;
use crate::nodes::NodeRef;
#[derive(Clone, Debug)]
pub struct ReflectedLight {
pub direct_diffuse: NodeRef,
pub direct_specular: NodeRef,
pub indirect_diffuse: NodeRef,
pub indirect_specular: NodeRef,
}
impl ReflectedLight {
fn new() -> Self {
let zero = || vec3(0.0, 0.0, 0.0);
Self {
direct_diffuse: zero().to_var("directDiffuse"),
direct_specular: zero().to_var("directSpecular"),
indirect_diffuse: zero().to_var("indirectDiffuse"),
indirect_specular: zero().to_var("indirectSpecular"),
}
}
}
#[derive(Clone, Debug)]
pub struct DirectLightData {
pub light_direction: NodeRef,
pub light_color: NodeRef,
pub reflected_light: ReflectedLight,
}
#[derive(Debug)]
pub struct LightingBuilder<'a> {
pub stack: Vec<NodeRef>,
pub reflected_light: ReflectedLight,
lights: &'a [LightDesc],
received_shadow_position: Option<&'a NodeRef>,
}
impl LightingBuilder<'_> {
pub fn push(&mut self, node: NodeRef) {
self.stack.push(node);
}
pub fn setup_lights<M: LightingModel + ?Sized>(&mut self, model: &M) {
for light in self.lights {
let Some((light_direction, light_color)) =
phong::setup_light(light, self.received_shadow_position, &mut self.stack)
else {
continue;
};
let data = DirectLightData {
light_direction,
light_color,
reflected_light: self.reflected_light.clone(),
};
model.direct(&data, self);
}
}
}
pub trait LightingModel: Debug {
fn start(&self, builder: &mut LightingBuilder) {
builder.setup_lights(self);
self.indirect(builder);
}
fn finish(&self, _builder: &mut LightingBuilder) {}
fn direct(&self, _data: &DirectLightData, _builder: &mut LightingBuilder) {}
fn indirect(&self, _builder: &mut LightingBuilder) {}
}
pub(crate) fn lights_node(
model: &dyn LightingModel,
lights: &[LightDesc],
received_shadow_position: Option<&NodeRef>,
backdrop: &dyn Fn(NodeRef) -> NodeRef,
out: &mut Vec<NodeRef>,
) -> NodeRef {
let mut builder = LightingBuilder {
stack: Vec::new(),
reflected_light: ReflectedLight::new(),
lights,
received_shadow_position,
};
model.start(&mut builder);
let ReflectedLight {
direct_diffuse,
direct_specular,
indirect_diffuse,
indirect_specular,
} = builder.reflected_light.clone();
builder.push(total_diffuse().assign(backdrop(direct_diffuse.add(indirect_diffuse))));
builder.push(total_specular().assign(direct_specular.add(indirect_specular)));
builder.push(outgoing_light().assign(total_diffuse().add(total_specular())));
model.finish(&mut builder);
out.extend(builder.stack);
outgoing_light()
}