Eliminated duplicate and incorrect definitions of transform applications to geometric primitives
This commit is contained in:
parent
ac7fdd7486
commit
aefd204577
2 changed files with 68 additions and 80 deletions
|
|
@ -294,7 +294,8 @@ impl Bounds3f {
|
|||
|
||||
// Check Z
|
||||
let tz_min = (bounds[dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
let tz_max = (bounds[1 - dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
let mut tz_max = (bounds[1 - dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
tz_max = tz_max * (1. + 2. * gamma(3));
|
||||
|
||||
if t_min > tz_max || tz_min > t_max {
|
||||
return None;
|
||||
|
|
@ -344,7 +345,8 @@ impl Bounds3f {
|
|||
}
|
||||
|
||||
let tz_min = (bounds[dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
let tz_max = (bounds[1 - dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
let mut tz_max = (bounds[1 - dir_is_neg[2]].z() - o.z()) * inv_dir.z();
|
||||
tz_max = tz_max * (1. + 2. * gamma(3));
|
||||
|
||||
if t_min > tz_max || tz_min > t_max {
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -94,46 +94,44 @@ impl<T: NumFloat + Sum + Product> Default for TransformGeneric<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T: NumFloat> TransformGeneric<T> {
|
||||
#[inline]
|
||||
pub fn apply_to_point(&self, p: Point<T, 3>) -> Point<T, 3> {
|
||||
let x = self.m[0][0]*p.x() + self.m[0][1]*p.y() + self.m[0][2]*p.z() + self.m[0][3];
|
||||
let y = self.m[1][0]*p.x() + self.m[1][1]*p.y() + self.m[1][2]*p.z() + self.m[1][3];
|
||||
let z = self.m[2][0]*p.x() + self.m[2][1]*p.y() + self.m[2][2]*p.z() + self.m[2][3];
|
||||
let w = self.m[3][0]*p.x() + self.m[3][1]*p.y() + self.m[3][2]*p.z() + self.m[3][3];
|
||||
if w == T::one() {
|
||||
Point([x, y, z])
|
||||
} else {
|
||||
Point([x / w, y / w, z / w])
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn apply_to_vector(&self, v: Vector<T, 3>) -> Vector<T, 3> {
|
||||
// directions: linear part only, no translation, no w-divide
|
||||
Vector([
|
||||
self.m[0][0]*v.x() + self.m[0][1]*v.y() + self.m[0][2]*v.z(),
|
||||
self.m[1][0]*v.x() + self.m[1][1]*v.y() + self.m[1][2]*v.z(),
|
||||
self.m[2][0]*v.x() + self.m[2][1]*v.y() + self.m[2][2]*v.z(),
|
||||
])
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn apply_to_normal(&self, n: Normal<T, 3>) -> Normal<T, 3> {
|
||||
// normals: inverse-transpose, no translation, no w-divide
|
||||
Normal([
|
||||
self.m_inv[0][0]*n.x() + self.m_inv[1][0]*n.y() + self.m_inv[2][0]*n.z(),
|
||||
self.m_inv[0][1]*n.x() + self.m_inv[1][1]*n.y() + self.m_inv[2][1]*n.z(),
|
||||
self.m_inv[0][2]*n.x() + self.m_inv[1][2]*n.y() + self.m_inv[2][2]*n.z(),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
pub type Transform = TransformGeneric<Float>;
|
||||
|
||||
impl TransformGeneric<Float> {
|
||||
pub fn apply_to_point(&self, p: Point3f) -> Point3f {
|
||||
let x = p.x();
|
||||
let y = p.y();
|
||||
let z = p.z();
|
||||
let xp = self.m[0][0] * x + self.m[0][1] * y + self.m[0][2] * z + self.m[0][3];
|
||||
let yp = self.m[1][0] * x + self.m[1][1] * y + self.m[1][2] * z + self.m[1][3];
|
||||
let zp = self.m[2][0] * x + self.m[2][1] * y + self.m[2][2] * z + self.m[2][3];
|
||||
let wp = self.m[3][0] * x + self.m[3][1] * y + self.m[3][2] * z + self.m[3][3];
|
||||
|
||||
if wp == 1. {
|
||||
Point3f::new(xp, yp, zp)
|
||||
} else {
|
||||
Point3f::new(xp / wp, yp / wp, zp / wp)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn apply_to_vector(&self, v: Vector3f) -> Vector3f {
|
||||
let x = v.x();
|
||||
let y = v.y();
|
||||
let z = v.z();
|
||||
let xv = self.m[0][0] * x + self.m[0][1] * y + self.m[0][2] * z;
|
||||
let yv = self.m[1][0] * x + self.m[1][1] * y + self.m[1][2] * z;
|
||||
let zv = self.m[2][0] * x + self.m[2][1] * y + self.m[2][2] * z;
|
||||
Vector3f::new(xv, yv, zv)
|
||||
|
||||
}
|
||||
|
||||
pub fn apply_to_normal(&self, p: Normal3f) -> Normal3f {
|
||||
let x = p.x();
|
||||
let y = p.y();
|
||||
let z = p.z();
|
||||
let xn = self.m_inv[0][0] * x + self.m_inv[1][1] * y + self.m_inv[2][0] * z;
|
||||
let yn = self.m_inv[1][0] * x + self.m_inv[1][1] * y + self.m_inv[2][1] * z;
|
||||
let zn = self.m_inv[2][0] * x + self.m_inv[1][2] * y + self.m_inv[2][2] * z;
|
||||
Normal3f::new(xn, yn, zn)
|
||||
}
|
||||
|
||||
impl Transform {
|
||||
pub fn apply_to_bounds(&self, b: Bounds3f) -> Bounds3f {
|
||||
let mut new_bounds = Bounds3f::default();
|
||||
for i in 0..8 {
|
||||
|
|
@ -669,61 +667,49 @@ impl Mul<TransformGeneric<Float>> for Float {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Mul<Point<T, 3>> for TransformGeneric<T>
|
||||
where
|
||||
T: NumFloat,
|
||||
{
|
||||
impl<T: NumFloat> Mul<Point<T, 3>> for TransformGeneric<T> {
|
||||
type Output = Point<T, 3>;
|
||||
fn mul(self, p: Point<T, 3>) -> Self::Output {
|
||||
let xp = self.m[0][0] * p.x() + self.m[0][1] * p.y() + self.m[0][2] * p.z() + self.m[0][3];
|
||||
let yp = self.m[1][0] * p.x() + self.m[1][1] * p.y() + self.m[1][2] * p.z() + self.m[1][3];
|
||||
let zp = self.m[2][0] * p.x() + self.m[2][1] * p.y() + self.m[2][2] * p.z() + self.m[2][3];
|
||||
let wp = self.m[3][0] * p.x() + self.m[3][1] * p.y() + self.m[3][2] * p.z() + self.m[3][3];
|
||||
|
||||
if wp == T::one() {
|
||||
Point([xp, yp, zp])
|
||||
} else {
|
||||
Point([xp / wp, yp / wp, zp / wp])
|
||||
#[inline]
|
||||
fn mul(self, p: Point<T, 3>) -> Point<T, 3> {
|
||||
self.apply_to_point(p)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Mul<Vector<T, 3>> for TransformGeneric<T>
|
||||
where
|
||||
T: NumFloat,
|
||||
{
|
||||
impl<T: NumFloat> Mul<Vector<T, 3>> for TransformGeneric<T> {
|
||||
type Output = Vector<T, 3>;
|
||||
fn mul(self, p: Vector<T, 3>) -> Self::Output {
|
||||
let xp = self.m[0][0] * p.x() + self.m[0][1] * p.y() + self.m[0][2] * p.z() + self.m[0][3];
|
||||
let yp = self.m[1][0] * p.x() + self.m[1][1] * p.y() + self.m[1][2] * p.z() + self.m[1][3];
|
||||
let zp = self.m[2][0] * p.x() + self.m[2][1] * p.y() + self.m[2][2] * p.z() + self.m[2][3];
|
||||
let wp = self.m[3][0] * p.x() + self.m[3][1] * p.y() + self.m[3][2] * p.z() + self.m[3][3];
|
||||
|
||||
if wp == T::one() {
|
||||
Vector([xp, yp, zp])
|
||||
} else {
|
||||
Vector([xp / wp, yp / wp, zp / wp])
|
||||
#[inline]
|
||||
fn mul(self, v: Vector<T, 3>) -> Vector<T, 3> {
|
||||
self.apply_to_vector(v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Mul<Normal<T, 3>> for TransformGeneric<T>
|
||||
where
|
||||
T: NumFloat,
|
||||
{
|
||||
impl<T: NumFloat> Mul<Normal<T, 3>> for TransformGeneric<T> {
|
||||
type Output = Normal<T, 3>;
|
||||
fn mul(self, p: Normal<T, 3>) -> Self::Output {
|
||||
let xp = self.m[0][0] * p.x() + self.m[0][1] * p.y() + self.m[0][2] * p.z() + self.m[0][3];
|
||||
let yp = self.m[1][0] * p.x() + self.m[1][1] * p.y() + self.m[1][2] * p.z() + self.m[1][3];
|
||||
let zp = self.m[2][0] * p.x() + self.m[2][1] * p.y() + self.m[2][2] * p.z() + self.m[2][3];
|
||||
let wp = self.m[3][0] * p.x() + self.m[3][1] * p.y() + self.m[3][2] * p.z() + self.m[3][3];
|
||||
|
||||
if wp == T::one() {
|
||||
Normal([xp, yp, zp])
|
||||
} else {
|
||||
Normal([xp / wp, yp / wp, zp / wp])
|
||||
#[inline]
|
||||
fn mul(self, n: Normal<T, 3>) -> Normal<T, 3> {
|
||||
self.apply_to_normal(n)
|
||||
}
|
||||
}
|
||||
|
||||
// reference versions, so `&t * v` works without consuming the transform
|
||||
impl<T: NumFloat> Mul<Point<T, 3>> for &TransformGeneric<T> {
|
||||
type Output = Point<T, 3>;
|
||||
#[inline]
|
||||
fn mul(self, p: Point<T, 3>) -> Point<T, 3> {
|
||||
self.apply_to_point(p)
|
||||
}
|
||||
}
|
||||
impl<T: NumFloat> Mul<Vector<T, 3>> for &TransformGeneric<T> {
|
||||
type Output = Vector<T, 3>;
|
||||
#[inline]
|
||||
fn mul(self, v: Vector<T, 3>) -> Vector<T, 3> {
|
||||
self.apply_to_vector(v)
|
||||
}
|
||||
}
|
||||
impl<T: NumFloat> Mul<Normal<T, 3>> for &TransformGeneric<T> {
|
||||
type Output = Normal<T, 3>;
|
||||
#[inline]
|
||||
fn mul(self, n: Normal<T, 3>) -> Normal<T, 3> {
|
||||
self.apply_to_normal(n)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Frame> for TransformGeneric<Float> {
|
||||
|
|
|
|||
Loading…
Reference in a new issue