OMKOgreVis.cpp

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
#include "OMKOgreVis.h"
#include "OMKUniqueConfigurationParameter.h"
#include "dotSceneInterface.h"
#include "OgreWindowEventUtilities.h"
#include "OBTSingleton.h"

using namespace OBT ;
using namespace OMK ;
using namespace OMK::Vis ;
using namespace Ogre ;

class LogOutput : public TracerOutput
{
public:
        LogOutput() {}
        virtual ~LogOutput() {}
        virtual void trace( const std::string& msg ) 
        { 
                Ogre::LogManager::getSingleton().logMessage( msg ) ; \
        }
} ;


REGISTER_OBJECT_FACTORY( OgreVis, "OgreVis" ) ;

//-------------------------------------------------------------------------
// constructor
//-------------------------------------------------------------------------
OgreVis::OgreVis( OMK::Controller& ctrl, const ObjectDescriptor& objectDescriptor )
:
VisBase( ctrl, objectDescriptor ),
_root( NULL )
{
}

//-------------------------------------------------------------------------
// destructor
//-------------------------------------------------------------------------
OgreVis::~OgreVis( void )
{
#if !defined NDEBUG 
        // reset the trace output to the console
        OBT::Singleton<OBT::Tracer>::getInstance().setOutput( 0, false ) ;
#endif

        // destroy camera, scene manager and root
        if( _root ) 
        {
                Ogre::SceneManager* sceneManager( _root->getSceneManager( "sceneManager" ) ) ;
                if( sceneManager ) 
                {
                        _root->destroySceneManager( sceneManager ) ;
                }
        }
        delete _root ;
}

//-------------------------------------------------------------------------
// loadConfigurationParameters
//-------------------------------------------------------------------------
bool 
OgreVis::loadParameters( const ConfigurationParameterDescriptor * node )
{
        bool ok( VisBase::loadParameters( node ) );

        // Retrieve the plugins for Ogre
        std::string pluginsFile ;
        if( ParametersAccessor::get( node, "OgreHome", pluginsFile ) )
        {
#if defined _MSC_VER
                // Windows
#  if defined NDEBUG 
                pluginsFile += "\\bin\\release\\Plugins.cfg" ;
#  else // !defined NDEBUG 
                pluginsFile += "\\bin\\debug\\Plugins.cfg" ;
#  endif
#else
    // Linux 
    pluginsFile += "/lib/OGRE/Plugins.cfg" ;
#endif
        }
        else if( !ParametersAccessor::get( node, "PluginsCfg", pluginsFile ) )
        {
                OMERROR( "Error for " << debugMsg( this ) << std::endl
                        << ">>> :-( Unable to determine which configuration must be used for Ogre." << std::endl
                        << "One of these two fields, 'OgreHome' or 'PluginsCfg', must be set." << std::endl
                        << "The path to the Ogre folder is defined in 'OgreHome' like this : OgreHome \"${OGRE_HOME}\"" << std::endl
                        << "Or the configuration file path is defined in 'OgrePluginsCfg' like this : PluginsCfg \"${OGRE_HOME}/lib/OGRE/plugins.cfg\"" << std::endl
                        << "See documentation" ) ;
                ok = false ;
        }

        if ( ok )
        {
                // Retrieve the configuration file
                std::string configFile( "ogre.cfg" ) ;
                if( !ParametersAccessor::get( node, "ConfigFile", configFile ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no configuration file provided, will use \"ogre.cfg\" by default" ) ; 
                }

                // Retrieve the resource configuration
                std::string resourcesFile( "resources.cfg" ) ;
                if( !ParametersAccessor::get( node, "ResourcesFile", resourcesFile ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no resources file provided, will use \"resources.cfg\" by default" ) ; 
                }

                // Retrieve the resource group name
                std::string resourceGroupName( "General" ) ; // default value
                if( !ParametersAccessor::get( node, "ResourceGroup", resourceGroupName ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no resource group name provided, will use \"General\" by default" ) ; 
                }

                // Retrieve scene file name
                std::string sceneFileName ;
                if( !ParametersAccessor::get( node, "SceneFile", sceneFileName ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no scene file name provided" ) ; 
                }

                // Retrieve camera name
                std::string cameraName ;
                if( !ParametersAccessor::get( node, "Camera", cameraName ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no camera name provided" ) ; 
                }

                // Retrieve sceneManagerType
                std::string sceneManagerType( "DefaultSceneManager" ) ;
                if( !ParametersAccessor::get( node, "SceneManagerType", sceneManagerType ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no SceneManagerType provided" ) ; 
                }

                // Retrieve windowName
                std::string windowName( "Ogre Window" ) ;
                if( !ParametersAccessor::get( node, "WindowName", windowName ) )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| no WindowName provided" ) ; 
                }

   // createLog 

                // OGRE initialisation
                ok = ogreInitialisation( pluginsFile, configFile, resourcesFile, sceneManagerType, windowName ) ;
                if ( ok )
                {
                        // load the dotScene file of configuration parameters "SceneFile" 
                        // and resource group "ResourceGroup"
                        loadSceneFile( resourceGroupName, sceneFileName ) ;

                        if ( _root->getAutoCreatedWindow()->getNumViewports() == 0 )
                        {
                                // try to initialise the camera named "Camera"
                                // if cameraName was not specified a default camera is created
                                cameraName = initCamera( cameraName ) ;


                                // creates a default viewport of colour (0.5,0.5,0.5)
                                createViewport( cameraName ) ;
                        }
                }
        }

        return ok ;
}

//-------------------------------------------------------------------------
// compute
//-------------------------------------------------------------------------
void 
OgreVis::computeParameters()
{
        VisBase::computeParameters() ;

        //Allow platform to pump/create/etc messages/events once per frame 
        Ogre::WindowEventUtilities::messagePump( ) ; 
        _root->renderOneFrame() ;
}

//-------------------------------------------------------------------------
// initialise
//-------------------------------------------------------------------------
bool 
OgreVis::ogreInitialisation(    const std::string& pluginsFile, 
                                                        const std::string& configurationFile, 
                                                        const std::string& resourcesFile,
                                                        const std::string& sceneManagerType,
                                                        const std::string& windowName )
{
        bool initialised( false ) ;

        // creation of Ogre Root
        _root = new Ogre::Root( pluginsFile, configurationFile, "" ) ;

        // add resource locations
        addResourceLocations( resourcesFile );

        // Show the configuration dialog and initialise the system
        // You can skip this and use root.restoreConfig() to load configuration
        // settings if you were sure there are valid ones saved in ogre.cfg
        if( ( _root->restoreConfig() == true ) || ( _root->showConfigDialog() == true ) )
        {
                // If returned true, user clicked OK so initialise
                // Here we choose to let the system create a default rendering window by passing 'true'
                _root->initialise( true, windowName ) ;

                // creates a sceneManager named "sceneManager" of type ST_GENERIC
                createSceneManager( sceneManagerType ) ;

                // Set default mipmap level (NB some APIs ignore this)
                TextureManager::getSingleton().setDefaultNumMipmaps( 5 ) ;

                // Create any resource listeners (for loading screens)
                createResourceListener() ;

                // Initialise resources
                initResources();

#if !defined NDEBUG 
                // Initialise the trace output to the console
                OBT::Singleton<OBT::Tracer>::getInstance().setOutput( new LogOutput, true ) ;
#endif

                initialised = true ;
        }

        return initialised ;
}

//-------------------------------------------------------------------------
// createSceneManager
//-------------------------------------------------------------------------
void 
OgreVis::createSceneManager( const std::string& sceneManagerType )
{
        try
        {
                // Create the SceneManager
                _root->createSceneManager( sceneManagerType, "sceneManager" ) ;
        }
        catch ( Ogre::ItemIdentityException& e )
        {
                OMFATALERROR( "Scene manager type : " << sceneManagerType << " does not exist" << std::endl 
                        << e.getFullDescription() ) ;
        }
}

//-------------------------------------------------------------------------
// createResourceListener
//-------------------------------------------------------------------------
void 
OgreVis::createResourceListener( void )
{
}

//-------------------------------------------------------------------------
// addResourceLocations
//-------------------------------------------------------------------------
void 
OgreVis::addResourceLocations( const std::string& resourcesFile )
{
        // Load resource paths from config file
        ConfigFile configFile ;
        configFile.load( resourcesFile ) ;

        // Go through all sections & settings in the file
        ConfigFile::SectionIterator sectionIterator( configFile.getSectionIterator() ) ;

        String sectionName ;
        String typeName ;
        String archName ;
        while ( sectionIterator.hasMoreElements() == true )
        {
                sectionName = sectionIterator.peekNextKey();
                ConfigFile::SettingsMultiMap* settings( sectionIterator.getNext() ) ;
                for ( ConfigFile::SettingsMultiMap::iterator i( settings->begin() ) ; i != settings->end(); ++i )
                {
                        typeName = i->first ;
                        archName = i->second ;
                        ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, sectionName ) ;
                }
        }
}

//-------------------------------------------------------------------------
// initResources
//-------------------------------------------------------------------------
void 
OgreVis::initResources( void )
{
        ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
}

//-------------------------------------------------------------------------
// loadSceneFile
//-------------------------------------------------------------------------
void
OgreVis::loadSceneFile( const std::string& resourceGroupName, const std::string& sceneFileName )
{
        if ( sceneFileName.empty() == false )
        {
                // load the scene associated to the simulated object OgreVis
                OBT::Singleton<dsi::dotSceneLoader>::getInstance().load
                        (       sceneFileName, 
                                resourceGroupName, 
                                _root->getSceneManager( "sceneManager" ), 
                                _root->getAutoCreatedWindow(), 
                                NULL, 
                                false, 
                                false, 
                                true ) ;

                // check for load errors
                dsi::dotSceneInfo::itLoadLog it( dsi::dotSceneInfo::getSceneLoadingLog() ) ;
                String errs ;
                while ( it.hasMoreElements() )
                {
                        errs += it.getNext() + "\n";
                }
                if ( errs != StringUtil::BLANK )
                {
                        OMTRACEID( OMK_DEBUG_VIS, "Warning for " << debugMsg( this ) << std::endl
                                << ">>> :-| errors occured during scene loading\n" << errs ) ;
                }
        }
}

//-------------------------------------------------------------------------
// initCamera
//-------------------------------------------------------------------------
const std::string&
OgreVis::initCamera( const std::string& cameraName )
{
        Ogre::SceneManager* sceneManager( _root->getSceneManager( "sceneManager" ) ) ;
        // creates a default camera if cameraName does not exist        
        if ( sceneManager->hasCamera( cameraName ) == false )
        {

                // Create the camera
                Camera* camera( sceneManager->createCamera( "camera0" ) ) ;
                // Position it at 0, 0, 0
                camera->setPosition( Vector3( 0, 0, 0 ) ) ;
                // Look back along -Z
                camera->lookAt( Vector3( 0, 0, -1 ) ) ;
                camera->setNearClipDistance( 1 ) ;
                camera->setFarClipDistance( 5000 ) ;
                
                //Put Camera on Node, useful for SoundListener 
                SceneNode* cameraNode( sceneManager->getRootSceneNode()->createChildSceneNode( "CameraNode" ) ) ;
                cameraNode->attachObject( camera );
                return camera->getName() ;
        }
        return cameraName ;
}

//-------------------------------------------------------------------------
// createViewport
//-------------------------------------------------------------------------
void 
OgreVis::createViewport( const std::string& cameraName )
{
        Ogre::Camera* camera( _root->getSceneManager( "sceneManager" )->getCamera( cameraName ) ) ;

        // Create one viewport, entire window
        Viewport* viewport( _root->getAutoCreatedWindow()->addViewport( camera ) ) ;
        viewport->setBackgroundColour( ColourValue( 0.5, 0.5, 0.5 ) ) ;

        // Alter the camera aspect ratio to match the viewport
        camera->setAspectRatio( Real( viewport->getActualWidth() ) / Real( viewport->getActualHeight() ) ) ;
}

---