stereokit-rust 0.4.0-alpha.22

High-Level Rust bindings around the StereoKitC library for XR
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#include "bbox.h"

namespace sk {

// Update the bounding box to include the point p
void
bbox_update(boundingbox& bbox, vec3 p)
{
    vec3 *bounds = bbox.bounds;

    if (p.x < bounds[0].x) bounds[0].x = p.x;
    if (p.y < bounds[0].y) bounds[0].y = p.y;
    if (p.z < bounds[0].z) bounds[0].z = p.z;

    if (p.x > bounds[1].x) bounds[1].x = p.x;
    if (p.y > bounds[1].y) bounds[1].y = p.y;
    if (p.z > bounds[1].z) bounds[1].z = p.z;
}

// Return the bounding box resulting from the combination of the
// two given bounding boxes
boundingbox
bbox_combine(const boundingbox& bbox1, const boundingbox& bbox2)
{
    vec3 min, max;

    min = bbox_min(bbox1);
    max = bbox_max(bbox1);

    const vec3 *bounds2 = bbox2.bounds;

    if (bounds2[0].x < min.x) min.x = bounds2[0].x;
    if (bounds2[0].y < min.y) min.y = bounds2[0].y;
    if (bounds2[0].z < min.z) min.z = bounds2[0].z;

    if (bounds2[1].x > max.x) max.x = bounds2[1].x;
    if (bounds2[1].y > max.y) max.y = bounds2[1].y;
    if (bounds2[1].z > max.z) max.z = bounds2[1].z;

    return boundingbox{min, max};
}


// Intersect a ray (delimited by t0 and t1) with the given bounding box.
// Returns true (and sets t_min and t_max) when the ray intersects the bbox,
// returns false otherwise

bool
bbox_intersect_full(const boundingbox& bbox, float& t_min, float& t_max, bbox_ray_t r, float t0, float t1)
{
    // This code makes handy use of IEEE floating-point behaviour, such
    // as division by zero. See
    // 1) Shirley et.al. Section 10.9.1
    // 2) Williams et.al., "An Efficient and Robust Ray-Box Intersection Algorithm"

    float tmin, tmax;
    float tymin, tymax, tzmin, tzmax;
    const vec3* bounds = bbox.bounds;

    tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
    tmax = (bounds[1-r.sign[0]].x - r.origin.x) * r.inv_direction.x;

    tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
    tymax = (bounds[1-r.sign[1]].y - r.origin.y) * r.inv_direction.y;

    if (tmin > tymax || tymin > tmax)
        return false;

    if (tymin > tmin)
        tmin = tymin;
    if (tymax < tmax)
        tmax = tymax;

    tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
    tzmax = (bounds[1-r.sign[2]].z - r.origin.z) * r.inv_direction.z;

    if (tmin > tzmax || tzmin > tmax)
        return false;

    if (tzmin > tmin)
        tmin = tzmin;
    if (tzmax < tmax)
        tmax = tzmax;

    t_min = tmin;
    t_max = tmax;

    return (tmin < t1 && tmax > t0);
}

// Intersect a ray with the given bounding box.
// Returns true when the ray intersects the bbox, returns false otherwise

bool
bbox_intersect(const boundingbox& bbox, bbox_ray_t r, float t0, float t1)
{
    // This code makes handy use of IEEE floating-point behaviour, such
    // as division by zero. See
    // 1) Shirley et.al. Section 10.9.1
    // 2) Williams et.al., "An Efficient and Robust Ray-Box Intersection Algorithm"

    float tmin, tmax;
    float tymin, tymax, tzmin, tzmax;
    const vec3* bounds = bbox.bounds;

    tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
    tmax = (bounds[1-r.sign[0]].x - r.origin.x) * r.inv_direction.x;

    tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
    tymax = (bounds[1-r.sign[1]].y - r.origin.y) * r.inv_direction.y;

    if (tmin > tymax || tymin > tmax)
        return false;

    if (tymin > tmin)
        tmin = tymin;
    if (tymax < tmax)
        tmax = tymax;

    tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
    tzmax = (bounds[1-r.sign[2]].z - r.origin.z) * r.inv_direction.z;

    if (tmin > tzmax || tzmin > tmax)
        return false;

    if (tzmin > tmin)
        tmin = tzmin;
    if (tzmax < tmax)
        tmax = tzmax;

    return (tmin < t1 && tmax > t0);
}
    
} // namespace sk