/*
===============
FindPlane
Returns a global plane number and the side that will be the front
===============
*/
int FindPlane( plane_t *dplane, int *side )
{
int i;
plane_t *dp, pl;
vec_t dot;
pl = *dplane;
NormalizePlane( &pl );
if( DotProduct( pl.normal, dplane->normal ) > 0 )
*side = 0;
else
*side = 1;
for( i = 0, dp = mapplanes; i < nummapplanes; i++, dp++ ) {
if( DotProduct( dp->normal, pl.normal ) > 1.0 - ANGLE_EPSILON && fabs( dp->dist - pl.dist ) < DIST_EPSILON )
return i; // regular match
}
if( nummapplanes == MAX_MAP_PLANES )
Error( "FindPlane: nummapplanes == MAX_MAP_PLANES" );
dot = VectorLength( dplane->normal );
if( dot < 1.0 - ANGLE_EPSILON || dot > 1.0 + ANGLE_EPSILON )
Error( "FindPlane: normalization error (%f %f %f, length %f)", dplane->normal[0], dplane->normal[1], dplane->normal[2], dot );
mapplanes[nummapplanes] = pl;
return nummapplanes++;
}
bool SpaceGameEngine::IfIntersect(const AxisAlignedBoundingBox & aabb, const Triangle & triangle)
{
Vector3D point[8];
point[0] = Vector3D(aabb.m_MinPosition.x, aabb.m_MaxPosition.y, aabb.m_MinPosition.z);
point[1] = Vector3D(aabb.m_MaxPosition.x, aabb.m_MaxPosition.y, aabb.m_MinPosition.z);
point[2] = Vector3D(aabb.m_MaxPosition.x, aabb.m_MinPosition.y, aabb.m_MinPosition.z);
point[3] = Vector3D(aabb.m_MinPosition);
point[4] = Vector3D(aabb.m_MinPosition.x, aabb.m_MaxPosition.y, aabb.m_MaxPosition.z);
point[5] = Vector3D(aabb.m_MaxPosition);
point[6] = Vector3D(aabb.m_MaxPosition.x, aabb.m_MinPosition.y, aabb.m_MaxPosition.z);
point[7] = Vector3D(aabb.m_MinPosition.x, aabb.m_MinPosition.y, aabb.m_MaxPosition.z);
Plane plane[6] = {
NormalizePlane(Plane(point[0],point[1],point[2])), //front
NormalizePlane(Plane(point[5],point[4],point[7])), //back
NormalizePlane(Plane(point[4],point[5],point[1])), //top
NormalizePlane(Plane(point[3],point[2],point[6])), //back
NormalizePlane(Plane(point[4],point[0],point[3])), //left
NormalizePlane(Plane(point[1],point[5],point[6])) //right
};//面都对外
for (int i = 0; i < 6; i++)
{
int fa_cot = 0;
for (int j = 0; j < 3; j++)
{
if (IfBeFrontOfPlane(plane[i], triangle.m_Positions[j]))
fa_cot += 1;
}
if (fa_cot == 3)
return false;
}
return true;
}
void Frustum::RecalculatePlanesEx(glm::mat4x4& p_view, glm::mat4x4& p_proj)
{
glm::mat4 matrix;
float a = -(m_far + m_near) / (m_far - m_near);
float b = -(2 * m_far * m_near) / (m_far - m_near);
float c = p_proj[2][2];
float d = p_proj[3][2];
matrix = p_proj * p_view;
m_planesEx[NEARP].a = matrix[0][3] + matrix[0][2];
m_planesEx[NEARP].b = matrix[1][3] + matrix[1][2];
m_planesEx[NEARP].c = matrix[2][3] + matrix[2][2];
m_planesEx[NEARP].d = matrix[3][3] + matrix[3][2];
NormalizePlane(m_planesEx[NEARP]);
m_planesEx[FARP].a = matrix[0][3] - matrix[0][2];
m_planesEx[FARP].b = matrix[1][3] - matrix[1][2];
m_planesEx[FARP].c = matrix[2][3] - matrix[2][2];
m_planesEx[FARP].d = matrix[3][3] - matrix[3][2];
NormalizePlane(m_planesEx[FARP]);
m_planesEx[LEFT].a = matrix[0][3] + matrix[0][0];
m_planesEx[LEFT].b = matrix[1][3] + matrix[1][0];
m_planesEx[LEFT].c = matrix[2][3] + matrix[2][0];
m_planesEx[LEFT].d = matrix[3][3] + matrix[3][0];
NormalizePlane(m_planesEx[LEFT]);
m_planesEx[RIGHT].a = matrix[0][3] - matrix[0][0];
m_planesEx[RIGHT].b = matrix[1][3] - matrix[1][0];
m_planesEx[RIGHT].c = matrix[2][3] - matrix[2][0];
m_planesEx[RIGHT].d = matrix[3][3] - matrix[3][0];
NormalizePlane(m_planesEx[RIGHT]);
m_planesEx[TOP].a = matrix[0][3] - matrix[0][1];
m_planesEx[TOP].b = matrix[1][3] - matrix[1][1];
m_planesEx[TOP].c = matrix[2][3] - matrix[2][1];
m_planesEx[TOP].d = matrix[3][3] - matrix[3][1];
NormalizePlane(m_planesEx[TOP]);
m_planesEx[BOTTOM].a = matrix[0][3] + matrix[0][1];
m_planesEx[BOTTOM].b = matrix[1][3] + matrix[1][1];
m_planesEx[BOTTOM].c = matrix[2][3] + matrix[2][1];
m_planesEx[BOTTOM].d = matrix[3][3] + matrix[3][1];
NormalizePlane(m_planesEx[BOTTOM]);
ftl = Intersect3Planes(m_planesEx[LEFT], m_planesEx[TOP], m_planesEx[FARP]);
fbl = Intersect3Planes(m_planesEx[LEFT], m_planesEx[BOTTOM], m_planesEx[FARP]);
fbr = Intersect3Planes(m_planesEx[RIGHT], m_planesEx[BOTTOM], m_planesEx[FARP]);
ftr = Intersect3Planes(m_planesEx[RIGHT], m_planesEx[TOP], m_planesEx[FARP]);
ntl = Intersect3Planes(m_planesEx[LEFT], m_planesEx[TOP], m_planesEx[NEARP]);
nbl = Intersect3Planes(m_planesEx[LEFT], m_planesEx[BOTTOM], m_planesEx[NEARP]);
nbr = Intersect3Planes(m_planesEx[RIGHT], m_planesEx[BOTTOM], m_planesEx[NEARP]);
ntr = Intersect3Planes(m_planesEx[RIGHT], m_planesEx[TOP], m_planesEx[NEARP]);
}
void Frustum::Extract(const vec3& eye,const mat4x4& camMatrix,const mat4x4& projMatrix)
{
m_pos = eye;
m_modView = camMatrix;
m_projMatrix = projMatrix;
mat4x4 MVPMatrix = m_projMatrix * m_modView;
MVPMatrix = glm::transpose(MVPMatrix);
//left and right planes
m_planes[0] = MVPMatrix[3] - MVPMatrix[0];
NormalizePlane(0);
m_planes[1] = MVPMatrix[3] + MVPMatrix[0];
NormalizePlane(1);
//near and far planes
m_planes[2] = MVPMatrix[3] - MVPMatrix[2];
NormalizePlane(2);
m_planes[3] = MVPMatrix[3] + MVPMatrix[2];
NormalizePlane(3);
//top and bottom planes
m_planes[4] = MVPMatrix[3] - MVPMatrix[1];
NormalizePlane(4);
m_planes[5] = MVPMatrix[3] + MVPMatrix[1];
NormalizePlane(5);
}
/*
===============
FindPlane
Returns a global plane number and the side that will be the front
===============
*/
int FindPlane (plane_t *dplane, int *side)
{
int i;
plane_t *dp, pl;
vec_t dot;
dot = VectorLength(dplane->normal);
if (dot < 1.0 - ANGLEEPSILON || dot > 1.0 + ANGLEEPSILON)
Error ("FindPlane: normalization error");
pl = *dplane;
NormalizePlane (&pl);
if (DotProduct(pl.normal, dplane->normal) > 0)
*side = 0;
else
*side = 1;
dp = planes;
for (i=0 ; i<numbrushplanes;i++, dp++)
{
dot = DotProduct (dp->normal, pl.normal);
if (dot > 1.0 - ANGLEEPSILON
&& fabs(dp->dist - pl.dist) < DISTEPSILON )
{ // regular match
return i;
}
}
if (numbrushplanes == MAX_MAP_PLANES)
Error ("numbrushplanes == MAX_MAP_PLANES");
planes[numbrushplanes] = pl;
numbrushplanes++;
return numbrushplanes-1;
}
/*
===============
FindPlane
Returns a global plane number and the side that will be the front
===============
*/
int FindPlane (plane_t *dplane, int *side)
{
int i;
plane_t *dp, pl;
vec_t dot;
dot = VectorLength(dplane->normal);
if (dot < 1.0 - ANGLEEPSILON || dot > 1.0 + ANGLEEPSILON)
Message (MSGERR, "FindPlane: Normalization error");
pl = *dplane;
NormalizePlane (&pl);
if (DotProduct(pl.normal, dplane->normal) > 0)
*side = 0;
else
*side = 1;
dp = planes;
for (i=0 ; i<numbrushplanes;i++, dp++)
{
dot = DotProduct (dp->normal, pl.normal);
if (dot > 1.0 - ANGLEEPSILON
&& fabs(dp->dist - pl.dist) < DISTEPSILON )
{ // regular match
return i;
}
}
if (validfacesactive)
ExtendArray(validfaces, numbrushplanes);
ExtendArray(planes, numbrushplanes);
planes[numbrushplanes] = pl;
numbrushplanes++;
return numbrushplanes-1;
}
//**************************************************************************************
// Function name : CFrustum::CalculateFrustum
// Author : Gary Ingram
// Return type : void
// Date Created : 25/05/2003
// Description : Calculates the frustum from the modelview and projection
// matrices, The frustrum that is set in this class is a
// static member and so will be the same wherever it is used
//**************************************************************************************
void CFrustum::CalculateFrustum()
{
CMatrix proj(GL_PROJECTION_MATRIX);
CMatrix modl(GL_MODELVIEW_MATRIX);
//////////////////////////////////////////////
//Now that we have our modelview and //
//projection matrix, if we combine these 2 //
//matrices, it will give us our clipping //
//planes. To combine 2 matrices, we //
//multiply them. //
//////////////////////////////////////////////
CMatrix clip(proj*modl);
//////////////////////////////////////////////
//Now we actually want to get the sides of //
//the frustum. To do this we take the //
//clipping planes we received above and //
//extract the sides from them. //
//////////////////////////////////////////////
//////////////////////////////////////////////
//This will extract the RIGHT side of the //
//frustum //
//////////////////////////////////////////////
m_Frustum[RIGHT][A] = clip.element( 3) - clip.element( 0);
m_Frustum[RIGHT][B] = clip.element( 7) - clip.element( 4);
m_Frustum[RIGHT][C] = clip.element(11) - clip.element( 8);
m_Frustum[RIGHT][D] = clip.element(15) - clip.element(12);
//////////////////////////////////////////////
//Now that we have a normal (A,B,C) and a //
//distance (D) to the plane, we want to //
//normalize that normal and distance. //
//////////////////////////////////////////////
//////////////////////////////////////////////
//Normalize the RIGHT side //
//////////////////////////////////////////////
NormalizePlane(RIGHT);
//////////////////////////////////////////////
//This will extract the LEFT side of the //
//frustum //
//////////////////////////////////////////////
m_Frustum[LEFT][A] = clip.element( 3) + clip.element( 0);
m_Frustum[LEFT][B] = clip.element( 7) + clip.element( 4);
m_Frustum[LEFT][C] = clip.element(11) + clip.element( 8);
m_Frustum[LEFT][D] = clip.element(15) + clip.element(12);
//////////////////////////////////////////////
//Normalize the LEFT side //
//////////////////////////////////////////////
NormalizePlane(LEFT);
//////////////////////////////////////////////
//This will extract the BOTTOM side of the //
//frustum //
//////////////////////////////////////////////
m_Frustum[BOTTOM][A] = clip.element( 3) + clip.element( 1);
m_Frustum[BOTTOM][B] = clip.element( 7) + clip.element( 5);
m_Frustum[BOTTOM][C] = clip.element(11) + clip.element( 9);
m_Frustum[BOTTOM][D] = clip.element(15) + clip.element(13);
//////////////////////////////////////////////
//Normalize the BOTTOM side //
//////////////////////////////////////////////
NormalizePlane(BOTTOM);
//////////////////////////////////////////////
//This will extract the TOP side of the //
//Frustum //
//////////////////////////////////////////////
m_Frustum[TOP][A] = clip.element( 3) - clip.element( 1);
m_Frustum[TOP][B] = clip.element( 7) - clip.element( 5);
m_Frustum[TOP][C] = clip.element(11) - clip.element( 9);
m_Frustum[TOP][D] = clip.element(15) - clip.element(13);
//////////////////////////////////////////////
//Normalize the TOP side //
//////////////////////////////////////////////
NormalizePlane(TOP);
//////////////////////////////////////////////
//This will extract the BACK side of the //
//frustum //
//////////////////////////////////////////////
m_Frustum[BACK][A] = clip.element( 3) - clip.element( 2);
m_Frustum[BACK][B] = clip.element( 7) - clip.element( 6);
m_Frustum[BACK][C] = clip.element(11) - clip.element(10);
m_Frustum[BACK][D] = clip.element(15) - clip.element(14);
//////////////////////////////////////////////
//Normalize the BACK side //
//////////////////////////////////////////////
NormalizePlane(BACK);
//////////////////////////////////////////////
//This will extract the FRONT side of the //
//frustum //
//////////////////////////////////////////////
m_Frustum[FRONT][A] = clip.element( 3) + clip.element( 2);
m_Frustum[FRONT][B] = clip.element( 7) + clip.element( 6);
m_Frustum[FRONT][C] = clip.element(11) + clip.element(10);
m_Frustum[FRONT][D] = clip.element(15) + clip.element(14);
//////////////////////////////////////////////
//Normalize the FRONT side //
//////////////////////////////////////////////
NormalizePlane(FRONT);
}
void CFrustum::CalculateFrustum()
{
float proj[16]; // This will hold our projection matrix
float modl[16]; // This will hold our modelview matrix
float clip[16]; // This will hold the clipping planes
// glGetFloatv() is used to extract information about our OpenGL world.
// Below, we pass in GL_PROJECTION_MATRIX to abstract our projection matrix.
// It then stores the matrix into an array of [16].
glGetFloatv( GL_PROJECTION_MATRIX, proj );
// By passing in GL_MODELVIEW_MATRIX, we can abstract our model view matrix.
// This also stores it in an array of [16].
glGetFloatv( GL_MODELVIEW_MATRIX, modl );
// Now that we have our modelview and projection matrix, if we combine these 2 matrices,
// it will give us our clipping planes. To combine 2 matrices, we multiply them.
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
// Now we actually want to get the sides of the frustum. To do this we take
// the clipping planes we received above and extract the sides from them.
// This will extract the RIGHT side of the frustum
m_Frustum[RIGHT][A] = clip[ 3] - clip[ 0];
m_Frustum[RIGHT][B] = clip[ 7] - clip[ 4];
m_Frustum[RIGHT][C] = clip[11] - clip[ 8];
m_Frustum[RIGHT][D] = clip[15] - clip[12];
// Now that we have a normal (A,B,C) and a distance (D) to the plane,
// we want to normalize that normal and distance.
// Normalize the RIGHT side
NormalizePlane(m_Frustum, RIGHT);
// This will extract the LEFT side of the frustum
m_Frustum[LEFT][A] = clip[ 3] + clip[ 0];
m_Frustum[LEFT][B] = clip[ 7] + clip[ 4];
m_Frustum[LEFT][C] = clip[11] + clip[ 8];
m_Frustum[LEFT][D] = clip[15] + clip[12];
// Normalize the LEFT side
NormalizePlane(m_Frustum, LEFT);
// This will extract the BOTTOM side of the frustum
m_Frustum[BOTTOM][A] = clip[ 3] + clip[ 1];
m_Frustum[BOTTOM][B] = clip[ 7] + clip[ 5];
m_Frustum[BOTTOM][C] = clip[11] + clip[ 9];
m_Frustum[BOTTOM][D] = clip[15] + clip[13];
// Normalize the BOTTOM side
NormalizePlane(m_Frustum, BOTTOM);
// This will extract the TOP side of the frustum
m_Frustum[TOP][A] = clip[ 3] - clip[ 1];
m_Frustum[TOP][B] = clip[ 7] - clip[ 5];
m_Frustum[TOP][C] = clip[11] - clip[ 9];
m_Frustum[TOP][D] = clip[15] - clip[13];
// Normalize the TOP side
NormalizePlane(m_Frustum, TOP);
// This will extract the BACK side of the frustum
m_Frustum[BACK][A] = clip[ 3] - clip[ 2];
m_Frustum[BACK][B] = clip[ 7] - clip[ 6];
m_Frustum[BACK][C] = clip[11] - clip[10];
m_Frustum[BACK][D] = clip[15] - clip[14];
// Normalize the BACK side
NormalizePlane(m_Frustum, BACK);
// This will extract the FRONT side of the frustum
m_Frustum[FRONT][A] = clip[ 3] + clip[ 2];
m_Frustum[FRONT][B] = clip[ 7] + clip[ 6];
m_Frustum[FRONT][C] = clip[11] + clip[10];
m_Frustum[FRONT][D] = clip[15] + clip[14];
// Normalize the FRONT side
NormalizePlane(m_Frustum, FRONT);
}
//get frustum
long SmtGLRenderDevice::GetFrustum(SmtFrustum &smtFrustum)
{
float frustum[6][4];
float proj[16]; // This will hold our projection matrix
float modl[16]; // This will hold our modelview matrix
float clip[16]; // This will hold the clipping planes
glGetFloatv( GL_PROJECTION_MATRIX, proj );
glGetFloatv( GL_MODELVIEW_MATRIX, modl );
// Now that we have our modelview and projection matrix, if we combine these 2 matrices,
// it will give us our clipping planes. To combine 2 matrices, we multiply them.
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
// Now we actually want to get the sides of the frustum. To do this we take
// the clipping planes we received above and extract the sides from them.
// This will extract the RIGHT side of the frustum
frustum[FS_RIGHT][P_A] = clip[ 3] - clip[ 0];
frustum[FS_RIGHT][P_B] = clip[ 7] - clip[ 4];
frustum[FS_RIGHT][P_C] = clip[11] - clip[ 8];
frustum[FS_RIGHT][P_D] = clip[15] - clip[12];
// Now that we have a normal (A,B,C) and a distance (D) to the plane,
// we want to normalize that normal and distance.
// Normalize the RIGHT side
NormalizePlane(frustum, FS_RIGHT);
// This will extract the LEFT side of the frustum
frustum[FS_LEFT][P_A] = clip[ 3] + clip[ 0];
frustum[FS_LEFT][P_B] = clip[ 7] + clip[ 4];
frustum[FS_LEFT][P_C] = clip[11] + clip[ 8];
frustum[FS_LEFT][P_D] = clip[15] + clip[12];
// Normalize the LEFT side
NormalizePlane(frustum, FS_LEFT);
// This will extract the BOTTOM side of the frustum
frustum[FS_BOTTOM][P_A] = clip[ 3] + clip[ 1];
frustum[FS_BOTTOM][P_B] = clip[ 7] + clip[ 5];
frustum[FS_BOTTOM][P_C] = clip[11] + clip[ 9];
frustum[FS_BOTTOM][P_D] = clip[15] + clip[13];
// Normalize the BOTTOM side
NormalizePlane(frustum, FS_BOTTOM);
// This will extract the TOP side of the frustum
frustum[FS_TOP][P_A] = clip[ 3] - clip[ 1];
frustum[FS_TOP][P_B] = clip[ 7] - clip[ 5];
frustum[FS_TOP][P_C] = clip[11] - clip[ 9];
frustum[FS_TOP][P_D] = clip[15] - clip[13];
// Normalize the TOP side
NormalizePlane(frustum, FS_TOP);
// This will extract the BACK side of the frustum
frustum[FS_BACK][P_A] = clip[ 3] - clip[ 2];
frustum[FS_BACK][P_B] = clip[ 7] - clip[ 6];
frustum[FS_BACK][P_C] = clip[11] - clip[10];
frustum[FS_BACK][P_D] = clip[15] - clip[14];
// Normalize the BACK side
NormalizePlane(frustum, FS_BACK);
// This will extract the FRONT side of the frustum
frustum[FS_FRONT][P_A] = clip[ 3] + clip[ 2];
frustum[FS_FRONT][P_B] = clip[ 7] + clip[ 6];
frustum[FS_FRONT][P_C] = clip[11] + clip[10];
frustum[FS_FRONT][P_D] = clip[15] + clip[14];
// Normalize the FRONT side
NormalizePlane(frustum, FS_FRONT);
smtFrustum.SetFrustum(frustum);
return SMT_ERR_NONE;
}
void Frustum::CalculateFrustum ()
{
float proj[16]; // array per projection matrix
float modl[16]; // array per modelview matrix
float clip[16]; // array per clipping planes
glGetFloatv( GL_PROJECTION_MATRIX, proj );
glGetFloatv( GL_MODELVIEW_MATRIX, modl );
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
// RIGHT side of the frustum
m_Frustum[RIGHT][A] = clip[ 3] - clip[ 0];
m_Frustum[RIGHT][B] = clip[ 7] - clip[ 4];
m_Frustum[RIGHT][C] = clip[11] - clip[ 8];
m_Frustum[RIGHT][D] = clip[15] - clip[12];
// Normalize the RIGHT side
NormalizePlane(m_Frustum, RIGHT);
// LEFT side of the frustum
m_Frustum[LEFT][A] = clip[ 3] + clip[ 0];
m_Frustum[LEFT][B] = clip[ 7] + clip[ 4];
m_Frustum[LEFT][C] = clip[11] + clip[ 8];
m_Frustum[LEFT][D] = clip[15] + clip[12];
// Normalize the LEFT side
NormalizePlane(m_Frustum, LEFT);
// BOTTOM side of the frustum
m_Frustum[BOTTOM][A] = clip[ 3] + clip[ 1];
m_Frustum[BOTTOM][B] = clip[ 7] + clip[ 5];
m_Frustum[BOTTOM][C] = clip[11] + clip[ 9];
m_Frustum[BOTTOM][D] = clip[15] + clip[13];
// Normalize the BOTTOM side
NormalizePlane(m_Frustum, BOTTOM);
// TOP side of the frustum
m_Frustum[TOP][A] = clip[ 3] - clip[ 1];
m_Frustum[TOP][B] = clip[ 7] - clip[ 5];
m_Frustum[TOP][C] = clip[11] - clip[ 9];
m_Frustum[TOP][D] = clip[15] - clip[13];
// Normalize the TOP side
NormalizePlane(m_Frustum, TOP);
// BACK side of the frustum
m_Frustum[BACK][A] = clip[ 3] - clip[ 2];
m_Frustum[BACK][B] = clip[ 7] - clip[ 6];
m_Frustum[BACK][C] = clip[11] - clip[10];
m_Frustum[BACK][D] = clip[15] - clip[14];
// Normalize the BACK side
NormalizePlane(m_Frustum, BACK);
// FRONT side of the frustum
m_Frustum[FRONT][A] = clip[ 3] + clip[ 2];
m_Frustum[FRONT][B] = clip[ 7] + clip[ 6];
m_Frustum[FRONT][C] = clip[11] + clip[10];
m_Frustum[FRONT][D] = clip[15] + clip[14];
// Normalize the FRONT side
NormalizePlane(m_Frustum, FRONT);
}
