489 lines
18 KiB
C
489 lines
18 KiB
C
|
/****************************************************************************
|
|||
|
|
Copyright (c) 2010,RadonLabs GmbH
|
|||
|
|
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
|||
|
|
|
|||
|
|
http://www.genesis-3d.com.cn
|
|||
|
|
|
|||
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|||
|
|
of this software and associated documentation files (the "Software"), to deal
|
|||
|
|
in the Software without restriction, including without limitation the rights
|
|||
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
|
|
copies of the Software, and to permit persons to whom the Software is
|
|||
|
|
furnished to do so, subject to the following conditions:
|
|||
|
|
|
|||
|
|
The above copyright notice and this permission notice shall be included in
|
|||
|
|
all copies or substantial portions of the Software.
|
|||
|
|
|
|||
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|||
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|||
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|||
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|||
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|||
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|||
|
|
THE SOFTWARE.
|
|||
|
|
****************************************************************************/
|
|||
|
|
#pragma once
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
@class Math::frustum
|
|||
|
|
|
|||
|
|
Defines a clipping frustum made of 6 planes.
|
|||
|
|
*/
|
|||
|
|
#include "math/plane.h"
|
|||
|
|
#include "math/matrix44.h"
|
|||
|
|
#include "math/bbox.h"
|
|||
|
|
#include "math/point.h"
|
|||
|
|
#include "math/clipstatus.h"
|
|||
|
|
#ifdef __OSX__
|
|||
|
|
#include "../rendersystem/config/RenderDeviceConfig.h"
|
|||
|
|
#else
|
|||
|
|
#include "rendersystem/config/RenderDeviceConfig.h"
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
namespace Math
|
|||
|
|
{
|
|||
|
|
class frustum
|
|||
|
|
{
|
|||
|
|
public:
|
|||
|
|
/// plane indices
|
|||
|
|
enum PlaneIndex
|
|||
|
|
{
|
|||
|
|
Near = 0,
|
|||
|
|
Far,
|
|||
|
|
Left,
|
|||
|
|
Right,
|
|||
|
|
Top,
|
|||
|
|
Bottom,
|
|||
|
|
|
|||
|
|
NumPlanes
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// default constructor
|
|||
|
|
frustum();
|
|||
|
|
///// construct from view and projection matrix
|
|||
|
|
//frustum(const matrix44& invViewProj);
|
|||
|
|
///// setup from view and proj matrix
|
|||
|
|
//void set(const matrix44& invViewProj);
|
|||
|
|
/// also view * proj
|
|||
|
|
void setmatrix(const matrix44& value);
|
|||
|
|
|
|||
|
|
/// setup from transformed bounding box
|
|||
|
|
void set(const bbox& box, const matrix44& boxTransform);
|
|||
|
|
/// test if point is inside frustum
|
|||
|
|
bool inside(const point& p) const;
|
|||
|
|
/// get clip bitmask of point (0 if inside, (1<<PlaneIndex) if outside)
|
|||
|
|
uint clipmask(const point& p) const;
|
|||
|
|
/// clip line against view frustum
|
|||
|
|
ClipStatus::Type clip(const line& l, line& clippedLine) const;
|
|||
|
|
/// get clip status of a local bounding box
|
|||
|
|
ClipStatus::Type clipstatus(const bbox& box) const;
|
|||
|
|
/// get clip status of a transformed bounding box
|
|||
|
|
ClipStatus::Type clipstatus(const bbox& box, const matrix44& boxTransform) const;
|
|||
|
|
/// convert to any type
|
|||
|
|
template<typename T> T as() const;
|
|||
|
|
|
|||
|
|
|
|||
|
|
static void ComputeFrustumFromProjection( float4* pOutFarPoints,float n,float f,const Math::matrix44& pProjection,bool isPersp = true );
|
|||
|
|
|
|||
|
|
static const int TopLeftFar = 0;
|
|||
|
|
static const int TopRightFar = 1;
|
|||
|
|
static const int BottomLeftFar = 2;
|
|||
|
|
static const int BottomRightFar = 3;
|
|||
|
|
static const int TopLeftNear = 4;
|
|||
|
|
static const int TopRightNear = 5;
|
|||
|
|
static const int BottomLeftNear = 6;
|
|||
|
|
static const int BottomRightNear = 7;
|
|||
|
|
|
|||
|
|
plane planes[NumPlanes]; //<2F><><EFBFBD>е<EFBFBD>ƽ<EFBFBD><C6BD><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><D7B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߡ<EFBFBD>
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
*/
|
|||
|
|
inline
|
|||
|
|
frustum::frustum()
|
|||
|
|
{
|
|||
|
|
// empty
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
////------------------------------------------------------------------------------
|
|||
|
|
///**
|
|||
|
|
//*/
|
|||
|
|
//inline
|
|||
|
|
//frustum::frustum(const matrix44& invViewProj)
|
|||
|
|
//{
|
|||
|
|
// this->set(invViewProj);
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
////------------------------------------------------------------------------------
|
|||
|
|
///**
|
|||
|
|
// Setup frustum from invViewProj matrix (transform from projection space
|
|||
|
|
// into world space).
|
|||
|
|
//*/
|
|||
|
|
//inline void
|
|||
|
|
//frustum::set(const matrix44& invViewProj)
|
|||
|
|
//{
|
|||
|
|
// // frustum corners in projection space
|
|||
|
|
// point projPoints[8];
|
|||
|
|
// projPoints[TopLeftFar].set(-1.0f, 1.0f, 1.0f);
|
|||
|
|
// projPoints[TopRightFar].set(1.0f, 1.0f, 1.0f);
|
|||
|
|
// projPoints[BottomLeftFar].set(-1.0f, -1.0f, 1.0f);
|
|||
|
|
// projPoints[BottomRightFar].set(1.0f, -1.0f, 1.0f);
|
|||
|
|
//
|
|||
|
|
// projPoints[TopLeftNear].set(-1.0f, 1.0f, 0.0f);
|
|||
|
|
// projPoints[TopRightNear].set(1.0f, 1.0f, 0.0f);
|
|||
|
|
// projPoints[BottomLeftNear].set(-1.0f, -1.0f, 0.0f);
|
|||
|
|
// projPoints[BottomRightNear].set(1.0f, -1.0f, 0.0);
|
|||
|
|
//
|
|||
|
|
// // compute frustum corners in world space
|
|||
|
|
// point worldPoints[8];
|
|||
|
|
// IndexT i;
|
|||
|
|
// for (i = 0; i < 8; i++)
|
|||
|
|
// {
|
|||
|
|
// point& p = worldPoints[i];
|
|||
|
|
// p = matrix44::transform(invViewProj,projPoints[i]);
|
|||
|
|
// p *= 1.0f / p.w();
|
|||
|
|
// }
|
|||
|
|
//
|
|||
|
|
// // setup planes
|
|||
|
|
// this->planes[Near].setup_from_points(worldPoints[TopRightNear], worldPoints[TopLeftNear], worldPoints[BottomLeftNear]);
|
|||
|
|
// this->planes[Far].setup_from_points(worldPoints[TopLeftFar], worldPoints[TopRightFar], worldPoints[BottomRightFar]);
|
|||
|
|
// this->planes[Left].setup_from_points(worldPoints[BottomLeftFar], worldPoints[BottomLeftNear], worldPoints[TopLeftNear]);
|
|||
|
|
// this->planes[Right].setup_from_points(worldPoints[TopRightFar], worldPoints[TopRightNear], worldPoints[BottomRightNear]);
|
|||
|
|
// this->planes[Top].setup_from_points(worldPoints[TopLeftNear], worldPoints[TopRightNear], worldPoints[TopRightFar]);
|
|||
|
|
// this->planes[Bottom].setup_from_points(worldPoints[BottomLeftFar], worldPoints[BottomRightFar], worldPoints[BottomRightNear]);
|
|||
|
|
//}
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
*/
|
|||
|
|
inline void
|
|||
|
|
frustum::setmatrix(const matrix44& value)
|
|||
|
|
{
|
|||
|
|
planes[Left].vec.x = -value.mx[3][0] - value.mx[0][0];
|
|||
|
|
planes[Left].vec.y = -value.mx[3][1] - value.mx[0][1];
|
|||
|
|
planes[Left].vec.z = -value.mx[3][2] - value.mx[0][2];
|
|||
|
|
planes[Left].vec.w = -value.mx[3][3] - value.mx[0][3];
|
|||
|
|
|
|||
|
|
planes[Right].vec.x = - value.mx[3][0] + value.mx[0][0];
|
|||
|
|
planes[Right].vec.y = - value.mx[3][1] + value.mx[0][1];
|
|||
|
|
planes[Right].vec.z = - value.mx[3][2] + value.mx[0][2];
|
|||
|
|
planes[Right].vec.w = - value.mx[3][3] + value.mx[0][3];
|
|||
|
|
|
|||
|
|
planes[Top].vec.x = - value.mx[3][0] + value.mx[1][0];
|
|||
|
|
planes[Top].vec.y = - value.mx[3][1] + value.mx[1][1];
|
|||
|
|
planes[Top].vec.z = - value.mx[3][2] + value.mx[1][2];
|
|||
|
|
planes[Top].vec.w = - value.mx[3][3] + value.mx[1][3];
|
|||
|
|
|
|||
|
|
planes[Bottom].vec.x = - value.mx[3][0] - value.mx[1][0];
|
|||
|
|
planes[Bottom].vec.y = - value.mx[3][1] - value.mx[1][1];
|
|||
|
|
planes[Bottom].vec.z = - value.mx[3][2] - value.mx[1][2];
|
|||
|
|
planes[Bottom].vec.w = - value.mx[3][3] - value.mx[1][3];
|
|||
|
|
|
|||
|
|
planes[Near].vec.x = - value.mx[2][0];
|
|||
|
|
planes[Near].vec.y = - value.mx[2][1];
|
|||
|
|
planes[Near].vec.z = - value.mx[2][2];
|
|||
|
|
planes[Near].vec.w = - value.mx[2][3];
|
|||
|
|
|
|||
|
|
planes[Far].vec.x = - value.mx[3][0] + value.mx[2][0];
|
|||
|
|
planes[Far].vec.y = - value.mx[3][1] + value.mx[2][1];
|
|||
|
|
planes[Far].vec.z = - value.mx[3][2] + value.mx[2][2];
|
|||
|
|
planes[Far].vec.w = - value.mx[3][3] + value.mx[2][3];
|
|||
|
|
|
|||
|
|
for (int i = 0; i < 6; i++)
|
|||
|
|
{
|
|||
|
|
plane& pl = planes[i];
|
|||
|
|
float num2 = n_sqrt(pl.vec.x * pl.vec.x + pl.vec.y * pl.vec.y + pl.vec.z * pl.vec.z );//pl.Normal.Length();
|
|||
|
|
//pl.Normal = (Vector3) (pl.Normal / num2);
|
|||
|
|
pl.vec.x /= num2;
|
|||
|
|
pl.vec.y /= num2;
|
|||
|
|
pl.vec.z /= num2;
|
|||
|
|
pl.vec.w /= num2;
|
|||
|
|
|
|||
|
|
//pl.D /= num2;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
Setup from a transformed bounding box.
|
|||
|
|
*/
|
|||
|
|
inline void
|
|||
|
|
frustum::set(const bbox& box, const matrix44& boxTransform)
|
|||
|
|
{
|
|||
|
|
// compute frustum corners in world space
|
|||
|
|
point localPoint;
|
|||
|
|
point worldPoints[8];
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < 8; i++)
|
|||
|
|
{
|
|||
|
|
// Top: pmax.y, Bottom: pmin.y, Left: pmin.x, Right: pmax.x, Far: pmax.z, Near: pmin.z
|
|||
|
|
switch (i)
|
|||
|
|
{
|
|||
|
|
// FIXME: replace with permute!
|
|||
|
|
case TopLeftFar: localPoint.set(box.pmin.x(), box.pmax.y(), box.pmax.z()); break;
|
|||
|
|
case TopRightFar: localPoint.set(box.pmax.x(), box.pmax.y(), box.pmax.z()); break;
|
|||
|
|
case BottomLeftFar: localPoint.set(box.pmin.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
case BottomRightFar: localPoint.set(box.pmax.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
case TopLeftNear: localPoint.set(box.pmin.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case TopRightNear: localPoint.set(box.pmax.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case BottomLeftNear: localPoint.set(box.pmin.x(), box.pmin.y(), box.pmin.z()); break;
|
|||
|
|
case BottomRightNear: localPoint.set(box.pmax.x(), box.pmin.y(), box.pmin.z()); break;
|
|||
|
|
}
|
|||
|
|
worldPoints[i] = matrix44::transform(boxTransform,localPoint);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// setup planes from transformed world space coordinates
|
|||
|
|
this->planes[Near].setup_from_points(worldPoints[TopLeftNear], worldPoints[TopRightNear], worldPoints[BottomLeftNear]);
|
|||
|
|
this->planes[Far].setup_from_points(worldPoints[TopRightFar], worldPoints[TopLeftFar], worldPoints[BottomRightFar]);
|
|||
|
|
this->planes[Left].setup_from_points(worldPoints[BottomLeftNear], worldPoints[BottomLeftFar], worldPoints[TopLeftNear]);
|
|||
|
|
this->planes[Right].setup_from_points(worldPoints[BottomRightNear], worldPoints[TopRightNear], worldPoints[TopRightFar]);
|
|||
|
|
this->planes[Top].setup_from_points(worldPoints[TopRightNear], worldPoints[TopLeftNear], worldPoints[TopRightFar]);
|
|||
|
|
this->planes[Bottom].setup_from_points(worldPoints[BottomRightFar], worldPoints[BottomLeftFar], worldPoints[BottomRightNear]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
Test if point is inside frustum.
|
|||
|
|
*/
|
|||
|
|
inline bool
|
|||
|
|
frustum::inside(const point& p) const
|
|||
|
|
{
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < NumPlanes; i++)
|
|||
|
|
{
|
|||
|
|
if (this->planes[i].dot(p) > 0.0f)
|
|||
|
|
{
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
Get clipmask of point.
|
|||
|
|
*/
|
|||
|
|
inline uint
|
|||
|
|
frustum::clipmask(const point& p) const
|
|||
|
|
{
|
|||
|
|
uint clipMask = 0;
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < NumPlanes; i++)
|
|||
|
|
{
|
|||
|
|
if (this->planes[i].dot(p) > 0.0f)
|
|||
|
|
{
|
|||
|
|
clipMask |= 1<<i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return clipMask;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
*/
|
|||
|
|
inline ClipStatus::Type
|
|||
|
|
frustum::clip(const line& l, line& clippedLine) const
|
|||
|
|
{
|
|||
|
|
ClipStatus::Type clipStatus = ClipStatus::Inside;
|
|||
|
|
line l0(l);
|
|||
|
|
line l1;
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < NumPlanes; i++)
|
|||
|
|
{
|
|||
|
|
ClipStatus::Type planeClipStatus = this->planes[i].clip(l0, l1);
|
|||
|
|
if (ClipStatus::Outside == planeClipStatus)
|
|||
|
|
{
|
|||
|
|
return ClipStatus::Outside;
|
|||
|
|
}
|
|||
|
|
else if (ClipStatus::Clipped == planeClipStatus)
|
|||
|
|
{
|
|||
|
|
clipStatus = ClipStatus::Clipped;
|
|||
|
|
}
|
|||
|
|
l0 = l1;
|
|||
|
|
}
|
|||
|
|
clippedLine = l0;
|
|||
|
|
return clipStatus;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
*/
|
|||
|
|
inline ClipStatus::Type
|
|||
|
|
frustum::clipstatus(const bbox& box) const
|
|||
|
|
{
|
|||
|
|
uint andFlags = 0xffff;
|
|||
|
|
uint orFlags = 0;
|
|||
|
|
point p;
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < 8; i++)
|
|||
|
|
{
|
|||
|
|
// get corner point of bounding box
|
|||
|
|
switch (i)
|
|||
|
|
{
|
|||
|
|
// FIXME: REPLACE WITH PERMUTE!
|
|||
|
|
case 0: p = box.pmin; break;
|
|||
|
|
case 1: p.set(box.pmin.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case 2: p.set(box.pmax.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case 3: p.set(box.pmax.x(), box.pmin.y(), box.pmin.z()); break;
|
|||
|
|
case 4: p = box.pmax; break;
|
|||
|
|
case 5: p.set(box.pmin.x(), box.pmax.y(), box.pmax.z()); break;
|
|||
|
|
case 6: p.set(box.pmin.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
case 7: p.set(box.pmax.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// get clip mask of current box corner against frustum
|
|||
|
|
uint clipMask = this->clipmask(p);
|
|||
|
|
andFlags &= clipMask;
|
|||
|
|
orFlags |= clipMask;
|
|||
|
|
}
|
|||
|
|
if (0 == orFlags) return ClipStatus::Inside;
|
|||
|
|
else if (0 != andFlags) return ClipStatus::Outside;
|
|||
|
|
else return ClipStatus::Clipped;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
/**
|
|||
|
|
Returns the clip status of a transformed bounding box.
|
|||
|
|
*/
|
|||
|
|
inline ClipStatus::Type
|
|||
|
|
frustum::clipstatus(const bbox& box, const matrix44& boxTransform) const
|
|||
|
|
{
|
|||
|
|
uint andFlags = 0xffff;
|
|||
|
|
uint orFlags = 0;
|
|||
|
|
point localPoint, transformedPoint;
|
|||
|
|
IndexT i;
|
|||
|
|
for (i = 0; i < 8; i++)
|
|||
|
|
{
|
|||
|
|
// get corner point of bounding box
|
|||
|
|
switch (i)
|
|||
|
|
{
|
|||
|
|
// FIXME: REPLACE WITH PERMUTE!
|
|||
|
|
case 0: localPoint = box.pmin; break;
|
|||
|
|
case 1: localPoint.set(box.pmin.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case 2: localPoint.set(box.pmax.x(), box.pmax.y(), box.pmin.z()); break;
|
|||
|
|
case 3: localPoint.set(box.pmax.x(), box.pmin.y(), box.pmin.z()); break;
|
|||
|
|
case 4: localPoint = box.pmax; break;
|
|||
|
|
case 5: localPoint.set(box.pmin.x(), box.pmax.y(), box.pmax.z()); break;
|
|||
|
|
case 6: localPoint.set(box.pmin.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
case 7: localPoint.set(box.pmax.x(), box.pmin.y(), box.pmax.z()); break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// transform bounding box point
|
|||
|
|
transformedPoint = matrix44::transform(boxTransform,localPoint);
|
|||
|
|
|
|||
|
|
// get clip mask of current box corner against frustum
|
|||
|
|
uint clipMask = this->clipmask(transformedPoint);
|
|||
|
|
andFlags &= clipMask;
|
|||
|
|
orFlags |= clipMask;
|
|||
|
|
}
|
|||
|
|
if (0 == orFlags) return ClipStatus::Inside;
|
|||
|
|
else if (0 != andFlags) return ClipStatus::Outside;
|
|||
|
|
else return ClipStatus::Clipped;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//-----------------------------------------------------------------------------
|
|||
|
|
// Build a frustum from a persepective projection matrix. The matrix may only
|
|||
|
|
// contain a projection; any rotation, translation or scale will cause the
|
|||
|
|
// constructed frustum to be incorrect.
|
|||
|
|
//-----------------------------------------------------------------------------
|
|||
|
|
inline void
|
|||
|
|
frustum::ComputeFrustumFromProjection( float4* pOutFarPoints,float n,float f,const Math::matrix44& pProjection,bool isPersp )
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
// Corners of the projection frustum in homogenous space.
|
|||
|
|
static float4 HomogenousPoints[8];
|
|||
|
|
HomogenousPoints[0].set(1.0f, 0.0f, 1.0f, 1.0f); // right (at far plane)
|
|||
|
|
HomogenousPoints[1].set(-1.0f, 0.0f, 1.0f, 1.0f); // left
|
|||
|
|
HomogenousPoints[2].set(0.0f, 1.0f, 1.0f, 1.0f);// top
|
|||
|
|
HomogenousPoints[3].set(0.0f, -1.0f, 1.0f, 1.0f); // bottom
|
|||
|
|
#if RENDERDEVICE_D3D9
|
|||
|
|
HomogenousPoints[4].set(0.0f, 0.0f, 0.0f, 1.0f); // near
|
|||
|
|
#endif
|
|||
|
|
#if RENDERDEVICE_OPENGL || RENDERDEVICE_OPENGLES
|
|||
|
|
HomogenousPoints[4].set(0.0f, 0.0f, -1.0f, 1.0f); // near
|
|||
|
|
#endif
|
|||
|
|
HomogenousPoints[5].set(0.0f, 0.0f, 1.0f, 1.0f); // far
|
|||
|
|
|
|||
|
|
matrix44 invProj = matrix44::inverse(pProjection);
|
|||
|
|
|
|||
|
|
float4 frustumPoints[6];
|
|||
|
|
// Compute the frustum corners to view space.
|
|||
|
|
for( int i = 0; i < 6; i++ )
|
|||
|
|
{
|
|||
|
|
// Transform point.
|
|||
|
|
frustumPoints[i] = matrix44::transform( invProj,HomogenousPoints[i] );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (isPersp)
|
|||
|
|
{
|
|||
|
|
// Compute the slopes.
|
|||
|
|
frustumPoints[0] = frustumPoints[0] * float4::reciprocal( frustumPoints[0] ).z();
|
|||
|
|
frustumPoints[1] = frustumPoints[1] * float4::reciprocal( frustumPoints[1] ).z();
|
|||
|
|
frustumPoints[2] = frustumPoints[2] * float4::reciprocal( frustumPoints[2] ).z();
|
|||
|
|
frustumPoints[3] = frustumPoints[3] * float4::reciprocal( frustumPoints[3] ).z();
|
|||
|
|
}
|
|||
|
|
float RightSlope,LeftSlope,TopSlope,BottomSlope,NearZ,FarZ;
|
|||
|
|
RightSlope = frustumPoints[0].x();
|
|||
|
|
LeftSlope = frustumPoints[1].x();
|
|||
|
|
TopSlope = frustumPoints[2].y();
|
|||
|
|
BottomSlope = frustumPoints[3].y();
|
|||
|
|
|
|||
|
|
// Compute near and far.
|
|||
|
|
frustumPoints[4] = frustumPoints[4] * float4::reciprocal( frustumPoints[4] ).w();
|
|||
|
|
frustumPoints[5] = frustumPoints[5] * float4::reciprocal( frustumPoints[5] ).w();
|
|||
|
|
|
|||
|
|
NearZ = frustumPoints[4].z();
|
|||
|
|
FarZ = frustumPoints[5].z();
|
|||
|
|
|
|||
|
|
NearZ = n < n_abs(NearZ) ? NearZ : -n;
|
|||
|
|
FarZ = -f;
|
|||
|
|
|
|||
|
|
if (isPersp)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
float4 vRightTop = float4(RightSlope,TopSlope,1.0f,1.0f);
|
|||
|
|
float4 vLeftBottom = float4(LeftSlope,BottomSlope,1.0f,1.0f);
|
|||
|
|
float4 vLeftTop = float4(LeftSlope,TopSlope,1.0f,1.0f);
|
|||
|
|
float4 vRightBottom = float4(RightSlope,BottomSlope,1.0f,1.0f);
|
|||
|
|
float4 vNear = float4(NearZ,NearZ,NearZ,1.0f);
|
|||
|
|
float4 vFar = float4(FarZ,FarZ,FarZ,1.0f);
|
|||
|
|
|
|||
|
|
float4 vRightTopNear = float4::multiply( vRightTop, vNear );
|
|||
|
|
float4 vRightTopFar = float4::multiply( vRightTop, vFar );
|
|||
|
|
float4 vLeftBottomNear = float4::multiply( vLeftBottom, vNear );
|
|||
|
|
float4 vLeftBottomFar = float4::multiply( vLeftBottom, vFar );
|
|||
|
|
|
|||
|
|
float4 vLeftTopNear = float4::multiply( vLeftTop, vNear );
|
|||
|
|
float4 vLeftTopFar = float4::multiply( vLeftTop, vFar );
|
|||
|
|
float4 vRightBottomNear = float4::multiply( vRightBottom, vNear );
|
|||
|
|
float4 vRightBottomFar = float4::multiply( vRightBottom, vFar );
|
|||
|
|
|
|||
|
|
pOutFarPoints[0] = vLeftTopFar; //TopLeftFar
|
|||
|
|
pOutFarPoints[1] = vRightTopFar; //TopRightFar
|
|||
|
|
pOutFarPoints[2] = vLeftBottomFar;//BottomLeftFar
|
|||
|
|
pOutFarPoints[3] = vRightBottomFar; //BottomRightFar
|
|||
|
|
pOutFarPoints[4] = vLeftTopNear; //TopLeftNear
|
|||
|
|
pOutFarPoints[5] = vRightTopNear; //TopRightNear
|
|||
|
|
pOutFarPoints[6] = vLeftBottomNear; //BottomLeftNear
|
|||
|
|
pOutFarPoints[7] = vRightBottomNear; //BottomRightNear
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
pOutFarPoints[0] = float4(LeftSlope,TopSlope,FarZ,1.f); //TopLeftFar
|
|||
|
|
pOutFarPoints[1] = float4(RightSlope,TopSlope,FarZ,1.f); //TopRightFar
|
|||
|
|
pOutFarPoints[2] = float4(LeftSlope,BottomSlope,FarZ,1.f);//BottomLeftFar
|
|||
|
|
pOutFarPoints[3] = float4(RightSlope,BottomSlope,FarZ,1.f); //BottomRightFar
|
|||
|
|
pOutFarPoints[4] = float4(LeftSlope,TopSlope,NearZ,1.f); //TopLeftNear
|
|||
|
|
pOutFarPoints[5] = float4(RightSlope,TopSlope,NearZ,1.f); //TopRightNear
|
|||
|
|
pOutFarPoints[6] = float4(LeftSlope,BottomSlope,NearZ,1.f); //BottomLeftNear
|
|||
|
|
pOutFarPoints[7] = float4(RightSlope,BottomSlope,NearZ,1.f); //BottomRightNear
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
} // namespace Math
|
|||
|
|
//------------------------------------------------------------------------------
|
|||
|
|
|