use std::cell::{Cell, RefCell, RefMut};
use std::rc::Rc;
use crate::cameras::{PerspectiveCamera, StereoCamera};
use crate::materials::MeshBasicNodeMaterial;
use crate::math::CoordinateSystem;
use crate::nodes::frame::register_texture_update;
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{PassNode, RenderTarget, RenderTargetOptions, Renderer, SceneRef};
use crate::textures::{Texture, TextureFilter, TextureType};
pub(super) const RENDERER_COORDINATE_SYSTEM: CoordinateSystem = CoordinateSystem::WebGpu;
pub(super) fn update_source_camera(camera: &RefCell<PerspectiveCamera>) {
camera.borrow_mut().update_matrix_world();
}
pub(super) struct AnaglyphEyes {
pub(super) eye_sep: Cell<f64>,
pub(super) plane_distance: Cell<f64>,
}
pub(crate) struct CompositeState {
pass: PassNode,
scene: SceneRef,
camera: Rc<RefCell<PerspectiveCamera>>,
stereo: RefCell<StereoCamera>,
target_l: RenderTarget,
target_r: RenderTarget,
quad: RefCell<QuadMesh>,
anaglyph: Option<AnaglyphEyes>,
}
impl CompositeState {
pub(super) fn new(
scene: SceneRef,
camera: Rc<RefCell<PerspectiveCamera>>,
anaglyph: Option<AnaglyphEyes>,
material: impl FnOnce(&Texture, &Texture) -> MeshBasicNodeMaterial,
) -> Rc<Self> {
let options = || RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: true,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Nearest,
};
let target_l = RenderTarget::new_with_options(1, 1, options())
.expect("three-rs: a stereo eye target is a colour type");
let target_r = RenderTarget::new_with_options(1, 1, options())
.expect("three-rs: a stereo eye target is a colour type");
let quad = QuadMesh::new(material(&target_l.texture(), &target_r.texture()));
let pass = PassNode::new();
let state = Rc::new(Self {
pass,
scene,
camera,
stereo: RefCell::new(StereoCamera::new()),
target_l,
target_r,
quad: RefCell::new(quad),
anaglyph,
});
register_texture_update(state.pass.texture().id(), &state);
register_texture_update(state.pass.depth_texture().id(), &state);
state
}
pub(super) fn node(&self) -> NodeRef {
self.pass.node()
}
pub(super) fn stereo(&self) -> RefMut<'_, StereoCamera> {
self.stereo.borrow_mut()
}
pub(super) fn quad(&self) -> std::cell::Ref<'_, QuadMesh> {
self.quad.borrow()
}
pub(super) fn anaglyph(&self) -> Option<&AnaglyphEyes> {
self.anaglyph.as_ref()
}
pub(super) fn update_stereo_camera(&self, coordinate_system: CoordinateSystem) {
let camera = self.camera.borrow();
let mut stereo = self.stereo.borrow_mut();
match &self.anaglyph {
None => {
stereo.camera_l.coordinate_system = coordinate_system;
stereo.camera_r.coordinate_system = coordinate_system;
stereo.update(&camera);
}
Some(eyes) => super::anaglyph_pass::update_stereo_camera(
&mut stereo,
&camera,
eyes.eye_sep.get(),
eyes.plane_distance.get(),
coordinate_system,
),
}
}
fn set_size(&self, width: u32, height: u32) {
let target = self.pass.render_target();
target.set_size(width, height);
let (width, height) = target.size();
self.target_l.set_size(width, height);
self.target_r.set_size(width, height);
}
}
impl NodeUpdate for CompositeState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
let mut renderer = renderer.reset_state();
update_source_camera(&self.camera);
self.update_stereo_camera(RENDERER_COORDINATE_SYSTEM);
let (width, height) = renderer.drawing_buffer_size();
self.set_size(width, height);
self.pass.render_target().set_samples(renderer.samples());
{
let scene = self.scene.borrow();
let mut stereo = self.stereo.borrow_mut();
renderer.set_render_target(Some(self.target_l.clone()));
renderer.render_nested(&scene, &mut stereo.camera_l);
renderer.set_render_target(Some(self.target_r.clone()));
renderer.render_nested(&scene, &mut stereo.camera_r);
}
renderer.set_render_target(Some(self.pass.render_target().clone()));
renderer.render_quad(&self.quad.borrow());
drop(renderer);
true
}
fn sync_before_build(&self, samples: u32) {
self.pass.render_target().set_samples(samples);
}
}