/////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas // Digital Ltd. LLC // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Industrial Light & Magic nor the names of // its contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // /////////////////////////////////////////////////////////////////////////// #ifndef INCLUDED_IMATHFRUSTUM_H #define INCLUDED_IMATHFRUSTUM_H #include "ImathVec.h" #include "ImathPlane.h" #include "ImathLine.h" #include "ImathMatrix.h" #include "ImathLimits.h" #include "ImathFun.h" #include "IexMathExc.h" #if defined _WIN32 || defined _WIN64 #ifdef near #undef near #endif #ifdef far #undef far #endif #endif namespace Imath { // // template class Frustum // // The frustum is always located with the eye point at the // origin facing down -Z. This makes the Frustum class // compatable with OpenGL (or anything that assumes a camera // looks down -Z, hence with a right-handed coordinate system) // but not with RenderMan which assumes the camera looks down // +Z. Additional functions are provided for conversion from // and from various camera coordinate spaces. // template class Frustum { public: Frustum(); Frustum(const Frustum &); Frustum(T near, T far, T left, T right, T top, T bottom, bool ortho=false); Frustum(T near, T far, T fovx, T fovy, T aspect); virtual ~Frustum(); //-------------------- // Assignment operator //-------------------- const Frustum &operator = (const Frustum &); //-------------------- // Operators: ==, != //-------------------- bool operator == (const Frustum &src) const; bool operator != (const Frustum &src) const; //-------------------------------------------------------- // Set functions change the entire state of the Frustum //-------------------------------------------------------- void set(T near, T far, T left, T right, T top, T bottom, bool ortho=false); void set(T near, T far, T fovx, T fovy, T aspect); //------------------------------------------------------ // These functions modify an already valid frustum state //------------------------------------------------------ void modifyNearAndFar(T near, T far); void setOrthographic(bool); //-------------- // Access //-------------- bool orthographic() const { return _orthographic; } T near() const { return _near; } T far() const { return _far; } T left() const { return _left; } T right() const { return _right; } T bottom() const { return _bottom; } T top() const { return _top; } //----------------------------------------------------------------------- // Sets the planes in p to be the six bounding planes of the frustum, in // the following order: top, right, bottom, left, near, far. // Note that the planes have normals that point out of the frustum. // The version of this routine that takes a matrix applies that matrix // to transform the frustum before setting the planes. //----------------------------------------------------------------------- void planes(Plane3 p[6]); void planes(Plane3 p[6], const Matrix44 &M); //---------------------- // Derived Quantities //---------------------- T fovx() const; T fovy() const; T aspect() const; Matrix44 projectionMatrix() const; //----------------------------------------------------------------------- // Takes a rectangle in the screen space (i.e., -1 <= left <= right <= 1 // and -1 <= bottom <= top <= 1) of this Frustum, and returns a new // Frustum whose near clipping-plane window is that rectangle in local // space. //----------------------------------------------------------------------- Frustum window(T left, T right, T top, T bottom) const; //---------------------------------------------------------- // Projection is in screen space / Conversion from Z-Buffer //---------------------------------------------------------- Line3 projectScreenToRay( const Vec2 & ) const; Vec2 projectPointToScreen( const Vec3 & ) const; T ZToDepth(long zval, long min, long max) const; T normalizedZToDepth(T zval) const; long DepthToZ(T depth, long zmin, long zmax) const; T worldRadius(const Vec3 &p, T radius) const; T screenRadius(const Vec3 &p, T radius) const; protected: Vec2 screenToLocal( const Vec2 & ) const; Vec2 localToScreen( const Vec2 & ) const; protected: T _near; T _far; T _left; T _right; T _top; T _bottom; bool _orthographic; }; template inline Frustum::Frustum() { set(T (0.1), T (1000.0), T (-1.0), T (1.0), T (1.0), T (-1.0), false); } template inline Frustum::Frustum(const Frustum &f) { *this = f; } template inline Frustum::Frustum(T n, T f, T l, T r, T t, T b, bool o) { set(n,f,l,r,t,b,o); } template inline Frustum::Frustum(T near, T far, T fovx, T fovy, T aspect) { set(near,far,fovx,fovy,aspect); } template Frustum::~Frustum() { } template const Frustum & Frustum::operator = (const Frustum &f) { _near = f._near; _far = f._far; _left = f._left; _right = f._right; _top = f._top; _bottom = f._bottom; _orthographic = f._orthographic; return *this; } template bool Frustum::operator == (const Frustum &src) const { return _near == src._near && _far == src._far && _left == src._left && _right == src._right && _top == src._top && _bottom == src._bottom && _orthographic == src._orthographic; } template inline bool Frustum::operator != (const Frustum &src) const { return !operator== (src); } template void Frustum::set(T n, T f, T l, T r, T t, T b, bool o) { _near = n; _far = f; _left = l; _right = r; _bottom = b; _top = t; _orthographic = o; } template void Frustum::modifyNearAndFar(T n, T f) { if ( _orthographic ) { _near = n; } else { Line3 lowerLeft( Vec3(0,0,0), Vec3(_left,_bottom,-_near) ); Line3 upperRight( Vec3(0,0,0), Vec3(_right,_top,-_near) ); Plane3 nearPlane( Vec3(0,0,-1), n ); Vec3 ll,ur; nearPlane.intersect(lowerLeft,ll); nearPlane.intersect(upperRight,ur); _left = ll.x; _right = ur.x; _top = ur.y; _bottom = ll.y; _near = n; _far = f; } _far = f; } template void Frustum::setOrthographic(bool ortho) { _orthographic = ortho; } template void Frustum::set(T near, T far, T fovx, T fovy, T aspect) { if (fovx != 0 && fovy != 0) throw Iex::ArgExc ("fovx and fovy cannot both be non-zero."); if (fovx != 0) { _right = near * Math::tan(fovx/2.0); _left = -_right; _top = ((_right - _left)/aspect)/2.0; _bottom = -_top; } else { _top = near * Math::tan(fovy/2.0); _bottom = -_top; _right = (_top - _bottom) * aspect / 2.0; _left = -_right; } _near = near; _far = far; _orthographic = false; } template T Frustum::fovx() const { return Math::atan2(_right,_near) - Math::atan2(_left,_near); } template T Frustum::fovy() const { return Math::atan2(_top,_near) - Math::atan2(_bottom,_near); } template T Frustum::aspect() const { T rightMinusLeft = _right-_left; T topMinusBottom = _top-_bottom; if (abs(topMinusBottom) < 1 && abs(rightMinusLeft) > limits::max() * abs(topMinusBottom)) { throw Iex::DivzeroExc ("Bad viewing frustum: " "aspect ratio cannot be computed."); } return rightMinusLeft / topMinusBottom; } template Matrix44 Frustum::projectionMatrix() const { T rightPlusLeft = _right+_left; T rightMinusLeft = _right-_left; T topPlusBottom = _top+_bottom; T topMinusBottom = _top-_bottom; T farPlusNear = _far+_near; T farMinusNear = _far-_near; if ((abs(rightMinusLeft) < 1 && abs(rightPlusLeft) > limits::max() * abs(rightMinusLeft)) || (abs(topMinusBottom) < 1 && abs(topPlusBottom) > limits::max() * abs(topMinusBottom)) || (abs(farMinusNear) < 1 && abs(farPlusNear) > limits::max() * abs(farMinusNear))) { throw Iex::DivzeroExc ("Bad viewing frustum: " "projection matrix cannot be computed."); } if ( _orthographic ) { T tx = -rightPlusLeft / rightMinusLeft; T ty = -topPlusBottom / topMinusBottom; T tz = -farPlusNear / farMinusNear; if ((abs(rightMinusLeft) < 1 && 2 > limits::max() * abs(rightMinusLeft)) || (abs(topMinusBottom) < 1 && 2 > limits::max() * abs(topMinusBottom)) || (abs(farMinusNear) < 1 && 2 > limits::max() * abs(farMinusNear))) { throw Iex::DivzeroExc ("Bad viewing frustum: " "projection matrix cannot be computed."); } T A = 2 / rightMinusLeft; T B = 2 / topMinusBottom; T C = -2 / farMinusNear; return Matrix44( A, 0, 0, 0, 0, B, 0, 0, 0, 0, C, 0, tx, ty, tz, 1.f ); } else { T A = rightPlusLeft / rightMinusLeft; T B = topPlusBottom / topMinusBottom; T C = -farPlusNear / farMinusNear; T farTimesNear = -2 * _far * _near; if (abs(farMinusNear) < 1 && abs(farTimesNear) > limits::max() * abs(farMinusNear)) { throw Iex::DivzeroExc ("Bad viewing frustum: " "projection matrix cannot be computed."); } T D = farTimesNear / farMinusNear; T twoTimesNear = 2 * _near; if ((abs(rightMinusLeft) < 1 && abs(twoTimesNear) > limits::max() * abs(rightMinusLeft)) || (abs(topMinusBottom) < 1 && abs(twoTimesNear) > limits::max() * abs(topMinusBottom))) { throw Iex::DivzeroExc ("Bad viewing frustum: " "projection matrix cannot be computed."); } T E = twoTimesNear / rightMinusLeft; T F = twoTimesNear / topMinusBottom; return Matrix44( E, 0, 0, 0, 0, F, 0, 0, A, B, C, -1, 0, 0, D, 0 ); } } template Frustum Frustum::window(T l, T r, T t, T b) const { // move it to 0->1 space Vec2 bl = screenToLocal( Vec2(l,b) ); Vec2 tr = screenToLocal( Vec2(r,t) ); return Frustum(_near, _far, bl.x, tr.x, tr.y, bl.y, _orthographic); } template Vec2 Frustum::screenToLocal(const Vec2 &s) const { return Vec2( _left + (_right-_left) * (1.f+s.x) / 2.f, _bottom + (_top-_bottom) * (1.f+s.y) / 2.f ); } template Vec2 Frustum::localToScreen(const Vec2 &p) const { T leftPlusRight = _left - 2 * p.x + _right; T leftMinusRight = _left-_right; T bottomPlusTop = _bottom - 2 * p.y + _top; T bottomMinusTop = _bottom-_top; if ((abs(leftMinusRight) < 1 && abs(leftPlusRight) > limits::max() * abs(leftMinusRight)) || (abs(bottomMinusTop) < 1 && abs(bottomPlusTop) > limits::max() * abs(bottomMinusTop))) { throw Iex::DivzeroExc ("Bad viewing frustum: " "local-to-screen transformation cannot be computed"); } return Vec2( leftPlusRight / leftMinusRight, bottomPlusTop / bottomMinusTop ); } template Line3 Frustum::projectScreenToRay(const Vec2 &p) const { Vec2 point = screenToLocal(p); if (orthographic()) return Line3( Vec3(point.x,point.y, 0.0), Vec3(point.x,point.y,-_near)); else return Line3( Vec3(0, 0, 0), Vec3(point.x,point.y,-_near)); } template Vec2 Frustum::projectPointToScreen(const Vec3 &point) const { if (orthographic() || point.z == 0) return localToScreen( Vec2( point.x, point.y ) ); else return localToScreen( Vec2( point.x * _near / -point.z, point.y * _near / -point.z ) ); } template T Frustum::ZToDepth(long zval,long zmin,long zmax) const { int zdiff = zmax - zmin; if (zdiff == 0) { throw Iex::DivzeroExc ("Bad call to Frustum::ZToDepth: zmax == zmin"); } if ( zval > zmax+1 ) zval -= zdiff; T fzval = (T(zval) - T(zmin)) / T(zdiff); return normalizedZToDepth(fzval); } template T Frustum::normalizedZToDepth(T zval) const { T Zp = zval * 2.0 - 1; if ( _orthographic ) { return -(Zp*(_far-_near) + (_far+_near))/2; } else { T farTimesNear = 2 * _far * _near; T farMinusNear = Zp * (_far - _near) - _far - _near; if (abs(farMinusNear) < 1 && abs(farTimesNear) > limits::max() * abs(farMinusNear)) { throw Iex::DivzeroExc ("Frustum::normalizedZToDepth cannot be computed. The " "near and far clipping planes of the viewing frustum " "may be too close to each other"); } return farTimesNear / farMinusNear; } } template long Frustum::DepthToZ(T depth,long zmin,long zmax) const { long zdiff = zmax - zmin; T farMinusNear = _far-_near; if ( _orthographic ) { T farPlusNear = 2*depth + _far + _near; if (abs(farMinusNear) < 1 && abs(farPlusNear) > limits::max() * abs(farMinusNear)) { throw Iex::DivzeroExc ("Bad viewing frustum: near and far clipping planes " "are too close to each other"); } T Zp = -farPlusNear/farMinusNear; return long(0.5*(Zp+1)*zdiff) + zmin; } else { // Perspective T farTimesNear = 2*_far*_near; if (abs(depth) < 1 && abs(farTimesNear) > limits::max() * abs(depth)) { throw Iex::DivzeroExc ("Bad call to DepthToZ function: value of `depth' " "is too small"); } T farPlusNear = farTimesNear/depth + _far + _near; if (abs(farMinusNear) < 1 && abs(farPlusNear) > limits::max() * abs(farMinusNear)) { throw Iex::DivzeroExc ("Bad viewing frustum: near and far clipping planes " "are too close to each other"); } T Zp = farPlusNear/farMinusNear; return long(0.5*(Zp+1)*zdiff) + zmin; } } template T Frustum::screenRadius(const Vec3 &p, T radius) const { // Derivation: // Consider X-Z plane. // X coord of projection of p = xp = p.x * (-_near / p.z) // Let q be p + (radius, 0, 0). // X coord of projection of q = xq = (p.x - radius) * (-_near / p.z) // X coord of projection of segment from p to q = r = xp - xq // = radius * (-_near / p.z) // A similar analysis holds in the Y-Z plane. // So r is the quantity we want to return. if (abs(p.z) > 1 || abs(-_near) < limits::max() * abs(p.z)) { return radius * (-_near / p.z); } else { throw Iex::DivzeroExc ("Bad call to Frustum::screenRadius: the magnitude of `p' " "is too small"); } return radius * (-_near / p.z); } template T Frustum::worldRadius(const Vec3 &p, T radius) const { if (abs(-_near) > 1 || abs(p.z) < limits::max() * abs(-_near)) { return radius * (p.z / -_near); } else { throw Iex::DivzeroExc ("Bad viewing frustum: the near clipping plane is too " "close to zero"); } } template void Frustum::planes(Plane3 p[6]) { // // Plane order: Top, Right, Bottom, Left, Near, Far. // Normals point outwards. // Vec3 a( _left, _bottom, -_near); Vec3 b( _left, _top, -_near); Vec3 c( _right, _top, -_near); Vec3 d( _right, _bottom, -_near); Vec3 o(0,0,0); p[0].set( o, c, b ); p[1].set( o, d, c ); p[2].set( o, a, d ); p[3].set( o, b, a ); p[4].set( Vec3(0, 0, 1), -_near ); p[5].set( Vec3(0, 0,-1), _far ); } template void Frustum::planes(Plane3 p[6], const Matrix44 &M) { // // Plane order: Top, Right, Bottom, Left, Near, Far. // Normals point outwards. // Vec3 a = Vec3( _left, _bottom, -_near) * M; Vec3 b = Vec3( _left, _top, -_near) * M; Vec3 c = Vec3( _right, _top, -_near) * M; Vec3 d = Vec3( _right, _bottom, -_near) * M; double s = _far / double(_near); T farLeft = (T) (s * _left); T farRight = (T) (s * _right); T farTop = (T) (s * _top); T farBottom = (T) (s * _bottom); Vec3 e = Vec3( farLeft, farBottom, -_far) * M; Vec3 f = Vec3( farLeft, farTop, -_far) * M; Vec3 g = Vec3( farRight, farTop, -_far) * M; Vec3 o = Vec3(0,0,0) * M; p[0].set( o, c, b ); p[1].set( o, d, c ); p[2].set( o, a, d ); p[3].set( o, b, a ); p[4].set( a, d, c ); p[5].set( e, f, g ); } typedef Frustum Frustumf; typedef Frustum Frustumd; } // namespace Imath #endif