clay 0.1.2

Fast, modular and extendable ray tracer powered by OpenCL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use std::collections::HashSet;
use nalgebra::{Vector3, Matrix3, linalg::SVD};
use crate::{
    prelude::*,
    map::*,
    shape::*,
};


type EllipsoidBase = ShapeMapper<UnitSphere, Affine>;
/// Ellipsoid shape defined by affine transform on unit sphere.
pub struct Ellipsoid(pub EllipsoidBase);

impl Ellipsoid {
    pub fn new(ori: Matrix3<f64>, pos: Vector3<f64>) -> Self {
        Self::from(UnitSphere::new().map(Linear::from(ori).chain(Shift::from(pos))))
    }
}
impl From<EllipsoidBase> for Ellipsoid {
    fn from(base: EllipsoidBase) -> Self {
        Self(base)
    }
}

impl Shape for Ellipsoid {}

impl Instance<ShapeClass> for Ellipsoid {
    fn source(cache: &mut HashSet<u64>) -> String { EllipsoidBase::source(cache) }
    fn inst_name() -> String { EllipsoidBase::inst_name() }
}

impl Pack for Ellipsoid {
    fn size_int() -> usize { EllipsoidBase::size_int() }
    fn size_float() -> usize { EllipsoidBase::size_float() }
    fn pack_to(&self, buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        self.0.pack_to(buffer_int, buffer_float);
    }
}

impl Bounded<Sphere> for Ellipsoid {
    fn bound(&self) -> Option<Sphere> {
        let rad = SVD::new(
            self.0.map.first.0,
            false, false,
        )
        .singular_values.as_slice().iter()
        .fold(std::f64::NAN, |a, b| f64::max(a, *b));
        Some(Sphere::new(rad, self.0.map.second.0))
    }
}