K3dIntersection.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "K3dIntersection.h"


K3dIntersection::K3dIntersection(K3dGameData *_pGameData):
        K3dIntrLinSph(_pGameData)
{
        m_pGameData = _pGameData;
        // Set this pointer to the game data
        m_pGameData->SetIntersection(this);
        m_pTrianglePlane = NULL;
}

K3dIntersection::~K3dIntersection(void)
{
}



// Find the point where a ray intersect a plane
bool K3dIntersection::RayPlane(const K3dRay &_rkRay, const K3dPlane &_rkPlane, K3dVector3Obj &_rkIPoint)
{
        K3dVector3 kOrigin;
        float fOrigin;
        K3dVector3Obj kDirection;
        float fDirection;
        float fValue;
        K3dVector3Obj kRayDirection;
        K3dVector3 kPlaneDistance;
        K3dVector3 kSign;
        float fSign;

        // Calculate distance plane and ray origin point
        int iDistOrigin = (int) PointPlane(_rkPlane, *_rkRay.GetOrigin());
        // Calculate distance plane and ray direction point
        int iDistDirection = (int) PointPlane(_rkPlane, *_rkRay.GetDirection());

        // If sign of origin and direction is equal then return false
        // Ray direction outside of plane
        if(K3dMath::Sign(iDistOrigin) == K3dMath::Sign(iDistDirection))
        {
                return false;
        }

        // Calc origin
        //fOrigin = kOrigin.Dot(*_rkPlane.GetNormal(), *_rkRay.GetOrigin());
        fOrigin = m_pGameData->GetVector3Work()->Dot(*_rkPlane.GetNormal(), *_rkRay.GetOrigin());
        fOrigin -= _rkPlane.GetDistance();
        
        // Calc Direction
        kRayDirection = *_rkRay.GetDirection() - *_rkRay.GetOrigin();
        //fDirection = kDirection.Dot(*_rkPlane.GetNormal(), kRayDirection);
        fDirection = m_pGameData->GetVector3Work()->Dot(*_rkPlane.GetNormal(), kRayDirection);
        
        // If direction is not zero then the Ray intersect the plane
        if(fDirection)
        {
                // Calc sign plane Ray normal vector
                //fSign = kSign.Dot(*_rkPlane.GetNormal(), *_rkRay.GetDirection());
                fSign = m_pGameData->GetVector3Work()->Dot(*_rkPlane.GetNormal(), *_rkRay.GetDirection());
                // If sign less zero, than no intersection
                if(fSign < (float)0)
                {
                        return false;
                }
                // Calculate t value
                fValue = -fOrigin/fDirection; 
                // Calculate point
                _rkIPoint = *_rkRay.GetOrigin() + (kRayDirection * fValue);
                return true;
        }

        _rkIPoint.Reset();
        return false;
}


// Find the point where a line intersect a triangle
bool K3dIntersection::LineTriangle(const K3dRay &_rkEdge, const K3dTriangle &_rkTriangle)
{
        K3dVector3Obj kE, kF, kG, kNE;
        float fDotF = 0.0f;
        float fDotG = 0.0f;
        float fResult = -1.0f;
        bool bInter = false;

        kE.Reset();
        kF.Reset();
        kG.Reset();
        kNE.Reset();
//      rkIPoint.Reset();

        // Set triangle plane
        m_pGameData->GetPlaneWork()->CalcPlane(m_pTrianglePlane, *_rkTriangle.GetVertex(0), *_rkTriangle.GetNormal());
        // Calc intersection line and plane
        bInter = LinePlane(_rkEdge, *m_pTrianglePlane); 

        // If line and plane is parallel
        if(!bInter)
        {
                return false;
        }

        // Go through all triangle edges
        for(int i=0; i<3; i++)
        {
                // Calc 2D differences by formula
                // E = P(i+1 mod 3) - P(i)
                // F = P(i+2 mod 3) - P(i)
                // G = P - P(i)
                // Compute 2D differences
                kE = *_rkTriangle.GetVertex((i+1)%3) - *_rkTriangle.GetVertex(i);  
                kF = *_rkTriangle.GetVertex((i+2)%3) - *_rkTriangle.GetVertex(i);
                kG = GetIntrPoint() - *_rkTriangle.GetVertex(i); 

                // If rotate vector E about 90 degree (which direction is not important), 
                // we can create a 2D normal vector to the edge E
                kNE[0] = -kE[1];
                kNE[1] = kE[0];
                kNE = m_pGameData->GetVector3Work()->Normalize(kNE);

                // If formula
                // (Ne . F)(Ne . G) >= 0
                // then point P lies inside the triangle
                fDotF = m_pGameData->GetVector3Work()->Dot(kF, kNE);
                fDotG = m_pGameData->GetVector3Work()->Dot(kG, kNE);
                fResult = fDotF * fDotG;
                if(fResult < 0)
                {
                        return false;
                }
        }

        return true;
}

// Find the point where a ray intersect a triangle
bool K3dIntersection::RayTriangle(const K3dRay &_rkRay, const K3dTriangle &_rkTriangle, K3dVector3Obj &_rkIPoint)
{
        K3dVector3Obj kE, kF, kG, kNE;
        float fDotF = 0.0f;
        float fDotG = 0.0f;
        float fResult = -1.0f;
        bool bInter = false;


        kE.Reset();
        kF.Reset();
        kG.Reset();
        kNE.Reset();

        // Set triangle plane
        m_pGameData->GetPlaneWork()->CalcPlane(m_pTrianglePlane, *_rkTriangle.GetVertex(0), *_rkTriangle.GetNormal());
        // Calc intersection ray and plane
        bInter = RayPlane(_rkRay, *m_pTrianglePlane, _rkIPoint);
        // Calc 2D differences by formula
        // E = P(i+1 mod 3) - P(i)
        // F = P(i+2 mod 3) - P(i)
        // G = P - P(i)

        // If Ray and plane is parallel
        if(!bInter)
        {
                return false;
        }

        // Go through all triangle edges
        for(int i=0; i<3; i++)
        {
                // Compute 2D differences
                kE = *_rkTriangle.GetVertex((i+1)%3) - *_rkTriangle.GetVertex(i);  
                kF = *_rkTriangle.GetVertex((i+2)%3) - *_rkTriangle.GetVertex(i);
                kG = _rkIPoint - *_rkTriangle.GetVertex(i); 

                // If rotate vector E about 90 degree (which direction is not important), 
                // we can create a 2D normal vector to the edge E
                kNE[0] = -kE[1];
                kNE[1] = kE[0];
                kNE = m_pGameData->GetVector3Work()->Normalize(kNE);

                // If formula
                // (Ne . F)(Ne . G) >= 0
                // then point P lies inside the triangle
                fDotF = m_pGameData->GetVector3Work()->Dot(kF, kNE);
                fDotG = m_pGameData->GetVector3Work()->Dot(kG, kNE);
                fResult = fDotF * fDotG;
                if(fResult < 0)
                {
                        return false;
                }
        }

        return true;
}

---