source/IpsaSimulator.cpp

Go to the documentation of this file.

/*
 *  IpsaSimulator.cpp
 *
 * Copyright (c) 2012, Karlsruhe Institute of Technology (Manfred Kroehnert)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "../include/IPSA/IpsaSimulator.h"
#include "../include/IPSA/IpsaSimulatorDelegate.h"
#include "../include/IPSA/ipsaclasses.h"

#include <iostream>

#include <Inventor/SoDB.h>
#include <Inventor/SoInput.h>
#include <Inventor/SoFullPath.h>
#include <Inventor/nodes/SoFile.h>
#include <Inventor/nodes/SoGroup.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/actions/SoSearchAction.h>
#include <Inventor/actions/SoWriteAction.h>
#include <Inventor/lists/SbPList.h>
#include <Inventor/lists/SoPathList.h>

IpsaSimulator::IpsaSimulator() :
    verboseOutput(true),
    isIpsaScheduled(false),
    sceneryFilename(""),
    simulationRoot(new SoSeparator),
    delegate(NULL)
{
    SoWorldPhysics::initClasses();
}


IpsaSimulator::~IpsaSimulator()
{
    SoWorldPhysics::DeInit();
}


void IpsaSimulator::setDelegate(IpsaSimulatorDelegate* delegate)
{
    this->delegate = delegate;
}


SoNode* IpsaSimulator::getSceneGraph()
{
    return simulationRoot;
}


bool IpsaSimulator::buildScenery()
{
    SoNode* root = NULL;
    if (delegate)
        root = delegate->createScenery();
    else
        root = readSceneryFromFile();

    if (!root)
        return false;

    root->ref();
    simulationRoot = createPhysicsWorldIfMissing(root);
    root->unref();

    if (!simulationRoot)
        return false;

    this->applyPrefixNodes();

    SoWorldPhysics::ApplyActionToWorldPhysicNodesInGraph(SoWorldPhysics::InitialiseWorldCB, simulationRoot);

    return true;
}


SoNode* IpsaSimulator::readSceneryFromFile(bool expandFileNodesInGraph /*=true*/)
{
    if (this->sceneryFilename.empty())
        return NULL;

    SoInput mySceneInput;
    if (!mySceneInput.openFile(this->sceneryFilename.c_str()))
    {
        std::cerr << "Cannot open file " << this->sceneryFilename << std::endl;
        return NULL;
    }

    // Read the whole file into the database
    SoNode* root = SoDB::readAll(&mySceneInput);
    mySceneInput.closeFile();

    if (NULL == root)
    {
        std::cerr
                << "[IpsaSimulator::readSceneryFromFile()] Problem reading file "
                << this->sceneryFilename << std::endl;
        return NULL;
    }

    root->ref();

    if (expandFileNodesInGraph)
        IpsaSimulator::ExpandFileNodes(root);

    root->unrefNoDelete();

    return root;
}


SoSeparator* IpsaSimulator::createPhysicsWorldIfMissing(SoNode* root)
{
    if (NULL == root)
        return NULL;
    SoSearchAction sa;
    sa.setType(SoWorldPhysics::getClassTypeId());
    sa.setSearchingAll(TRUE);

    sa.apply(root);

    if (NULL != sa.getPath())
    {
        // At least one SoWorldPhysics is present
        SoSeparator* world = new SoSeparator();
        world->addChild(root);
        return world;
    }

    SoSeparator* worldPhysics = new SoWorldPhysics("DefaultWorld");
    worldPhysics->addChild(root);

    std::cerr << std::endl
            << "*******************************************************************************"
            << std::endl
            << "*  Default SoWorldPhysics created because none was found in the Inventor Graph."
            << std::endl << "*  Did you forget to specify one?" << std::endl
            << "*******************************************************************************"
            << std::endl << std::endl;

    return worldPhysics;
}


void IpsaSimulator::applyPrefixNodes()
{
    SoSearchAction sa;
    sa.setType(SoPrefixNode::getClassTypeId());
    sa.setInterest(SoSearchAction::ALL);
    sa.setSearchingAll(TRUE);

    sa.apply(simulationRoot);

    SoPathList pList = sa.getPaths();

    for (int i = 0; i < pList.getLength(); i++)
    {
        SoPath* path = (pList[i]);
        if (NULL == path)
            continue;
        SoPrefixNode* prefixNode = dynamic_cast<SoPrefixNode*> (path->getTail());
        prefixNode->updatePrefixes();
    }
}


void IpsaSimulator::ExpandFileNodes(SoNode* root)
{
    root->ref();
    //
    // Special case: if root is a file node, replace it with a group.
    //
    if (root->isOfType(SoFile::getClassTypeId()))
    {
        SoFile *f = dynamic_cast<SoFile*> (root);
        SoGroup *g = f->copyChildren();
        root->unref();
        root = dynamic_cast<SoSeparator*> (g);
        root->ref();
    }

    // Search for all file nodes
    SoSearchAction sa;
    sa.setType(SoFile::getClassTypeId());
    sa.setInterest(SoSearchAction::FIRST);
    sa.setSearchingAll(TRUE);

    sa.apply(root);

    // We'll keep on searching until there are no more file nodes
    // left.  We don't search for all file nodes at once, because we
    // need to modify the scene graph, and so the paths returned may
    // be truncated (if there are several file nodes under a group, if
    // there are files within files, etc).  Dealing properly with that
    // is complicated-- it is easier (but slower) to just reapply the
    // search until it fails.
    // We need an SoFullPath here because we're searching node kit
    // contents.
    SoFullPath *p = (SoFullPath *) sa.getPath();
    while (p != NULL)
    {
        SoGroup *parent = (SoGroup *) p->getNodeFromTail(1);
        assert(parent != NULL);

        SoFile *file = (SoFile *) p->getTail();

        // If the filename includes a directory path, add the directory name
        // to the list of directories where to look for input files
        SbString filename = file->name.getValue();

        printf("OI: expanding file %s\n", filename.getString());

        int slashIndex = filename.find("/");
        if (-1 != slashIndex)
        {
            SbString searchPath = filename.getSubString(0, slashIndex - 1);
            SoInput::addDirectoryFirst(searchPath.getString());
        }

        int fileIndex = p->getIndexFromTail(0);
        assert(fileIndex != -1);

        // Now, add group of all children to file's parent's list of children,
        // right after the file node:
        SoGroup *fileGroup = file->copyChildren();
        fileGroup->ref();
        if (fileGroup != NULL)
        {
            parent->insertChild(fileGroup, fileIndex + 1);
        }
        else
        {
            // So we can at least see where the file node contents were
            // supposed to go.
            parent->insertChild(new SoGroup, fileIndex + 1);
        }

        // And expand the child node from the group.
        // Note that if the File node is multiply instanced,
        // the groups will not be instanced, but the children of the
        // groups will be.
        parent->removeChild(fileIndex);

        sa.apply(root);
        p = (SoFullPath *) sa.getPath();
    }
    root->unrefNoDelete(); // never delete after expansion
}


void IpsaSimulator::reload()
{
    // unschedule first
    if (isIpsaScheduled)
        this->schedule();

    SoWorldPhysics::DeInit();

    // delete scene
    SoSeparator* scene = dynamic_cast<SoSeparator*>(simulationRoot);
    if (NULL != scene)
        scene->removeAllChildren();

    // rebuild scene
    this->buildScenery();
    SoWorldPhysics::Init();
}


void IpsaSimulator::reset()
{
    // unschedule first
    if (isIpsaScheduled)
        this->schedule();

    SoWorldPhysics::ApplyActionToWorldPhysicNodesInGraph(SoWorldPhysics::ResetWorldCB, simulationRoot);
}


void IpsaSimulator::save(const std::string& saveFile)
{
    if (saveFile.empty())
        return;

    printf("Saving scenegraph to file: %s\n", saveFile.c_str());
    SoOutput out;
    out.openFile(saveFile.c_str());
    SoWriteAction wa(&out);
    wa.apply(simulationRoot);
    out.closeFile();
}


void IpsaSimulator::schedule()
{
    if (isIpsaScheduled)
    {
        SoWorldPhysics::ApplyActionToWorldPhysicNodesInGraph(
                SoWorldPhysics::UnscheduleWorldCB,
                simulationRoot);
        isIpsaScheduled = false;
    }
    else
    {
        SoWorldPhysics::ApplyActionToWorldPhysicNodesInGraph(
                SoWorldPhysics::ScheduleWorldCB,
                simulationRoot);
        isIpsaScheduled = true;
    }
}

---