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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#include <mbgl/util/bounding_volumes.hpp>
#include <gtest/gtest.h>
#include <math.h>
using namespace mbgl;
TEST(BoundingVolumes, CreateAabb) {
util::AABB aabb({0, 0, 0}, {2, 4, 6});
EXPECT_EQ(aabb.min, (vec3{0, 0, 0}));
EXPECT_EQ(aabb.max, (vec3{2, 4, 6}));
}
TEST(BoundingVolumes, AabbEquality) {
util::AABB aabb0({-4.23, 1.01, 2.0}, {-1.0, 1.02, 100.0});
util::AABB aabb1({-4.23, 1.01, 2.0}, {-1.0, 1.02, 100.0});
util::AABB aabb2({-4.23, 1.01, 2.0}, {-1.0, 1.03, 55.0});
EXPECT_EQ(aabb0, aabb1);
EXPECT_NE(aabb0, aabb2);
}
TEST(BoundingVolumes, CreateAabbQuadrants) {
util::AABB aabb({0, 0, 0}, {2, 4, 16});
util::AABB quadrant0({0, 0, 0}, {1, 2, 16});
util::AABB quadrant1({1, 0, 0}, {2, 2, 16});
util::AABB quadrant2({0, 2, 0}, {1, 4, 16});
util::AABB quadrant3({1, 2, 0}, {2, 4, 16});
EXPECT_EQ(aabb.quadrant(0), quadrant0);
EXPECT_EQ(aabb.quadrant(1), quadrant1);
EXPECT_EQ(aabb.quadrant(2), quadrant2);
EXPECT_EQ(aabb.quadrant(3), quadrant3);
}
TEST(BoundingVolumes, AabbDistanceToPoint) {
util::AABB aabb({-1.0, -1.0, -1.0}, {1.0, 1.0, 1.0});
EXPECT_EQ(aabb.distanceXYZ({0.5, -0.5, 0.5}), (vec3{0, 0, 0}));
EXPECT_EQ(aabb.distanceXYZ({1, 1, 1}), (vec3{0, 0, 0}));
EXPECT_EQ(aabb.distanceXYZ({0, 10, 0}), (vec3{0, 9, 0}));
EXPECT_EQ(aabb.distanceXYZ({-2, -2, -4}), (vec3{1, 1, 3}));
}
TEST(BoundingVolumes, AabbAabbIntersection) {
util::AABB aabb0({1, 0, 0}, {3, 2, 1});
util::AABB aabb1({2.5, 1.5, -1}, {6.0, 2.5, 1});
util::AABB aabb2({3.5, -2, -2}, {5.0, 1, -1.5});
util::AABB aabb3({0.5, -1, -1}, {6.5, 3, 4});
EXPECT_EQ(aabb0.intersects(aabb1), true);
EXPECT_EQ(aabb0.intersects(aabb2), false);
EXPECT_EQ(aabb1.intersects(aabb2), false);
EXPECT_EQ(aabb3.intersects(aabb0), true);
EXPECT_EQ(aabb3.intersects(aabb1), true);
EXPECT_EQ(aabb3.intersects(aabb2), false);
}
TEST(BoundingVolumes, CreateFrustumFromProjectionMatrix) {
mat4 projMatrix;
mat4 invProjMatrix;
matrix::perspective(projMatrix, M_PI_2, 1.0, 0.1, 100.0);
matrix::invert(invProjMatrix, projMatrix);
const util::Frustum frustum = util::Frustum::fromInvProjMatrix(invProjMatrix, 1.0, 0.0, false);
const std::array<vec3, 8> expectedPoints = {vec3{-0.1, 0.1, -0.1},
vec3{0.1, 0.1, -0.1},
vec3{0.1, -0.1, -0.1},
vec3{-0.1, -0.1, -0.1},
vec3{-100.0, 100.0, -100.0},
vec3{100.0, 100.0, -100.0},
vec3{100.0, -100.0, -100.0},
vec3{-100.0, -100.0, -100.0}};
const std::array<vec4, 6> expectedPlanes = {
vec4{0, -0.707, 0.707, 0},
vec4{-0.707, 0, 0.707, 0},
vec4{0.707, 0, 0.707, 0},
vec4{0, 0.707, 0.707, 0},
vec4{0, 0, 1.0, 0.1},
vec4{0, 0, -1.0, -100.0}};
const auto roundPoint = [](vec3& v) {
for (auto& p : v) {
p = round(p * 10.0) / 10.0;
}
};
const auto roundPlane = [](vec4& v) {
for (auto& p : v) {
p = round(p * 1000.0) / 1000.0;
}
};
std::array<vec3, 8> actualPoints = frustum.getPoints();
std::array<vec4, 6> actualPlanes = frustum.getPlanes();
std::for_each(actualPoints.begin(), actualPoints.end(), roundPoint);
std::for_each(actualPlanes.begin(), actualPlanes.end(), roundPlane);
EXPECT_EQ(actualPoints, expectedPoints);
EXPECT_EQ(actualPlanes, expectedPlanes);
}
static util::Frustum createTestFrustum(
double fovy, double aspectRatio, double zNear, double zFar, double elevation, double bearing) {
mat4 proj;
mat4 invProj;
// Create a complete projection matrix for transforming from world space to clip space
matrix::perspective(proj, fovy, aspectRatio, zNear, zFar);
matrix::scale(proj, proj, 1, -1, 1);
matrix::translate(proj, proj, 0, 0, elevation);
matrix::rotate_z(proj, proj, bearing);
matrix::invert(invProj, proj);
return util::Frustum::fromInvProjMatrix(invProj, 1.0, 0.0);
}
TEST(BoundingVolumes, AabbFullyInsideFrustum) {
const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, 0.0);
const std::array<util::AABB, 3> aabbArray = {
util::AABB({-1, -1, 0}, {1, 1, 0}), util::AABB({-5, -5, 0}, {5, 5, 0}), util::AABB({-5, -5, 0}, {-4, -2, 0})};
EXPECT_EQ(frustum.intersects(aabbArray[0]), util::IntersectionResult::Contains);
EXPECT_EQ(frustum.intersects(aabbArray[1]), util::IntersectionResult::Contains);
EXPECT_EQ(frustum.intersects(aabbArray[2]), util::IntersectionResult::Contains);
}
TEST(BoundingVolumes, AabbIntersectsFrustum) {
const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, 0.0);
const std::array<util::AABB, 2> aabbArray = {util::AABB({-6, -6, 0}, {6, 6, 0}),
util::AABB({-6, -6, 0}, {-5, -5, 0})};
EXPECT_EQ(frustum.intersects(aabbArray[0]), util::IntersectionResult::Intersects);
EXPECT_EQ(frustum.intersects(aabbArray[1]), util::IntersectionResult::Intersects);
}
TEST(BoundingVolumes, AabbIntersectsFrustumEdgeCase) {
const util::Frustum frustum = createTestFrustum(M_PI_2, 1.0, 0.1, 100.0, -5.0, M_PI_4);
const util::AABB aabb({-10, 10, 0}, {10, 12, 0});
// Intersection test should report intersection even though shapes are separate
EXPECT_EQ(frustum.intersects(aabb), util::IntersectionResult::Intersects);
EXPECT_EQ(frustum.intersectsPrecise(aabb), util::IntersectionResult::Separate);
}
|
