| 1 |
// |
| 2 |
// SPDX-License-Identifier: BSD-3-Clause |
| 3 |
// Copyright Contributors to the OpenEXR Project. |
| 4 |
// |
| 5 |
|
| 6 |
#ifdef NDEBUG |
| 7 |
# undef NDEBUG |
| 8 |
#endif |
| 9 |
|
| 10 |
#include <ImathEuler.h> |
| 11 |
#include <ImathFrustum.h> |
| 12 |
#include <ImathFun.h> |
| 13 |
#include <ImathVec.h> |
| 14 |
#include <assert.h> |
| 15 |
#include <iostream> |
| 16 |
#include "testFrustum.h" |
| 17 |
|
| 18 |
// Include ImathForward *after* other headers to validate forward declarations |
| 19 |
#include <ImathForward.h> |
| 20 |
|
| 21 |
using namespace std; |
| 22 |
|
| 23 |
namespace |
| 24 |
{ |
| 25 |
|
| 26 |
void |
| 27 |
testFrustumPlanes (IMATH_INTERNAL_NAMESPACE::Frustumf& frustum) |
| 28 |
{ |
| 29 |
bool ortho = frustum.orthographic(); |
| 30 |
IMATH_INTERNAL_NAMESPACE::V3f o (0.0f, 0.0f, 0.0f); |
| 31 |
float eps = 5.0e-4f; |
| 32 |
|
| 33 |
for (auto xRo : { 0.0f, 100.0f, 200.0f }) |
| 34 |
{ |
| 35 |
for (auto yRo : { 0.0f, 105.0f, 210.0f, 315.0f }) |
| 36 |
{ |
| 37 |
for (auto zRo : { 0.0f, 110.0f, 220.0f, 330.0f }) |
| 38 |
{ |
| 39 |
for (auto xTr : |
| 40 |
{ -10.0f, -8.0f, -6.0f, -4.0f, -2.0f, 0.0f, 2.0f, 4.0f, 6.0f, 8.0f }) |
| 41 |
{ |
| 42 |
for (auto yTr : { -10.0f, -7.0f, -4.0f, -1.0f, 2.0f, 5.0f, 8.0f }) |
| 43 |
{ |
| 44 |
for (auto zTr : { -10.0f, -6.0f, -2.0f, 2.0f, 6.0f }) |
| 45 |
{ |
| 46 |
float xRoRad = xRo * (2.0f * float (M_PI) / 360.0f); |
| 47 |
float yRoRad = yRo * (2.0f * float (M_PI) / 360.0f); |
| 48 |
float zRoRad = zRo * (2.0f * float (M_PI) / 360.0f); |
| 49 |
IMATH_INTERNAL_NAMESPACE::Eulerf e (xRoRad, yRoRad, zRoRad); |
| 50 |
IMATH_INTERNAL_NAMESPACE::M44f mView = e.toMatrix44(); |
| 51 |
mView.translate (IMATH_INTERNAL_NAMESPACE::V3f (xTr, yTr, zTr)); |
| 52 |
|
| 53 |
IMATH_INTERNAL_NAMESPACE::Plane3f planes0[6]; |
| 54 |
frustum.planes (planes0); |
| 55 |
|
| 56 |
IMATH_INTERNAL_NAMESPACE::Plane3f planes[6]; |
| 57 |
frustum.planes (planes, mView); |
| 58 |
|
| 59 |
IMATH_INTERNAL_NAMESPACE::V3f up = |
| 60 |
IMATH_INTERNAL_NAMESPACE::V3f (0, 1, 0); |
| 61 |
assert ((up ^ planes0[0].normal) > 0.0); |
| 62 |
mView.multDirMatrix (up, up); |
| 63 |
assert ((up ^ planes[0].normal) > 0.0); |
| 64 |
|
| 65 |
IMATH_INTERNAL_NAMESPACE::V3f pt = |
| 66 |
(!ortho) |
| 67 |
? o |
| 68 |
: IMATH_INTERNAL_NAMESPACE::V3f (0.0f, frustum.top(), 0.0f); |
| 69 |
float d = planes0[0].distanceTo (pt); |
| 70 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 71 |
pt = pt * mView; |
| 72 |
d = planes[0].distanceTo (pt); |
| 73 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 74 |
|
| 75 |
IMATH_INTERNAL_NAMESPACE::V3f right = |
| 76 |
IMATH_INTERNAL_NAMESPACE::V3f (1, 0, 0); |
| 77 |
assert ((right ^ planes0[1].normal) > 0.0); |
| 78 |
mView.multDirMatrix (right, right); |
| 79 |
assert ((right ^ planes[1].normal) > 0.0); |
| 80 |
|
| 81 |
pt = (!ortho) |
| 82 |
? o |
| 83 |
: IMATH_INTERNAL_NAMESPACE::V3f (frustum.right(), 0.0f, 0.0f); |
| 84 |
d = planes0[1].distanceTo (pt); |
| 85 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 86 |
pt = pt * mView; |
| 87 |
d = planes[1].distanceTo (pt); |
| 88 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 89 |
|
| 90 |
IMATH_INTERNAL_NAMESPACE::V3f down = |
| 91 |
IMATH_INTERNAL_NAMESPACE::V3f (0, -1, 0); |
| 92 |
assert ((down ^ planes0[2].normal) > 0.0); |
| 93 |
mView.multDirMatrix (down, down); |
| 94 |
assert ((down ^ planes[2].normal) > 0.0); |
| 95 |
|
| 96 |
pt = (!ortho) |
| 97 |
? o |
| 98 |
: IMATH_INTERNAL_NAMESPACE::V3f (0.0f, frustum.bottom(), 0.0f); |
| 99 |
d = planes0[2].distanceTo (pt); |
| 100 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 101 |
pt = pt * mView; |
| 102 |
d = planes[2].distanceTo (pt); |
| 103 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 104 |
|
| 105 |
IMATH_INTERNAL_NAMESPACE::V3f left = |
| 106 |
IMATH_INTERNAL_NAMESPACE::V3f (-1, 0, 0); |
| 107 |
assert ((left ^ planes0[3].normal) > 0.0); |
| 108 |
mView.multDirMatrix (left, left); |
| 109 |
assert ((left ^ planes[3].normal) > 0.0); |
| 110 |
|
| 111 |
pt = (!ortho) |
| 112 |
? o |
| 113 |
: IMATH_INTERNAL_NAMESPACE::V3f (frustum.left(), 0.0f, 0.0f); |
| 114 |
d = planes0[3].distanceTo (pt); |
| 115 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 116 |
pt = pt * mView; |
| 117 |
d = planes[3].distanceTo (pt); |
| 118 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 119 |
|
| 120 |
IMATH_INTERNAL_NAMESPACE::V3f front = |
| 121 |
IMATH_INTERNAL_NAMESPACE::V3f (0, 0, 1); |
| 122 |
assert ((front ^ planes0[4].normal) > 0.0); |
| 123 |
mView.multDirMatrix (front, front); |
| 124 |
assert ((front ^ planes[4].normal) > 0.0); |
| 125 |
|
| 126 |
pt = IMATH_INTERNAL_NAMESPACE::V3f (0.0f, 0.0f, -frustum.nearPlane()); |
| 127 |
d = planes0[4].distanceTo (pt); |
| 128 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 129 |
pt = pt * mView; |
| 130 |
d = planes[4].distanceTo (pt); |
| 131 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 132 |
|
| 133 |
IMATH_INTERNAL_NAMESPACE::V3f back = |
| 134 |
IMATH_INTERNAL_NAMESPACE::V3f (0, 0, -1); |
| 135 |
assert ((back ^ planes0[5].normal) > 0.0); |
| 136 |
mView.multDirMatrix (back, back); |
| 137 |
assert ((back ^ planes[5].normal) > 0.0); |
| 138 |
|
| 139 |
pt = IMATH_INTERNAL_NAMESPACE::V3f (0.0f, 0.0f, -frustum.farPlane()); |
| 140 |
d = planes0[5].distanceTo (pt); |
| 141 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 142 |
pt = pt * mView; |
| 143 |
d = planes[5].distanceTo (pt); |
| 144 |
assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); |
| 145 |
} |
| 146 |
} |
| 147 |
} |
| 148 |
} |
| 149 |
} |
| 150 |
} |
| 151 |
} |
| 152 |
|
| 153 |
} // namespace |
| 154 |
|
| 155 |
void |
| 156 |
testFrustum() |
| 157 |
{ |
| 158 |
cout << "Testing functions in ImathFrustum.h"; |
| 159 |
|
| 160 |
cout << "\nperspective "; |
| 161 |
|
| 162 |
float n = 1.7f; |
| 163 |
float f = 567.0f; |
| 164 |
float l = -3.5f; |
| 165 |
float r = 2.0f; |
| 166 |
float b = -1.3f; |
| 167 |
float t = 0.9f; |
| 168 |
|
| 169 |
IMATH_INTERNAL_NAMESPACE::Frustum<float> frustum (n, f, l, r, t, b, false); |
| 170 |
|
| 171 |
assert (IMATH_INTERNAL_NAMESPACE::abs<float> (frustum.fovx() - (atan2 (r, n) - atan2 (l, n))) < |
| 172 |
1e-6); |
| 173 |
assert (IMATH_INTERNAL_NAMESPACE::abs<float> (frustum.fovy() - (atan2 (t, n) - atan2 (b, n))) < |
| 174 |
1e-6); |
| 175 |
cout << "1"; |
| 176 |
assert (IMATH_INTERNAL_NAMESPACE::abs<float> (frustum.aspectExc() - ((r - l) / (t - b))) < 1e-6); |
| 177 |
assert (IMATH_INTERNAL_NAMESPACE::abs<float> (frustum.aspect() - ((r - l) / (t - b))) < |
| 178 |
1e-6); |
| 179 |
cout << "2"; |
| 180 |
|
| 181 |
IMATH_INTERNAL_NAMESPACE::M44f m = frustum.projectionMatrixExc (); |
| 182 |
assert ( |
| 183 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][0] - ((2 * n) / (r - l))) < |
| 184 |
1e-6f && |
| 185 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][1]) < 1e-6f && |
| 186 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][2]) < 1e-6f && |
| 187 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][3]) < 1e-6f && |
| 188 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][0]) < 1e-6f && |
| 189 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][1] - ((2 * n) / (t - b))) < |
| 190 |
1e-6f && |
| 191 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][2]) < 1e-6f && |
| 192 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][3]) < 1e-6f && |
| 193 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][0] - ((r + l) / (r - l))) < |
| 194 |
1e-6f && |
| 195 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][1] - ((t + b) / (t - b))) < |
| 196 |
1e-6f && |
| 197 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][2] - (-(f + n) / (f - n))) < |
| 198 |
1e-6f && |
| 199 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][3] - -1.0f) < 1e-6f && |
| 200 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][0]) < 1e-6f && |
| 201 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][1]) < 1e-6f && |
| 202 |
IMATH_INTERNAL_NAMESPACE::abs<float> ( |
| 203 |
m[3][2] - ((-2 * f * n) / (f - n))) < 1e-6f && |
| 204 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][3]) < 1e-6f); |
| 205 |
m = frustum.projectionMatrix (); |
| 206 |
assert ( |
| 207 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][0] - ((2 * n) / (r - l))) < |
| 208 |
1e-6f && |
| 209 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][1]) < 1e-6f && |
| 210 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][2]) < 1e-6f && |
| 211 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][3]) < 1e-6f && |
| 212 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][0]) < 1e-6f && |
| 213 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][1] - ((2 * n) / (t - b))) < |
| 214 |
1e-6f && |
| 215 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][2]) < 1e-6 && |
| 216 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][3]) < 1e-6 && |
| 217 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][0] - ((r + l) / (r - l))) < |
| 218 |
1e-6f && |
| 219 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][1] - ((t + b) / (t - b))) < |
| 220 |
1e-6f && |
| 221 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][2] - (-(f + n) / (f - n))) < |
| 222 |
1e-6f && |
| 223 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][3] - -1.0f) < 1e-6f && |
| 224 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][0]) < 1e-6f && |
| 225 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][1]) < 1e-6f && |
| 226 |
IMATH_INTERNAL_NAMESPACE::abs<float> ( |
| 227 |
m[3][2] - ((-2 * f * n) / (f - n))) < 1e-6f && |
| 228 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][3]) < 1e-6f); |
| 229 |
cout << "3"; |
| 230 |
|
| 231 |
cout << "\nplanes "; |
| 232 |
testFrustumPlanes (frustum); |
| 233 |
|
| 234 |
cout << "\nexceptions "; |
| 235 |
IMATH_INTERNAL_NAMESPACE::Frustum<float> badFrustum; |
| 236 |
|
| 237 |
bool caught; |
| 238 |
|
| 239 |
badFrustum.set (n, n, l, r, t, b, false); |
| 240 |
caught = false; |
| 241 |
try |
| 242 |
{ |
| 243 |
(void) badFrustum.projectionMatrixExc(); |
| 244 |
assert (!"near == far didn't throw an exception"); |
| 245 |
} |
| 246 |
catch (std::domain_error&) |
| 247 |
{ |
| 248 |
caught = true; |
| 249 |
} |
| 250 |
assert (caught); |
| 251 |
cout << "1"; |
| 252 |
|
| 253 |
badFrustum.set (n, f, l, l, t, b, false); |
| 254 |
caught = false; |
| 255 |
try |
| 256 |
{ |
| 257 |
(void) badFrustum.projectionMatrixExc(); |
| 258 |
assert (!"left == right didn't throw an exception"); |
| 259 |
} |
| 260 |
catch (std::domain_error&) |
| 261 |
{ |
| 262 |
caught = true; |
| 263 |
} |
| 264 |
assert (caught); |
| 265 |
cout << "2"; |
| 266 |
|
| 267 |
badFrustum.set (n, f, l, r, t, t, false); |
| 268 |
caught = false; |
| 269 |
try |
| 270 |
{ |
| 271 |
(void) badFrustum.projectionMatrixExc(); |
| 272 |
assert (!"top == bottom didn't throw an exception"); |
| 273 |
} |
| 274 |
catch (std::domain_error&) |
| 275 |
{ |
| 276 |
caught = true; |
| 277 |
} |
| 278 |
assert (caught); |
| 279 |
cout << "3"; |
| 280 |
|
| 281 |
cout << "\northographic "; |
| 282 |
|
| 283 |
frustum.setOrthographic (true); |
| 284 |
|
| 285 |
m = frustum.projectionMatrix (); |
| 286 |
assert ( |
| 287 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][0] - (2 / (r - l))) < 1e-6f && |
| 288 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][1]) < 1e-6f && |
| 289 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][2]) < 1e-6f && |
| 290 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[0][3]) < 1e-6f && |
| 291 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][0]) < 1e-6f && |
| 292 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][1] - (2 / (t - b))) < 1e-6f && |
| 293 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][2]) < 1e-6f && |
| 294 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[1][3]) < 1e-6f && |
| 295 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][0]) < 1e-6f && |
| 296 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][1]) < 1e-6f && |
| 297 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][2] - (-2 / (f - n))) < |
| 298 |
1e-6f && |
| 299 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[2][3]) < 1e-6f && |
| 300 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][0] - (-(r + l) / (r - l))) < |
| 301 |
1e-6f && |
| 302 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][1] - (-(t + b) / (t - b))) < |
| 303 |
1e-6f && |
| 304 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][2] - (-(f + n) / (f - n))) < |
| 305 |
1e-6f && |
| 306 |
IMATH_INTERNAL_NAMESPACE::abs<float> (m[3][3] - 1.0f) < 1e-6f); |
| 307 |
cout << "1"; |
| 308 |
|
| 309 |
cout << "\nplanes "; |
| 310 |
testFrustumPlanes (frustum); |
| 311 |
|
| 312 |
// TODO - There are many little functions in IMATH_INTERNAL_NAMESPACE::Frustum which |
| 313 |
// aren't tested here. Those test should be added. But this is |
| 314 |
// a start. |
| 315 |
|
| 316 |
IMATH_INTERNAL_NAMESPACE::Frustum<float> f1 (n, f, l, r, t, b, false); |
| 317 |
IMATH_INTERNAL_NAMESPACE::Frustum<float> f2 (n, f, l, r, t, b, true); |
| 318 |
assert (f1 != f2); |
| 319 |
f2.set (n + 0.1f, f, l, r, t, b, false); |
| 320 |
assert (f1 != f2); |
| 321 |
f2.set (n, f + 0.1f, l, r, t, b, false); |
| 322 |
assert (f1 != f2); |
| 323 |
f2.set (n, f, l + 0.1f, r, t, b, false); |
| 324 |
assert (f1 != f2); |
| 325 |
f2.set (n, f, l, r + 0.1f, t, b, false); |
| 326 |
assert (f1 != f2); |
| 327 |
f2.set (n, f, l, r, t + 0.1f, b, false); |
| 328 |
assert (f1 != f2); |
| 329 |
f2.set (n, f, l, r, t, b + 0.1f, false); |
| 330 |
assert (f1 != f2); |
| 331 |
cout << "\npassed inequality test"; |
| 332 |
|
| 333 |
f1 = f2; |
| 334 |
assert (f1 == f2); |
| 335 |
cout << "\npassed equality test"; |
| 336 |
|
| 337 |
long zMax = 100; |
| 338 |
long zMin = 1; |
| 339 |
float zero = 0; |
| 340 |
float one = 1; |
| 341 |
IMATH_INTERNAL_NAMESPACE::Vec3<float> v3 (zero, zero, one); |
| 342 |
|
| 343 |
f1.set (n, f, one, zero, one); |
| 344 |
f2.setExc (n, f, one, zero, one); |
| 345 |
|
| 346 |
assert (f1 == f2); |
| 347 |
|
| 348 |
assert ( |
| 349 |
f1.ZToDepth (zMin, zMin, zMax) == f1.ZToDepthExc (zMin, zMin, zMax)); |
| 350 |
assert (f1.normalizedZToDepth (float(zMin)) == f1.normalizedZToDepthExc (float(zMin))); |
| 351 |
assert (f1.DepthToZ (n, zMin, zMax) == f1.DepthToZExc (n, zMin, zMax)); |
| 352 |
assert (f1.worldRadius (v3, one) == f1.worldRadiusExc (v3, one)); |
| 353 |
assert (f1.screenRadius (v3, one) == f1.screenRadiusExc (v3, one)); |
| 354 |
assert (f1.projectPointToScreen (v3) == f1.projectPointToScreenExc (v3)); |
| 355 |
|
| 356 |
cout << "\npassed noexcept equality verification"; |
| 357 |
|
| 358 |
cout << "\nok\n\n"; |
| 359 |
} |