turbine_process3d 0.7.0

Processing for the Turbine game engine
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Ray algorithms.

use crate::{Chunk, PixelPos, Point, Ray, RayHit, Triangle};
use crate::frustrum::{near_dim, near_uv_pos};
use crate::cam::CameraPerspective;

/// Ray triangle intersection using Möller-Trumbore algorithm.
pub fn ray_triangle_hit((origin, direction): Ray, (a, b, c): Triangle) -> Option<f32> {
    use vecmath::vec3_sub as sub;
    use vecmath::vec3_cross as cross;
    use vecmath::vec3_dot as dot;

    let e1 = sub(b, a);
    let e2 = sub(c, a);

    let ray_cross_e2 = cross(direction, e2);
    let det = dot(e1, ray_cross_e2);

    // Check whether ray is parallel to this triangle.
    let eps = f32::EPSILON;
    if det > -eps && det < eps {return None}

    let inv_det = 1.0 / det;
    let s = sub(origin, a);
    let u = inv_det * dot(s, ray_cross_e2);
    if u < 0.0 || u > 1.0 {
        return None;
    }

    let s_cross_e1 = cross(s, e1);
    let v = inv_det * dot(direction, s_cross_e1);
    if v < 0.0 || u + v > 1.0 {
        return None;
    }
    // At this stage we can compute t to find out where the intersection point is on the line.
    let t = inv_det * dot(e2, s_cross_e1);

    if t > eps { // ray intersection
        return Some(t);
    }

    None
}

/// Ray intersection against a triangle chunk with a mask.
pub fn ray_triangle_chunk_hit(
    ray: Ray,
    chunk: &Chunk<Triangle>,
    mask: u64
) -> RayHit {
    if mask == 0 {return None};

    let mut min: Option<(f32, usize)> = None;
    for i in 0..64 {
        if (mask >> i) & 1 == 1 {
            if let Some(t) = ray_triangle_hit(ray, chunk[i]) {
                if min.is_none() || t < min.unwrap().0 {
                    min = Some((t, i))
                }
            }
        }
    }
    min
}

/// Offset ray hit index.
pub fn ray_hit_offset(hit: RayHit, off: usize) -> RayHit {
    if let Some((d, i)) = hit {
        Some((d, i + off))
    } else {None}
}

/// Ray hit of triangle chunk with mask, updating hit.
pub fn ray_triangle_chunk_hit_update(
    ray: Ray,
    chunk: &Chunk<Triangle>,
    mask: u64,
    off: usize,
    res: &mut RayHit,
) {
    *res = match (*res, ray_hit_offset(ray_triangle_chunk_hit(ray, &chunk, mask), off)) {
        (None, x) | (x, None) => x,
        (Some((ti, mi)), Some((tj, mj))) => {
            if tj < ti {Some((tj, mj))} else {Some((ti, mi))}
        }
    }
}

/// Ray hit of iterator over triangle chunks.
///
/// This can be used when you only need to check one ray per triangle chunk.
pub fn ray_triangle_chunk_iter_hit(
    ray: Ray,
    iter: impl Iterator<Item = (usize, (Chunk<Triangle>, u64))>
) -> RayHit {
    let mut min: Option<(f32, usize)> = None;
    for (off, (chunk, mask)) in iter {
        ray_triangle_chunk_hit_update(ray, &chunk, mask, off, &mut min);
    }
    min
}

/// Calculate ray direction.
pub fn ray_dir(
    persp: &CameraPerspective,
    eye: Point,
    pos: PixelPos,
    dim: PixelPos,
) -> Point {
    use vecmath::vec3_sub as sub;
    use vecmath::vec3_normalized as normalized;

    let x = (pos[0] as f32 + 0.5) / dim[0] as f32 * 2.0 - 1.0;
    let y = (pos[1] as f32 + 0.5) / dim[1] as f32 * 2.0 - 1.0;
    let ndim = near_dim(persp);
    let npos = near_uv_pos(persp, [x, y], ndim);
    normalized(sub(npos, eye))
}