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

K3dCutPoly::K3dCutPoly(K3dGameData *_pGameData):
        K3dCutEdge(_pGameData)
{
        m_pGameData = _pGameData;
        m_pPoly = NULL;
        m_pPolyFront = NULL;
        m_pPolyBack = NULL;
        m_bPlaneIntersectPoly = false;
        m_iTestVertex = 0;
        m_pPlane = NULL;
        m_iNumEdges = 0;
        m_pPlaneBuild = m_pGameData->GetPlaneBuild();
        m_pBoxWork = m_pGameData->GetBoxWork();
        m_pIntersection = m_pGameData->GetIntersection();
        m_pBoxBuild = m_pGameData->GetBoxBuild();
        InitCutPoly();
}

K3dCutPoly::~K3dCutPoly()
{
}

void K3dCutPoly::InitCutPoly()
{
        if(m_pGameData->GetPlaneObjSP().FindPointer(m_pEdgePlane) == false)
        {
                m_pEdgePlane = m_pPlaneBuild->CreateNewPlaneObj();
        }       
}

bool K3dCutPoly::CalcNewEdges()
{
        cout << "void K3dCutPoly::CalcNewEdges()" << endl;
        int iNumVerts = (int) m_vVertex.size();
        m_pGameData->GetVector3Work()->CheckVector3Array(m_vVertex);
        // Line origin
        K3dVector3Obj *pV0 = NULL;
        // Line direction
        K3dVector3Obj *pV1 = NULL;
        // Test vector
        K3dVector3Obj *pV2 = NULL;
        // If number of edges is equalt to number of vertices
        if(m_iNumEdges == iNumVerts)
        {
                return false;
        }
        if((iNumVerts >= 3)&&(m_iTestVertex <= 2))
        {
                // Get test vertex 
                pV0 = m_vVertex[m_iTestVertex];
                // Go through all other vertices
                for(int i=0; i<iNumVerts; i++)
                {
                        pV1 = m_vVertex[i];
                        if((pV1 != pV0))
                        {
                                // Calculate direction vector
                                K3dVector3Obj kDirection = *pV1 - *pV0;
                                // Calculate cross product between direction and plane normal
                                kDirection = m_pGameData->GetVector3Work()->UnitCross(kDirection, *m_pPlane->GetNormal());
                                kDirection = m_pGameData->GetVector3Work()->Normalize(kDirection);
                                // Create plane from line origin direction normal vector
                                m_pPlaneBuild->CalcPlane(m_pEdgePlane, *pV0, kDirection);
                                // Front and back side switches
                                bool bIsFront = false;
                                bool bIsBack = false;
                                for(int j=0; j<iNumVerts; j++)
                                {
                                        pV2 = m_vVertex[j];
                                        if((pV2 != pV0) && (pV2 != pV1))
                                        {
                                                // Calculate distance between point and plane
                                                float fDistance = m_pIntersection->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_pBoxBuild->CreateEdge(pV0, pV1);
                                        // Create back edge with same origin and direction vector
                                        K3dVector3Obj *pOrigin = m_pGameData->GetVector3SP().New();
                                        pOrigin->GetId() = m_pGameData->GetVector3SP().GetNum()-1;
                                        K3dVector3Obj *pDirection = m_pGameData->GetVector3SP().New();
                                        pDirection->GetId() =  m_pGameData->GetVector3SP().GetNum()-1;
                                        *pOrigin = *pV0;
                                        *pDirection = *pV1;
                                        pEdge = m_pBoxBuild->CreateEdge(pOrigin, pDirection);
                                        // Add number of new edges
                                        m_iNumEdges++;
                                }
                        }
                }
                m_iTestVertex++;
                return true;
        }
        return false;
}

void K3dCutPoly::DeleteOpositePlane(const bool _bIsFrontPoly)
{
        cout << "void K3dCutPoly::DeleteOpositePlane(const bool _bIsFrontPoly)" << endl;
        K3dPolyObj *pPoly = NULL;
        if(_bIsFrontPoly == true)
        {
                pPoly = m_pPolyFront;
        }
        else
        {
                pPoly = m_pPolyBack;
        }
        cout << "_bIsFrontPoly = " << _bIsFrontPoly << endl;
        cout << "Cut plane = " << m_pPlane << endl;
        //m_pPlane->CheckPlane();
        cout << "Num of poly planes = " << pPoly->GetPlaneArray().size() << endl;
        for(int i=0; i<(int) pPoly->GetPlaneArray().size(); i++)
        {
                K3dPolyPlane *pPlane = pPoly->GetPlaneArray()[i];
                bool bVertexOnFrontSide = false;
                bool bVertexOnBackSide = false;
                bool bPlaneForDelete = true;
                cout << "Num of poly on plane vertices = " << pPlane->GetOnPlaneVertexArray().size() << endl;
                // If all vertices lies on the plane are on the front side
                for(int j=0; j<(int) pPlane->GetOnPlaneVertexArray().size(); j++)
                {
                        K3dVector3Obj *pVertex = pPlane->GetOnPlaneVertexArray()[j];
                        float fDistance = m_pIntersection->PointPlane(*m_pPlane, *pVertex);
                        if(fDistance > 0)
                        {
                                if(bVertexOnBackSide == true)
                                {
                                        bPlaneForDelete = false;
                                        break;
                                }
                                bVertexOnFrontSide = true;
                        }
                        if(fDistance < 0)
                        {
                                if(bVertexOnFrontSide == true)
                                {
                                        bPlaneForDelete = false;
                                        break;
                                }
                                bVertexOnBackSide = true;
                        }
                        
                }
                if(bPlaneForDelete == true)
                {
                        // Delete oposite plane
                        if((_bIsFrontPoly == true) && (bVertexOnBackSide == true))
                        {
                                cout << "Delete plane id =" << pPlane->GetId() << endl;
                                pPoly->DeletePlane(pPlane);
                        }
                        if((_bIsFrontPoly == false) && (bVertexOnFrontSide == true))
                        {
                                cout << "Delete plane id =" << pPlane->GetId() << endl;
                                pPoly->DeletePlane(pPlane);
                        }
                }
        }
}

void K3dCutPoly::DeleteOpositeEdges(const bool _bIsFrontPoly)
{
        K3dPolyObj *pPoly = NULL;
        if(_bIsFrontPoly == true)
        {
                pPoly = m_pPolyFront;
        }
        else
        {
                pPoly = m_pPolyBack;
        }
        for(int i=0; i< (int)pPoly->GetEdgeArray().size(); i++)
        {
                K3dLineObj *pEdge = pPoly->GetEdgeArray()[i];
                // Calculate distance between line and plane
                int iDist = m_pIntersection->DistLinePlane(*m_pPlane, *pEdge->GetOrigin(), *pEdge->GetDirection());
                // If front poly and distance is negative delete edge
                if((_bIsFrontPoly == true) && (iDist == -1))
                {
                        pPoly->DeleteEdge(pEdge);
                        i--;
                }
                // If back poly and distance is positive delete edge
                if((_bIsFrontPoly == false) && (iDist == 1))
                {
                        pPoly->DeleteEdge(pEdge);
                        i--;
                }
                // If distance is zero then line intesect the plane
        }
}

void K3dCutPoly::AddNewPlane(const bool _bIsFrontPoly)
{
        cout << "void K3dCutPoly::AddNewPlane(const bool _bIsFrontPoly)" << endl;
        K3dPolyPlane *pPlane = m_pGameData->GetPolyPlaneBuild()->CreateNewPolyPlaneObj();
        if(_bIsFrontPoly == true)
        {
                *pPlane->GetPosition() = *m_vVertex[0];
        }
        else
        {
                *pPlane->GetPosition() = *m_vVertex[1];
        }
        cout << "_bIsFrontPoly = " << _bIsFrontPoly << endl;
        pPlane->GetIsVisible() = m_pPolyFront->GetIsVisible();
        pPlane->GetWidth() = K3D_CUTPOLY_SIZE;
        pPlane->GetHeight() = K3D_CUTPOLY_SIZE;
        K3dVector3Obj kNormal = *m_pPlane->GetNormal();
        if(_bIsFrontPoly == true)
        {
                // Reverse normal vector
                kNormal.GetX() = -kNormal.GetX();
                kNormal.GetY() = -kNormal.GetY();
                kNormal.GetZ() = -kNormal.GetZ();
        }
        *pPlane->GetNormal() = kNormal; 
        m_pPlaneBuild->Init(pPlane);
        // Calculate vertices lies on the plane
        m_pGameData->GetPolyPlaneBuild()->CalcVertsOnPlane(pPlane);
        if(_bIsFrontPoly == true)
        {
                m_pPolyFront->AddPlane(pPlane);
        }
        else
        {
                m_pPolyBack->AddPlane(pPlane);
        }
}

K3dPolyObj *K3dCutPoly::Cut(K3dPolyObj *_pPoly, K3dPlaneObj *_pPlane)
{
        cout << "K3dPolyObj *K3dCutPoly::Cut(K3dPolyObj *_pPoly, K3dPlaneObj *_pPlane)" << endl;
        // Set temporary polyhedron
        K3dPolyObj kTempPoly = *_pPoly;
        //m_pBoxWork->CheckPoly(&kTempPoly);
        // Set new front end back polyhedron
        m_pPolyFront = _pPoly;
        //m_pPolyFront->DeletePoly();
        m_pPolyBack = m_pGameData->GetPolyBuild()->CreateNewPolyObj();
        *m_pPolyBack = *m_pPolyFront;
        m_pPlane = _pPlane;
        m_vEdge.clear();
        m_vVertex.clear();
        // Go through all temp poly edges
        for(int i=0; i<(int)kTempPoly.GetEdgeArray().size(); i++)
        {
                // Get edge
                K3dLineObj *pEdge = kTempPoly.GetEdgeArray()[i];
                // Cut edge and create new back of plane edge. Input edge changes to front of plane edge
                K3dLineObj *pBackEdge = CutEdge(pEdge, _pPlane);
                if(pBackEdge != NULL)
                {
                        // Add back edge to the back polyhedron
                        m_pPolyBack->AddEdge(pBackEdge);
                        // Delete front edge from back polyhedron
                        m_pPolyBack->DeleteEdge(pEdge);
                        // Add intersection point to the vertex array.
                        // Intersection point is back edge direction vector
                        m_vVertex.push_back(pBackEdge->GetDirection());
                }
                else    // Edge don`t intersect the plane
                {
                        // Check plane position oposit the plane after edge plane intersection 
                        switch (m_pIntersection->GetLinePlanePos())
                        {
                                case K3D_FRONT_LINE:
                                        // Delete this edge from back poly
                                        m_pPolyBack->DeleteEdge(pEdge);
                                        break;
                                case K3D_BACK_LINE:
                                        // Delete this edge from front poly
                                        m_pPolyFront->DeleteEdge(pEdge);
                                        break;
                                default:
                                        break;
                        }
                }
        }
        // Calculate new edges from intersection vertex array
        m_iTestVertex = 0;
        m_iNumEdges = 0;
        bool bNewEdge = true;
        while(bNewEdge)
        {
                cout << endl;
                cout << "Edge size = " << m_iNumEdges << endl;
                cout << "Vertex size = " << m_vVertex.size() << endl;
                // Calculate new edges from intersection vertex array
                bNewEdge = CalcNewEdges();
        }
        // Delete poly plane if plane lies on oposite side of dividing plane
        DeleteOpositePlane(true);
        DeleteOpositePlane(false);
        // Add new plane to the front polyhedron
        AddNewPlane(true);
        // Add new plane to the back polyhedron
        AddNewPlane(false);
        return m_pPolyBack;
}

---