source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Triangle3.cpp @ 3070

#include "Triangle3.h"
#include "AxisAlignedBox3.h"
#include "common.h"
#include "Plane3.h"


using namespace std;


namespace CHCDemoEngine {

        
Triangle3::Triangle3(const Vector3 &a, const Vector3 &b, const Vector3 &c) 
{
        Init(a, b, c);
}


void Triangle3::Init(const Vector3 &a, const Vector3 &b, const Vector3 &c) 
{
        mVertices[0] = a;
        mVertices[1] = b;
        mVertices[2] = c;
}


AxisAlignedBox3 Triangle3::GetBoundingBox() const
{
        AxisAlignedBox3 box;
        box.Initialize();

        box.Include(mVertices[0]);
        box.Include(mVertices[1]);
        box.Include(mVertices[2]);

        box.EnlargeToMinSize();
        
        return box;
}


Vector3 Triangle3::GetNormal() const 
{
        const Vector3 v1 = mVertices[0] - mVertices[1];
        const Vector3 v2 = mVertices[2] - mVertices[1];

        return Normalize(CrossProd(v2, v1));
}


Vector3 Triangle3::GetWorldCenter() const 
{
        return (mVertices[0] + mVertices[1] + mVertices[2]) / 3.0f;
}


float Triangle3::GetArea() const 
{
        Vector3 v1 = mVertices[0] - mVertices[1], v2=mVertices[2] - mVertices[1];
        return 0.5f * Magnitude(CrossProd(v2, v1));
}


bool Triangle3::GetPlaneIntersection(const Plane3 &plane, 
                                                                         Vector3 &intersectA, 
                                                                         Vector3 &intersectB) const
{
        int side[3];

        // compute distance from plane
        for (int i = 0; i < 3; ++ i)
                side[i] = plane.Side(mVertices[i], Limits::Small);

        /////
        // no intersection => early exit
        if (((side[0] > 0) && (side[1] > 0) && (side[2] > 0)) ||
                ((side[0] < 0) && (side[1] < 0) && (side[2] < 0)))
        {
                return false;
        }

        /////////////
        // at least 2 triangle vertices lie in plane => early exit

        for (int i = 0; i < 3; ++ i)
        {
                if (!side[i] && !side[(i + 1) % 3])
                {
                        intersectA = mVertices[i];
                        intersectB = mVertices[(i + 1) % 3];
                        
                        return true;
                }
        }

        bool foundA = false;

        // compute intersection points
        for (int i = 0; i < 3; ++ i)
        {
                const int i_2 = (i + 1) % 3;

                // intersection found
                if ((side[i] >= 0) && (side[i_2] <= 0) ||
                        (side[i] <= 0) && (side[i_2] >= 0))
                {       
                        const float t = plane.FindT(mVertices[i], mVertices[i_2]);
                        
                        if (!foundA)
                        {
                                intersectA = mVertices[i] + t * (mVertices[i_2] - mVertices[i]);
                                foundA = true;
                        }
                        else
                        {
                                intersectB = mVertices[i] + t * (mVertices[i_2] - mVertices[i]);
                                return true;
                        }
                }
        }

        cout << "warning! wrong triangle - plane intersection" << endl;
        return false; // something went wrong!
}


bool Triangle3::Valid() const
{
        const Vector3 a = mVertices[0] - mVertices[1];
        const Vector3 b = mVertices[0] - mVertices[2];
        const Vector3 cross_a_b = CrossProd(a, b);

        const float eps = 1e-6f;
        
        if (SqrMagnitude(cross_a_b) <= eps * eps) 
        {
                // v0, v1 & v2 lies on a line (area == 0)
                return false;
        }

        return true;
}


}