libs/math/frustum.h

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #if !defined(INCLUDED_MATH_FRUSTUM_H)
  23 #define INCLUDED_MATH_FRUSTUM_H
  24
  25 /// \file
  26 /// \brief View-frustum data types and related operations.
  27
  28 #include "generic/enumeration.h"
  29 #include "math/matrix.h"
  30 #include "math/plane.h"
  31 #include "math/aabb.h"
  32 #include "math/line.h"
  33
  34 inline Matrix4 matrix4_frustum(float left, float right, float bottom, float top, float nearval, float farval)
  35 {
  36   return Matrix4(
  37     static_cast<float>( (2*nearval) / (right-left) ),
  38     0,
  39     0,
  40     0,
  41     0,
  42     static_cast<float>( (2*nearval) / (top-bottom) ),
  43     0,
  44     0,
  45     static_cast<float>( (right+left) / (right-left) ),
  46     static_cast<float>( (top+bottom) / (top-bottom) ),
  47     static_cast<float>( -(farval+nearval) / (farval-nearval) ),
  48     -1,
  49     0,
  50     0,
  51     static_cast<float>( -(2*farval*nearval) / (farval-nearval) ),
  52     0
  53   );
  54 }
  55
  56
  57
  58 typedef unsigned char ClipResult;
  59 const ClipResult c_CLIP_PASS = 0x00; // 000000
  60 const ClipResult c_CLIP_LT_X = 0x01; // 000001
  61 const ClipResult c_CLIP_GT_X = 0x02; // 000010
  62 const ClipResult c_CLIP_LT_Y = 0x04; // 000100
  63 const ClipResult c_CLIP_GT_Y = 0x08; // 001000
  64 const ClipResult c_CLIP_LT_Z = 0x10; // 010000
  65 const ClipResult c_CLIP_GT_Z = 0x20; // 100000
  66 const ClipResult c_CLIP_FAIL = 0x3F; // 111111
  67
  68 template<typename Index>
  69 class Vector4ClipLT
  70 {
  71 public:
  72   static bool compare(const Vector4& self)
  73   {
  74     return self[Index::VALUE] < self[3];
  75   }
  76   static double scale(const Vector4& self, const Vector4& other)
  77   {
  78     return (self[Index::VALUE] - self[3]) / (other[3] - other[Index::VALUE]);
  79   }
  80 };
  81
  82 template<typename Index>
  83 class Vector4ClipGT
  84 {
  85 public:
  86   static bool compare(const Vector4& self)
  87   {
  88     return self[Index::VALUE] > -self[3];
  89   }
  90   static double scale(const Vector4& self, const Vector4& other)
  91   {
  92     return (self[Index::VALUE] + self[3]) / (-other[3] - other[Index::VALUE]);
  93   }
  94 };
  95
  96 template<typename ClipPlane>
  97 class Vector4ClipPolygon
  98 {
  99 public:
 100   typedef Vector4* iterator;
 101   typedef const Vector4* const_iterator;
 102
 103   static std::size_t apply(const_iterator first, const_iterator last, iterator out)
 104   {
 105     const_iterator next = first, i = last - 1;
 106     iterator tmp(out);
 107     bool b0 = ClipPlane::compare(*i);
 108     while(next != last)
 109     {
 110       bool b1 = ClipPlane::compare(*next);
 111       if(b0 ^ b1)
 112       {
 113         *out = vector4_subtracted(*next, *i);
 114
 115         double scale = ClipPlane::scale(*i, *out);
 116
 117         (*out)[0] = static_cast<float>((*i)[0] + scale*((*out)[0]));
 118         (*out)[1] = static_cast<float>((*i)[1] + scale*((*out)[1]));
 119         (*out)[2] = static_cast<float>((*i)[2] + scale*((*out)[2]));
 120         (*out)[3] = static_cast<float>((*i)[3] + scale*((*out)[3]));
 121
 122         ++out;
 123       }
 124
 125       if(b1)
 126       {
 127         *out = *next;
 128         ++out;
 129       }
 130
 131       i = next;
 132       ++next;
 133       b0 = b1;
 134     }
 135
 136     return out - tmp;
 137   }
 138 };
 139
 140 #define CLIP_X_LT_W(p) (Vector4ClipLT< IntegralConstant<0> >::compare(p))
 141 #define CLIP_X_GT_W(p) (Vector4ClipGT< IntegralConstant<0> >::compare(p))
 142 #define CLIP_Y_LT_W(p) (Vector4ClipLT< IntegralConstant<1> >::compare(p))
 143 #define CLIP_Y_GT_W(p) (Vector4ClipGT< IntegralConstant<1> >::compare(p))
 144 #define CLIP_Z_LT_W(p) (Vector4ClipLT< IntegralConstant<2> >::compare(p))
 145 #define CLIP_Z_GT_W(p) (Vector4ClipGT< IntegralConstant<2> >::compare(p))
 146
 147 inline ClipResult homogenous_clip_point(const Vector4& clipped)
 148 {
 149   ClipResult result = c_CLIP_FAIL;
 150   if(CLIP_X_LT_W(clipped)) result &= ~c_CLIP_LT_X; // X < W
 151   if(CLIP_X_GT_W(clipped)) result &= ~c_CLIP_GT_X; // X > -W
 152   if(CLIP_Y_LT_W(clipped)) result &= ~c_CLIP_LT_Y; // Y < W
 153   if(CLIP_Y_GT_W(clipped)) result &= ~c_CLIP_GT_Y; // Y > -W
 154   if(CLIP_Z_LT_W(clipped)) result &= ~c_CLIP_LT_Z; // Z < W
 155   if(CLIP_Z_GT_W(clipped)) result &= ~c_CLIP_GT_Z; // Z > -W
 156   return result;
 157 }
 158
 159 /// \brief Clips \p point by canonical matrix \p self.
 160 /// Stores the result in \p clipped.
 161 /// Returns a bitmask indicating which clip-planes the point was outside.
 162 inline ClipResult matrix4_clip_point(const Matrix4& self, const Vector3& point, Vector4& clipped)
 163 {
 164   clipped[0] = point[0];
 165   clipped[1] = point[1];
 166   clipped[2] = point[2];
 167   clipped[3] = 1;
 168   matrix4_transform_vector4(self, clipped);
 169   return homogenous_clip_point(clipped);
 170 }
 171
 172
 173 inline std::size_t homogenous_clip_triangle(Vector4 clipped[9])
 174 {
 175   Vector4 buffer[9];
 176   std::size_t count = 3;
 177   count = Vector4ClipPolygon< Vector4ClipLT< IntegralConstant<0> > >::apply(clipped, clipped + count, buffer);
 178   count = Vector4ClipPolygon< Vector4ClipGT< IntegralConstant<0> > >::apply(buffer, buffer + count, clipped);
 179   count = Vector4ClipPolygon< Vector4ClipLT< IntegralConstant<1> > >::apply(clipped, clipped + count, buffer);
 180   count = Vector4ClipPolygon< Vector4ClipGT< IntegralConstant<1> > >::apply(buffer, buffer + count, clipped);
 181   count = Vector4ClipPolygon< Vector4ClipLT< IntegralConstant<2> > >::apply(clipped, clipped + count, buffer);
 182   return Vector4ClipPolygon< Vector4ClipGT< IntegralConstant<2> > >::apply(buffer, buffer + count, clipped);
 183 }
 184
 185 /// \brief Transforms and clips the triangle formed by \p p0, \p p1, \p p2 by the canonical matrix \p self.
 186 /// Stores the resulting polygon in \p clipped.
 187 /// Returns the number of points in the resulting polygon.
 188 inline std::size_t matrix4_clip_triangle(const Matrix4& self, const Vector3& p0, const Vector3& p1, const Vector3& p2, Vector4 clipped[9])
 189 {
 190   clipped[0][0] = p0[0];
 191   clipped[0][1] = p0[1];
 192   clipped[0][2] = p0[2];
 193   clipped[0][3] = 1;
 194   clipped[1][0] = p1[0];
 195   clipped[1][1] = p1[1];
 196   clipped[1][2] = p1[2];
 197   clipped[1][3] = 1;
 198   clipped[2][0] = p2[0];
 199   clipped[2][1] = p2[1];
 200   clipped[2][2] = p2[2];
 201   clipped[2][3] = 1;
 202
 203   matrix4_transform_vector4(self, clipped[0]);
 204   matrix4_transform_vector4(self, clipped[1]);
 205   matrix4_transform_vector4(self, clipped[2]);
 206
 207   return homogenous_clip_triangle(clipped);
 208 }
 209
 210 inline std::size_t homogenous_clip_line(Vector4 clipped[2])
 211 {
 212   const Vector4& p0 = clipped[0];
 213   const Vector4& p1 = clipped[1];
 214
 215   // early out
 216   {
 217     ClipResult mask0 = homogenous_clip_point(clipped[0]);
 218     ClipResult mask1 = homogenous_clip_point(clipped[1]);
 219
 220     if((mask0 | mask1) == c_CLIP_PASS) // both points passed all planes
 221       return 2;
 222
 223     if(mask0 & mask1) // both points failed any one plane
 224       return 0;
 225   }
 226
 227   {
 228     const bool index = CLIP_X_LT_W(p0);
 229     if(index ^ CLIP_X_LT_W(p1))
 230     {
 231       Vector4 clip(vector4_subtracted(p1, p0));
 232
 233       double scale = (p0[0] - p0[3]) / (clip[3] - clip[0]);
 234
 235       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 236       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 237       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 238       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 239
 240       clipped[index] = clip;
 241     }
 242     else if(index == 0)
 243       return 0;
 244   }
 245
 246   {
 247     const bool index = CLIP_X_GT_W(p0);
 248     if(index ^ CLIP_X_GT_W(p1))
 249     {
 250       Vector4 clip(vector4_subtracted(p1, p0));
 251
 252       double scale = (p0[0] + p0[3]) / (-clip[3] - clip[0]);
 253
 254       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 255       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 256       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 257       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 258
 259       clipped[index] = clip;
 260     }
 261     else if(index == 0)
 262       return 0;
 263   }
 264
 265   {
 266     const bool index = CLIP_Y_LT_W(p0);
 267     if(index ^ CLIP_Y_LT_W(p1))
 268     {
 269       Vector4 clip(vector4_subtracted(p1, p0));
 270
 271       double scale = (p0[1] - p0[3]) / (clip[3] - clip[1]);
 272
 273       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 274       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 275       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 276       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 277
 278       clipped[index] = clip;
 279     }
 280     else if(index == 0)
 281       return 0;
 282   }
 283
 284   {
 285     const bool index = CLIP_Y_GT_W(p0);
 286     if(index ^ CLIP_Y_GT_W(p1))
 287     {
 288       Vector4 clip(vector4_subtracted(p1, p0));
 289
 290       double scale = (p0[1] + p0[3]) / (-clip[3] - clip[1]);
 291
 292       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 293       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 294       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 295       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 296
 297       clipped[index] = clip;
 298     }
 299     else if(index == 0)
 300       return 0;
 301   }
 302
 303   {
 304     const bool index = CLIP_Z_LT_W(p0);
 305     if(index ^ CLIP_Z_LT_W(p1))
 306     {
 307       Vector4 clip(vector4_subtracted(p1, p0));
 308
 309       double scale = (p0[2] - p0[3]) / (clip[3] - clip[2]);
 310
 311       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 312       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 313       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 314       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 315
 316       clipped[index] = clip;
 317     }
 318     else if(index == 0)
 319       return 0;
 320   }
 321
 322   {
 323     const bool index = CLIP_Z_GT_W(p0);
 324     if(index ^ CLIP_Z_GT_W(p1))
 325     {
 326       Vector4 clip(vector4_subtracted(p1, p0));
 327
 328       double scale = (p0[2] + p0[3]) / (-clip[3] - clip[2]);
 329
 330       clip[0] = static_cast<float>(p0[0] + scale * clip[0]);
 331       clip[1] = static_cast<float>(p0[1] + scale * clip[1]);
 332       clip[2] = static_cast<float>(p0[2] + scale * clip[2]);
 333       clip[3] = static_cast<float>(p0[3] + scale * clip[3]);
 334
 335       clipped[index] = clip;
 336     }
 337     else if(index == 0)
 338       return 0;
 339   }
 340
 341   return 2;
 342 }
 343
 344 /// \brief Transforms and clips the line formed by \p p0, \p p1 by the canonical matrix \p self.
 345 /// Stores the resulting line in \p clipped.
 346 /// Returns the number of points in the resulting line.
 347 inline std::size_t matrix4_clip_line(const Matrix4& self, const Vector3& p0, const Vector3& p1, Vector4 clipped[2])
 348 {
 349   clipped[0][0] = p0[0];
 350   clipped[0][1] = p0[1];
 351   clipped[0][2] = p0[2];
 352   clipped[0][3] = 1;
 353   clipped[1][0] = p1[0];
 354   clipped[1][1] = p1[1];
 355   clipped[1][2] = p1[2];
 356   clipped[1][3] = 1;
 357
 358   matrix4_transform_vector4(self, clipped[0]);
 359   matrix4_transform_vector4(self, clipped[1]);
 360
 361   return homogenous_clip_line(clipped);
 362 }
 363
 364
 365
 366
 367 struct Frustum
 368 {
 369   Plane3 right, left, bottom, top, back, front;
 370
 371   Frustum()
 372   {
 373   }
 374   Frustum(const Plane3& _right,
 375     const Plane3& _left,
 376     const Plane3& _bottom,
 377     const Plane3& _top,
 378     const Plane3& _back,
 379     const Plane3& _front)
 380     : right(_right), left(_left), bottom(_bottom), top(_top), back(_back), front(_front)
 381   {
 382   }
 383 };
 384
 385 inline Frustum frustum_transformed(const Frustum& frustum, const Matrix4& transform)
 386 {
 387   return Frustum(
 388     plane3_transformed(frustum.right, transform),
 389     plane3_transformed(frustum.left, transform),
 390     plane3_transformed(frustum.bottom, transform),
 391     plane3_transformed(frustum.top, transform),
 392     plane3_transformed(frustum.back, transform),
 393     plane3_transformed(frustum.front, transform)
 394   );
 395 }
 396
 397 inline Frustum frustum_inverse_transformed(const Frustum& frustum, const Matrix4& transform)
 398 {
 399   return Frustum(
 400     plane3_inverse_transformed(frustum.right, transform),
 401     plane3_inverse_transformed(frustum.left, transform),
 402     plane3_inverse_transformed(frustum.bottom, transform),
 403     plane3_inverse_transformed(frustum.top, transform),
 404     plane3_inverse_transformed(frustum.back, transform),
 405     plane3_inverse_transformed(frustum.front, transform)
 406   );
 407 }
 408
 409 inline bool viewproj_test_point(const Matrix4& viewproj, const Vector3& point)
 410 {
 411   Vector4 hpoint(matrix4_transformed_vector4(viewproj, Vector4(point, 1.0f)));
 412   if(fabs(hpoint[0]) < fabs(hpoint[3])
 413     && fabs(hpoint[1]) < fabs(hpoint[3])
 414     && fabs(hpoint[2]) < fabs(hpoint[3]))
 415     return true;
 416   return false;
 417 }
 418
 419 inline bool viewproj_test_transformed_point(const Matrix4& viewproj, const Vector3& point, const Matrix4& localToWorld)
 420 {
 421   return viewproj_test_point(viewproj, matrix4_transformed_point(localToWorld, point));
 422 }
 423
 424 inline Frustum frustum_from_viewproj(const Matrix4& viewproj)
 425 {
 426   return Frustum
 427   (
 428     plane3_normalised(Plane3(viewproj[ 3] - viewproj[ 0], viewproj[ 7] - viewproj[ 4], viewproj[11] - viewproj[ 8], viewproj[15] - viewproj[12])),
 429     plane3_normalised(Plane3(viewproj[ 3] + viewproj[ 0], viewproj[ 7] + viewproj[ 4], viewproj[11] + viewproj[ 8], viewproj[15] + viewproj[12])),
 430     plane3_normalised(Plane3(viewproj[ 3] + viewproj[ 1], viewproj[ 7] + viewproj[ 5], viewproj[11] + viewproj[ 9], viewproj[15] + viewproj[13])),
 431     plane3_normalised(Plane3(viewproj[ 3] - viewproj[ 1], viewproj[ 7] - viewproj[ 5], viewproj[11] - viewproj[ 9], viewproj[15] - viewproj[13])),
 432     plane3_normalised(Plane3(viewproj[ 3] - viewproj[ 2], viewproj[ 7] - viewproj[ 6], viewproj[11] - viewproj[10], viewproj[15] - viewproj[14])),
 433     plane3_normalised(Plane3(viewproj[ 3] + viewproj[ 2], viewproj[ 7] + viewproj[ 6], viewproj[11] + viewproj[10], viewproj[15] + viewproj[14]))
 434   );
 435 }
 436
 437 struct VolumeIntersection
 438 {
 439   enum Value
 440   {
 441     OUTSIDE,
 442     INSIDE,
 443     PARTIAL
 444   };
 445 };
 446
 447 typedef EnumeratedValue<VolumeIntersection> VolumeIntersectionValue;
 448
 449 const VolumeIntersectionValue c_volumeOutside(VolumeIntersectionValue::OUTSIDE);
 450 const VolumeIntersectionValue c_volumeInside(VolumeIntersectionValue::INSIDE);
 451 const VolumeIntersectionValue c_volumePartial(VolumeIntersectionValue::PARTIAL);
 452
 453 inline VolumeIntersectionValue frustum_test_aabb(const Frustum& frustum, const AABB& aabb)
 454 {
 455   VolumeIntersectionValue result = c_volumeInside;
 456
 457   switch(aabb_classify_plane(aabb, frustum.right))
 458   {
 459   case 2:
 460     return c_volumeOutside;
 461   case 1:
 462     result = c_volumePartial;
 463   }
 464
 465   switch(aabb_classify_plane(aabb, frustum.left))
 466   {
 467   case 2:
 468     return c_volumeOutside;
 469   case 1:
 470     result = c_volumePartial;
 471   }
 472
 473   switch(aabb_classify_plane(aabb, frustum.bottom))
 474   {
 475   case 2:
 476     return c_volumeOutside;
 477   case 1:
 478     result = c_volumePartial;
 479   }
 480
 481   switch(aabb_classify_plane(aabb, frustum.top))
 482   {
 483   case 2:
 484     return c_volumeOutside;
 485   case 1:
 486     result = c_volumePartial;
 487   }
 488
 489   switch(aabb_classify_plane(aabb, frustum.back))
 490   {
 491   case 2:
 492     return c_volumeOutside;
 493   case 1:
 494     result = c_volumePartial;
 495   }
 496
 497   switch(aabb_classify_plane(aabb, frustum.front))
 498   {
 499   case 2:
 500     return c_volumeOutside;
 501   case 1:
 502     result = c_volumePartial;
 503   }
 504
 505   return result;
 506 }
 507
 508 inline double plane_distance_to_point(const Plane3& plane, const Vector3& point)
 509 {
 510   return vector3_dot(plane.normal(), point) + plane.d;
 511 }
 512
 513 inline double plane_distance_to_oriented_extents(const Plane3& plane, const Vector3& extents, const Matrix4& orientation)
 514 {
 515   return fabs(extents[0] * vector3_dot(plane.normal(), vector4_to_vector3(orientation.x())))
 516     + fabs(extents[1] * vector3_dot(plane.normal(), vector4_to_vector3(orientation.y())))
 517     + fabs(extents[2] * vector3_dot(plane.normal(), vector4_to_vector3(orientation.z())));
 518 }
 519
 520 /// \brief Return false if \p aabb with \p orientation is partially or completely outside \p plane.
 521 inline bool plane_contains_oriented_aabb(const Plane3& plane, const AABB& aabb, const Matrix4& orientation)
 522 {
 523   double dot = plane_distance_to_point(plane, aabb.origin);
 524   return !(dot > 0 || -dot < plane_distance_to_oriented_extents(plane, aabb.extents, orientation));
 525 }
 526
 527 inline VolumeIntersectionValue frustum_intersects_transformed_aabb(const Frustum& frustum, const AABB& aabb, const Matrix4& localToWorld)
 528 {
 529   AABB aabb_world(aabb);
 530   matrix4_transform_point(localToWorld, aabb_world.origin);
 531
 532   if(plane_contains_oriented_aabb(frustum.right, aabb_world, localToWorld)
 533     || plane_contains_oriented_aabb(frustum.left, aabb_world, localToWorld)
 534     || plane_contains_oriented_aabb(frustum.bottom, aabb_world, localToWorld)
 535     || plane_contains_oriented_aabb(frustum.top, aabb_world, localToWorld)
 536     || plane_contains_oriented_aabb(frustum.back, aabb_world, localToWorld)
 537     || plane_contains_oriented_aabb(frustum.front, aabb_world, localToWorld))
 538     return c_volumeOutside;
 539   return c_volumeInside;
 540 }
 541
 542 inline bool plane3_test_point(const Plane3& plane, const Vector3& point)
 543 {
 544   return vector3_dot(point, plane.normal()) + plane.dist() <= 0;
 545 }
 546
 547 inline bool plane3_test_line(const Plane3& plane, const Segment& segment)
 548 {
 549   return segment_classify_plane(segment, plane) == 2;
 550 }
 551
 552 inline bool frustum_test_point(const Frustum& frustum, const Vector3& point)
 553 {
 554   return !plane3_test_point(frustum.right, point)
 555     && !plane3_test_point(frustum.left, point)
 556     && !plane3_test_point(frustum.bottom, point)
 557     && !plane3_test_point(frustum.top, point)
 558     && !plane3_test_point(frustum.back, point)
 559     && !plane3_test_point(frustum.front, point);
 560 }
 561
 562 inline bool frustum_test_line(const Frustum& frustum, const Segment& segment)
 563 {
 564   return !plane3_test_line(frustum.right, segment)
 565     && !plane3_test_line(frustum.left, segment)
 566     && !plane3_test_line(frustum.bottom, segment)
 567     && !plane3_test_line(frustum.top, segment)
 568     && !plane3_test_line(frustum.back, segment)
 569     && !plane3_test_line(frustum.front, segment);
 570 }
 571
 572 inline bool viewer_test_plane(const Vector4& viewer, const Plane3& plane)
 573 {
 574   return ((plane.a * viewer[0])
 575     + (plane.b * viewer[1])
 576     + (plane.c * viewer[2])
 577     + (plane.d * viewer[3])) > 0;
 578 }
 579
 580 inline Vector3 triangle_cross(const Vector3& p0, const Vector3& p1, const Vector3& p2)
 581 {
 582   return vector3_cross(vector3_subtracted(p1, p0), vector3_subtracted(p1, p2));
 583 }
 584
 585 inline bool viewer_test_triangle(const Vector4& viewer, const Vector3& p0, const Vector3& p1, const Vector3& p2)
 586 {
 587   Vector3 cross(triangle_cross(p0, p1, p2));
 588   return ((viewer[0] * cross[0])
 589     + (viewer[1] * cross[1])
 590     + (viewer[2] * cross[2])
 591     + (viewer[3] * 0)) > 0;
 592 }
 593
 594 inline Vector4 viewer_from_transformed_viewer(const Vector4& viewer, const Matrix4& transform)
 595 {
 596   if(viewer[3] == 0)
 597   {
 598     return Vector4(matrix4_transformed_direction(transform, vector4_to_vector3(viewer)), 0);
 599   }
 600   else
 601   {
 602     return Vector4(matrix4_transformed_point(transform, vector4_to_vector3(viewer)), viewer[3]);
 603   }
 604 }
 605
 606 inline bool viewer_test_transformed_plane(const Vector4& viewer, const Plane3& plane, const Matrix4& localToWorld)
 607 {
 608 #if 0
 609   return viewer_test_plane(viewer_from_transformed_viewer(viewer, matrix4_affine_inverse(localToWorld)), plane);
 610 #else
 611   return viewer_test_plane(viewer, plane3_transformed(plane, localToWorld));
 612 #endif
 613 }
 614
 615 inline Vector4 viewer_from_viewproj(const Matrix4& viewproj)
 616 {
 617   // get viewer pos in object coords
 618   Vector4 viewer(matrix4_transformed_vector4(matrix4_full_inverse(viewproj), Vector4(0, 0, -1, 0)));
 619   if(viewer[3] != 0) // non-affine matrix
 620   {
 621     viewer[0] /= viewer[3];
 622     viewer[1] /= viewer[3];
 623     viewer[2] /= viewer[3];
 624     viewer[3] /= viewer[3];
 625   }
 626   return viewer;
 627 }
 628
 629 #endif