root/simulator/trunk/src/simulator/graphics.cpp

//    OSRail -- a network enabled railroad operations simulator and utilities
//    Copyright (C) 2007,2008 Samuel E. Henley sehenley@comcast.net
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
/// \file
/// Implementation file for Graphics manager of the simulator and the IGraphics factory.

// Pre-Compiled Header for Simulator
#include "presimulator.h"

#include "graphics.h"

/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup simulatorcomponent "Simulator Components"
    /// @{
        /// \addtogroup graphics "Graphics"
        /// @{

extern IGraphics* createGraphics( ISystem& sys )
{
    return new Graphics( sys );
}

Graphics::Graphics( ISystem& sys )
    : system( sys ), scenemanager(0), viewport(0), camera(0), renderwindow(0)
{
}

Graphics::~Graphics()
{
    if( viewport )
    {
        renderwindow->removeViewport( viewport->getZOrder() );
        viewport = 0;
    }

    if( renderwindow )
    {
        root->detachRenderTarget( renderwindow );
        delete renderwindow;
        renderwindow = 0;
    }
}

// ISimulatorComponent - interfaces
//virtual
void Graphics::startup()
{
    /// \todo try all Ogre device before admitting failure.
    MESSAGE( "Simulator", "Graphics", "Startup" )
    try
    {
        Ogre::String log_file = paths::getLogsPath() + "simulatorogre.log";
        Ogre::String resources_path = paths::getMediaPath();


        // defaults to pluginFileName="plugins.cfg" configFileName="ogre.cfg" logFileName="Ogre.log")
        root = boost::shared_ptr< Ogre::Root >( new Ogre::Root( "", "", log_file ) );


        // Plug-ins
        #ifdef WIN32
            #ifdef _DEBUG
                root->loadPlugin( "Plugin_BSPSceneManager_d" );
                root->loadPlugin( "Plugin_CgProgramManager_d" );
                root->loadPlugin( "Plugin_OctreeSceneManager_d" );
                root->loadPlugin( "Plugin_ParticleFX_d" );
                root->loadPlugin( "RenderSystem_Direct3D9_d" );
                root->loadPlugin( "RenderSystem_GL_d" );
            #else
                root->loadPlugin( "Plugin_BSPSceneManager" );
                root->loadPlugin( "Plugin_CgProgramManager" );
                root->loadPlugin( "Plugin_OctreeSceneManager" );
                root->loadPlugin( "Plugin_ParticleFX" );
                root->loadPlugin( "RenderSystem_Direct3D9" );
                root->loadPlugin( "RenderSystem_GL" );
           #endif // _DEBUG
        #else //Linux
            root->loadPlugin( "/usr/local/lib/OGRE/Plugin_BSPSceneManager" );
            root->loadPlugin( "/usr/local/lib/OGRE/Plugin_CgProgramManager" );
            root->loadPlugin( "/usr/local/lib/OGRE/Plugin_OctreeSceneManager" );
            root->loadPlugin( "/usr/local/lib/OGRE/Plugin_ParticleFX" );
            root->loadPlugin( "/usr/local/lib/OGRE/RenderSystem_GL" );
        #endif //WIN32

        /// resources
        Ogre::ResourceGroupManager* resource_group_manager = Ogre::ResourceGroupManager::getSingletonPtr();
        //[Bootstrap]
        //Zip=../../Media/packs/OgreCore.zip

        //# Resource locations to be added to the default path
        //[General]
        //FileSystem=../../Media
        //FileSystem=../../Media/fonts
        //FileSystem=../../Media/materials/programs
        //FileSystem=../../Media/materials/scripts
        //FileSystem=../../Media/materials/textures
        //FileSystem=../../Media/models
        //FileSystem=../../Media/overlays
        //FileSystem=../../Media/particle
        //FileSystem=../../Media/gui
        //FileSystem=../../Media/DeferredShadingMedia
        //Zip=../../Media/packs/cubemap.zip
        //Zip=../../Media/packs/cubemapsJS.zip
        //Zip=../../Media/packs/dragon.zip
        //Zip=../../Media/packs/fresneldemo.zip
        //Zip=../../Media/packs/ogretestmap.zip
        //Zip=../../Media/packs/skybox.zip

        Ogre::String sz = resources_path + "packs/traingearmedia.zip";
        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//        Ogre::String sz = resources_path + _T("packs\\OgreCore.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "Bootstrap" );
//
//        sz = resources_path;
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("fonts");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("materials\\programs");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("materials\\scripts");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("materials\\textures");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("models");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("overlays");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("particals");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("gui");
//        resource_group_manager->addResourceLocation( sz, "FileSystem", "General" );
//
//        sz = resources_path + _T("packs\\cubemap.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
//        sz = resources_path + _T("packs\\cubemapsJS.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
//        sz = resources_path + _T("packs\\dragon.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
//        sz = resources_path + _T("packs\\fresneldemo.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
//        sz = resources_path + _T("packs\\ogretestmap.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
//        sz = resources_path + _T("packs\\skybox.zip");
//        resource_group_manager->addResourceLocation( sz, "Zip", "General" );
//
        const Ogre::RenderSystemList& list = root->getAvailableRenderers();
        if( list.empty() )throw Ogre::Exception( Ogre::Exception::ERR_NOT_IMPLEMENTED,
                                                  _("No rendering devices found"),
                                                  _("Creating Graphics System")  );

        size_t size = list.size();
        /// \todo Pick the best on the list or the best on the default monitor
        /// \todo Select opengl when using a remode desktop
        //Check for remote desktop connection
        bool remote = false;
    #if _WIN32
        remote = ::GetSystemMetrics( SM_REMOTESESSION ) != 0;
    #endif //_WIN32

        Ogre::RenderSystem* select = list.at(0); //First on the list? - default -
        /// \note Must use OpenGL in windows remote desktop - Sometimes this works
        if( remote )
        {
            for( size_t j = 0; j<size; j++ )
            {
                Ogre::RenderSystem* p = list.at(j);    //default to first system listed
                Ogre::String sz = p->getName();
                if( sz.compare( "OpenGL Rendering Subsystem" ) == 0 )
                {
                    select = list.at(j);
                    break;
                }
            }
        }
        root->setRenderSystem( select );
        root->initialise( false );



        Ogre::NameValuePairList options;
        options["fullscreen"] = "false";
        options["vsync"] = "false";

        // directx, and opengl device created here
        renderwindow = root->createRenderWindow( _("OSRail Simulation"), 1024, 768, false, &options );

        Ogre::WindowEventUtilities::addWindowEventListener( renderwindow, this );


        scenemanager = root->createSceneManager( Ogre::ST_GENERIC );

        camera = scenemanager->createCamera( _("Player") );
        camera->setPosition( Ogre::Vector3( 0.0f, 0.0f, 500.0f ));
        camera->lookAt( Ogre::Vector3( 0.0f, 0.0f, -300.0f ) );
        camera->setNearClipDistance(5.0f);
        viewport = renderwindow->addViewport( camera );
        viewport->setBackgroundColour( Ogre::ColourValue( 0.0f, 0.0f, 0.0f ));

        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);

        scenemanager->setAmbientLight( Ogre::ColourValue( 0.2f, 0.2f, 0.2f ));

        /// Must be done after window is created
        resource_group_manager->initialiseAllResourceGroups();


        createScene();
        frame_timer.reset();

    }
    catch(Ogre::Exception& e)
    {
        /// \todo Hook exceptions up to console utility.
        std::string data = "Startup Ogre Exception: ";
        data += e.getDescription();
        data += ", Class: ";
        data += typeid( e ).name();
        EXCEPTION(  "Simulator", "Graphics", data.c_str() );

        shutdown();
    }
    catch( ... )
    {
        std::string data = "Unknown Exception";
        EXCEPTION(  "Simulator", "Graphics", data.c_str() );
        shutdown();
    }


}

//virtual
unsigned long Graphics::getFrameMilliseconds()
{
    return frame_timer.getMicroseconds();
}


// private
void Graphics::createScene( void )
{
    scenemanager->setAmbientLight( Ogre::ColourValue( 0.2f, 0.2f, 0.2f ));
    scenemanager->setSkyDome( true, "Examples/CloudySky", 5, 8 );
    Ogre::Light* light = scenemanager->createLight("MainLight");
    light->setPosition( 20, 80, 50 );

    Ogre::Plane plane;
    plane.normal = Ogre::Vector3::UNIT_Y;
    plane.d = 200;
    Ogre::MeshManager::getSingleton().createPlane( "FloorPlane",
        Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
        plane,
        200000, 200000, 20, 20, true, 1, 50, 50, Ogre::Vector3::UNIT_Z );

    Ogre::Entity* entity = scenemanager->createEntity("floor", "FloorPlane");
    entity->setMaterialName("Examples/RustySteel");
    scenemanager->getRootSceneNode()->createChildSceneNode()->attachObject( entity );

    Ogre::SceneNode* node = scenemanager->getRootSceneNode()->createChildSceneNode();
    Ogre::Entity* head = scenemanager->createEntity( "Head", "ogrehead.mesh" );
    node->attachObject( head );

    camera->setAutoTracking( true, node );
    node = scenemanager->getRootSceneNode()->createChildSceneNode();
    node->attachObject( camera );

    Ogre::Animation* animation = scenemanager->createAnimation( "CameraTrack", 10 );
    animation->setInterpolationMode( Ogre::Animation::IM_SPLINE );
    Ogre::NodeAnimationTrack* track = animation->createNodeTrack( 0, node );

    Ogre::TransformKeyFrame* key = track->createNodeKeyFrame(0.0f);

    key = track->createNodeKeyFrame( 2.5f );
    key->setTranslate( Ogre::Vector3( 500, 500, -1000 ));

    key = track->createNodeKeyFrame( 5.0f );
    key->setTranslate( Ogre::Vector3( 1500, 1000, -600 ));

    key = track->createNodeKeyFrame( 7.5f );
    key->setTranslate( Ogre::Vector3( 0, -100, 0 ));

    key = track->createNodeKeyFrame( 10.0f );
    key->setTranslate( Ogre::Vector3( 0, 0, 0 ));

    animation_state = scenemanager->createAnimationState( "CameraTrack" );

    /// initial animation speed
    animation_speed = 0.01f;

    animation_state->setEnabled( true );

}


//virtual
void Graphics::operator()()
{
    if( viewport )
    {
//      static unsigned char tone[3] = { 0, 0, 0 }; //range 0 - xffffff
//      static int c = 0;
//      static int d = 1;
//      if( tone[c] == 0xff )
//      {
//          d = -1;
//      }
//
//      if( tone[c] == 0x0 )
//      {
//          c++;
//          c %= 3;
//          d = 1;
//      }
//
//      tone[c] += d;
//
//      viewport->setBackgroundColour( Ogre::ColourValue( float( ( tone[0] & 0xff )/255.0f ),
//                                                        float( ( tone[1] & 0xff )/255.0f ),
//                                                        float( ( tone[2] & 0xff )/255.0f ),
//                                                        1.0f ));
//
        TWEAKER( "Simulator", "Tweeker", float, speed, 0.01f, "Animation Speed" )
        animation_state->addTime( *speed );

        Ogre::WindowEventUtilities::messagePump();

        if( root )root->renderOneFrame();

        if( renderwindow )renderwindow->update();

        frame_timer.reset();
    }
}

//virtual
void Graphics::shutdown()
{
    MESSAGE( "Simulator", "Graphics", "Shutdown" )
    if( viewport && renderwindow )
    {
        renderwindow->removeViewport( viewport->getZOrder() );
        viewport = 0;
    }

    if( renderwindow && root )
    {
        root->detachRenderTarget( renderwindow );
        delete renderwindow;
        renderwindow = 0;
    }

    root.reset();
}

// IGraphics - interfaces

//virtual
bool Graphics::isClosed() const
{
    if( renderwindow )return renderwindow->isClosed();

    return true;
}


//virtual
bool Graphics::isVisible() const
{
    if( renderwindow )return renderwindow->isVisible();
    return false;
}

//WindowEventListener
//virtual
/// \note Under DirectX this routine prevents a surface rendering error, after window closed.
bool Graphics::windowClosing( Ogre::RenderWindow* rw )
{
    #ifdef WIN32
        shutdown();
        return false;
    #else
        return true;
    #endif
}


        /// @}   group graphics
    /// @}   group simulatorcomponent
/// @} group simulator