use std::ops::{Deref, DerefMut};
use std::rc::Rc;
use crate::core::Layers;
use crate::materials::{MeshBasicNodeMaterial, ToneMapping};
use crate::math::ColorSpace;
use crate::nodes::display::OitRenderObjects;
use crate::nodes::{MrtNode, NodeRef};
use super::pass::ShadowContext;
use super::render_target::RenderTarget;
use super::{OutlineSelection, RenderObjectFunction, Renderer};
#[derive(Clone, Default)]
pub(crate) struct RenderObjects {
toon_outline: Option<Rc<MeshBasicNodeMaterial>>,
function: Option<Rc<dyn RenderObjectFunction>>,
oit: Option<OitRenderObjects>,
outline_selection: Option<OutlineSelection>,
}
#[derive(Clone)]
pub(crate) struct RendererState {
render_target: Option<RenderTarget>,
active_mipmap_level: u32,
mrt: Option<MrtNode>,
clear_color: [f64; 4],
auto_clear: bool,
auto_clear_color: bool,
auto_clear_depth: bool,
opaque: bool,
transparent: bool,
lighting_enabled: bool,
camera_layers: Option<Layers>,
context_shadow: Option<ShadowContext>,
context_ao: Option<NodeRef>,
render_objects: RenderObjects,
tone_mapping: ToneMapping,
tone_mapping_exposure: f64,
output_color_space: ColorSpace,
pixel_ratio: f64,
scissor_test: bool,
}
impl RendererState {
fn reset(&mut self) {
self.mrt = None;
self.render_objects = RenderObjects::default();
self.clear_color = [0.0, 0.0, 0.0, 1.0];
self.auto_clear = true;
}
}
pub(crate) trait HoldsRendererState {
fn renderer_state(&self) -> RendererState;
fn set_renderer_state(&mut self, state: RendererState);
}
impl HoldsRendererState for Renderer {
fn renderer_state(&self) -> RendererState {
RendererState {
render_target: self.render_target.clone(),
active_mipmap_level: self.active_mipmap_level,
mrt: self.mrt.clone(),
clear_color: self.clear_color,
auto_clear: self.auto_clear,
auto_clear_color: self.auto_clear_color,
auto_clear_depth: self.auto_clear_depth,
opaque: self.opaque,
transparent: self.transparent,
lighting_enabled: self.lighting_enabled,
camera_layers: self.camera_layers,
context_shadow: self.context_shadow.clone(),
context_ao: self.context_ao.clone(),
render_objects: RenderObjects {
toon_outline: self.toon_outline.clone(),
function: self.render_object_function.clone(),
oit: self.oit,
outline_selection: self.outline_selection.clone(),
},
tone_mapping: self.tone_mapping,
tone_mapping_exposure: self.tone_mapping_exposure,
output_color_space: self.output_color_space,
pixel_ratio: self.pixel_ratio,
scissor_test: self.scissor_test,
}
}
fn set_renderer_state(&mut self, state: RendererState) {
self.set_render_target_level(state.render_target, state.active_mipmap_level);
self.mrt = state.mrt;
self.clear_color = state.clear_color;
self.auto_clear = state.auto_clear;
self.auto_clear_color = state.auto_clear_color;
self.auto_clear_depth = state.auto_clear_depth;
self.opaque = state.opaque;
self.transparent = state.transparent;
self.lighting_enabled = state.lighting_enabled;
self.camera_layers = state.camera_layers;
self.context_shadow = state.context_shadow;
self.context_ao = state.context_ao;
self.toon_outline = state.render_objects.toon_outline;
self.render_object_function = state.render_objects.function;
self.oit = state.render_objects.oit;
self.outline_selection = state.render_objects.outline_selection;
self.tone_mapping = state.tone_mapping;
self.tone_mapping_exposure = state.tone_mapping_exposure;
self.output_color_space = state.output_color_space;
if self.pixel_ratio != state.pixel_ratio {
self.set_pixel_ratio(state.pixel_ratio);
}
self.scissor_test = state.scissor_test;
}
}
pub(crate) struct RendererStateScope<'a, T: HoldsRendererState = Renderer> {
holder: &'a mut T,
saved: Option<RendererState>,
}
impl<'a, T: HoldsRendererState> RendererStateScope<'a, T> {
pub(crate) fn save(holder: &'a mut T) -> Self {
let saved = holder.renderer_state();
Self {
holder,
saved: Some(saved),
}
}
pub(crate) fn reset(holder: &'a mut T) -> Self {
let scope = Self::save(holder);
let mut reset = scope
.saved
.clone()
.expect("three-rs: a renderer state scope holds its state until drop");
reset.reset();
scope.holder.set_renderer_state(reset);
scope
}
}
impl<T: HoldsRendererState> Deref for RendererStateScope<'_, T> {
type Target = T;
fn deref(&self) -> &T {
self.holder
}
}
impl<T: HoldsRendererState> DerefMut for RendererStateScope<'_, T> {
fn deref_mut(&mut self) -> &mut T {
self.holder
}
}
impl<T: HoldsRendererState> Drop for RendererStateScope<'_, T> {
fn drop(&mut self) {
if let Some(saved) = self.saved.take() {
self.holder.set_renderer_state(saved);
}
}
}
impl Renderer {
pub(crate) fn save_state(&mut self) -> RendererStateScope<'_> {
RendererStateScope::save(self)
}
pub(crate) fn reset_state(&mut self) -> RendererStateScope<'_> {
RendererStateScope::reset(self)
}
pub(crate) fn with_fullscreen_pass<R>(
&mut self,
fullscreen_pass: bool,
render: impl FnOnce(&mut Self) -> R,
) -> R {
let previous = std::mem::replace(&mut self.fullscreen_pass, fullscreen_pass);
let result = render(self);
self.fullscreen_pass = previous;
result
}
}
#[cfg(test)]
mod tests {
use std::panic::{catch_unwind, AssertUnwindSafe};
use super::*;
struct Holder(RendererState);
impl HoldsRendererState for Holder {
fn renderer_state(&self) -> RendererState {
self.0.clone()
}
fn set_renderer_state(&mut self, state: RendererState) {
self.0 = state;
}
}
fn initial() -> RendererState {
RendererState {
render_target: None,
active_mipmap_level: 0,
mrt: None,
clear_color: [0.0, 0.0, 0.0, 0.0],
auto_clear: true,
auto_clear_color: true,
auto_clear_depth: true,
opaque: true,
transparent: true,
lighting_enabled: true,
camera_layers: None,
context_shadow: None,
context_ao: None,
render_objects: RenderObjects::default(),
tone_mapping: ToneMapping::None,
tone_mapping_exposure: 1.0,
output_color_space: ColorSpace::Srgb,
pixel_ratio: 1.0,
scissor_test: false,
}
}
fn outer() -> RendererState {
RendererState {
render_target: Some(RenderTarget::new(4, 4)),
active_mipmap_level: 2,
mrt: Some(MrtNode::default()),
clear_color: [0.25, 0.5, 0.75, 0.5],
auto_clear: false,
auto_clear_color: false,
auto_clear_depth: false,
opaque: false,
transparent: false,
lighting_enabled: false,
camera_layers: Some(Layers::default()),
context_shadow: None,
context_ao: Some(crate::nodes::tsl::float(1.0)),
render_objects: RenderObjects {
oit: Some(OitRenderObjects::Accumulate),
..RenderObjects::default()
},
tone_mapping: ToneMapping::AcesFilmic,
tone_mapping_exposure: 2.0,
output_color_space: ColorSpace::LinearSrgb,
pixel_ratio: 2.0,
scissor_test: true,
}
}
fn assert_same(a: &RendererState, b: &RendererState) {
let target = |s: &RendererState| s.render_target.as_ref().map(|t| t.texture().id());
assert_eq!(target(a), target(b), "render target");
assert_eq!(a.active_mipmap_level, b.active_mipmap_level);
assert_eq!(a.mrt.is_some(), b.mrt.is_some(), "mrt");
assert_eq!(a.clear_color, b.clear_color);
assert_eq!(a.auto_clear, b.auto_clear);
assert_eq!(a.auto_clear_color, b.auto_clear_color);
assert_eq!(a.auto_clear_depth, b.auto_clear_depth);
assert_eq!(a.opaque, b.opaque);
assert_eq!(a.transparent, b.transparent);
assert_eq!(a.lighting_enabled, b.lighting_enabled);
assert_eq!(a.camera_layers, b.camera_layers);
assert_eq!(a.context_shadow.is_some(), b.context_shadow.is_some());
assert_eq!(
a.context_ao.as_ref().map(NodeRef::key),
b.context_ao.as_ref().map(NodeRef::key),
"context ao"
);
assert_eq!(a.render_objects.oit, b.render_objects.oit);
assert_eq!(
a.render_objects.toon_outline.is_some(),
b.render_objects.toon_outline.is_some()
);
assert_eq!(
a.render_objects.function.is_some(),
b.render_objects.function.is_some()
);
assert_eq!(
a.render_objects.outline_selection.is_some(),
b.render_objects.outline_selection.is_some()
);
assert_eq!(a.tone_mapping, b.tone_mapping);
assert_eq!(a.tone_mapping_exposure, b.tone_mapping_exposure);
assert_eq!(a.output_color_space, b.output_color_space);
assert_eq!(a.pixel_ratio, b.pixel_ratio);
assert_eq!(a.scissor_test, b.scissor_test);
}
#[test]
fn save_restores_every_field_on_drop() {
let start = outer();
let mut holder = Holder(start.clone());
{
let mut scope = RendererStateScope::save(&mut holder);
assert_same(&scope.0, &start);
scope.0 = initial();
scope.0.render_target = Some(RenderTarget::new(2, 2));
}
assert_same(&holder.0, &start);
}
#[test]
fn reset_changes_its_four_fields_and_restores_them() {
let start = outer();
let mut holder = Holder(start.clone());
{
let scope = RendererStateScope::reset(&mut holder);
let mut expected = start.clone();
expected.mrt = None;
expected.render_objects = RenderObjects::default();
expected.clear_color = [0.0, 0.0, 0.0, 1.0];
expected.auto_clear = true;
assert_same(&scope.0, &expected);
}
assert_same(&holder.0, &start);
}
#[test]
fn nested_scopes_restore_in_order() {
let mut holder = Holder(initial());
{
let mut outer_scope = RendererStateScope::save(&mut holder);
outer_scope.0.auto_clear_depth = false;
{
let mut inner = RendererStateScope::reset(&mut *outer_scope);
inner.0.auto_clear_depth = true;
inner.0.clear_color = [1.0, 1.0, 1.0, 1.0];
}
assert!(!outer_scope.0.auto_clear_depth);
assert_eq!(outer_scope.0.clear_color, [0.0, 0.0, 0.0, 0.0]);
}
assert_same(&holder.0, &initial());
}
#[test]
fn early_return_restores() {
fn nested(holder: &mut Holder, bail: bool) -> Option<()> {
let mut scope = RendererStateScope::reset(holder);
scope.0.opaque = false;
if bail {
return None;
}
scope.0.transparent = false;
Some(())
}
let mut holder = Holder(initial());
assert_eq!(nested(&mut holder, true), None);
assert_same(&holder.0, &initial());
assert_eq!(nested(&mut holder, false), Some(()));
assert_same(&holder.0, &initial());
}
#[test]
fn panic_restores() {
let start = outer();
let mut holder = Holder(start.clone());
let result = catch_unwind(AssertUnwindSafe(|| {
let mut scope = RendererStateScope::reset(&mut holder);
scope.0.render_target = None;
panic!("nested render failed");
}));
assert!(result.is_err());
assert_same(&holder.0, &start);
}
}