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

K3dSphereWork::K3dSphereWork(K3dGameData *_pGameData)
{
        m_iSphereId = -1;
        m_pGameData = _pGameData;
        m_eRotAxis = K3D_ROT_AXIS_X;
        m_bIsMouseRightUp = true;
        m_pPlane = NULL;
        m_pIntersection = m_pGameData->GetIntersection();
        m_pPlaneBuild = m_pGameData->GetPlaneBuild();
        InitSphereWork();
}

K3dSphereWork::~K3dSphereWork()
{
}

void K3dSphereWork::InitSphereWork()
{
        if(m_pGameData->GetPlaneObjSP().FindPointer(m_pPlane) == false)
        {
                m_pPlane = m_pPlaneBuild->CreateNewPlaneObj();
        }
}

void K3dSphereWork::MoveByMouse(const int _iSphereId)
{
        // Get sphere
        K3dSphereObj *pSphere = m_pGameData->GetSphereObjSP().Get(_iSphereId);
        if(pSphere)
        {
                // Get active camera index
                int iCamId = m_pGameData->GetActiveCamId();
                if(iCamId>=0)
                {
                        K3dMouse *pMouse = m_pGameData->GetMouse();
                        
                        // Get active camera
                        K3dCameraObj *pCamera = m_pGameData->GetCameraObjSP().Get(iCamId);
                        K3dVector3Obj kPos = *pSphere->GetPosition();
                        K3dVector3Obj kNormal = kPos - pCamera->GetPosition();
                        K3dVector3Obj kIntrPoint;
                        if(pMouse->MouseButtonLeft())
                        {
                                kNormal = m_pGameData->GetVector3Work()->Normalize(kNormal);
                                // Create aiming plane by sphere position and camera view vector
                                m_pPlaneBuild->CalcPlane(m_pPlane, kPos, kNormal);
                                // Get aiming ray
                                K3dRayObj *pRay = m_pGameData->GetRayObjSP().Get(m_pGameData->GetAimRayId());
                                // Calculate ray plane intersection
                                if(m_pIntersection->LinePlane(*pRay, *m_pPlane))
                                {
                                        *pSphere->GetPosition() = m_pIntersection->GetIntrPoint();
                                }
                        }
                        if(pMouse->MouseButtonRight())
                        {
                                if (m_bIsMouseRightUp)
                                {
                                        m_bIsMouseRightUp = false;
                                        switch (m_eRotAxis)
                                        {
                                                case K3D_ROT_AXIS_X:
                                                        m_eRotAxis = K3D_ROT_AXIS_Y;
                                                        break;
                                                case K3D_ROT_AXIS_Y:
                                                        m_eRotAxis = K3D_ROT_AXIS_Z;
                                                        break;
                                                case K3D_ROT_AXIS_Z:
                                                        m_eRotAxis = K3D_ROT_AXIS_X;
                                                        break;
                                                default: 
                                                        break;
                                        }
                                }
                        }
                        else
                        {
                                m_bIsMouseRightUp = true;       
                        }
                        // Set rotation
                        if(pMouse->MouseWheelButtonDown())
                        {
                                switch (m_eRotAxis)
                                {
                                        case K3D_ROT_AXIS_X:
                                                pSphere->GetRotation()->GetX() += 10;
                                                break;
                                        case K3D_ROT_AXIS_Y:
                                                pSphere->GetRotation()->GetY() += 10;
                                                break;
                                        case K3D_ROT_AXIS_Z:
                                                pSphere->GetRotation()->GetZ() += 10;
                                                break;
                                        default: 
                                                break;
                                }
                        }
                        if(pMouse->MouseWheelButtonUp())
                        {
                                switch (m_eRotAxis)
                                {
                                        case K3D_ROT_AXIS_X:
                                                pSphere->GetRotation()->GetX() -= 10;
                                                break;
                                        case K3D_ROT_AXIS_Y:
                                                pSphere->GetRotation()->GetY() -= 10;
                                                break;
                                        case K3D_ROT_AXIS_Z:
                                                pSphere->GetRotation()->GetZ() -= 10;
                                                break;
                                        default: 
                                                break;
                                }
                        }
                        pSphere->Move(*pSphere->GetPosition(), *pSphere->GetRotation());
                }
        }
        else
        {
                cerr << "Error in void K3dSphereWork::MoveByMouse() -- pSphere = " << pSphere << endl;
        }
}

void K3dSphereWork::UpdateSpheres()
{
        for(int iSphereId=0; iSphereId < m_pGameData->GetSphereObjSP().GetNum(); iSphereId++)
        {
                // Get sphere
                K3dSphereObj *pSphere = m_pGameData->GetSphereObjSP().Get(iSphereId);
                for(TIntIntMap::iterator i = pSphere->GetLinkObjMap().begin(); i!=pSphere->GetLinkObjMap().end(); ++i)
                {
                        // Get object index
                        int iObjId = i->first;
                        // Get object type
                        int iObjType = i->second;
                        K3dPlaneObj *pPlane;
                        K3dLineObj *pLine;
                        switch (iObjType)
                        {
                                case K3D_IMAGE_OBJ:
                                        break;
                                case K3D_VERTEX_OBJ:
                                        break;
                                case K3D_SPHERE_OBJ:
                                        break;
                                case K3D_CAMERA_OBJ:
                                        break;
                                case K3D_LINE_OBJ:
                                        // Get line
                                        pLine = m_pGameData->GetLineObjSP().Get( iObjId);
                                        // Change line matrix by sphere matrix
                                        pLine->SetMatrix(pSphere->GetMatrix());
                                        break;
                                case K3D_RAY_OBJ:
                                        break;
                                case K3D_PLANE_OBJ:
                                        // Get plane
                                        pPlane = m_pGameData->GetPlaneObjSP().Get( iObjId);
                                        // Change plane matrix by sphere matrix
                                        pPlane->SetMatrix(pSphere->GetMatrix());
                                        break;
                                default: 
                                        break;
                        }
                }
        }
}

void K3dSphereWork::LinkObject(const int _iSphereId, const int _iObjId, const int _iObjType)
{
        K3dSphereObj *pSphere = m_pGameData->GetSphereObjSP().Get(_iSphereId);
        if(pSphere)
        {
                pSphere->GetLinkObjMap().insert(TIntIntPair(_iObjId, _iObjType));
        }
        else
        {
                cerr << "Error in void K3dSphereWork::LinkObject() -- pSphere = " << pSphere << endl;
        }
}

int K3dSphereWork::FindSphereId(const char* _strName)
{
        K3dString strName(_strName);
        for(int i=0; i<m_pGameData->GetSphereObjSP().GetNum(); i++)
        {
                K3dSphereObj *pSphere = m_pGameData->GetSphereObjSP().Get(i);
                if(strName == pSphere->GetName())
                {
                        return i;
                }
        }
        return -1;
}

---