AnimaL

Tutorial

Documentation

---

Documentation

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

---

DeformableOctreeShapeNode.cpp

Go to the documentation of this file.

#include "DeformableOctreeShapeNode.h"

#include <X3DTK/private/X3D_Material.h>
#include <GL/gl.h>

#include "ConstrainedVertex.h"
#include "SFVec3fCellConstrained.h"



namespace X3DTK
{


  namespace X3D
  {



    DeformableOctreeShapeNode::DeformableOctreeShapeNode() :
        _coordinate(NULL), _ifs(NULL), _appearance(NULL), _octree(NULL)
        , _renderingMethod( DOSN_METHOD_VA )
        //, _withCG(false), _withArrays(true)
        //  ,_cgRM(NULL)
    {
      // Node
      define(Recorder<DeformableOctreeShapeNode>::getTypeName("DeformableOctreeShapeNode"));
    }

    DeformableOctreeShapeNode::~DeformableOctreeShapeNode()
    {
      /*
        if( _cgRM )
        {
            delete _cgRM;
        }
      */
    }


    void DeformableOctreeShapeNode::postInit()
    {
      std::cerr << "DOSN::postInit()\n";

      MFNode children = getChildList();

      for( MFNode::iterator it = children.begin() ; it != children.end() ; ++it )
      {


        if ( IndexedFaceSet *tmpifs = dynamic_cast<IndexedFaceSet *>(*it) )
        {
          std::cerr << "Got IFS !\n";
          Require( !_ifs );

          if( ! tmpifs->getCoord() )
          {
            std::cerr << "Can't get coord\n";
          }

          setIFS( tmpifs );
        }
        else if ( Appearance* tmpapp = dynamic_cast<Appearance *>(*it) )
        {
          std::cerr << "Got appareance\n";
          Require( !_appearance );

          _appearance = tmpapp;
        }
      }
    }


    void DeformableOctreeShapeNode::setIFS( IndexedFaceSet *ifs )
    {
      _ifs = ifs;
      _coordinate = dynamic_cast<Coordinate*>(_ifs->getCoord());
    }





    X3D::Coordinate* DeformableOctreeShapeNode::getCoordinate() const
    {
      return _coordinate;
    }



    // Warning : the methods should correspond to the methods in the designer dialog box
    void DeformableOctreeShapeNode::setRenderingMethod( int method )
    {
      _renderingMethod = method;
    }
    int DeformableOctreeShapeNode::getRenderingMethod( ) const
    {
      return _renderingMethod;
    }


    void DeformableOctreeShapeNode::setOctree( animal::octree::Octree *octree )
    {
      Require( _ifs );
      _octree = octree;
      //    _cgRM = new animal::octree::CGRenderingMachine( _octree, _ifs);
    }


    MFVec3f DeformableOctreeShapeNode::computeNormals() const
    {
      Require( _coordinate );
      Require( _ifs );


      const MFInt32 coordIndex = _ifs->getCoordIndex();

      // Each vertex will have a normal accumulated for each triangle it's part of
      MFVec3f normals(coordIndex.size());
      // how many triangles have this vertex
      MFInt32 nTriangles(coordIndex.size());

      unsigned short nVertices = 0;

      //
      // For each triplet of vertex
      // ONLY WORK WITH TRIANGLES !!!
      //
      for( MFInt32::const_iterator it = coordIndex.begin() ; it!=coordIndex.end() ; ++it )
      {
        if( nVertices == 0 )
        {
          // Compute the normal for the 3 next vertices
          const SFVec3f vec0 = _coordinate->getPoint()[*(it+0)];
          const SFVec3f vec1 = _coordinate->getPoint()[*(it+1)];
          const SFVec3f vec2 = _coordinate->getPoint()[*(it+2)];

          const SFVec3f normal = crossprod(vec1-vec0,vec2-vec0);
          normals[*(it+0)] += normal;
          normals[*(it+1)] += normal;
          normals[*(it+2)] += normal;

          nTriangles[*(it+0)]++;
          nTriangles[*(it+1)]++;
          nTriangles[*(it+2)]++;

        }
        nVertices++;

        if( *it == -1 )
        {
          nVertices = 0;
        }
      }

      /*
      MFInt32::iterator itNT = nTriangles.begin();
      for( MFVec3f::iterator itNorm = normals.begin();
              itNorm != normals.end() ;
              ++itNorm, ++itNT
         )
      {
          if( *itNT != 0 )
          {
              (*itNorm)[0] /= *itNT;
              (*itNorm)[1] /= *itNT;
              (*itNorm)[2] /= *itNT;
              (*itNorm).normalize();
          }
      }
      */
      for( MFVec3f::iterator itNorm = normals.begin() ; itNorm != normals.end() ; ++itNorm )
      {
        (*itNorm).normalize();
      }


      return normals;
    }


    void DeformableOctreeShapeNode::draw() const
    {
      //std::cerr << "DeformableOctreeShapeNode::draw()\n";

      if( _coordinate )
      {
        glPushAttrib( GL_ALL_ATTRIB_BITS );

        glEnable( GL_LIGHTING );
        glEnable( GL_NORMALIZE );
        glDisable( GL_COLOR_MATERIAL );
        glEnable( GL_SMOOTH );

        if( _appearance )
        {
          Material * mat = (Material*)_appearance->getMaterial();

          float myVec3[3];
          myVec3[0] = 0;
          myVec3[1] = 0;
          myVec3[2] = 0;

          SFColor myColor;
          SFFloat myFloat;

          if( mat )
          {
            myColor = mat->getDiffuseColor();
            myVec3[0] = myColor.r;
            myVec3[1] = myColor.g;
            myVec3[2] = myColor.b;
            glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, myVec3 );

            myColor = mat->getSpecularColor();
            myVec3[0] = myColor.r;
            myVec3[1] = myColor.g;
            myVec3[2] = myColor.b;
            glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, myVec3 );

            myFloat = mat->getShininess();
            glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, myFloat );
          }
        }

        if( _renderingMethod != DOSN_METHOD_CG )
        {
          // Get the normals
          MFVec3f normals = computeNormals();
          //MFVec3f normals( _coordinate->getPoint().size() );

          const MFInt32 coordIndex = _ifs->getCoordIndex();

          if( _renderingMethod == DOSN_METHOD_VA )
          {


            // Now convert the data to GL_void compatible types
            GLuint myGlIndex[ coordIndex.size() ];
            GLfloat myGlVertex[ 3*_coordinate->getPoint().size() ];
            GLfloat myGlNormal[ 3*normals.size() ];

            unsigned int i;

            i=0;
            for( MFInt32::const_iterator it = coordIndex.begin() ; it != coordIndex.end() ; ++it )
            {
              // Skip -1 identificators
              if( *it != -1 )
              {
                myGlIndex[ i ] = *it;
                ++i;
              }
            }
            unsigned int nTriangleVertices = i;

            i=0;
            for( MFVec3f::iterator it = normals.begin() ; it != normals.end() ; ++it )
            {
              myGlNormal[ i++ ] = (*it)[0];
              myGlNormal[ i++ ] = (*it)[1];
              myGlNormal[ i++ ] = (*it)[2];
            }

            i=0;
            for( MFVec3f::const_iterator it = _coordinate->getPoint().begin() ; it != _coordinate->getPoint().end() ; ++it )
            {
              myGlVertex[ i++ ] = (*it)[0];
              myGlVertex[ i++ ] = (*it)[1];
              myGlVertex[ i++ ] = (*it)[2];
            }


            glEnableClientState(GL_VERTEX_ARRAY);
            glVertexPointer( 3, GL_FLOAT, 0, myGlVertex );

            glEnableClientState(GL_NORMAL_ARRAY);
            glNormalPointer( GL_FLOAT, 0, myGlNormal );

            glDrawElements( GL_TRIANGLES, nTriangleVertices, GL_UNSIGNED_INT, myGlIndex );

          }
          else if( _renderingMethod == DOSN_METHOD_BOURRIN )
          {

            glBegin( GL_POLYGON );
            for( MFInt32::const_iterator it = coordIndex.begin() ; it!=coordIndex.end() ; ++it )
            {
              if( *it == -1 )
              {
                glEnd();
                glBegin( GL_POLYGON );
              }
              else
              {
                const SFVec3f normal = normals[*it];
                const SFVec3f vec = _coordinate->getPoint()[*it];
                glNormal3f( normal[0], normal[1], normal[2] );
                glVertex3f( vec[0], vec[1], vec[2] );
              }
            }
            glEnd();
          }

          /*
          glBegin( GL_POINTS );
          for( MFVec3f::const_iterator it=_coordinate->getPoint().begin() ; it != _coordinate->getPoint().end() ; ++it )
          {
            glVertex3f( (*it)[0], (*it)[1], (*it)[2] );
          }
          glEnd();
          */
        }
        else
        {
          // Use CG

          /*
          if( !_cgRM->cgIsInitialized() )
          {
            _cgRM->initializeCg( _octree->getPositionMethod() );
          }

          _cgRM->render( _octree->getPositionMethod() );
          */

          /*
          // With CG
          // Get the normals from the octree
          std::vector<Vec3d> normals = _octree->getNormals();
          animal::octree::OctreeDataPoints vertices = _octree->getMeshVertices();

          const MFInt32 coordIndex = _ifs->getCoordIndex();

          glBegin( GL_POLYGON );
          for( MFInt32::const_iterator it = coordIndex.begin() ; it!=coordIndex.end() ; ++it )
          {         
            if( *it == -1 )
            {
                glEnd();
                glBegin( GL_POLYGON );
            }
            else
            {
                Vec3d normal;
                //normal = normals[*it];
                
                animal::octree::SFVec3fCellConstrained* vertex = vertices[*it];
                for( unsigned int i=0 ; i<8 ; ++i )
                {
                    FloatingPointType w1 = vertex->getRelativeWeight( vertex->getCell()->vertex(i) );
                    FloatingPointType w2 = vertex->getInitNormalRelativeWeight( vertex->getCell()->vertex(i) );
                    
                    FloatingPointType wn = w2-w1;
                    normal += wn * vertex->getCell()->vertex(i)->getPosition();
                }
                normal.normalize();
                
                const SFVec3f vec = _coordinate->getPoint()[*it];
                glNormal3f( normal[0], normal[1], normal[2] );
                glVertex3f( vec[0], vec[1], vec[2] );
            }       
          }

          glEnd();          
          */

        }

        glPopAttrib();
      }
    }


  }
}

---