bool SpherePolygonCollision(CVector3 vPolygon[],
CVector3 &vCenter, int vertexCount, float radius)
{
// 1) STEP ONE - Finding the sphere's classification
// Let's use our Normal() function to return us the normal to this polygon
CVector3 vNormal = Normal(vPolygon);
// This will store the distance our sphere is from the plane
float distance = 0.0f;
// This is where we determine if the sphere is in FRONT, BEHIND, or INTERSECTS the plane
int classification = ClassifySphere(vCenter, vNormal, vPolygon[0], radius, distance);
// If the sphere intersects the polygon's plane, then we need to check further
if(classification == INTERSECTS)
{
// 2) STEP TWO - Finding the psuedo intersection point on the plane
// Now we want to project the sphere's center onto the polygon's plane
CVector3 vOffset = vNormal * distance;
// Once we have the offset to the plane, we just subtract it from the center
// of the sphere. "vPosition" now a point that lies on the plane of the polygon.
CVector3 vPosition = vCenter - vOffset;
// 3) STEP THREE - Check if the intersection point is inside the polygons perimeter
// If the intersection point is inside the perimeter of the polygon, it returns true.
// We pass in the intersection point, the list of vertices and vertex count of the poly.
if(InsidePolygon(vPosition, vPolygon, 3))
return true; // We collided!
else
{
// 4) STEP FOUR - Check the sphere intersects any of the polygon's edges
// If we get here, we didn't find an intersection point in the perimeter.
// We now need to check collision against the edges of the polygon.
if(EdgeSphereCollision(vCenter, vPolygon, vertexCount, radius))
{
return true; // We collided!
}
}
}
// If we get here, there is obviously no collision
return false;
}
bool SpherePolygonCollision(Vector3 vPolygon[],
Vector3 &vCenter, int vertexCount, float radius)
{
Vector3 vNormal = Normal(vPolygon);
float distance = 0.0f; //球体到平面的距离
int classification = ClassifySphere(vCenter, vNormal, vPolygon[0], radius, distance);
if(classification == INTERSECTS)
{
Vector3 vOffset = vNormal * distance; //投影球体中心到平面
Vector3 vPosition = vCenter - vOffset;
if(InsidePolygon(vPosition, vPolygon, 3)) //判断交点是否在多变形内
return true;
else
{
if(EdgeSphereCollision(vCenter, vPolygon, vertexCount, radius)) //检查边
{
return true;
}
}
}
return false;
}
void CCamera::CheckCameraCollision(CVector3 *pVertices, int numOfVerts)
{
// This function is pretty much a direct rip off of SpherePolygonCollision()
// We needed to tweak it a bit though, to handle the collision detection once
// it was found, along with checking every triangle in the list if we collided.
// pVertices is the world data. If we have space partitioning, we would pass in
// the vertices that were closest to the camera. What happens in this function
// is that we go through every triangle in the list and check if the camera's
// sphere collided with it. If it did, we don't stop there. We can have
// multiple collisions so it's important to check them all. One a collision
// is found, we calculate the offset to move the sphere off of the collided plane.
// Go through all the triangles
for(int i = 0; i < numOfVerts; i += 3)
{
// Store of the current triangle we testing
CVector3 vTriangle[3] = { pVertices[i], pVertices[i+1], pVertices[i+2] };
// 1) STEP ONE - Finding the sphere's classification
// We want the normal to the current polygon being checked
CVector3 vNormal = Normal(vTriangle);
// This will store the distance our sphere is from the plane
float distance = 0.0f;
// This is where we determine if the sphere is in FRONT, BEHIND, or INTERSECTS the plane
int classification = ClassifySphere(m_vPosition, vNormal, vTriangle[0], m_radius, distance);
// If the sphere intersects the polygon's plane, then we need to check further
if(classification == INTERSECTS)
{
// 2) STEP TWO - Finding the psuedo intersection point on the plane
// Now we want to project the sphere's center onto the triangle's plane
CVector3 vOffset = vNormal * distance;
// Once we have the offset to the plane, we just subtract it from the center
// of the sphere. "vIntersection" is now a point that lies on the plane of the triangle.
CVector3 vIntersection = m_vPosition - vOffset;
// 3) STEP THREE - Check if the intersection point is inside the triangles perimeter
// We first check if our intersection point is inside the triangle, if not,
// the algorithm goes to step 4 where we check the sphere again the polygon's edges.
// We do one thing different in the parameters for EdgeSphereCollision though.
// Since we have a bulky sphere for our camera, it makes it so that we have to
// go an extra distance to pass around a corner. This is because the edges of
// the polygons are colliding with our peripheral view (the sides of the sphere).
// So it looks likes we should be able to go forward, but we are stuck and considered
// to be colliding. To fix this, we just pass in the radius / 2. Remember, this
// is only for the check of the polygon's edges. It just makes it look a bit more
// realistic when colliding around corners. Ideally, if we were using bounding box
// collision, cylinder or ellipses, this wouldn't really be a problem.
if(InsidePolygon(vIntersection, vTriangle, 3) ||
EdgeSphereCollision(m_vPosition, vTriangle, 3, m_radius / 2))
{
// If we get here, we have collided! To handle the collision detection
// all it takes is to find how far we need to push the sphere back.
// GetCollisionOffset() returns us that offset according to the normal,
// radius, and current distance the center of the sphere is from the plane.
vOffset = GetCollisionOffset(vNormal, m_radius, distance);
// Now that we have the offset, we want to ADD it to the position and
// view vector in our camera. This pushes us back off of the plane. We
// don't see this happening because we check collision before we render
// the scene.
m_vPosition = m_vPosition + vOffset;
m_vView = m_vView + vOffset;
}
}
}
}
