AnimaL

Tutorial

Documentation

---

Documentation

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

---

mainScene.cpp

Go to the documentation of this file.

//                            mainScene.cpp                                   //

#include <X3DTK/memreleaser.h>
#include <X3DTK/X3D/scenegraph.h>
#include <X3DTK/X3D/glbuilder.h>
#include <X3DTK/X3D/scenesaver.h>
#include <X3DTK/X3D/bboxupdater.h>
//debug
//#include <X3DTK/graphtester.h>

//#include <animal/X3DTK/X3D/engine/engineRemover.h>
#include <animal/X3DTK/X3D/engine/engineWalker.h>
#include <animal/X3DTK/X3D/engine/engineLoaderVisitor.h>
#include <animal/X3DTK/X3D/engine/engineLoader.h>
#include <animal/X3DTK/X3D/engine/glBuilderEngineNodeVisitor.h>
#include <animal/X3DTK/Qt/mainControllerGUI/MainController.h>
#include <animal/engine/engine.h>
#include <animal/event/keyEvent.h>
#include <animal/event/mouseEvent.h>
#include <animal/X3DTK/X3D/massSpringNode/massSpringNode.h>

#include "mainScene.h"
#include <iostream>
using std::cout;
using std::endl;
using std::cerr;


namespace X3DTK
{

MainScene::MainScene()
        : x3dscene(NULL)
        , glscene(NULL)
        , x3dloader(NULL)
        , mainController(NULL)
        , m_selectedNode(NULL)
{
    // Init all the processors
    engineLoader = new X3D::EngineLoader(&allEngineNodes, &kinematicEngines, &dynamicEngines, &collisionEngines);
    //bboxupdater = new X3D::BBoxUpdater();
/*    builder = new  X3D::GLBuilder();
    builder->setComponentVisitor(new X3D::GLBuilderEngineNodeVisitor());*/
//    renderer = new  GL::MyRenderer();
//    releaser = new  MemReleaser();
//    x3dGLMapBuilder = new  GL::X3DGLMapBuilder();

    // Create the x3d scene, the root x3d node
    x3dscene = new X3D::Scene();
    bbupdater = new X3D::BBoxUpdater();
    buildGL();

}

MainScene:: ~MainScene()
{
    releaseNode(x3dscene);
    releaseNode(glscene);
    x3dscene = NULL;
    glscene = NULL;

    if (x3dloader)
    {
        //delete x3dloader;
        x3dloader = NULL;
    }
/*    if (bboxupdater)
    {
        delete bboxupdater;
        bboxupdater = NULL;
    }*/
/*    if (builder)
    {
        delete builder;
        builder = NULL;
    }*/
/*    if (renderer)
    {
        delete renderer;
        renderer = NULL;
    }*/
/*    if (releaser)
    {
        delete releaser;
        releaser = NULL;
    }*/
/*    if (engineLoaderVisitor)
    {
        delete engineLoaderVisitor;
        engineLoaderVisitor = NULL;
    }*/
//     if (engineLoader)
//     {
//         delete engineLoader;
//         engineLoader = NULL;
//     }

}


void MainScene::load(const char *file, bool fileValidation)
{
    // Load the x3d scene file
    if (!x3dloader)
    {
        std::cerr<<"Warning MainScene::load(): impossible to load because the x3dloader is NULL."<<std::endl;
        return;
    }
    releaseNode(x3dscene);
    x3dscene = NULL;
    x3dscene = x3dloader->load(file, fileValidation);

    // Create the list of engines
    engineLoader->initialize(x3dscene);

    // Reload the gl graph
    buildGL();

}

void MainScene::load(const char *file, X3D::X3DNode * node, bool fileValidation)
{
    if (!node)
    {
        std::cerr<< "Warning: impossible to insert. The node from where you want to insert new nodes is NULL."<< std::endl;
        return;
    }

    if (node && dynamic_cast<X3D::X3DGroupingNode *>(node) == NULL)
    {
        std::cerr<< "Warning: impossible to insert. The node from where you want to insert new nodes is not an X3D::X3DGroupingNode."<< std::endl;
        return;
    }

    // Load the x3d scene file
    if (!x3dloader)
    {
        std::cerr<<"Warning MainScene::load(): impossible to load because the x3dloader is NULL."<<std::endl;
        return;
    }
    X3D::Scene * sceneTmp = x3dloader->load(file, fileValidation);

    // Get all the children of the sceneTmp
    MFNode childrenList = sceneTmp->getChildren();
    for(MFNode::iterator it = childrenList.begin(); it != childrenList.end();++it)
    {
        engineLoader->initialize(*it);
        pastNode((*it), node);
    }

    delete  sceneTmp;
}

bool MainScene::pastNode(X3DAbstractNode* node, X3DAbstractNode* parentNode)
{
    if (!node)
    {
        std::cerr<< "Warning MainScene::pastNode(): impossible to past. The node you want to past is NULL."<< std::endl;
        return false;
    }

    if (!parentNode)
    {
        std::cerr<< "Warning MainScene::pastNode(): impossible to past. The parent node where you want to past a node is NULL."<< std::endl;
        return false;
    }

    if (isADescendant(parentNode, node))
    {
        std::cerr<< "Warning MainScene::pastNode(): impossible to past. The parentNode is a descendant of the node you want to past."<< std::endl;
        return false;
    }

    if (parentNode && dynamic_cast<X3D::X3DGroupingNode *>(parentNode) == NULL)
    {
        std::cerr<< "Warning MainScene::pastNode(): impossible to past. The node from where you want to past new nodes is not an X3D::X3DGroupingNode."<< std::endl;
        return false;
    }

    parentNode->setChild(node);

    // Add the name of the node in the DEFDic
    SFString s = node->getName();//X3DAbstractNode::DEFDict.getNameOfNode(node);
    if (s=="")
    {
        node->setName(node->getType()->getName());
    }

    // Load the new engines contain in the x3d node
    engineLoader->initialize(node);

    // Reload the gl graph
    buildGL();

    return true;
}

bool MainScene::cutNode(X3DAbstractNode* node, X3DAbstractNode* parentNode)
{
    if (!node)
    {
        std::cerr<< "Warning MainScene::cutNode(): impossible to cut. The node you want to cut is NULL."<< std::endl;
        return false;
    }

    if (dynamic_cast<X3D::X3DChildNode *>(node) == NULL)
    {
        std::cerr<< "Warning MainScene::cutNode(): impossible to cut. The node you want to cut is not an X3D::X3DChildNode."<< std::endl;
        return false;
    }

    engineLoader->release(node);
    if (parentNode)
    {
        // Remove the link
        parentNode->removeChild(node);

        //         MFNode parentList = node->getParentList();
        //         // Get the engines contain in the x3d node and remove them
        //         if(parentList.size()== 0)
        //         {
        //             engineLoader->release(node);
        //         }

    }
    else if (x3dscene==node)
    {
        // Get all the children of the scene and delete it
        MFNode childrenList = x3dscene->getChildren();
        for(MFNode::iterator it = childrenList.begin(); it != childrenList.end();++it)
        {
            // Delete the node
            deleteNode(*it, x3dscene);
        }
    }

    // Reload the gl graph
    buildGL();

    return true;

}

void MainScene::deleteNode(X3DAbstractNode* node, X3DAbstractNode* parentNode)
{
    if(cutNode(node, parentNode))
    {
        // Get all the children of the x3d node
        // and remove the link between the x3d node
        // and its corresponding QWidget in
        // the main GUI and delete the QWidget
        if (mainController && !isADescendant(node, x3dscene))
        {
            MFNode childrenList = node->getChildList();
            for(MFNode::iterator it = childrenList.begin(); it != childrenList.end();++it)
                mainController->removeX3DQtMap(dynamic_cast<X3D::X3DNode *>(*it));
            mainController->removeX3DQtMap(node);
        }

        // release the x3d node
        releaseNode(node);
    }
}

void MainScene::releaseNode(X3DAbstractNode* node)
{
    if (node==x3dscene)
    {
        // Get all the children of the scene and delete them
        MFNode childrenList = x3dscene->getChildren();
        for(MFNode::iterator it = childrenList.begin(); it != childrenList.end();++it)
            deleteNode(*it, x3dscene);
    }
    else
    {
        if( X3D::EngineNode* e=dynamic_cast<X3D::EngineNode*>(node) )
        {
            glUpdates.erase(e);
        }
        MemReleaser releaser;
        releaser.release(node);
    }
}

void MainScene::draw()
{
    //std::cerr<< " MainScene::draw()" <<std::endl;

    // Draw the engines which doesn't have a corresponding x3d node
    for( AnimalEngines::iterator i=animalEngines.begin(); i!=animalEngines.end(); ++i )
    {
        if((*i)->drawEngine)
            (*i)->draw();
        if((*i)->drawBBox)
            (*i)->drawBoundingBox();
    }
    
    if (glscene)
    {
        // Draw the gl scene
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        //GL::MyRenderer renderer;
        renderer.render(glscene);
        glPopAttrib();
    }
}

void MainScene::save(const char *file)
{
    //Close the engine nodes
    for( X3D::EngineNodes::iterator i= allEngineNodes.begin(); i!=allEngineNodes.end(); ++i )
        (*i)->close();
      
    for( X3D::EngineNodes::reverse_iterator i= allEngineNodes.rbegin(); i!=allEngineNodes.rend(); ++i )
        (*i)->postClose();
    
    X3D::SceneSaver sceneSaver;
    sceneSaver.saveAs(x3dscene, file);
}

void MainScene::reset()
{
    //Init the animalEngines
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        if((*i)->resetEngine)
            (*i)->reset();

    //Init the engine nodes
    for( X3D::EngineNodes::iterator i= allEngineNodes.begin(); i!=allEngineNodes.end(); ++i )
        (*i)->reset();
      
    for( X3D::EngineNodes::reverse_iterator i= allEngineNodes.rbegin(); i!=allEngineNodes.rend(); ++i )
        (*i)->postReset();

    updateGL();
}

void MainScene::move(double dt)
{
    //std::cerr<< "MainScene::move()" << std::endl;

    // Move the animal::engines
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        if ((*i)->moveEngine)
            (*i)->move(dt);
    // Move the engine nodes
    for( X3D::EngineNodes::iterator i= allEngineNodes.begin(); i!=allEngineNodes.end(); ++i )
    {
        if( (*i)->m_animate ) 
            (*i)->animate(dt);
    }
    for( X3D::EngineNodes::reverse_iterator i= allEngineNodes.rbegin(); i!=allEngineNodes.rend(); ++i )
    {
        if( (*i)->m_animate ) 
            (*i)->postAnimate(dt);
    }
    
    updateGL();
}

bool MainScene::computeBbox()
{

    //std::cerr<<"MainScene::computeBbox()"<<std::endl;

    for( X3D::EngineNodes::iterator i= allEngineNodes.begin(); i!=allEngineNodes.end(); ++i )
    {
        (*i)->updateBoundingBox();
        //std::cerr<<"update bounding box of engine "<<(*i)->getName() << endl;
    }
    
    // Bounding box of the x3d scene
    bbupdater->update(x3dscene);
    SFVec3f center = x3dscene->getBBoxCenter();
    SFVec3f size = x3dscene->getBBoxSize();

    SFVec3f A = center + 0.5f*size;
    SFVec3f B = center - 0.5f*size;

    if (A.x < B.x)
    {
        min.x = A.x;
        max.x = B.x;
    }
    else
    {
        min.x = B.x;
        max.x = A.x;
    }

    if (A.y < B.y)
    {
        min.y = A.y;
        max.y = B.y;
    }
    else
    {
        min.y = B.y;
        max.y = A.y;
    }

    if (A.z < B.z)
    {
        min.z = A.z;
        max.z = B.z;
    }
    else
    {
        min.z = B.z;
        max.z = A.z;
    }
    //cerr<<"MainScene::computeBbox graph "<< min.x <<", "<< min.y <<", "<<min.z<<", "<<max.x<<", "<<max.y<<", "<<max.z<<endl;;

    float minX, minY, minZ, maxX, maxY, maxZ;
    // Bounding box of all the engines
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
    {
        (*i)->getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
        if (minX < min.x)
            min.x = minX;
        if (minY < min.y)
            min.y = minY;
        if (minZ < min.z)
            min.z = minZ;
        if (max.x < maxX)
            max.x = maxX;
        if (max.y < maxY)
            max.y = maxY;
        if (max.z < maxZ)
            max.z = maxZ;
    }

    //cout<<"MainScene::computeBbox total "<< min.x <<", "<< min.y <<", "<<min.z<<", "<<max.x<<", "<<max.y<<", "<<max.z<<endl;;
    return true;
}

//====================== Manage engines
void MainScene::addEngine( animal::Engine * engine)
{
    animalEngines.push_back(engine);
    engine->init();
    computeBbox();
}

void MainScene::removeEngine(animal::Engine* engine)
{
    animalEngines.remove(engine);
    computeBbox();
}

void MainScene::clearEngines()
{
    animalEngines.clear();
    computeBbox();
}

void MainScene::updateGL()
{
    for( GLUpdates::iterator u=glUpdates.begin(); u!=glUpdates.end(); ++u )
    {
        for( GLNodeList::iterator g=(*u).second.begin(); g!=(*u).second.end(); ++g )
        {
            (*g)->update();
        }
    }
    computeBbox();
    //  std::cerr<<"MainScene::updateGL() - end -------------------------------------------------"<<std::endl;
}

void MainScene::buildGL()
{
    //std::cout<<"MainScene::buildGL start " << std::endl;
    // Build the glscene from the x3dscene
    releaseNode(glscene);
    glscene = NULL;
    X3D::GLBuilder builder;
    builder.setComponentVisitor(new X3D::GLBuilderEngineNodeVisitor());
    glscene = builder.build(x3dscene);

    // Update the list glNodeToUpdate
    GL::X3DGLMapBuilder x3dGLMapBuilder;
    x3dGLMap = *x3dGLMapBuilder.build(glscene);
    glUpdates.clear();

    // Find the nodes modified by the engines
    for( X3DGLMap::iterator i= x3dGLMap.begin(); i!=x3dGLMap.end(); ++i )
    {
       //std::cout<<"MainScene::buildGL found node named "<<(*i).first->getName() << std::endl;
       X3DTK::X3D::EngineNode* engineNode = dynamic_cast<X3DTK::X3D::EngineNode*>((*i).first);
        if(engineNode)
        {
            //std::cout<<"MainScene::buildGL found engine node named "<<engineNode->getName() << std::endl;
            typedef X3DTK::X3D::X3D_X3DNodeList NodeList;
            NodeList outputs;
            outputs.clear();
            engineNode->declareOutputs(outputs);
            //std::cout<<"this node has "<<outputs.size()<<" outputs"<< std::endl;
            for(NodeList::iterator n=outputs.begin(); n!=outputs.end(); ++n )
            {
                if( X3DTK::X3D::Coordinate* c = dynamic_cast<X3DTK::X3D::Coordinate*>(*n) )
                {
                    // find the Geometry nodes linked to this Coordinate node
                    MFNode parents = c->getParentList();
                    for( MFNode::iterator p=parents.begin(); p!=parents.end(); ++p)
                    {
                        if( X3DTK::X3D::X3DGeometryNode* g = dynamic_cast<X3DTK::X3D::X3DGeometryNode*>(*p) )
                        {
                            // add its corresponding gl nodes to the list glNodeToUpdate
                            for (std::list<GL::X3DNode *>::iterator i= x3dGLMap[g].begin(); i!=x3dGLMap[g].end(); ++i)
                            {
                                //std::cout<<"MainScene::buildGL, geometry node named "<<(*i)->getX3DReference()->getName() <<" to update"<<std::endl;
                                glUpdates[engineNode].push_back(*i);
                            }
                        }
                    }
                }
                else if( X3DTK::X3D::Transform* t = dynamic_cast<X3DTK::X3D::Transform*>(*n) )
                {
                    // add its corresponding gl nodes to the list glNodeToUpdate
                    for (std::list<GL::X3DNode *>::iterator i= x3dGLMap[t].begin(); i!=x3dGLMap[t].end(); ++i)
                    {
                        //std::cout<<"MainScene::buildGL, transform node named "<<(*i)->getX3DReference()->getName() <<" to update"<<std::endl;
                        glUpdates[engineNode].push_back(*i);
                    }
                }
                else if( dynamic_cast<X3DTK::X3D::MassSpringNode*>(*n) )
                {
                    // nothing to do
                }
                else
                {
/*                    std::cout<<"MainScene::buildGL, engine "<< engineNode->getName();
                    std::cout <<", can not find gl update to perform for output "<< (*n)->getName() << std::endl;*/
                    std::cout<<"MainScene::buildGL, can not find gl update to perform for output "<< (*n)->getName() << std::endl;
                }
            }

        }
        else
        {
            /*            std::cout<<"MainScene::buildGL found non-engine node named "<<(*i).first->getName() << std::endl;*/
        }
    }

}


bool MainScene::isADescendant(X3DAbstractNode* node1, X3DAbstractNode* node2)
{
    if (node1 == node2)
        return true;

    if (!node2 || !node1)
        return false;

    MFNode childrenList = node2->getChildList();
    for(MFNode::iterator it = childrenList.begin(); it != childrenList.end();++it)
        if(isADescendant(node1,static_cast<X3DTK::X3D::X3DNode*>(*it)))
            return true;
    return false;
}

//-----------Mouse and key board events-------------
void MainScene::keyPressEvent(animal::KeyEvent *e)
{
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        (*i)->keyPressEvent(e);
}

void MainScene::mouseDoubleClickEvent(animal::MouseEvent * e)
{
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        (*i)->mouseDoubleClickEvent(e);
}

void MainScene::mouseMoveEvent(animal::MouseEvent * e)
{
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        (*i)->mouseMoveEvent(e);
}

void MainScene::mousePressEvent(animal::MouseEvent * e)
{
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        (*i)->mousePressEvent(e);
}

void MainScene::mouseReleaseEvent(animal::MouseEvent * e)
{
    for( AnimalEngines::iterator i= animalEngines.begin(); i!=animalEngines.end(); ++i )
        (*i)->mouseReleaseEvent(e);
}
//-----------End of mouse and key board events-------------

// ----------  FF: picking -----------------------------
animal::ConstrainedItem* MainScene::pickPoint(float origin[3], float direction[3],
        float threshold )
{
    animal::ConstrainedItem* item = 0;

    //std::cout<<"MainScene::pickPoint"<<std::endl;
    AnimalEngines::iterator e=animalEngines.begin(), eend=animalEngines.end();
    while( e != eend && item==0 )
    {
        //std::cout<<"MainScene::pickPoint engine" << std::endl;
        item = (*e)->pickPoint( origin, direction, threshold );
        ++e;
    }

    X3D::EngineNodes::iterator en=allEngineNodes.begin(), enend=allEngineNodes.end();
    while( en != enend && item==0 )
    {
        //std::cout<<"MainScene::pickPoint engine" << std::endl;
        item = (*en)->pickPoint( origin, direction, threshold );
        ++en;
    }
/*    if(item) cout<<"MainScene::pickPoint, found !!"<<endl;
    else cout<<"MainScene::pickPoint, nothing !!"<<endl;*/
    return item;
}
// ----------  end FF: picking -----------------------------

   void MainScene::setSelectedNode( X3D::X3DBoundedObject * n )
   {
       m_selectedNode = n;
        renderer.setBoundedObject(m_selectedNode);
   }


}// X3DTK

---