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

K3dConvex::K3dConvex(K3dGameData *_pGameData)
{
        m_pGameData = _pGameData;
        m_vPolyPlane.clear();
        m_vEdge.clear();
        m_vVertex.clear();
        m_pPolyPlane = NULL;
        m_pEdgePlane = NULL;
        InitConvex();
}

K3dConvex::~K3dConvex()
{
}

void K3dConvex::InitConvex()
{
        if(m_pGameData->GetPlaneObjSP().FindPointer(m_pEdgePlane) == false)
        {
                m_pEdgePlane = m_pGameData->GetPlaneBuild()->CreateNewPlaneObj();
        }       
}

bool K3dConvex::CheckConvexPlane()
{
        // Delete on plane vertex array
        m_pPolyPlane->GetOnPlaneVertexArray().clear();
        // Go through all vertices
        for(size_t i=0; i<m_vVertex.size(); i++)
        {
                // Get vertex
                K3dVertexObj *pVertex = m_vVertex[i];
                // Calculate distance between plane and point
                int iDistance = (int) m_pGameData->GetIntersection()->PointPlane(*m_pPolyPlane, *pVertex->GetPosition());
                // If distance is positive, vertex is on the front side of the plane, return false
                if(iDistance > 0)
                {
                        return false;
                }
                // If distance is zero, add vertex to the on plane vertex array
                else if(iDistance == 0)
                {
                        m_pPolyPlane->GetOnPlaneVertexArray().push_back(pVertex->GetPosition());
                }
        }
        // Return true if all vertices are on the plane or on the back side of the plane
        return true;
}

void K3dConvex::CreateConvexPlane(const K3dVector3Obj &_rkV0,const K3dVector3Obj &_rkV1,const K3dVector3Obj &_rkV2)
{
        // Create plane from three vertices
        m_pPolyPlane = m_pGameData->GetPolyPlaneBuild()->CreateNewPolyPlaneObj(_rkV0,_rkV1,_rkV2);
        // Add plane to the plane array if plane distance doesn`t zero
        if(m_pPolyPlane->GetDistance() != (float) 0)
        {
                // Compare plane with plane array if plane doesnt`t exist in plane array
                if(!m_pGameData->GetPlaneWork()->ComparePlane(m_pPolyPlane, m_vPolyPlane))
                {
                        // If plane is convex plane
                        if(CheckConvexPlane())
                        {
                                m_vPolyPlane.push_back(m_pPolyPlane);
                        }
                }
        }
}

void K3dConvex::CheckEdge(const K3dVector3Obj *_pV0,const K3dVector3Obj *_pV1)
{
        // Front and back side switches
        bool bIsFront = false;
        bool bIsBack = false;
        // Go through all other vertices
        for(size_t i=0; i<m_pPolyPlane->GetOnPlaneVertexArray().size(); i++)
        {
                K3dVector3Obj *pV2 = m_pPolyPlane->GetOnPlaneVertexArray()[i];
                if((pV2 != _pV0) && (pV2 != _pV1))
                {
                        // Calculate distance between point and plane
                        float fDistance = m_pGameData->GetIntersection()->PointPlane(*m_pEdgePlane, *pV2);
                        if(fDistance > 0)
                        {
                                bIsFront = true;
                        }
                        if(fDistance < 0)
                        {
                                bIsBack = true;
                        }
                }
        }
        // If all vertices are on front or back side
        if(bIsFront != bIsBack)
        {
                // Create front edge
                K3dLineObj *pEdge = m_pGameData->GetLineBuild()->CreateNewLineObj(*_pV0, *_pV1);
                // Add edge to the edge array
                m_vEdge.push_back(pEdge);
        }
}

void K3dConvex::CreateOnPlaneEdges()
{
        // Go through all other vertices
        for(size_t iV0=0; iV0<m_pPolyPlane->GetOnPlaneVertexArray().size(); iV0++)
        {
                // Get first vertex
                K3dVector3Obj *pV0 = m_pPolyPlane->GetOnPlaneVertexArray()[iV0];
                for(size_t iV1=iV0+1; iV1<m_pPolyPlane->GetOnPlaneVertexArray().size(); iV1++)
                {
                        // Get second vertex
                        K3dVector3Obj *pV1 = m_pPolyPlane->GetOnPlaneVertexArray()[iV1];
                        // Calculate direction vector
                        K3dVector3Obj kDirection = *pV1 - *pV0;
                        // Calculate cross product between direction and plane normal
                        kDirection = m_pGameData->GetVector3Work()->UnitCross(kDirection, *m_pPolyPlane->GetNormal());
                        kDirection = m_pGameData->GetVector3Work()->Normalize(kDirection);
                        // Create plane from line origin direction normal vector
                        m_pGameData->GetPlaneWork()->CalcPlane(m_pEdgePlane, *pV0, kDirection);
                        // Test edge. If all other vertices are on front or back plane side, than add edge to the edge array
                        CheckEdge(pV0, pV1);
                }
        }
}

void K3dConvex::CreateEdgesFromVertexArray()
{
        // Clear previous edge array
        m_vEdge.clear();
        // Go through all convex planes and create edges from on plane vertices
        for(size_t i=0; i<m_vPolyPlane.size(); i++)
        {
                m_pPolyPlane = m_vPolyPlane[i];
                CreateOnPlaneEdges();
        }
}

void K3dConvex::CreateResultVertexArray()
{
        TVertexArray vResultVertex;
        // Go through all verices
        for(size_t iV=0; iV<m_vVertex.size(); iV++)
        {
                // Get vertex
                K3dVertexObj *pV = m_vVertex[iV];
                // Compare vertex with line origin and direction vector
                for(size_t iE=0; iE<m_vEdge.size(); iE++)
                {
                        K3dLineObj *pEdge = m_vEdge[iE];
                        if((*pV->GetPosition() == *pEdge->GetOrigin()) || (*pV->GetPosition() == *pEdge->GetDirection()))
                        {
                                // Add Vertex to the result vertex
                                vResultVertex.push_back(pV);
                                break;
                        }
                        
                }
        }
        // Set new vertex array from result vertex array
        m_vVertex = vResultVertex;
}

K3dPolyObj *K3dConvex::CreatePolyFromVertexArray(const TVertexArray &_rvVertex)
{
        // Create temp vertex array
        m_vVertex = _rvVertex;
        // Delete duplicated vertices from vertex array
        m_pGameData->GetVertexWork()->DeleteDupVerts(m_vVertex);
        K3dPolyObj *pPoly = m_pGameData->GetPolyBuild()->CreateNewPolyObj();
        //Get arbitrary three vertices from vertex array and create planes.
        for(size_t iV0=0; iV0<m_vVertex.size(); iV0++)
        {
                // Get first vertex
                K3dVertexObj *pVertex0 = m_vVertex[iV0];
                for(size_t iV1=iV0+1; iV1<m_vVertex.size(); iV1++)
                {
                        // Get second vertex
                        K3dVertexObj *pVertex1 = m_vVertex[iV1];
                        for(size_t iV2=iV1+1; iV2<m_vVertex.size(); iV2++)
                        {
                                // Get third vertex
                                K3dVertexObj *pVertex2 = m_vVertex[iV2];
                                // Create convex plane from three vertices
                                CreateConvexPlane(*pVertex0->GetPosition(),*pVertex1->GetPosition(),*pVertex2->GetPosition());
                                // Create oposite convex plane from three vertices 
                                CreateConvexPlane(*pVertex1->GetPosition(),*pVertex0->GetPosition(),*pVertex2->GetPosition());
                        }
                }
        }
        // Create polyhedron edges from vertex array
        CreateEdgesFromVertexArray();
        // Delete duplicated edges from edge array
        m_pGameData->GetLineWork()->DeleteDupLines(m_vEdge);
        // Compare vertex array with all edges and if vertex is equal with one of edge origin
        // or direction vector add this vertex to result vertex array
        CreateResultVertexArray();
        // Set result polyhedron
        pPoly->GetVertexArray() = m_vVertex;
        pPoly->GetEdgeArray() = m_vEdge;
        pPoly->GetPlaneArray() = m_vPolyPlane;
        m_pGameData->GetPolyWork()->CheckPoly(pPoly);
        m_pGameData->GetPolyWork()->VisiblePoly(pPoly);
        return pPoly;
}

---