IceIndexedTriangle.cpp

Go to the documentation of this file.

// Precompiled Header
#include "Stdafx.h"

using namespace IceMaths;




void IndexedTriangle::Flip()
{
        Swap(mVRef[1], mVRef[2]);
}


float IndexedTriangle::Area(const Point* verts) const
{
        if(!verts)      return 0.0f;
        const Point& p0 = verts[0];
        const Point& p1 = verts[1];
        const Point& p2 = verts[2];
        return ((p0-p1)^(p0-p2)).Magnitude() * 0.5f;
}


float IndexedTriangle::Perimeter(const Point* verts)    const
{
        if(!verts)      return 0.0f;
        const Point& p0 = verts[0];
        const Point& p1 = verts[1];
        const Point& p2 = verts[2];
        return          p0.Distance(p1)
                        +       p0.Distance(p2)
                        +       p1.Distance(p2);
}


float IndexedTriangle::Compacity(const Point* verts) const
{
        if(!verts)      return 0.0f;
        float P = Perimeter(verts);
        if(P==0.0f)     return 0.0f;
        return (4.0f*PI*Area(verts)/(P*P));
}


void IndexedTriangle::Normal(const Point* verts, Point& normal) const
{
        if(!verts)      return;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];
        normal = ((p2-p1)^(p0-p1)).Normalize();
}


void IndexedTriangle::DenormalizedNormal(const Point* verts, Point& normal)     const
{
        if(!verts)      return;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];
        normal = ((p2-p1)^(p0-p1));
}


void IndexedTriangle::Center(const Point* verts, Point& center) const
{
        if(!verts)      return;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];
        center = (p0+p1+p2)*INV3;
}


void IndexedTriangle::CenteredNormal(const Point* verts, Point& normal) const
{
        if(!verts)      return;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];
        Point Center = (p0+p1+p2)*INV3;
        normal = Center + ((p2-p1)^(p0-p1)).Normalize();
}


void IndexedTriangle::RandomPoint(const Point* verts, Point& random)    const
{
        if(!verts)      return;

        // Random barycentric coords
        float Alpha     = UnitRandomFloat();
        float Beta      = UnitRandomFloat();
        float Gamma     = UnitRandomFloat();
        float OneOverTotal = 1.0f / (Alpha + Beta + Gamma);
        Alpha   *= OneOverTotal;
        Beta    *= OneOverTotal;
        Gamma   *= OneOverTotal;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];
        random = Alpha*p0 + Beta*p1 + Gamma*p2;
}


bool IndexedTriangle::IsVisible(const Point* verts, const Point& source)        const
{
        // Checkings
        if(!verts)      return false;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];

        // Compute denormalized normal
        Point Normal = (p2 - p1)^(p0 - p1);

        // Backface culling
        return (Normal | source) >= 0.0f;

// Same as:
//      Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
//      return PL.Distance(source) > PL.d;
}


bool IndexedTriangle::BackfaceCulling(const Point* verts, const Point& source)  const
{
        // Checkings
        if(!verts)      return false;

        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];

        // Compute base
//      Point Base = (p0 + p1 + p2)*INV3;

        // Compute denormalized normal
        Point Normal = (p2 - p1)^(p0 - p1);

        // Backface culling
//      return (Normal | (source - Base)) >= 0.0f;
        return (Normal | (source - p0)) >= 0.0f;

// Same as: (but a bit faster)
//      Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
//      return PL.Distance(source)>0.0f;
}


float IndexedTriangle::ComputeOcclusionPotential(const Point* verts, const Point& view) const
{
        if(!verts)      return 0.0f;
        // Occlusion potential: -(A * (N|V) / d^2)
        // A = polygon area
        // N = polygon normal
        // V = view vector
        // d = distance viewpoint-center of polygon

        float A = Area(verts);
        Point N;        Normal(verts, N);
        Point C;        Center(verts, C);
        float d = view.Distance(C);
        return -(A*(N|view))/(d*d);
}


bool IndexedTriangle::ReplaceVertex(udword oldref, udword newref)
{
                        if(mVRef[0]==oldref)    { mVRef[0] = newref; return true; }
        else    if(mVRef[1]==oldref)    { mVRef[1] = newref; return true; }
        else    if(mVRef[2]==oldref)    { mVRef[2] = newref; return true; }
        return false;
}


bool IndexedTriangle::IsDegenerate()    const
{
        if(mVRef[0]==mVRef[1])  return true;
        if(mVRef[1]==mVRef[2])  return true;
        if(mVRef[2]==mVRef[0])  return true;
        return false;
}


bool IndexedTriangle::HasVertex(udword ref)     const
{
        if(mVRef[0]==ref)       return true;
        if(mVRef[1]==ref)       return true;
        if(mVRef[2]==ref)       return true;
        return false;
}


bool IndexedTriangle::HasVertex(udword ref, udword* index)      const
{
        if(mVRef[0]==ref)       { *index = 0;   return true; }
        if(mVRef[1]==ref)       { *index = 1;   return true; }
        if(mVRef[2]==ref)       { *index = 2;   return true; }
        return false;
}


ubyte IndexedTriangle::FindEdge(udword vref0, udword vref1)     const
{
                        if(mVRef[0]==vref0 && mVRef[1]==vref1)  return 0;
        else    if(mVRef[0]==vref1 && mVRef[1]==vref0)  return 0;
        else    if(mVRef[0]==vref0 && mVRef[2]==vref1)  return 1;
        else    if(mVRef[0]==vref1 && mVRef[2]==vref0)  return 1;
        else    if(mVRef[1]==vref0 && mVRef[2]==vref1)  return 2;
        else    if(mVRef[1]==vref1 && mVRef[2]==vref0)  return 2;
        return 0xff;
}


udword IndexedTriangle::OppositeVertex(udword vref0, udword vref1)      const
{
                        if(mVRef[0]==vref0 && mVRef[1]==vref1)  return mVRef[2];
        else    if(mVRef[0]==vref1 && mVRef[1]==vref0)  return mVRef[2];
        else    if(mVRef[0]==vref0 && mVRef[2]==vref1)  return mVRef[1];
        else    if(mVRef[0]==vref1 && mVRef[2]==vref0)  return mVRef[1];
        else    if(mVRef[1]==vref0 && mVRef[2]==vref1)  return mVRef[0];
        else    if(mVRef[1]==vref1 && mVRef[2]==vref0)  return mVRef[0];
        return INVALID_ID;
}


void IndexedTriangle::GetVRefs(ubyte edgenb, udword& vref0, udword& vref1, udword& vref2) const
{
        if(edgenb==0)
        {
                vref0 = mVRef[0];
                vref1 = mVRef[1];
                vref2 = mVRef[2];
        }
        else if(edgenb==1)
        {
                vref0 = mVRef[0];
                vref1 = mVRef[2];
                vref2 = mVRef[1];
        }
        else if(edgenb==2)
        {
                vref0 = mVRef[1];
                vref1 = mVRef[2];
                vref2 = mVRef[0];
        }
}


float IndexedTriangle::MinEdgeLength(const Point* verts)        const
{
        if(!verts)      return 0.0f;

        float Min = MAX_FLOAT;
        float Length01 = verts[0].Distance(verts[1]);
        float Length02 = verts[0].Distance(verts[2]);
        float Length12 = verts[1].Distance(verts[2]);
        if(Length01 < Min)      Min = Length01;
        if(Length02 < Min)      Min = Length02;
        if(Length12 < Min)      Min = Length12;
        return Min;
}


float IndexedTriangle::MaxEdgeLength(const Point* verts)        const
{
        if(!verts)      return 0.0f;

        float Max = MIN_FLOAT;
        float Length01 = verts[0].Distance(verts[1]);
        float Length02 = verts[0].Distance(verts[2]);
        float Length12 = verts[1].Distance(verts[2]);
        if(Length01 > Max)      Max = Length01;
        if(Length02 > Max)      Max = Length02;
        if(Length12 > Max)      Max = Length12;
        return Max;
}


void IndexedTriangle::ComputePoint(const Point* verts, float u, float v, Point& pt, udword* nearvtx)    const
{
        // Checkings
        if(!verts)      return;

        // Get face in local or global space
        const Point& p0 = verts[mVRef[0]];
        const Point& p1 = verts[mVRef[1]];
        const Point& p2 = verts[mVRef[2]];

        // Compute point coordinates
        pt = (1.0f - u - v)*p0 + u*p1 + v*p2;

        // Compute nearest vertex if needed
        if(nearvtx)
        {
                // Compute distance vector
                Point d(p0.SquareDistance(pt),  // Distance^2 from vertex 0 to point on the face
                                p1.SquareDistance(pt),  // Distance^2 from vertex 1 to point on the face
                                p2.SquareDistance(pt)); // Distance^2 from vertex 2 to point on the face

                // Get smallest distance
                *nearvtx = mVRef[d.SmallestAxis()];
        }
}

        //**************************************
        // Angle between two vectors (in radians)
        // we use this formula
        // uv = |u||v| cos(u,v)
        // u  ^ v  = w
        // |w| = |u||v| |sin(u,v)|
        //**************************************
        float Angle(const Point& u, const Point& v)
        {
                float NormU = u.Magnitude();    // |u|
                float NormV = v.Magnitude();    // |v|
                float Product = NormU*NormV;    // |u||v|
                if(Product==0.0f)       return 0.0f;
                float OneOverProduct = 1.0f / Product;

                // Cosinus
                float Cosinus = (u|v) * OneOverProduct;

                // Sinus
                Point w = u^v;
                float NormW = w.Magnitude();

                float AbsSinus = NormW * OneOverProduct;

                // Remove degeneracy
                if(AbsSinus > 1.0f) AbsSinus = 1.0f;
                if(AbsSinus < -1.0f) AbsSinus = -1.0f;

                if(Cosinus>=0.0f)       return asinf(AbsSinus);
                else                            return (PI-asinf(AbsSinus));
        }


float IndexedTriangle::Angle(const IndexedTriangle& tri, const Point* verts)    const
{
        // Checkings
        if(!verts)      return 0.0f;

        // Compute face normals
        Point n0, n1;
        Normal(verts, n0);
        tri.Normal(verts, n1);

        // Compute angle
        float dp = n0|n1;
        if(dp>1.0f)             return 0.0f;
        if(dp<-1.0f)    return PI;
        return acosf(dp);

//      return ::Angle(n0,n1);
}


bool IndexedTriangle::Equal(const IndexedTriangle& tri) const
{
        // Test all vertex references
        return (HasVertex(tri.mVRef[0]) && 
                        HasVertex(tri.mVRef[1]) &&
                        HasVertex(tri.mVRef[2]));
}