mgcintrplnloz.cpp

3D Game Engine Design Source Code非常棒

// Magic Software, Inc.
// http://www.magic-software.com
// Copyright (c) 2000, All Rights Reserved
//
// Source code from Magic Software is supplied under the terms of a license
// agreement and may not be copied or disclosed except in accordance with the
// terms of that agreement.  The various license agreements may be found at
// the Magic Software web site.  This file is subject to the license
//
// FREE SOURCE CODE
// http://www.magic-software.com/License/free.pdf

#include "MgcIntrPlnLoz.h"

//----------------------------------------------------------------------------
bool MgcTestIntersection (const MgcPlane& rkPlane,
    const MgcLozenge& rkLozenge, bool bUnitNormal)
{
    MgcVector3 kNormal = rkPlane.Normal();
    MgcReal fConstant = rkPlane.Constant();
    if ( !bUnitNormal )
    {
        MgcReal fLength = kNormal.Unitize();
        fConstant /= fLength;
    }

    MgcVector3 kC10 = rkLozenge.Origin() + rkLozenge.Edge0();
    MgcVector3 kC01 = rkLozenge.Origin() + rkLozenge.Edge1();
    MgcVector3 kC11 = kC10 + rkLozenge.Edge1();

    MgcReal fTmp00 = kNormal.Dot(rkLozenge.Origin()) - fConstant;
    MgcReal fTmp10 = kNormal.Dot(kC10) - fConstant;
    if ( fTmp00*fTmp10 <= 0.0 )
    {
        // two lozenge ends on opposite sides of the plane
        return true;
    }

    MgcReal fTmp01 = kNormal.Dot(kC01) - fConstant;
    fTmp01 -= rkPlane.Constant();
    if ( fTmp00*fTmp10 <= 0.0 )
    {
        // two lozenge ends on opposite sides of the plane
        return true;
    }

    MgcReal fTmp11 = kNormal.Dot(kC11) - fConstant;
    if ( fTmp10*fTmp11 <= 0.0 )
    {
        // two lozenge ends on opposite sides of the plane
        return true;
    }

    return MgcMath::Abs(fTmp00) <= rkLozenge.Radius()
        || MgcMath::Abs(fTmp10) <= rkLozenge.Radius()
        || MgcMath::Abs(fTmp01) <= rkLozenge.Radius()
        || MgcMath::Abs(fTmp11) <= rkLozenge.Radius();
}
//----------------------------------------------------------------------------
bool MgcCulled (const MgcPlane& rkPlane, const MgcLozenge& rkLozenge,
    bool bUnitNormal)
{
    MgcVector3 kNormal = rkPlane.Normal();
    MgcReal fConstant = rkPlane.Constant();
    if ( !bUnitNormal )
    {
        MgcReal fLength = kNormal.Unitize();
        fConstant /= fLength;
    }

    MgcReal fTmp00 = kNormal.Dot(rkLozenge.Origin()) - fConstant;
    if ( fTmp00 < 0.0 )
    {
        MgcReal fDotNE0 = kNormal.Dot(rkLozenge.Edge0());
        MgcReal fTmp10 = fTmp00 + fDotNE0;
        if ( fTmp10 < 0.0 )
        {
            MgcReal fDotNE1 = kNormal.Dot(rkLozenge.Edge1());
            MgcReal fTmp01 = fTmp00 + fDotNE1;
            if ( fTmp01 < 0.0 )
            {
                MgcReal fTmp11 = fTmp10 + fDotNE1;
                if ( fTmp11 < 0.0 )
                {
                    // all four lozenge corners on negative side of plane
                    if ( fTmp00 <= fTmp10 )
                    {
                        if ( fTmp00 <= fTmp01 )
                            return fTmp00 <= -rkLozenge.Radius();
                        else
                            return fTmp01 <= -rkLozenge.Radius();
                    }
                    else
                    {
                        if ( fTmp10 <= fTmp11 )
                            return fTmp10 <= -rkLozenge.Radius();
                        else
                            return fTmp11 <= -rkLozenge.Radius();
                    }
                }
            }
        }
    }

    return false;
}
//----------------------------------------------------------------------------