K3dIntrLinSph.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 "K3dIntrLinSph.h"

K3dIntrLinSph::K3dIntrLinSph(K3dGameData *_pGameData):
        K3dIntrLinePlane(_pGameData)
{
        m_pGameData = _pGameData;
}

K3dIntrLinSph::~K3dIntrLinSph(void)
{
}

bool K3dIntrLinSph::RaySphere(const K3dRay &_rkRay, const K3dSphere &_rkSphere)
{
        float fSqrDist = (float) 0;
        float fSqr = (float) 0;

        fSqrDist = SqrPointRay(*_rkSphere.GetPosition(),_rkRay, 0);
        fSqr = _rkSphere.GetRadius()*_rkSphere.GetRadius();
        if(fSqrDist<=fSqr)
        {
                return true;
        }
        return false;
}

//----------------------------------------------------------------------------------------------------//
/*
// Test intersection ray and sphere
bool CIntrLinSph::TestIntersection (const CRay kRay, const CSphere kSphere)
{
    CDistance kDistance;
        float fSqrDist = (float) 0;
        float fSqr = (float) 0;

        fSqrDist = kDistance.SqrPointRay(kSphere.Center(),kRay, 0);
        fSqr = kSphere.Radius()*kSphere.Radius();
        if(fSqrDist<=fSqr)
        {
                return true;
        }
                
        return false;

    
}

//----------------------------------------------------------------------------------------------------//

// Find the point where a line intersect a sphere
bool CIntrLinSph::FindLineSphere(const CLine kLine, const CSphere kSphere, int& riQuantity,  CVector3 akPoint[2])
{
        float fA = (float) 0.0;
        float fInvA = (float) 0.0;
        float fB = (float) 0.0;
        float fC = (float) 0.0;
        float fD = (float) 0.0;
        float afT[2];// = (float) 0.0;
        float fRoot = (float) 0.0;
        CVector3 kDiff, kLineDirection;

        // Calc line direction
        kLineDirection = kLine.Direction() - kLine.Origin();
        // Calc difference between line ortigin and sphere center
        kDiff = kLine.Origin() - kSphere.Center();
        // Set up quadratic Q(t) = a*t^2 + 2*b*t + c
        fA = kLineDirection.SquaredLength();
        fB = kDiff.Dot(kLineDirection);
        fC = kDiff.SquaredLength() - kSphere.Radius() * kSphere.Radius();
        fD = fB*fB - fA*fC;
        // If D < 0 then no intersection occurs
        // if D = 0 then the line is tangent to the sphere
        // if D > 0 then there are two distinct point
        if(fD < (float)0.0)
        {
                riQuantity = 0;
                return false;
        }
        else if(fD > (float)0.0)
        {
                fRoot = (float)sqrt(fD);
                if(fA)
                {
                        fInvA = ((float)1.0)/fA;
                        riQuantity = 2;
                        afT[0] = (-fB - fRoot)*fInvA;
                        afT[1] = (-fB + fRoot)*fInvA;
                        //kLineDirection = kLine.Direction() - kLine.Origin();
                        akPoint[0] = kLine.Origin() + ( kLineDirection*afT[0]);
                        akPoint[1] = kLine.Origin() + ( kLineDirection*afT[1]);
                        return true;
                }
        }
        else
        {
                if(fA)
                {
                        riQuantity = 1;
                        afT[0] = -fB/fA;
                        akPoint[0] = kLine.Origin() + ( kLineDirection*afT[0]);
                        return true;
                }
        }

        return false;
}

//----------------------------------------------------------------------------------------------------//

// Find the point where a ray intersect a sphere
bool CIntrLinSph::FindRaySphere(const CRay kRay, const CSphere kSphere, int& riQuantity,  CVector3 akPoint[2])
{
        float fA = (float) 0.0;
        float fInvA = (float) 0.0;
        float fB = (float) 0.0;
        float fC = (float) 0.0;
        float fD = (float) 0.0;
        float afT[2];// = (float) 0.0;
        float fRoot = (float) 0.0;
        CVector3 kDiff, kRayDirection;

        // Calc Ray direction
        kRayDirection = kRay.Direction() - kRay.Origin();
        // Calc difference between Ray ortigin and sphere center
        kDiff = kRay.Origin() - kSphere.Center();
        // Set up quadratic Q(t) = a*t^2 + 2*b*t + c
        fA = kRayDirection.SquaredLength();
        fB = kDiff.Dot(kRayDirection);
        fC = kDiff.SquaredLength() - kSphere.Radius() * kSphere.Radius();
        fD = fB*fB - fA*fC;
        // If D < 0 then no intersection occurs
        // if D = 0 then the Ray is tangent to the sphere
        // if D > 0 then there are two distinct point
        if(fD < (float)0.0)
        {
                riQuantity = 0;
                return false;
        }
        else if(fD > (float)0.0)
        {
                fRoot = (float)sqrt(fD);
                if(fA)
                {
                        fInvA = ((float)1.0)/fA;
                        riQuantity = 2;
                        afT[0] = (-fB - fRoot)*fInvA;
                        afT[1] = (-fB + fRoot)*fInvA;
                        if ( afT[0] >= (float)0.0 )
                        {
                                riQuantity = 2;
                                akPoint[0] = kRay.Origin() + ( kRayDirection*afT[0]);
                                akPoint[1] = kRay.Origin() + ( kRayDirection*afT[1]);
                                return true;
                        }
                        else if ( afT[1] >= (float)0.0 )
                        {
                                riQuantity = 1;
                                akPoint[0] = kRay.Origin() + ( kRayDirection*afT[1]);
                                return true;
                        }
                        else
                        {
                                riQuantity = 0;
                                return false;
                        }
                }
        }
        else
        {
                if(fA)
                {
                        riQuantity = 1;
                        afT[0] = -fB/fA;
                        if ( afT[0] >= (float)0.0 )
                        {
                                riQuantity = 1;
                                akPoint[0] = kRay.Origin() + ( kRayDirection*afT[0]);
                                return true;
                        }
                        else
                        {
                                riQuantity = 0;
                                return false;
                        }
                }
        }

        return false;
}
*/

---