AnimaL

Tutorial

Documentation

---

Documentation

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

---

ManipulatedMeshVertex.cpp

Go to the documentation of this file.

//
// C++ Implementation: ManipulatedMeshVertex
//
// Description: 
//
//
// Author: François Faure <>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "ManipulatedMeshVertex.h"
#include "assertions.h"
#include <GL/glut.h>

namespace animal {

namespace octree {

/*
ManipulatedMeshVertex::ManipulatedMeshVertex( Octree *octree, SFVec3fCellConstrained * vertex ) :
    _octree(octree)
    , _vertex(vertex)
{
    Require( _octree );
    Require( _vertex );
}
*/

ManipulatedMeshVertex::ManipulatedMeshVertex( X3DTK::X3D::DeformableOctreeNode *dosn, const X3DTK::SFVec3f *meshVertex ) :
    _dosn(dosn)
{
    Octree *octree = dosn->getOctree();
    
    Require( octree );
    
    _vertex = NULL;
    
    // First find in the root the SFConstrainedVertex
    Cell *cell = octree->root();

    if( cell->isLeaf() )
    {
        OctreeDataPoints::iterator it;
        for( it = cell->getData()._points.begin() ; 
            it != cell->getData()._points.end() ;
            ++it )
        {
            if( (*it)->getSFVec3f() == meshVertex)
            {
                _vertex = *it;
                break;
            }
        }
        Require( _vertex );
    }
    else
    {
        while( !cell->isLeaf() )
        {   
            std::cerr << "Searching from cell : " << *cell << "\n";
            
            // Find which of our children contains this vertex
            unsigned int i;
            _vertex = NULL;
            Cell *child = NULL;
            for( i=0 ; i<8 ; ++i )
            {
                child = cell->child(i);
                //std::cerr << "\tSearching for the vertex in the cell" << cell->child(i) << "\n";
                OctreeDataPoints::iterator it;
                for( it = child->getData()._points.begin() ; 
                    it != child->getData()._points.end() ;
                    ++it )
                {
                    if( (*it)->getSFVec3f() == meshVertex)
                    {
                        _vertex = *it;
                        break;
                    }
                }
                if( it != child->getData()._points.end() )
                {
                    // We found it
                    break;
                }
                
            }
            // Means that we've found it
            Require( i!=8 );
            cell = child;
            //std::cerr << "\t found child " << i << " cell : " << *cell << "\n";
        }
    }
    
    // Now _vertex contains the pointer to the vertex and cell the child
    

    /*
    // Then find the leaf cell containing this vertex
     * With the alpha, beta, gamma
     * But this depend on the subdivision scheme
     * Beter put this method in the "Octree" class so
     * people can understand where to look at the subdivision scheme
     */
     
     _initPos = Vec3d( (*meshVertex)[0], (*meshVertex)[1], (*meshVertex)[2] );
     
     //std::cerr << "Initposition is " << _initPos << "\n";
     
    Ensure( _vertex );
    
}

ManipulatedMeshVertex::~ManipulatedMeshVertex()
{
    Require( _octree );
    _dosn->updateGL();
}

void ManipulatedMeshVertex::getPoint( float& x, float& y, float& z ) const
{
    //std::cerr << "ManipulatedMeshVertex::getPoint( float& x, float& y, float& z )\n";
    x = _initPos[0];
    y = _initPos[1];
    z = _initPos[2];
}
    
    
void ManipulatedMeshVertex::moveTo( float x, float y, float z )
{
    //std::cerr << "ManipulatedMeshVertex::moveTo( " << x << ", " << y << " , " << z << " )\n";
    Require( _octree );
    Require( _vertex );
    _dosn->getOctree()->directManipulation( _vertex, Vec3d(x,y,z) );
    _dosn->getOctree()->movedRecLeaves( _dosn->getOctree()->root() );
    _dosn->updateGL();
    //std::cerr << "\tPosition is now : " << *_vertex->getSFVec3f() << "\n";
    /*
    (*(_vertex->getSFVec3f()))[0] = _initPos[0]+x;
    (*(_vertex->getSFVec3f()))[1] = _initPos[1]+y;
    (*(_vertex->getSFVec3f()))[2] = _initPos[2]+z;
    */
}


bool ManipulatedMeshVertex::operator==( const ConstrainedItem* mmv ) const
{
    const ManipulatedMeshVertex* p = dynamic_cast<const ManipulatedMeshVertex*>(mmv);
    return p && (_dosn == p->_dosn) && (_vertex == p->_vertex);
}

void ManipulatedMeshVertex::draw()
{
        glPushAttrib( GL_ALL_ATTRIB_BITS );

        glDisable( GL_LIGHTING );
        glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
        glEnable (GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
    
    glPushMatrix();
    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
    glEnable( GL_CULL_FACE );
    
    X3DTK::SFVec3f pos = *_vertex->getSFVec3f();
    glTranslatef( pos[0], pos[1], pos[2] );
    glColor4f( 0.0, 0.0 , 1.0, 0.5 );
    glutSolidSphere( _dosn->getToolsSize(), 10, 10 );
    
    glPopMatrix();
    glPopAttrib();
    
}

};

};

---