use super::config::LightProbeConfig;
use super::error::LightProbeError;
use super::irradiance::IrradianceSH;
use super::projection::{lp_generate_sphere_samples, lp_project_samples_to_sh};
use super::sampling::bilinear_sample_rgb;
use super::sh_math::lp_normalize_dir;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(usize)]
pub enum CubemapFace {
PosX = 0,
NegX = 1,
PosY = 2,
NegY = 3,
PosZ = 4,
NegZ = 5,
}
pub fn lp_dir_to_cubemap_uv(dir: [f32; 3]) -> (CubemapFace, f32, f32) {
let [x, y, z] = dir;
let ax = x.abs();
let ay = y.abs();
let az = z.abs();
if ax >= ay && ax >= az {
if x >= 0.0 {
let inv = 0.5 / ax;
let u = (-z * inv + 0.5).clamp(0.0, 1.0);
let v = (-y * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::PosX, u, v)
} else {
let inv = 0.5 / ax;
let u = (z * inv + 0.5).clamp(0.0, 1.0);
let v = (-y * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::NegX, u, v)
}
} else if ay >= ax && ay >= az {
if y >= 0.0 {
let inv = 0.5 / ay;
let u = (x * inv + 0.5).clamp(0.0, 1.0);
let v = (z * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::PosY, u, v)
} else {
let inv = 0.5 / ay;
let u = (x * inv + 0.5).clamp(0.0, 1.0);
let v = (-z * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::NegY, u, v)
}
} else {
if z >= 0.0 {
let inv = 0.5 / az;
let u = (x * inv + 0.5).clamp(0.0, 1.0);
let v = (-y * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::PosZ, u, v)
} else {
let inv = 0.5 / az;
let u = (-x * inv + 0.5).clamp(0.0, 1.0);
let v = (-y * inv + 0.5).clamp(0.0, 1.0);
(CubemapFace::NegZ, u, v)
}
}
}
#[derive(Debug, Clone)]
pub struct CubemapProbe {
pub faces: Vec<Vec<f32>>,
pub resolution: u32,
}
impl CubemapProbe {
pub fn new(resolution: u32) -> Result<Self, LightProbeError> {
if resolution < 4 || !resolution.is_power_of_two() {
return Err(LightProbeError::InvalidResolution { res: resolution });
}
let face_len = (resolution as usize) * (resolution as usize) * 3;
let faces = vec![vec![0.0_f32; face_len]; 6];
Ok(Self { faces, resolution })
}
pub fn sample(&self, dir: [f32; 3]) -> Result<[f32; 3], LightProbeError> {
let d = lp_normalize_dir(dir)?;
let (face, u, v) = lp_dir_to_cubemap_uv(d);
let face_data = &self.faces[face as usize];
let rgb = bilinear_sample_rgb(face_data, self.resolution, self.resolution, u, v);
Ok(rgb)
}
pub fn sample_nearest(&self, dir: [f32; 3]) -> Result<[f32; 3], LightProbeError> {
let d = lp_normalize_dir(dir)?;
let (face, u, v) = lp_dir_to_cubemap_uv(d);
let res = self.resolution as usize;
let px = ((u * self.resolution as f32) as usize).min(res - 1);
let py = ((v * self.resolution as f32) as usize).min(res - 1);
let base = (py * res + px) * 3;
let face_data = &self.faces[face as usize];
Ok([face_data[base], face_data[base + 1], face_data[base + 2]])
}
}
pub fn lp_cubemap_to_sh(
probe: &CubemapProbe,
n_samples: usize,
seed: u64,
) -> Result<IrradianceSH, LightProbeError> {
let dirs = lp_generate_sphere_samples(n_samples, seed);
let mut radiances = Vec::with_capacity(n_samples);
for d in &dirs {
let rgb = probe.sample(*d)?;
radiances.push(rgb);
}
lp_project_samples_to_sh(&dirs, &radiances)
}
pub fn lp_cubemap_to_sh_with_config(
probe: &CubemapProbe,
config: &LightProbeConfig,
seed: u64,
) -> Result<IrradianceSH, LightProbeError> {
lp_cubemap_to_sh(probe, config.n_samples_projection, seed)
}