use std::collections::HashSet;
use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use crate::math::{Aabb, Point3, Vec2, Vec3};
#[derive(Debug)]
pub(crate) struct FaceMemo {
pub id: u64,
pub volume: OnceLock<FaceVolume>,
#[cfg(debug_assertions)]
pub layout: OnceLock<Vec<Vec<(u64, u64, bool)>>>,
pub integrals: Mutex<Option<(IntegralKey, (f64, f64))>>,
pub moments: Mutex<Option<(IntegralKey, [f64; 11])>>,
pub pcurves: OnceLock<Vec<Vec<Vec<Vec2>>>>,
pub clean: OnceLock<()>,
pub images: OnceLock<crate::boolean::FaceImages>,
pub loose_box: OnceLock<Aabb>,
pub apart: Mutex<HashSet<u64>>,
}
impl Default for FaceMemo {
fn default() -> FaceMemo {
static NEXT: AtomicU64 = AtomicU64::new(0);
FaceMemo {
id: NEXT.fetch_add(1, Ordering::Relaxed),
volume: OnceLock::new(),
#[cfg(debug_assertions)]
layout: OnceLock::new(),
integrals: Mutex::new(None),
moments: Mutex::new(None),
pcurves: OnceLock::new(),
clean: OnceLock::new(),
images: OnceLock::new(),
loose_box: OnceLock::new(),
apart: Mutex::new(HashSet::new()),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct IntegralKey([u64; 5], bool);
impl IntegralKey {
pub(crate) fn new(c: Point3, scale: f64, rel: f64, reversed: bool) -> IntegralKey {
IntegralKey([c.x, c.y, c.z, scale, rel].map(f64::to_bits), reversed)
}
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct FaceVolume {
pub anchor: Point3,
pub volume: f64,
pub vector_area: Vec3,
}
#[derive(Clone, Default)]
pub(crate) struct Memos(pub Vec<Arc<FaceMemo>>);
impl PartialEq for Memos {
fn eq(&self, _: &Memos) -> bool {
true
}
}
impl fmt::Debug for Memos {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Memos({})", self.0.len())
}
}