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


K3dAim::K3dAim(K3dGameData *_pGameData)
{
        m_pGameData = _pGameData;
        m_pRayBuild = m_pGameData->GetRayBuild();
}

K3dAim::~K3dAim()
{
}



void K3dAim::CalcAimRayAverage(const float _fFarDist)
{
        // Get screen width
        float fWidth = (float) m_pGameData->GetGraphicOption()->iWidth;
        // Get far plane
        //float fFar = (float) m_pGameData->GetGraphicOption()->iFarPlane;
        m_fFarDist = _fFarDist;
        // Calculate far plane width
        // Equation is:
        // FarPlaneWidth = (atan(a) * FarPlane);
        float fFarPlaneWidth = (K3dMath::ATan((float)m_pGameData->GetGraphicOption()->iFovy) * /*fFar*/m_fFarDist);
        if(fWidth > 0)
        {
                m_fAverage = (fFarPlaneWidth) / fWidth;
        }
}

void K3dAim::CalcAimRay()
{
        // Get active camera index
        int iCamId = m_pGameData->GetActiveCamId();
        if(iCamId>=0)
        {
                // Get active camera
                K3dCameraObj *pCamera = m_pGameData->GetCameraObjSP().Get(iCamId);
                //
                // Calculate ray origin and direction
                //
                K3dVector3Obj kCamPos = pCamera->GetCameraPos();
                //float fFar = (float) m_pGameData->GetGraphicOption()->iFarPlane;
                float fWidth = (float) m_pGameData->GetGraphicOption()->iWidth;
                float fHeight = (float) m_pGameData->GetGraphicOption()->iHeight;
                // Get view, up and right camera vector
                K3dVector3Obj kView = pCamera->GetView();
                K3dVector3Obj kUp = pCamera->GetUp();
                K3dVector3Obj kRight = pCamera->GetRight();
                // Get mouse cursor position
                K3dMouse *pMouse = m_pGameData->GetMouse();
                int  *pMousePos;
                pMousePos = pMouse->GetMousePosition();
                // Calculate middle width and height
                float fMiddleWidth = fWidth * (float) 0.5;
                float fMiddleHeight = fHeight * (float) 0.5;
                // Calculate near plane center
                K3dVector3Obj kNearPlaneCenter = kCamPos + (kView * m_fFarDist);
                // Calculate cursor position in 2d
                K3dVector2 kCursorPos;
                kCursorPos[0] = -(pMousePos[1] - fMiddleHeight)* m_fAverage;
                kCursorPos[1] = (pMousePos[0]- fMiddleWidth) * m_fAverage;
                K3dVector3Obj kNearPlaneUp = kUp * kCursorPos[0];
                K3dVector3Obj kNearPlaneRight = kRight * kCursorPos[1];
                //m_kRay.GetDirection() = kNearPlaneCenter + (kNearPlaneUp + kNearPlaneRight);
                //m_kRay.GetOrigin() = kCamPos;

                m_pRay = m_pGameData->GetRayObjSP().Get(m_pGameData->GetAimRayId());
                *m_pRay->GetDirection() = kNearPlaneCenter + (kNearPlaneUp + kNearPlaneRight);
                *m_pRay->GetOrigin() = kCamPos;
        }
        else
        {
                cerr << "void K3dAim::CalcAimRay() -- Error - Pointer to camera object is NULL!!" << endl;
        }

        //return m_kRay;
}

void K3dAim::CreateAimRay()
{
        // Calculate aiming average
        CalcAimRayAverage((float) m_pGameData->GetGraphicOption()->iFarPlane);
        // Create aiming ray
        m_pRay = m_pRayBuild->CreateNewRayObj();
        m_pGameData->GetAimRayId() = m_pGameData->GetRayObjSP().GetNum()-1;
        // Calculate aiming ray
        CalcAimRay();
}

---