use std::collections::HashMap;
use std::rc::Rc;
use crate::cameras::PerspectiveCamera;
use crate::core::BufferGeometry;
use crate::error::Error;
use crate::geometries::box_geometry;
use crate::materials::{Blending, MeshBasicNodeMaterial, Side};
use crate::math::Vector3;
use crate::nodes::node::{SettableValue, Type};
use crate::nodes::pmrem_utils;
use crate::nodes::tsl::{
block, cube_texture, dpdx, dpdy, equirect_uv, float, position_world_direction, texture_level,
to_const, uniform_settable, uniform_value, vec4_join,
};
use crate::nodes::NodeRef;
use crate::objects::{Background, Mesh, Scene};
use crate::textures::{CubeTexture, Texture, TextureFilter, TextureType};
use super::cube_render_target::{FACES, FOV};
use super::render_target::{RenderTarget, RenderTargetOptions};
pub(crate) const MIN_SIZE: u32 = 256;
pub(crate) const LOD_MIN: u32 = 3;
pub(crate) const BLUR_SAMPLES: usize = 20;
pub(crate) const GGX_SAMPLES: usize = 256;
#[doc(hidden)]
pub const INTEGRATION_SIZE: u32 = 16;
pub(crate) const INTEGRATION_LEVELS: u32 = 3;
pub(crate) const SCENE_SIZE: u32 = 256;
pub(crate) const SCENE_NEAR: f64 = 0.1;
pub(crate) const SCENE_FAR: f64 = 100.0;
const CUBE_NEAR: f64 = 1.0;
const CUBE_FAR: f64 = 10.0;
#[derive(Clone, Debug)]
pub(crate) enum PmremSource {
Cube(CubeTexture),
Equirectangular(Texture),
}
impl PmremSource {
pub fn requested_size(&self) -> u32 {
match self {
PmremSource::Cube(cube) => match cube.size().0 {
0 => MIN_SIZE,
width => width,
},
PmremSource::Equirectangular(texture) => texture.size().0 / 4,
}
}
}
#[doc(hidden)]
pub fn cube_size_for(requested: u32) -> u32 {
let floor_pow2 = if requested == 0 {
0
} else {
1u32 << (31 - requested.leading_zeros())
};
MIN_SIZE.max(floor_pow2)
}
#[doc(hidden)]
pub fn max_lod_for(size: u32) -> u32 {
size.trailing_zeros().saturating_sub(LOD_MIN)
}
pub fn lod_to_roughness(lod: u32, max_lod: u32) -> f64 {
if max_lod > 0 {
1.0 - (1.0 - lod as f64 / max_lod as f64).sqrt()
} else {
0.0
}
}
#[doc(hidden)]
pub fn lod_bias(size: u32, roughness: f64) -> f64 {
if roughness > 0.0 {
(size as f64).log2() + 0.5 * (6.0 / (GGX_SAMPLES as f64 * roughness.powi(4))).log2() + 0.5
} else {
0.0
}
}
#[doc(hidden)]
pub fn uses_integration(lod: u32, max_lod: u32) -> bool {
lod as i64 > max_lod as i64 - INTEGRATION_LEVELS as i64
}
pub(crate) fn allocate_target(size: u32) -> CubeTexture {
CubeTexture::pmrem_render_target(size, Some(max_lod_for(size) + 1))
}
struct GgxMaterial {
material: MeshBasicNodeMaterial,
roughness: SettableValue,
lod_bias: SettableValue,
}
struct IntegrationMaterial {
material: MeshBasicNodeMaterial,
roughness: SettableValue,
source_lod: SettableValue,
}
pub struct PmremGenerator {
cube_size: u32,
source: Option<(CubeTexture, bool)>,
face_targets: HashMap<(u32, bool), RenderTarget>,
box_geometry: Rc<BufferGeometry>,
cubemap_material: Option<MeshBasicNodeMaterial>,
equirect_material: Option<MeshBasicNodeMaterial>,
ggx: Option<GgxMaterial>,
integration: Option<IntegrationMaterial>,
}
impl Default for PmremGenerator {
fn default() -> Self {
Self::new()
}
}
impl PmremGenerator {
pub fn new() -> Self {
Self {
cube_size: 0,
source: None,
face_targets: HashMap::new(),
box_geometry: Rc::new(box_geometry(5.0, 5.0, 5.0, 1, 1, 1)),
cubemap_material: None,
equirect_material: None,
ggx: None,
integration: None,
}
}
fn set_size(&mut self, requested: u32) {
self.cube_size = cube_size_for(requested);
}
fn source_target(&mut self, depth_buffer: bool) -> CubeTexture {
let size = self.cube_size;
let fresh = match &self.source {
None => true,
Some((source, depth)) => source.size().0 != size || (depth_buffer && !depth),
};
if fresh {
self.source = Some((CubeTexture::pmrem_render_target(size, None), depth_buffer));
self.ggx = None;
self.integration = None;
}
self.source
.as_ref()
.expect("three-rs: the source target was just allocated")
.0
.clone()
}
fn face_target(&mut self, size: u32, depth_buffer: bool) -> Result<RenderTarget, Error> {
if let Some(target) = self.face_targets.get(&(size, depth_buffer)) {
return Ok(target.clone());
}
let target = RenderTarget::new_with_options(
size,
size,
RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)?;
self.face_targets
.insert((size, depth_buffer), target.clone());
Ok(target)
}
#[allow(clippy::too_many_arguments)]
fn render_faces(
&mut self,
renderer: &mut super::Renderer,
scene: &mut Scene,
target: &CubeTexture,
lod: u32,
near: f64,
far: f64,
position: Vector3,
depth_buffer: bool,
) -> Result<(), Error> {
let size = target.size().0 >> lod;
let face_target = self.face_target(size, depth_buffer)?;
let previous_mrt = renderer.mrt();
let previous_target = renderer.render_target();
renderer.set_mrt(None);
renderer.set_render_target(Some(face_target.clone()));
let mut camera = PerspectiveCamera::new(FOV, 1.0, near, far);
for (layer, (up, look_at)) in FACES.iter().enumerate() {
{
let mut object = camera.node.borrow_mut();
object.position.set(position.x, position.y, position.z);
object.up = Vector3::new(up[0], up[1], up[2]);
}
camera.look_at(&Vector3::new(
position.x + look_at[0],
position.y + look_at[1],
position.z + look_at[2],
));
renderer.render(scene, &mut camera);
renderer.copy_to_cube_layer(&face_target, target, layer as u32, lod);
}
renderer.set_render_target(previous_target);
renderer.set_mrt(previous_mrt);
Ok(())
}
fn render_cube(
&mut self,
renderer: &mut super::Renderer,
target: &CubeTexture,
lod: u32,
material: &MeshBasicNodeMaterial,
) -> Result<(), Error> {
let mesh = Mesh::new(self.box_geometry.clone(), material.clone());
let mut scene = Scene::new();
scene.add(&mesh);
self.render_faces(
renderer,
&mut scene,
target,
lod,
CUBE_NEAR,
CUBE_FAR,
Vector3::ZERO,
false,
)
}
pub fn from_scene(
&mut self,
renderer: &mut super::Renderer,
scene: &mut Scene,
sigma: f64,
render_target: Option<CubeTexture>,
) -> Result<CubeTexture, Error> {
self.set_size(SCENE_SIZE);
let pmrem = render_target.unwrap_or_else(|| allocate_target(self.cube_size));
let source = self.source_target(true);
let auto_clear = (
renderer.auto_clear,
renderer.auto_clear_color,
renderer.auto_clear_depth,
);
renderer.auto_clear = true;
renderer.auto_clear_color = true;
renderer.auto_clear_depth = true;
let background = scene.background.clone();
if background.is_none() {
scene.background = Some(Background::Color(renderer.clear_color()));
}
let result = self.render_faces(
renderer,
scene,
&source,
0,
SCENE_NEAR,
SCENE_FAR,
Vector3::ZERO,
true,
);
(
renderer.auto_clear,
renderer.auto_clear_color,
renderer.auto_clear_depth,
) = auto_clear;
scene.background = background;
result?;
if sigma > 0.0 {
self.blur(renderer, &pmrem, sigma)?;
} else {
renderer.generate_cube_mipmaps(&source);
}
self.apply_pmrem(renderer, &pmrem)?;
Ok(pmrem)
}
pub fn from_cubemap(
&mut self,
renderer: &mut super::Renderer,
cubemap: &CubeTexture,
render_target: Option<CubeTexture>,
) -> Result<CubeTexture, Error> {
self.from_texture(renderer, &PmremSource::Cube(cubemap.clone()), render_target)
}
pub fn from_equirectangular(
&mut self,
renderer: &mut super::Renderer,
equirectangular: &Texture,
render_target: Option<CubeTexture>,
) -> Result<CubeTexture, Error> {
self.from_texture(
renderer,
&PmremSource::Equirectangular(equirectangular.clone()),
render_target,
)
}
#[allow(clippy::wrong_self_convention)] pub(crate) fn from_texture(
&mut self,
renderer: &mut super::Renderer,
source: &PmremSource,
render_target: Option<CubeTexture>,
) -> Result<CubeTexture, Error> {
self.set_size(source.requested_size());
let pmrem = render_target.unwrap_or_else(|| allocate_target(self.cube_size));
self.texture_to_cubemap(renderer, source)?;
self.apply_pmrem(renderer, &pmrem)?;
Ok(pmrem)
}
fn texture_to_cubemap(
&mut self,
renderer: &mut super::Renderer,
source: &PmremSource,
) -> Result<(), Error> {
let material = match source {
PmremSource::Cube(cube) => self
.cubemap_material
.get_or_insert_with(|| cubemap_material(cube))
.clone(),
PmremSource::Equirectangular(map) => self
.equirect_material
.get_or_insert_with(|| equirect_material(map))
.clone(),
};
let target = self.source_target(false);
self.render_cube(renderer, &target, 0, &material)?;
renderer.generate_cube_mipmaps(&target);
Ok(())
}
fn apply_pmrem(
&mut self,
renderer: &mut super::Renderer,
pmrem: &CubeTexture,
) -> Result<(), Error> {
let size = self.cube_size;
let source = self.source_target(false);
if self.ggx.is_none() {
self.ggx = Some(ggx_material(&source));
self.integration = Some(integration_material(&source));
}
let max_lod = pmrem.mip_level_count() - 1;
let (ggx, integration) = (
self.ggx.as_ref().expect("three-rs: built above"),
self.integration.as_ref().expect("three-rs: built above"),
);
let (ggx_material, ggx_roughness, ggx_lod_bias) = (
ggx.material.clone(),
ggx.roughness.clone(),
ggx.lod_bias.clone(),
);
let (integration_material, integration_roughness) =
(integration.material.clone(), integration.roughness.clone());
integration
.source_lod
.set(vec![(size as f64 / INTEGRATION_SIZE as f64).log2()]);
for lod in 0..=max_lod {
let roughness = lod_to_roughness(lod, max_lod);
if uses_integration(lod, max_lod) {
integration_roughness.set(vec![roughness]);
self.render_cube(renderer, pmrem, lod, &integration_material)?;
} else {
ggx_roughness.set(vec![roughness]);
ggx_lod_bias.set(vec![lod_bias(size, roughness)]);
self.render_cube(renderer, pmrem, lod, &ggx_material)?;
}
}
Ok(())
}
fn blur(
&mut self,
renderer: &mut super::Renderer,
pmrem: &CubeTexture,
sigma: f64,
) -> Result<(), Error> {
let source = self.source_target(false);
let sigma = sigma.min(std::f64::consts::PI) / std::f64::consts::SQRT_2;
let (forward, forward_sigma) = blur_material(&source);
forward_sigma.set(vec![sigma]);
self.render_cube(renderer, pmrem, 0, &forward)?;
let (back, back_sigma) = blur_material(pmrem);
back_sigma.set(vec![sigma]);
self.render_cube(renderer, &source, 0, &back)?;
renderer.generate_cube_mipmaps(&source);
Ok(())
}
}
fn pmrem_material(name: &'static str, fragment_node: NodeRef) -> MeshBasicNodeMaterial {
let mut material = MeshBasicNodeMaterial::new();
material.name = name;
material.side = Side::Back;
material.blending = Blending::No;
material.depth_test = false;
material.depth_write = false;
material.fragment_node = Some(fragment_node);
material
}
#[doc(hidden)]
pub fn cubemap_material(cubemap: &CubeTexture) -> MeshBasicNodeMaterial {
pmrem_material(
"PMREM_cubemap",
cube_texture(cubemap, position_world_direction()),
)
}
#[doc(hidden)]
pub fn equirect_material(map: &Texture) -> MeshBasicNodeMaterial {
let direction = position_world_direction();
let dx = to_const(None, dpdx(direction.clone()).mul(float(0.25)));
let dy = to_const(None, dpdy(direction.clone()).mul(float(0.25)));
let taps: Vec<NodeRef> = [
direction.sub(dx.clone()).sub(dy.clone()),
direction.add(dx.clone()).sub(dy.clone()),
direction.sub(dx.clone()).add(dy.clone()),
direction.add(dx.clone()).add(dy.clone()),
]
.into_iter()
.map(|d| to_const(None, d.normalize()))
.collect();
let tap = |d: &NodeRef| texture_level(map, equirect_uv(d.clone()), float(0.0)).xyz();
let color = tap(&taps[0])
.add(tap(&taps[1]))
.add(tap(&taps[2]))
.add(tap(&taps[3]));
pmrem_material(
"PMREM_equirect",
block(
vec![dx, dy],
vec4_join(vec![color.mul(float(0.25)), float(1.0)]),
),
)
}
fn ggx_material(source: &CubeTexture) -> GgxMaterial {
let (roughness, roughness_cell) = uniform_settable(Type::F32, vec![0.0]);
let (lod_bias, lod_bias_cell) = uniform_settable(Type::F32, vec![0.0]);
GgxMaterial {
material: pmrem_material(
"PMREM_ggx",
pmrem_utils::ggx_convolution(
roughness,
lod_bias,
source,
position_world_direction(),
GGX_SAMPLES,
),
),
roughness: roughness_cell,
lod_bias: lod_bias_cell,
}
}
fn integration_material(source: &CubeTexture) -> IntegrationMaterial {
let (roughness, roughness_cell) = uniform_settable(Type::F32, vec![0.0]);
let (source_lod, source_lod_cell) = uniform_settable(Type::F32, vec![0.0]);
let source_size = uniform_value(Type::I32, vec![INTEGRATION_SIZE as f64]);
IntegrationMaterial {
material: pmrem_material(
"PMREM_integration",
pmrem_utils::ggx_integration(
roughness,
source_lod,
source_size,
source,
position_world_direction(),
),
),
roughness: roughness_cell,
source_lod: source_lod_cell,
}
}
fn blur_material(env_map: &CubeTexture) -> (MeshBasicNodeMaterial, SettableValue) {
let (sigma, sigma_cell) = uniform_settable(Type::F32, vec![0.0]);
(
pmrem_material(
"PMREM_blur",
pmrem_utils::spherical_gaussian_blur(
BLUR_SAMPLES,
sigma,
position_world_direction(),
env_map,
),
),
sigma_cell,
)
}
#[doc(hidden)]
pub fn dump_materials() -> Vec<(&'static str, MeshBasicNodeMaterial)> {
let source = CubeTexture::pmrem_render_target(MIN_SIZE, None);
vec![
("pmrem_ggx", ggx_material(&source).material),
("pmrem_integration", integration_material(&source).material),
("pmrem_blur", blur_material(&source).0),
]
}