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

K3dTriangulation::K3dTriangulation ( K3dGameData *_pGameData ) : K3dConvex ( _pGameData )
{
        m_pGameData = _pGameData;
        m_pBoxWork = m_pGameData->GetBoxWork();
        m_pVector3Build = m_pGameData->GetVector3Build();
        m_pTriangleBuild = m_pGameData->GetTriangleBuild();
}

K3dTriangulation::~K3dTriangulation()
{
        cout << "K3dTriangulation::~K3dTriangulation()" << endl;
}

void K3dTriangulation::CreateNewTriangle ( K3dVector3Obj *_pV0, K3dVector3Obj *_pV1, K3dVector3Obj *_pV2, const K3dVector3Obj *_pNormal )
{
        // Calculate triangle normal
        K3dVector3Obj kNormal = m_pVector3Build->Normal ( *_pV0, *_pV1, *_pV2 );
        // If triangle normal equal with plane normal create new triangle
        if ( kNormal == *_pNormal )
        {
                m_pTriangleBuild->CreateNewTriangleObj ( _pV0, _pV1, _pV2 );
        }
        else    // Swap first ant second vertex and create new triangle
        {
                m_pTriangleBuild->CreateNewTriangleObj ( _pV1, _pV0, _pV2 );
        }
}

void K3dTriangulation::SortVector3ArrayByAngle ( K3dPolyPlane *_pPolyPlane )
{
        cout << "SortVector3ArrayByAngle" << endl;
        // Result vertex array
        TVector3Array vVector;
        TFloatIntMap mapFloatInt;
        // Calculate vertex array centre
        K3dVector3Obj kCentre;
        kCentre.Reset();
        m_pVector3Build->CalcVectorArrayCentre ( kCentre, _pPolyPlane->GetOnPlaneVertexArray() );
        // Get first vertex
        K3dVector3Obj *pV0 = _pPolyPlane->GetOnPlaneVertexArray() [0];
        // Insert angle to the float int map. First angle is zero
        mapFloatInt.insert ( TFloatIntPair ( 0, 0 ) );
        cout << "Vector3 array size = " << _pPolyPlane->GetOnPlaneVertexArray().size() << endl;
        // Go through all on plane vertices
        for ( size_t i = 1; i<_pPolyPlane->GetOnPlaneVertexArray().size(); i++ )
        {
                K3dVector3Obj *pV1 = _pPolyPlane->GetOnPlaneVertexArray() [i];
                // Calculate angle between vectors toward to vectors centre
                float fAngle = m_pVector3Build->AngleBetweenVectors ( *pV0, *pV1, kCentre );
                // Insert angle to the float int map
                mapFloatInt.insert ( TFloatIntPair ( fAngle, i ) );
        }
        // Check map sorting
        for ( TFloatIntMap::iterator it=mapFloatInt.begin(); it!=mapFloatInt.end(); ++it )
        {
                cout << endl;
                cout << "Key:" << it->first << endl;
                cout << " Value:" << it->second << endl;
                // Save sorted vertices
                vVector.push_back ( _pPolyPlane->GetOnPlaneVertexArray() [it->second] );
        }
        // Copy sorted vertex array to the poly plane vertex array
        _pPolyPlane->GetOnPlaneVertexArray() = vVector;
}



void K3dTriangulation::TriangulatePolyPlane ( K3dPolyPlane *_pPolyPlane )
{
        cout << "TriangulatePolyPlane" << endl;
        // Sort vertex array by angle
        SortVector3ArrayByAngle ( _pPolyPlane );
        cout << "Vector3 array size = " << _pPolyPlane->GetOnPlaneVertexArray().size() << endl;
        // Go through all sorted on plane vertices
        for ( size_t i = 0; i<_pPolyPlane->GetOnPlaneVertexArray().size(); i++ )
        {
                K3dVector3Obj *pV0;
                K3dVector3Obj *pV1;
                K3dVector3Obj *pV2;
                if ( i+2 < _pPolyPlane->GetOnPlaneVertexArray().size() )
                {
                        pV0 = _pPolyPlane->GetOnPlaneVertexArray() [0];
                        pV1 = _pPolyPlane->GetOnPlaneVertexArray() [i+1];
                        pV2 = _pPolyPlane->GetOnPlaneVertexArray() [i+2];
                        CreateNewTriangle ( pV0,pV1,pV2,_pPolyPlane->GetNormal() );
                }
        }
}

void K3dTriangulation::TriangulatePoly ( K3dPolyObj *_pPoly )
{
        // Go through all planes
        for ( size_t i = 0; i<_pPoly->GetPlaneArray().size(); i++ )
        {
                K3dPolyPlane *pPolyPlane = _pPoly->GetPlaneArray() [i];
                // Triangulate poly plane
                TriangulatePolyPlane ( pPolyPlane );
        }
}

void K3dTriangulation::Triangulate ( const TVertexArray &_rvVertex )
{
        // Try calculate polyhedron from vertex array
        K3dPolyObj *pPoly = CreatePolyFromVertexArray ( _rvVertex );
        // Triangulate polyhedron
        TriangulatePoly ( pPoly );
}

void K3dTriangulation::BuildTriangles()
{
        cout << "void K3dTriangleBuild::BuildTriangles()" << endl;
        int iNumFaces = m_pGameData->GetFaceObjSP().GetNum();
        for ( int i=0; i<iNumFaces; i++ )
        {
                K3dFaceObj *pFace =  m_pGameData->GetFaceObjSP().Get ( i );
                // Triangulate vertex array and return result vertex array
                Triangulate ( pFace->GetVertexArray() );
                cout << "Number of vertices in vertex array after face triangulation = " << pFace->GetVertexArray().size() << endl;
        }
}

---