AnimaL

Tutorial

Documentation

---

Documentation

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

---

DeformableOctreeParticleSystemNode.cpp

Go to the documentation of this file.

//
// C++ Implementation: DeformableOctreeParticleSystemNode
//
// Description:
//
//
// Author: Matthieu Nesme <>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "DeformableOctreeParticleSystemNode.h"
#include "OctreeParticleSystemEngine.cpp"
#include <animal/X3DTK/linearX3DTK.h>
#include "ManipulatedMeshVertexAnimated.cpp"

using std::cerr;
using std::cout;
using std::endl;



namespace X3DTK
{

namespace X3D
{

typedef animal::octree::OctreeParticleSystemEngine<MFVec3f,float,MFFloat> OctreeParticleSystemEngine;
typedef ManipulatedMeshVertexAnimated<MFVec3f,float,MFFloat> ManipulatedMeshVertexAnimated;


DeformableOctreeParticleSystemNode::DeformableOctreeParticleSystemNode()
        : DeformableOctreeNode()
{
    DeformableOctreeNode::defineTypeName("DeformableOctreeParticleSystemNode");
    //cerr<<"DeformableOctreeParticleSystemNode\n";
}


DeformableOctreeParticleSystemNode::~DeformableOctreeParticleSystemNode()
{}


void DeformableOctreeParticleSystemNode::animate( float dt )
{
    //cerr<<"DeformableOctreeParticleSystemNode::animate( float dt )\n";
    _octree->move(dt);
    
}

void DeformableOctreeParticleSystemNode::postAnimate( float dt )
{
        //_octree->postMove(dt);
}


void DeformableOctreeParticleSystemNode::postInit()
{
   // DeformableOctreeNode::postInit();
        std::cerr << "DON::postInit\n";
    //glEnable( GL_COLOR_MATERIAL );
    //glColorMaterial( GL_FRONT_AND_BACK,  GL_SPECULAR );

    MFAbstractNode children = getChildList();

    for( MFAbstractNode::iterator it = children.begin() ; it != children.end() ; ++it )
    {
        std::cerr << "\tGot one child : " << (*it)->getName() << "\n";

        if( DeformableOctreeShapeNode *tmpNode =dynamic_cast<DeformableOctreeShapeNode *>(*it) )
        {
            Require( !_dosn );

            // anciennes verifications
            /*
            if(_dosn)
                return false;
            */

            // Find a Coordinate Node if any
            if( !tmpNode->getCoordinate() )
            {
                std::cerr << "DON::init : can't get coordinates from DOSN\n";
            }

            setDeformableOctreeShapeNode( tmpNode );
        }
    }

    //_octree->init();
}


void DeformableOctreeParticleSystemNode::createOctree()
{
    std::cerr << "DeformableOctreeParticleSystemNode::createOctree()\n";

    X3D::Coordinate * coord = _dosn->getCoordinate();


    if (!coord)
    {
        std::cerr<< "Warning: impossible to init the octree. In the file .x3d, there is no Coordinate child of the ShapeNode."<< std::endl;
        return;
    }
    if ( coord->getPoint().size() == 0)
    {
        std::cerr << "Warning: no vertex in the mesh !\n";
        return;
    }

    // Get the points
    const MFVec3f * pointsTmp = &(coord->getPoint());
    MFVec3f * points = const_cast<MFVec3f *>(pointsTmp);

    Vec3d minVec, maxVec;
    minVec.x = (*points)[0].x;
    maxVec.x = (*points)[0].x;
    minVec.y = (*points)[0].y;
    maxVec.y = (*points)[0].y;
    minVec.z = (*points)[0].z;
    maxVec.z = (*points)[0].z;

    for( unsigned int i=0 ; i< points->size() ; ++i )
    {
        SFVec3f p = (*points)[i];

        if( p.x < minVec.x )
            minVec.x = p.x;
        if( p.y < minVec.y )
            minVec.y = p.y;
        if( p.z < minVec.z )
            minVec.z = p.z;

        if( p.x > maxVec.x )
            maxVec.x = p.x;
        if( p.y > maxVec.y )
            maxVec.y = p.y;
        if( p.z > maxVec.z )
            maxVec.z = p.z;
    }



    Vec3d sizeVec = maxVec - minVec;

    // Give the octree a little larger BBox so that every points are SURE to be inside
    minVec -= sizeVec/100.0;
    maxVec += sizeVec/100.0;

    minVec.z -= 0.5;
    maxVec.z += 1;

    sizeVec = maxVec - minVec;

    MFVec3f normals = _dosn->computeNormals();


    cerr<<"DeformableOctreeNode::createOctree create a particle octree"<<endl;
    _octree = new OctreeParticleSystemEngine( minVec, maxVec, points, normals, 10000 );
    this->DeformableOctreeNode::_octree = _octree;
    
    
    _selectedCell = _octree->root();
}


void DeformableOctreeParticleSystemNode::setDeformableOctreeShapeNode( DeformableOctreeShapeNode *dosn)
{
    _dosn = dosn;
    createOctree();
    if( _octree )
    {
        _dosn->setOctree( _octree );
    }
}


void DeformableOctreeParticleSystemNode::draw()
{
    DeformableOctreeNode::draw();
    if(_drawOctree) _octree->draw();
}

void DeformableOctreeParticleSystemNode::slotSubdivide()
{
    //cerr<<"DeformableOctreeParticleSystemNode::slotSubdivide()\n";
    _octree->OctreeParticleSystemEngine::subdivideRecDeformed( getSelectedCell() );
}

void DeformableOctreeParticleSystemNode::slotSimplify()
{
    _octree->OctreeParticleSystemEngine::simplify(getSelectedCell());
    //updateGL();
}



animal::ConstrainedItem* DeformableOctreeParticleSystemNode::pickPoint( float* origin, float* direction, float threshold )
{
    //std::cerr << "DeformableOctreeNode::pickPoint()\n";

    if( _dosn )
    {
        X3D::Coordinate* coord = _dosn->getCoordinate();

        int index;
        float distance;
        SFVec3f lineOrigin(origin[0], origin[1], origin[2]);
        SFVec3f lineDirection(direction[0],direction[1],direction[2]);
        //cout<<"ParticleSystemNode::pickPoint"<<endl;

        if( animal::findClosestPointToLine( index, distance, coord->getPoint(), lineOrigin, lineDirection, threshold ) )
        {
            ManipulatedMeshVertexAnimated * c = new ManipulatedMeshVertexAnimated( this, &coord->getPoint()[index]);
            return c;
        }
        else
        {
            return NULL;
        }
    }
    else
    {
        return NULL;
    }

}




};

};

---