mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
697 lines
18 KiB
697 lines
18 KiB
/////////////////////////////////////////////////////////////////////////// |
|
// |
|
// 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<T> |
|
// |
|
// 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 T> |
|
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<T> &src) const; |
|
bool operator != (const Frustum<T> &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<T> p[6]); |
|
void planes(Plane3<T> p[6], const Matrix44<T> &M); |
|
|
|
//---------------------- |
|
// Derived Quantities |
|
//---------------------- |
|
|
|
T fovx() const; |
|
T fovy() const; |
|
T aspect() const; |
|
Matrix44<T> 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<T> window(T left, T right, T top, T bottom) const; |
|
|
|
//---------------------------------------------------------- |
|
// Projection is in screen space / Conversion from Z-Buffer |
|
//---------------------------------------------------------- |
|
|
|
Line3<T> projectScreenToRay( const Vec2<T> & ) const; |
|
Vec2<T> projectPointToScreen( const Vec3<T> & ) 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<T> &p, T radius) const; |
|
T screenRadius(const Vec3<T> &p, T radius) const; |
|
|
|
|
|
protected: |
|
|
|
Vec2<T> screenToLocal( const Vec2<T> & ) const; |
|
Vec2<T> localToScreen( const Vec2<T> & ) const; |
|
|
|
protected: |
|
T _near; |
|
T _far; |
|
T _left; |
|
T _right; |
|
T _top; |
|
T _bottom; |
|
bool _orthographic; |
|
}; |
|
|
|
|
|
template<class T> |
|
inline Frustum<T>::Frustum() |
|
{ |
|
set(T (0.1), |
|
T (1000.0), |
|
T (-1.0), |
|
T (1.0), |
|
T (1.0), |
|
T (-1.0), |
|
false); |
|
} |
|
|
|
template<class T> |
|
inline Frustum<T>::Frustum(const Frustum &f) |
|
{ |
|
*this = f; |
|
} |
|
|
|
template<class T> |
|
inline Frustum<T>::Frustum(T n, T f, T l, T r, T t, T b, bool o) |
|
{ |
|
set(n,f,l,r,t,b,o); |
|
} |
|
|
|
template<class T> |
|
inline Frustum<T>::Frustum(T near, T far, T fovx, T fovy, T aspect) |
|
{ |
|
set(near,far,fovx,fovy,aspect); |
|
} |
|
|
|
template<class T> |
|
Frustum<T>::~Frustum() |
|
{ |
|
} |
|
|
|
template<class T> |
|
const Frustum<T> & |
|
Frustum<T>::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 <class T> |
|
bool |
|
Frustum<T>::operator == (const Frustum<T> &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 <class T> |
|
inline bool |
|
Frustum<T>::operator != (const Frustum<T> &src) const |
|
{ |
|
return !operator== (src); |
|
} |
|
|
|
template<class T> |
|
void Frustum<T>::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<class T> |
|
void Frustum<T>::modifyNearAndFar(T n, T f) |
|
{ |
|
if ( _orthographic ) |
|
{ |
|
_near = n; |
|
} |
|
else |
|
{ |
|
Line3<T> lowerLeft( Vec3<T>(0,0,0), Vec3<T>(_left,_bottom,-_near) ); |
|
Line3<T> upperRight( Vec3<T>(0,0,0), Vec3<T>(_right,_top,-_near) ); |
|
Plane3<T> nearPlane( Vec3<T>(0,0,-1), n ); |
|
|
|
Vec3<T> 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<class T> |
|
void Frustum<T>::setOrthographic(bool ortho) |
|
{ |
|
_orthographic = ortho; |
|
} |
|
|
|
template<class T> |
|
void Frustum<T>::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<T>::tan(fovx/2.0); |
|
_left = -_right; |
|
_top = ((_right - _left)/aspect)/2.0; |
|
_bottom = -_top; |
|
} |
|
else |
|
{ |
|
_top = near * Math<T>::tan(fovy/2.0); |
|
_bottom = -_top; |
|
_right = (_top - _bottom) * aspect / 2.0; |
|
_left = -_right; |
|
} |
|
_near = near; |
|
_far = far; |
|
_orthographic = false; |
|
} |
|
|
|
template<class T> |
|
T Frustum<T>::fovx() const |
|
{ |
|
return Math<T>::atan2(_right,_near) - Math<T>::atan2(_left,_near); |
|
} |
|
|
|
template<class T> |
|
T Frustum<T>::fovy() const |
|
{ |
|
return Math<T>::atan2(_top,_near) - Math<T>::atan2(_bottom,_near); |
|
} |
|
|
|
template<class T> |
|
T Frustum<T>::aspect() const |
|
{ |
|
T rightMinusLeft = _right-_left; |
|
T topMinusBottom = _top-_bottom; |
|
|
|
if (abs(topMinusBottom) < 1 && |
|
abs(rightMinusLeft) > limits<T>::max() * abs(topMinusBottom)) |
|
{ |
|
throw Iex::DivzeroExc ("Bad viewing frustum: " |
|
"aspect ratio cannot be computed."); |
|
} |
|
|
|
return rightMinusLeft / topMinusBottom; |
|
} |
|
|
|
template<class T> |
|
Matrix44<T> Frustum<T>::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<T>::max() * abs(rightMinusLeft)) || |
|
(abs(topMinusBottom) < 1 && |
|
abs(topPlusBottom) > limits<T>::max() * abs(topMinusBottom)) || |
|
(abs(farMinusNear) < 1 && |
|
abs(farPlusNear) > limits<T>::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<T>::max() * abs(rightMinusLeft)) || |
|
(abs(topMinusBottom) < 1 && |
|
2 > limits<T>::max() * abs(topMinusBottom)) || |
|
(abs(farMinusNear) < 1 && |
|
2 > limits<T>::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<T>( 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<T>::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<T>::max() * abs(rightMinusLeft)) || |
|
(abs(topMinusBottom) < 1 && |
|
abs(twoTimesNear) > limits<T>::max() * abs(topMinusBottom))) |
|
{ |
|
throw Iex::DivzeroExc ("Bad viewing frustum: " |
|
"projection matrix cannot be computed."); |
|
} |
|
|
|
T E = twoTimesNear / rightMinusLeft; |
|
T F = twoTimesNear / topMinusBottom; |
|
|
|
return Matrix44<T>( E, 0, 0, 0, |
|
0, F, 0, 0, |
|
A, B, C, -1, |
|
0, 0, D, 0 ); |
|
} |
|
} |
|
|
|
template<class T> |
|
Frustum<T> Frustum<T>::window(T l, T r, T t, T b) const |
|
{ |
|
// move it to 0->1 space |
|
|
|
Vec2<T> bl = screenToLocal( Vec2<T>(l,b) ); |
|
Vec2<T> tr = screenToLocal( Vec2<T>(r,t) ); |
|
|
|
return Frustum<T>(_near, _far, bl.x, tr.x, tr.y, bl.y, _orthographic); |
|
} |
|
|
|
|
|
template<class T> |
|
Vec2<T> Frustum<T>::screenToLocal(const Vec2<T> &s) const |
|
{ |
|
return Vec2<T>( _left + (_right-_left) * (1.f+s.x) / 2.f, |
|
_bottom + (_top-_bottom) * (1.f+s.y) / 2.f ); |
|
} |
|
|
|
template<class T> |
|
Vec2<T> Frustum<T>::localToScreen(const Vec2<T> &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<T>::max() * abs(leftMinusRight)) || |
|
(abs(bottomMinusTop) < 1 && |
|
abs(bottomPlusTop) > limits<T>::max() * abs(bottomMinusTop))) |
|
{ |
|
throw Iex::DivzeroExc |
|
("Bad viewing frustum: " |
|
"local-to-screen transformation cannot be computed"); |
|
} |
|
|
|
return Vec2<T>( leftPlusRight / leftMinusRight, |
|
bottomPlusTop / bottomMinusTop ); |
|
} |
|
|
|
template<class T> |
|
Line3<T> Frustum<T>::projectScreenToRay(const Vec2<T> &p) const |
|
{ |
|
Vec2<T> point = screenToLocal(p); |
|
if (orthographic()) |
|
return Line3<T>( Vec3<T>(point.x,point.y, 0.0), |
|
Vec3<T>(point.x,point.y,-_near)); |
|
else |
|
return Line3<T>( Vec3<T>(0, 0, 0), Vec3<T>(point.x,point.y,-_near)); |
|
} |
|
|
|
template<class T> |
|
Vec2<T> Frustum<T>::projectPointToScreen(const Vec3<T> &point) const |
|
{ |
|
if (orthographic() || point.z == 0) |
|
return localToScreen( Vec2<T>( point.x, point.y ) ); |
|
else |
|
return localToScreen( Vec2<T>( point.x * _near / -point.z, |
|
point.y * _near / -point.z ) ); |
|
} |
|
|
|
template<class T> |
|
T Frustum<T>::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<class T> |
|
T Frustum<T>::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<T>::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<class T> |
|
long Frustum<T>::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<T>::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<T>::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<T>::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<class T> |
|
T Frustum<T>::screenRadius(const Vec3<T> &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<T>::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<class T> |
|
T Frustum<T>::worldRadius(const Vec3<T> &p, T radius) const |
|
{ |
|
if (abs(-_near) > 1 || abs(p.z) < limits<T>::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<class T> |
|
void Frustum<T>::planes(Plane3<T> p[6]) |
|
{ |
|
// |
|
// Plane order: Top, Right, Bottom, Left, Near, Far. |
|
// Normals point outwards. |
|
// |
|
|
|
Vec3<T> a( _left, _bottom, -_near); |
|
Vec3<T> b( _left, _top, -_near); |
|
Vec3<T> c( _right, _top, -_near); |
|
Vec3<T> d( _right, _bottom, -_near); |
|
Vec3<T> 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<T>(0, 0, 1), -_near ); |
|
p[5].set( Vec3<T>(0, 0,-1), _far ); |
|
} |
|
|
|
|
|
template<class T> |
|
void Frustum<T>::planes(Plane3<T> p[6], const Matrix44<T> &M) |
|
{ |
|
// |
|
// Plane order: Top, Right, Bottom, Left, Near, Far. |
|
// Normals point outwards. |
|
// |
|
|
|
Vec3<T> a = Vec3<T>( _left, _bottom, -_near) * M; |
|
Vec3<T> b = Vec3<T>( _left, _top, -_near) * M; |
|
Vec3<T> c = Vec3<T>( _right, _top, -_near) * M; |
|
Vec3<T> d = Vec3<T>( _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<T> e = Vec3<T>( farLeft, farBottom, -_far) * M; |
|
Vec3<T> f = Vec3<T>( farLeft, farTop, -_far) * M; |
|
Vec3<T> g = Vec3<T>( farRight, farTop, -_far) * M; |
|
Vec3<T> o = Vec3<T>(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<float> Frustumf; |
|
typedef Frustum<double> Frustumd; |
|
|
|
|
|
} // namespace Imath |
|
|
|
#endif
|
|
|