K3dDrawTriangle.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 "K3dDrawTriangle.h"
#include "../Geometry/K3dTriangle.h"

void K3dDrawTriangle::DrawTriangleArray()
{
        // Color for rendering
        



/*
        //if(glIsEnabled(GL_TEXTURE_2D))
        //{
        //      glDisable(GL_TEXTURE_2D);
        //}
        
        if(pTriangle->IsBlend())
        {
                glColor3fv( aC );               // Set color
                // Disable depth test
                //CGL::m_glDisable( GL_DEPTH_TEST );    
                //if(CGL::m_glIsEnabled(GL_DEPTH_TEST)) // If enabled depth buffer test
                //      CGL::m_glDisable( GL_DEPTH_TEST );      // Disable 
                // Enable blending
                glEnable(GL_BLEND);
                // Set blend function
                glBlendFunc(GL_ONE, GL_ONE);
                // Set vertex array 
                glVertexPointer(3, GL_FLOAT, 0, akV);//akTriangle[0]);
                // Enable vertex array 
                glEnableClientState(GL_VERTEX_ARRAY);
                
                
                //CGL::m_glPushMatrix();
                // Draw square
                //CGL::m_glDrawArrays(GL_TRIANGLES, 0, 3);
                glDrawArrays(GL_TRIANGLES, 0, 3);
                //CGL::m_glPopMatrix();
                // Disable vertex array 
                glDisableClientState(GL_VERTEX_ARRAY);
                //glColor3ub( 255, 255, 255 );          // Set white color
                // Disable blending
                glDisable(GL_BLEND);
                //CGL::m_glEnable( GL_DEPTH_TEST );     // Enable depth buffer test 
                glColor3ub( 255, 255, 255 );            // Set white color
                // Enable depth test
                //CGL::m_glEnable( GL_DEPTH_TEST );     
        }
        else*/



        float aC[3];
        aC[0] = 0;
        aC[1] = 0;
        aC[2] = 1;
        glColor3fv( aC );               // Set color
        glDrawArrays(GL_TRIANGLES, 0, m_iNumVertices );

        // Dreaw triangle array lines
        aC[0] = 0;
        aC[1] = 1;
        aC[2] = 0;
        glColor3fv( aC );               // Set color
        glDisable(GL_LIGHTING);
                glBegin(GL_LINES);
                for(int i=0; i<m_iNumVertices-2; i++)
                {
                        // First line
                        glVertex3fv(m_ptVertexArray[i].afVector);
                        glVertex3fv(m_ptVertexArray[i+1].afVector);
                        // Second line
                        glVertex3fv(m_ptVertexArray[i+1].afVector);
                        glVertex3fv(m_ptVertexArray[i+2].afVector);
                        // Third line
                        glVertex3fv(m_ptVertexArray[i+2].afVector);
                        glVertex3fv(m_ptVertexArray[i].afVector);
                        // Jump to next triangle
                        i=i+2;
                }
                glEnd();
        glEnable(GL_LIGHTING);
        //glDrawArrays(GL_LINES, 0, m_iNumVertices );
        glColor3ub( 255, 255, 255 );            // Set white color


}

void K3dDrawTriangle::InitTriangleArray()
{
        cout << "void K3dDrawTriangle::InitTriangleArray()" << endl;
        // Enable vertex array 
        glEnableClientState(GL_VERTEX_ARRAY);
        
        // Set vertex array 
        glVertexPointer(3, GL_FLOAT, sizeof(TRenderVertex), m_ptVertexArray);
        
        // Enable normal vector array
        glEnableClientState(GL_NORMAL_ARRAY);
        // Set normal vector array
        glNormalPointer(GL_FLOAT, sizeof(TRenderVertex), m_ptNormalArray);
        
}

void K3dDrawTriangle::ReallocVertexArray(const int _iNewSize)
{
        cout << "void K3dDrawTriangle::ReallocVertexArray()" << endl;
        // Return if new size is not greater than number of vertices
        if(m_iNumVertices >= _iNewSize)
                return;
        
        TRenderVertex *ptNewVertexArray = new TRenderVertex[_iNewSize];
        TRenderVertex *ptNewNormalArray = new TRenderVertex[_iNewSize];
        // Copy current render array to the new render array
        for(int i=0; i<m_iNumVertices; i++)
        {
                ptNewVertexArray[i] = m_ptVertexArray[i];
                ptNewNormalArray[i] = m_ptNormalArray[i];
        }
        // Detele previous vertex array
        DeleteVertexArray();
        // Copy current pointer to new pointer
        m_ptVertexArray = ptNewVertexArray;
        m_ptNormalArray = ptNewNormalArray;
        // Set new number of vertices
        m_iNumVertices = _iNewSize;
}

void K3dDrawTriangle::AddTriangle(TRenderTriangle &_rtTriangle)
{
        cout << "void K3dDrawTriangle::AddTriangle()" << endl;
        // Add 3 vertices to the array
        ReallocVertexArray(m_iNumVertices+3);
        
        // Set new 3 vertices in vertex array
        int iNumVerts = m_iNumVertices - 3;
        // Go through triangle vertices
        for(int i=0; i<3; i++)
        {
                // Set new vertex to the vertex array
                m_ptVertexArray[iNumVerts] = _rtTriangle.atVertex[i];
                // Set new normal to the vertex array
                m_ptNormalArray[iNumVerts] = _rtTriangle.atNormal[i];
                // Add number of vertices
                iNumVerts++;
        }
}

void K3dDrawTriangle::DeleteVertexArray()
{
        cout << "void K3dDrawTriangle::DeleteVertexArray()" << endl;
        if(m_ptVertexArray != NULL)
        {
                glDisableClientState(GL_VERTEX_ARRAY);
                //m_ptVertexArray = g_RenderVertexSP.Delete(m_ptVertexArray);
                delete [] m_ptVertexArray;
                m_ptVertexArray = NULL;
        }
        if(m_ptNormalArray != NULL)
        {
                glDisableClientState(GL_NORMAL_ARRAY);
                //m_ptNormalArray = g_RenderVertexSP.Delete(m_ptNormalArray);
                delete [] m_ptNormalArray;
                m_ptNormalArray = NULL;
        }
        m_iNumVertices=0;
}

---