use super::*;
use crate::{ImpostorGrid, ImpostorLayout, ImpostorSwitch};
pub const FAR_FIELD_BYTES: usize = 64;
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct FarField {
pub caller_tag: u32,
pub payload_hash: u64,
pub grid: ImpostorGrid,
pub view_resolution: u32,
pub texel_error: f64,
pub view_error: f64,
pub world_error: f32,
}
impl FarField {
pub fn from_switch(
caller_tag: u32,
payload: &[u8],
grid: ImpostorGrid,
view_resolution: u32,
switch: ImpostorSwitch,
) -> Result<Self, Error> {
if !switch.distance.is_finite() || switch.distance < 0.0 {
return Err(Error::Invalid);
}
let value = Self {
caller_tag,
payload_hash: xxh64(payload, 0),
grid,
view_resolution,
texel_error: switch.texel_error,
view_error: switch.view_error,
world_error: crate::clusterlod::bounds_math::f32_up(
switch.texel_error.max(switch.view_error),
),
};
value.encode()?;
Ok(value)
}
pub fn encode(self) -> Result<[u8; FAR_FIELD_BYTES], Error> {
self.grid.view_count().map_err(|_| Error::Invalid)?;
if !(1..=4096).contains(&self.view_resolution)
|| ![
self.texel_error,
self.view_error,
f64::from(self.world_error),
]
.iter()
.all(|x| x.is_finite() && *x >= 0.0)
|| f64::from(self.world_error) < self.texel_error.max(self.view_error)
{
return Err(Error::Invalid);
}
let mut b = [0u8; FAR_FIELD_BYTES];
b[0..4].copy_from_slice(&self.caller_tag.to_le_bytes());
b[8..16].copy_from_slice(&self.payload_hash.to_le_bytes());
let layout = match self.grid.layout {
ImpostorLayout::Hemisphere => 0u32,
ImpostorLayout::Sphere => 1,
};
b[16..20].copy_from_slice(&layout.to_le_bytes());
b[20..24].copy_from_slice(&self.grid.views_per_axis.to_le_bytes());
b[24..28].copy_from_slice(&self.view_resolution.to_le_bytes());
b[32..40].copy_from_slice(&self.texel_error.to_le_bytes());
b[40..48].copy_from_slice(&self.view_error.to_le_bytes());
b[48..52].copy_from_slice(&self.world_error.to_le_bytes());
Ok(b)
}
pub fn decode(b: &[u8]) -> Result<Self, Error> {
if b.len() != FAR_FIELD_BYTES || [4, 28, 52, 56, 60].iter().any(|&at| le32(b, at) != Ok(0))
{
return Err(Error::Invalid);
}
let layout = match le32(b, 16)? {
0 => ImpostorLayout::Hemisphere,
1 => ImpostorLayout::Sphere,
_ => return Err(Error::Invalid),
};
let value = Self {
caller_tag: le32(b, 0)?,
payload_hash: le64(b, 8)?,
grid: ImpostorGrid::new(layout, le32(b, 20)?).map_err(|_| Error::Invalid)?,
view_resolution: le32(b, 24)?,
texel_error: f64::from_bits(le64(b, 32)?),
view_error: f64::from_bits(le64(b, 40)?),
world_error: fl(b, 48)?,
};
value.encode()?;
Ok(value)
}
}