AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

CGRenderingMachine.cpp

Go to the documentation of this file.

#include "assertions.h"

#include "CGRenderingMachine.h"


#include <Cg/cg.h>
#include <Cg/cgGL.h>

#include <X3DTK/private/X3DBaseTypes.h>




namespace animal
{
namespace octree
{
 
CGcontext vContext;
CGprogram vProgram;
CGprofile vProfile;

CGparameter ModelViewProj;
CGparameter ModelView;
CGparameter ModelViewIT;

CGparameter CellVerticesID;
CGparameter CellID;

void cgErrorCallback(void);
void cleanExit(int exitval);
void drawTest( void );
static void InitializeCgGL( void );








CGRenderingMachine::CGRenderingMachine( Octree *octree, X3DTK::X3D::IndexedFaceSet *ifs ) :
    _octree(octree), _ifs(ifs), _cgInitiliazed(false)
{
    _cgData.cellsVertexIDsArray = NULL;
}



void CGRenderingMachine::initializeCg( int method )
{
    InitializeCgGL();
        
    structureUpdated( method );
    
    _cgInitiliazed = true;
}
bool CGRenderingMachine::cgIsInitialized() const
{
    return _cgInitiliazed;
}

              
void CGRenderingMachine::render( int method )
{
    Require( _octree != NULL );
    
    std::cerr << "\nCGRenderingMachine::render( "<< method << " )\n";
    
    switch( method )
    {
    
        case LINEAR:
            drawMethodLinear();
            break;
            
        default:
            std::cerr << "Unkown method !\n";
            break;
    }
    
    std::cerr << "CGRenderingMachine::render( "<< method << " ) end\n";
}





void CGRenderingMachine::structureUpdated( int method )
{
    computeCGData( method );
    loadCGParameters( method );
}



CGData& CGRenderingMachine::computeCGData( int method )
{   
    if( _cgData.cellsVertexIDsArray )
    {
        delete []_cgData.cellsVertexIDsArray;
    }
    
    
    Cell *cell = _octree->root();
    unsigned int nMeshPoints = cell->getData()._points.size();
        
    //
    // First get a unique list of octree's vertex with associated IDs
    //
    unsigned int nVertices = 0;
    for( Cell::vertex_width_iterator it( cell ) ; !it.empty() ; )
    {
        ConstrainedVertex* v = ++it;
        
        _cgData.verticesIDs[v] = nVertices;
        
        nVertices++;
    }

    
    // Now get the list of unique cell associated to each vertex of the mesh
    _cgData.meshPointsCell.resize( nMeshPoints );
    _cgData.meshPointsSFVCC.resize( nMeshPoints );
    
    unsigned int nCells = 0;
    std::map<Cell*,unsigned int> cellIDs;
    
    for( Octree::dfs_leaf_iterator itCell( cell ) ; !itCell.empty() ; )
    {
        Cell *tmpCell = ++itCell;

        if( tmpCell->isLeaf() )
        {
            cellIDs[ tmpCell ] = nCells;
            
            // Draw the vertices using the CG shader
            OctreeDataPoints *points = &(cell->getData()._points);
            for( OctreeDataPoints::iterator point = points->begin() ; point != points->end() ; ++point )
            {
                _cgData.meshPointsCell[(*point)->getVertexID()] = nCells;
                _cgData.meshPointsSFVCC[(*point)->getVertexID()] = *point;
            }
            
            nCells++;
            // Advance to the next cell
            // Becaus the iterator is not so good...
            ++itCell;           
        }
    }
    
    //std::cerr << "Getting the cellVertexIDs\n";
    // Now, for each cell, get it's vertex ids
    // For each cell of ID "i" store a vector containing the unique IDs of cell vertices
    //
    _cgData.cellsVertexIDs.resize(nCells);
    unsigned int i=0;
    
    //
    // Here we put the parameters for the cells IDs
    // for each cell, give the IDs of the 8 vertices
    //
    _cgData.cellsVertexIDsArray = new float[8*_cgData.cellsVertexIDs.size()];
    
    for( Octree::dfs_leaf_iterator itCell2( cell ) ; !itCell2.empty() ; )
    {
        Cell *tmpCell = ++itCell2;

        if( tmpCell->isLeaf() )
        {
            //std::cerr << "\tCell is" << *tmpCell << "\n";
            _cgData.cellsVertexIDs[ i ] = std::vector<unsigned int>(8);
            
            for( unsigned int j=0 ; j<8 ; ++j )
            {
                _cgData.cellsVertexIDs[i][j] = _cgData.verticesIDs[ tmpCell->vertex(j) ];
                _cgData.cellsVertexIDsArray[i*_cgData.cellsVertexIDs.size()+j] = _cgData.cellsVertexIDs[i][j];  
            }
            ++i;
            // Advance to the next cell
            // Becaus the iterator is not so good...
            ++itCell2;
        }
    }   

    return _cgData;
}


void CGRenderingMachine::loadCGParameters( int method ) const
{
    cgGLSetStateMatrixParameter( ModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
    
    switch( method )
    {
        case LINEAR:
            break;
            
        default:
            std::cerr << "loadCGParameters() : unknown method\n";
    
    }
}


void CGRenderingMachine::drawMethodLinear()
{
    Require( cgIsInitialized() );
    
    cgGLBindProgram(vProgram);
    cgGLEnableProfile(vProfile);

    cgGLSetStateMatrixParameter( ModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
    
    
    //
    // Now parse the ifs coordindex
    //
    const X3DTK::MFInt32 coordIndex = _ifs->getCoordIndex();
    
    glBegin( GL_POLYGON );
    for( X3DTK::MFInt32::const_iterator it = coordIndex.begin() ; it!=coordIndex.end() ; ++it )
    {           
        if( *it == -1 )
        {
            glEnd();
            glBegin( GL_POLYGON );
        }
        else
        {
            // Send the cell ID
            cgGLSetParameter1f( CellID, _cgData.meshPointsCell[*it] );
            // Send the parameters via the glVertex3f
            glVertex3fv( _cgData.meshPointsSFVCC[*it]->getLocalParams() );
        }       
    }
    glEnd();    

        /*        
    cgGLSetParameter4f( MyPosition, (float)(time(NULL) % 10) / 10.0, 0.0, 0.0, 0.0);
    cgGLSetStateMatrixParameter( ModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
    */

    cgGLDisableProfile(vProfile);
}







/*******************************************************************************
 * NOW CG STUFF
 */



void cleanExit(int exitval)
{
    if (vProgram) cgDestroyProgram(vProgram);
    if (vContext) cgDestroyContext(vContext);

    exit(exitval);
}
void cgErrorCallback(void)
{
    CGerror LastError = cgGetError();

    if(LastError)
    {
        const char *Listing = cgGetLastListing(vContext);
        printf("\n---------------------------------------------------\n");
        printf("%s\n\n", cgGetErrorString(LastError));
        printf("%s\n", Listing);
        printf("---------------------------------------------------\n");
        printf("Cg error, exiting...\n");
        cleanExit(0);
    }
}






void drawTest( void )
{    
   cgGLBindProgram(vProgram);
   cgGLEnableProfile(vProfile);
        
   //cgGLSetParameter4f( MyPosition, (float)(time(NULL) % 10) / 10.0, 0.0, 0.0, 0.0);
   cgGLSetStateMatrixParameter( ModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
   
   /*
   cgGLSetStateMatrixParameter( ModelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
   cgGLSetStateMatrixParameter( ModelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
   */

   glPointSize( 20 );
   
    glBegin( GL_TRIANGLES );
    glVertex3f( 0.0, 0.0, 0.1 );
    glVertex3f( 0.1, 0.0, 0.1 );
    glVertex3f( 0.1, 0.1, 0.1 );
    glEnd();

   cgGLDisableProfile(vProfile);
}




static void InitializeCgGL ( void)
{
   cgSetErrorCallback( cgErrorCallback );
   
   // cgContext creation
   vContext = cgCreateContext();
   
   vProfile = CG_PROFILE_ARBVP1;
   /*
    if (cgGLIsProfileSupported(CG_PROFILE_ARBVP1))
   {
        vProfile = CG_PROFILE_ARBVP1;
    }
   else if (cgGLIsProfileSupported(CG_PROFILE_VP20))
   {
        vProfile = CG_PROFILE_VP20;
    }
    else
   {
        std::cout <<"Vertex programming extensions (GL_ARB_vertex_program or GL_NV_vertex_program) not supported"<<std::endl;
        exit(0);
   }
   */

   

   // create the vertex program
   char filename[] = "test.cg";
   
   vProgram = cgCreateProgramFromFile( vContext, 
                              CG_SOURCE, filename,
                              vProfile, NULL, NULL);

   cgGLLoadProgram(vProgram);
   
   ModelViewProj = cgGetNamedParameter( vProgram, "ModelViewProj" );
   /*
   ModelView = cgGetNamedParameter( vProgram, "ModelView" );
   ModelViewIT = cgGetNamedParameter( vProgram, "ModelViewIT");
   */
   
   CellVerticesID = cgGetNamedParameter( vProgram, "CellVerticesID" );
   CellID = cgGetNamedParameter( vProgram, "CellID" );
   
   // verify that parameters were retrieved successfully
   if(  !CellID || !ModelViewProj || !CellVerticesID )
    {
        std::cout << "Unable to retrieve program parameters, exiting.."<< std::endl;
        cleanExit(0);
    }
    
}


/*
int main(int argc, char **argv)
{
   keys();

   // Initialize the data for the rectangular grid of vertices.
   DataInitialize();

   InitializeGlut( argc, argv);
   
   // Create Cg Context
   InitializeCgGL ();
   
   glutMainLoop();

   glDeleteLists(vertexListSine,1);

   // free memory of vertices
   if (vertices)
     delete vertices;
     
   return (1);
}     
*/        
        
}
}

---