use crate::core::ObjectRef;
use crate::error::Error;
use crate::lights::LightProbe;
use crate::math::{Color, ColorSpace, SphericalHarmonics3, Vector3};
use crate::renderer::Renderer;
use crate::textures::{CubeTexture, TextureType};
pub struct LightProbeGenerator;
struct Projection {
sh: SphericalHarmonics3,
total_weight: f64,
}
impl Projection {
fn new() -> Self {
Self {
sh: SphericalHarmonics3::default(),
total_weight: 0.0,
}
}
fn add(&mut self, coord: Vector3, color: Color) {
let length_sq = coord.length_sq();
let weight = 4.0 / (length_sq.sqrt() * length_sq);
self.total_weight += weight;
let mut dir = coord;
dir.normalize();
let basis = SphericalHarmonics3::static_get_basis_at(&dir);
for (c, b) in self.sh.coefficients.iter_mut().zip(basis) {
c.x += b * color.r * weight;
c.y += b * color.g * weight;
c.z += b * color.b * weight;
}
}
fn finish(mut self) -> SphericalHarmonics3 {
let norm = (4.0 * std::f64::consts::PI) / self.total_weight;
for c in &mut self.sh.coefficients {
c.x *= norm;
c.y *= norm;
c.z *= norm;
}
self.sh
}
}
fn project_rendered_face(
projection: &mut Projection,
face_index: u32,
image_width: usize, data: &[f32],
color_space: ColorSpace,
) {
let flip = 1.0;
let pixel_size = 2.0 / image_width as f64;
for (pixel_index, texel) in data.as_chunks::<4>().0.iter().enumerate() {
let mut color = Color::new(texel[0] as f64, texel[1] as f64, texel[2] as f64);
convert_color_to_linear(&mut color, color_space);
let col = (1.0 - ((pixel_index % image_width) as f64 + 0.5) * pixel_size) * flip;
let row = 1.0 - ((pixel_index / image_width) as f64 + 0.5) * pixel_size;
let coord = match face_index {
0 => Vector3::new(-flip, row, col * flip),
1 => Vector3::new(flip, row, -col * flip),
2 => Vector3::new(col, 1.0, -row),
3 => Vector3::new(col, -1.0, row),
4 => Vector3::new(col, row, 1.0),
_ => Vector3::new(-col, row, -1.0),
};
projection.add(coord, color);
}
}
fn convert_color_to_linear(color: &mut Color, color_space: ColorSpace) {
match color_space {
ColorSpace::Srgb => {
color.convert_srgb_to_linear();
}
ColorSpace::LinearSrgb | ColorSpace::NoColorSpace => {}
}
}
impl LightProbeGenerator {
pub fn from_cube_texture(cube_texture: &CubeTexture) -> Result<ObjectRef, Error> {
let texture_type = cube_texture.texture_type();
if texture_type != TextureType::UnsignedByte {
return Err(Error::UnsupportedTextureType {
what: "LightProbeGenerator.fromCubeTexture",
texture_type,
});
}
let color_space = cube_texture.color_space();
let inner = cube_texture.borrow();
let mut projection = Projection::new();
for face_index in 0..6 {
let image = inner.images.get(face_index).filter(|image| {
!image.data.is_empty()
&& image.data.len() == (image.width * image.height * 4) as usize
});
let Some(image) = image else {
return Err(Error::UnsupportedFormat {
what: "LightProbeGenerator.fromCubeTexture face",
value: format!("face {face_index} has no RGBA8 pixels"),
});
};
let image_width = image.width as usize; let pixel_size = 2.0 / image_width as f64;
for (pixel_index, texel) in image.data.as_chunks::<4>().0.iter().enumerate() {
let mut color = Color::new(
texel[0] as f64 / 255.0,
texel[1] as f64 / 255.0,
texel[2] as f64 / 255.0,
);
convert_color_to_linear(&mut color, color_space);
let col = -1.0 + ((pixel_index % image_width) as f64 + 0.5) * pixel_size;
let row = 1.0 - ((pixel_index / image_width) as f64 + 0.5) * pixel_size;
let coord = match face_index {
0 => Vector3::new(-1.0, row, -col),
1 => Vector3::new(1.0, row, col),
2 => Vector3::new(-col, 1.0, -row),
3 => Vector3::new(-col, -1.0, row),
4 => Vector3::new(-col, row, 1.0),
_ => Vector3::new(col, row, -1.0),
};
projection.add(coord, color);
}
}
Ok(LightProbe::new(projection.finish(), 1.0))
}
pub async fn from_cube_render_target_async(
renderer: &mut Renderer,
cube_render_target: &CubeTexture,
) -> Result<ObjectRef, Error> {
let texture_type = cube_render_target.texture_type();
let color_space = cube_render_target.color_space();
let mut projection = Projection::new();
for face_index in 0..6u32 {
let (image_width, _, data): (u32, u32, Vec<f32>) = match texture_type {
TextureType::HalfFloat => {
renderer
.read_cube_pixels_rgba16f_async(cube_render_target, face_index, 0)
.await?
}
_ => {
let (w, h, bytes) = renderer
.read_cube_pixels_rgba8_async(cube_render_target, face_index, 0)
.await?;
(w, h, bytes.iter().map(|&b| b as f32 / 255.0).collect())
}
};
project_rendered_face(
&mut projection,
face_index,
image_width as usize,
&data,
color_space,
);
}
Ok(LightProbe::new(projection.finish(), 1.0))
}
#[cfg(not(target_arch = "wasm32"))]
pub fn from_cube_render_target(
renderer: &mut Renderer,
cube_render_target: &CubeTexture,
) -> Result<ObjectRef, Error> {
pollster::block_on(Self::from_cube_render_target_async(
renderer,
cube_render_target,
))
}
}