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

K3dPlaneWork::K3dPlaneWork ( K3dGameData *_pGameData )
{
        m_pGameData = _pGameData;
        // Set this pointer to the game data
        m_pGameData->SetPlaneWork ( this );
        m_pVector3Work = m_pGameData->GetVector3Work();
}

K3dPlaneWork::~K3dPlaneWork()
{
}

void K3dPlaneWork::CalcVertexArray ( K3dPlaneObj *_pPlane )
{
        K3dVector3Obj kUp ( 0,1,0 );
        K3dVector3Obj kPos0, kPos1, kPos2, kPos3;
        K3dVector3Obj *pNormal = _pPlane->GetNormal();
        float fWidth = _pPlane->GetWidth();
        float fHeight = _pPlane->GetHeight();
        K3dVector3Obj kCross = m_pVector3Work->Cross ( kUp, *pNormal );
        // If cross product is parallel to the up vector
        if ( m_pVector3Work->Length(kCross) == 0 )
        {
                K3dVector3Obj kFront ( 0,0,-1 );
                K3dVector3Obj kRight ( 1,0,0 );
                float fDot = m_pVector3Work->Dot ( kUp, *pNormal );
                // If normal vector is (0,1,0)
                if ( fDot>0 )
                {
                        kPos0 = ( -kFront * fHeight );
                        kPos1 = ( -kRight * fWidth );
                        kPos2 = ( kFront * fHeight );
                        kPos3 = ( kRight * fWidth );
                }
                else if ( fDot < 0 )            // If normal vector is (0,-1,0)
                {
                        kPos3 = ( -kFront * fHeight );
                        kPos2 = ( -kRight * fWidth );
                        kPos1 = ( kFront * fHeight );
                        kPos0 = ( kRight * fWidth );
                }
                // Set result plane vertices
                if ( _pPlane->GetVertexArray().size() == 4 )
                {
                        *_pPlane->GetVertexArray() [3] = *_pPlane->GetPosition() + ( kPos0 + kPos1 );
                        *_pPlane->GetVertexArray() [2] = *_pPlane->GetPosition() + ( kPos1 + kPos2 );
                        *_pPlane->GetVertexArray() [1] = *_pPlane->GetPosition() + ( kPos2 + kPos3 );
                        *_pPlane->GetVertexArray() [0] = *_pPlane->GetPosition() + ( kPos3 + kPos0 );
                }
                else
                {
                        cerr << "Error in K3dPlaneVis::CalcVertexArray() -- Number of plane vertices must be 4, current number is " << _pPlane->GetVertexArray().size() << endl;
                }
        }
        else    // If cross product is not parallel to the up vector
        {
                kPos0 = ( kCross * fWidth );
                kCross = m_pVector3Work->UnitCross ( kCross, *pNormal );
                kPos1 = ( kCross * fHeight );
                kCross = m_pVector3Work->UnitCross ( kCross, *pNormal );
                kPos2 = ( kCross * fWidth );
                kCross = m_pVector3Work->UnitCross ( kCross, *pNormal );
                kPos3 = ( kCross * fHeight );

                if ( _pPlane->GetVertexArray().size() == 4 )
                {
                        // Set result plane vertices
                        *_pPlane->GetVertexArray() [3] = *_pPlane->GetPosition() + ( kPos0 + kPos1 );
                        *_pPlane->GetVertexArray() [2] = *_pPlane->GetPosition() + ( kPos1 + kPos2 );
                        *_pPlane->GetVertexArray() [1] = *_pPlane->GetPosition() + ( kPos2 + kPos3 );
                        *_pPlane->GetVertexArray() [0] = *_pPlane->GetPosition() + ( kPos3 + kPos0 );
                }
                else
                {
                        cerr << "Error in K3dPlaneVis::CalcVertexArray() -- Number of plane vertices must be 4, current number is " << _pPlane->GetVertexArray().size() << endl;
                }
        }
}

void K3dPlaneWork::CalcDistance ( K3dPlaneObj *_pPlane )
{
        _pPlane->GetDistance() = m_pVector3Work->Dot ( *_pPlane->GetNormal(), *_pPlane->GetPosition() );
}

void K3dPlaneWork::Init ( K3dPlaneObj *_pPlane )
{
        *_pPlane->GetRelNormal() = *_pPlane->GetNormal();
        *_pPlane->GetRelPosition() = *_pPlane->GetPosition();
        CalcDistance ( _pPlane );
        CalcVertexArray ( _pPlane );
}

void K3dPlaneWork::CalcPlane ( K3dPlaneObj *_pPlane, const K3dVector3Obj &_rkPosition, const K3dVector3Obj &_rkNormal )
{
        *_pPlane->GetPosition() = _rkPosition;
        *_pPlane->GetNormal() = _rkNormal;
        Init ( _pPlane );
}

void K3dPlaneWork::CalcPlane ( K3dPlaneObj *_pPlane, const K3dVector3Obj &_rkV0, const K3dVector3Obj &_rkV1, const K3dVector3Obj &_rkV2 )
{
        *_pPlane->GetPosition() = _rkV0;
        // Calculate plane normal vector
        K3dVector3Obj kNormal;
        kNormal = m_pVector3Work->Normal ( _rkV0, _rkV1, _rkV2 );
        kNormal = m_pVector3Work->Normalize ( kNormal );
        // Set plane normal
        *_pPlane->GetNormal() = kNormal;
        // Initilize plane for moving and visualization
        Init ( _pPlane );
}

void K3dPlaneWork::UpdateMatrix ( K3dPlaneObj *_pPlane )
{
        // Set position from matrix
        _pPlane->GetMatrix()->GetTranslation ( *_pPlane->GetPosition() );
        // Set rotation matrix
        *_pPlane->GetRotMatrix() = *_pPlane->GetMatrix();
        _pPlane->GetRotMatrix()->ResetTranslation();
        //*GetNormal() = *GetRelNormal();
        // Change relative normal by rotation matrix
        K3dVector3Obj kRelNormal = *_pPlane->GetRelNormal();
        _pPlane->GetRotMatrix()->ChangeVectorGL ( kRelNormal );
        *_pPlane->GetNormal() = kRelNormal;
        *_pPlane->GetPosition() = *_pPlane->GetRelPosition() + *_pPlane->GetPosition();
        CalcDistance ( _pPlane );
}

int K3dPlaneWork::FindPlaneId ( const char* _strName )
{
        K3dString strName ( _strName );
        for ( int i=0; i<m_pGameData->GetPlaneObjSP().GetNum(); i++ )
        {
                K3dPlaneObj *pPlane = m_pGameData->GetPlaneObjSP().Get ( i );
                if ( strName == pPlane->GetName() )
                {
                        return i;
                }
        }
        return -1;
}

void K3dPlaneWork::UpdatePlanes()
{
        for ( int i=0; i<m_pGameData->GetPlaneObjSP().GetNum(); i++ )
        {
                UpdateMatrix ( m_pGameData->GetPlaneObjSP().Get ( i ) );
        }
}

void K3dPlaneWork::CheckPlane ( const int _iPlaneId )
{
        K3dPlaneObj *pPlane = m_pGameData->GetPlaneObjSP().Get ( _iPlaneId );
        if ( pPlane )
        {
                cout << "void K3dPlaneObj::CheckPlane()" << endl;
                cout << "Address = " << pPlane << endl;
                cout << "m_iId = " << pPlane->GetId() << endl;
                cout << "m_bIsVisible = " << pPlane->GetIsVisible() << endl;
                cout << "Position X = " << pPlane->GetPosition()->GetX() << endl;
                cout << "Position Y = " << pPlane->GetPosition()->GetY() << endl;
                cout << "Position Z = " << pPlane->GetPosition()->GetZ() << endl;
                cout << "Normal X = " << pPlane->GetNormal()->GetX() << endl;
                cout << "Normal Y = " << pPlane->GetNormal()->GetY() << endl;
                cout << "Normal Z = " << pPlane->GetNormal()->GetZ() << endl;
                cout << "Distance = " << pPlane->GetDistance() << endl;
                cout << "Num of verts" << pPlane->GetVertexArray().size() << endl;
                for ( int i=0; i< ( int ) pPlane->GetVertexArray().size(); i++ )
                {
                        cout << "Vertex " << i << endl;
                        cout << "Position X = " << pPlane->GetVertexArray() [i]->GetX() << endl;
                        cout << "Position Y = " << pPlane->GetVertexArray() [i]->GetY() << endl;
                        cout << "Position Z = " << pPlane->GetVertexArray() [i]->GetZ() << endl;
                }
        }
        else
        {
                cerr << "Error in void K3dPlaneWork::CheckPlane() -- pPlane = " << pPlane << endl;
        }
}

bool K3dPlaneWork::ComparePlane ( K3dPolyPlane *_pPlane,const TPolyPlaneArray &_rPlaneArray )
{
        for ( size_t i=0; i<_rPlaneArray.size(); i++ )
        {
                K3dPolyPlane *pTestPlane = _rPlaneArray[i];
                // If plane has same normal vector
                if ( *_pPlane->GetNormal() == *pTestPlane->GetNormal() )
                {
                        // If plane position lies on test plane
                        int iDist = ( int ) m_pGameData->GetIntersection()->PointPlane ( *_pPlane, *pTestPlane->GetPosition() );
                        if ( iDist == 0 )
                        {
                                return true;
                        }
                }
        }
        return false;
}

---