use crate::materials::environment::PmremHandle;
use crate::nodes::node::Type;
use crate::nodes::tsl::uniform_value;
use crate::nodes::NodeRef;
use crate::renderer::pmrem::{
allocate_target, cube_size_for, max_lod_for, PmremGenerator, PmremSource, SCENE_SIZE,
};
use crate::renderer::Renderer;
use crate::textures::{CubeTexture, Texture};
pub struct PmremEnvironment {
source: Option<PmremSource>,
generator: PmremGenerator,
texture: CubeTexture,
max_lod: NodeRef,
built: bool,
}
impl PmremEnvironment {
pub fn new(source: &CubeTexture) -> Self {
Self::from_source(PmremSource::Cube(source.clone()))
}
pub fn from_equirectangular(source: &Texture) -> Self {
Self::from_source(PmremSource::Equirectangular(source.clone()))
}
pub fn from_scene(
renderer: &mut Renderer,
scene: &mut crate::objects::Scene,
sigma: f64,
) -> Result<Self, crate::error::Error> {
let mut environment = Self::with_size(None, cube_size_for(SCENE_SIZE));
let texture = environment.texture.clone();
environment
.generator
.from_scene(renderer, scene, sigma, Some(texture))?;
environment.built = true;
Ok(environment)
}
fn from_source(source: PmremSource) -> Self {
let size = cube_size_for(source.requested_size());
Self::with_size(Some(source), size)
}
fn with_size(source: Option<PmremSource>, size: u32) -> Self {
let texture = allocate_target(size);
Self {
source,
generator: PmremGenerator::new(),
texture,
max_lod: uniform_value(Type::F32, vec![max_lod_for(size) as f64]),
built: false,
}
}
pub fn update(&mut self, renderer: &mut Renderer) -> Result<(), crate::error::Error> {
if self.built {
return Ok(());
}
let Some(source) = self.source.clone() else {
return Ok(());
};
self.generator
.from_texture(renderer, &source, Some(self.texture.clone()))?;
self.built = true;
Ok(())
}
pub fn handle(&self) -> PmremHandle {
PmremHandle {
texture: self.texture.clone(),
max_lod: self.max_lod.clone(),
}
}
pub fn texture(&self) -> &CubeTexture {
&self.texture
}
pub fn sample(&self, uv: NodeRef, level: NodeRef) -> NodeRef {
self.handle().sample(uv, level)
}
}
pub fn pmrem_texture(env: &PmremEnvironment, uv: NodeRef, level: NodeRef) -> NodeRef {
env.sample(uv, level)
}