Method ExtractFrustum

trinity/TriFrustum.cpp:38–119

}

void TriFrustum::ExtractFrustum( const Matrix* proj )
{ /**
	proj	-	The projection matrix to extract a frustum from.
 */
#ifdef TRINITYDEV
	if( m_frustumTestCounter != 0 )
		m_frustumCullingRatio = (float)m_frustumRejectionCounter / (float)m_frustumTestCounter;
	m_frustumRejectionCounter = 0;
	m_frustumTestCounter = 0;
#endif
	// Frustum Extraction
	// This is actually very simple when you understand all the components of the projection matrix.
	// dRatio = far/(far - near )
	// Columns
	// X->( (1/tan(fov/2))/aspectratio, 0, 0 ). You need to scale all the input values by the 1/tan, because when the 'fov' changes you want to see more.
	//											We also want to make sure that the values are not stretched when the screen is not a perfect square. That is why
	//											we like to scale the x values by the 1/aspectRatio.
	// Y->( 0 1/tan(fov/2), 0 )					The Y values need scaling to, but they do not have to be changed by the aspect ratio because the aspect ratio is a scale relating the
	//											size of 'Y' to x values. x/Y.
	//
	// Z->( 0, 0, dRatio, -near*dRatio )		The depth values get mapped to the z-buffer between the ranges of 0.0 - 1.0. To ensure that no values get divided by zero
	//											we use the near plane and store the actual z value in the w member of the output vector. No value get projected to 2D space before
	//											the z-buffer test, so the projection matrix does not project anything. It basically just scales the values so they can be projected
	//											in a simple homogeneous fashion, x/w, y/w, z/w by a frustum with a 90 degree fov.
	//											To map the depth values correctly to the z-buffer and make sure we don't divide by zero we subtract the near plane from the z-value, so
	//											if the z-value was behind the near plane the sign of the value would switch. Then we need to scale it back to where it was to get the
	//											correct z-buffer value. We want all our values to be mapped correctly between 0.0 - 1.0 where 0.0 is our near plane and 1.0 is our far plane.
	//											So we can't just subtract the nearplane then divide that by the distance between the near and far plane, because than the depth values that
	//											would lie on or behind the farplane(by distance equal to the nearplane) would get drawn. So the value we need to scale the value back into place
	//											after we have subtracted the nearplane is the ratio between the distance to the farplane and the distance between the near and far plane.
	//											*)dRatio = farplane/ (farplane - nearplane )
	//											*)zbuffer = z - nearplane*dRatio
	//											We can split this formula up in the projection matrix to correctly store the z-buffer information in the z member of the output vector.
	//											z-nearplane*dRatio = z*dRation - nearplane*dRatio. As you can see in the third column of the projection matrix, and given that the input vector
	//											is homogeneous with a w=1.0.
	//
	// W->( 0, 0, 1.0, 0 )						All this does is copy the depth value to the w member of the output vector.
	//
	// So to extract the frustums we only need to add and subtract column vectors to get the normals.

	// front
	// The normal of the near plane is the same as the w-component in the projection matrix
	m_planes[PLANE_FRONT].a = ( proj->_13 );
	m_planes[PLANE_FRONT].b = ( proj->_23 );
	m_planes[PLANE_FRONT].c = ( proj->_33 );
	m_planes[PLANE_FRONT].d = ( proj->_43 ); // This will produce the correct number when it is divided by the length of the normal
	//left
	m_planes[PLANE_LEFT].a = ( proj->_14 + proj->_11 );
	m_planes[PLANE_LEFT].b = ( proj->_24 + proj->_21 );
	m_planes[PLANE_LEFT].c = ( proj->_34 + proj->_31 );
	m_planes[PLANE_LEFT].d = ( proj->_44 + proj->_41 );
	//top
	m_planes[PLANE_TOP].a = ( proj->_14 - proj->_12 );
	m_planes[PLANE_TOP].b = ( proj->_24 - proj->_22 );
	m_planes[PLANE_TOP].c = ( proj->_34 - proj->_32 );
	m_planes[PLANE_TOP].d = ( proj->_44 - proj->_42 );
	//right
	m_planes[PLANE_RIGHT].a = ( proj->_14 - proj->_11 );