root/simulator/trunk/src/simulator/main.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
/// Main simulator program file, commandline and message loop.

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

/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup gameloop "Game Loop"
    /// @{

// \page simulatorcommandline Simulator Commandline Arguments.
// \par Commandline arguments
// \par Version
// - -v                        print simulator version
// - -version
// \par Help
// - -h                        print help message
// - --help
// \par Select Render System
// - -r "<name>"               select render system
// - --renderer "<name>"
// \par Window Size
// - -w ["<x>x<y>"]            select window mode, optional size, default 1024x768
// - -window ["<x>x<y>"]
// \par Fullscreen Mode
// - -f ["<x>x<y>"]            select fullscreen mode, optional size, default 1024x768
// - -fullscreen ["<x>x<y>"]
// \par Display Depth
// - -d                        select display depth, fullscreen mode only
// - -depth "<16|24|32>"
// \par Shared Memory (IPC)  Internal
// - -s "name"                 internal - shared memory for console
// - --shared-memory "<name>"
// \par Resource Directory
// - -x "<path>"               simulator resource directory
// - --directory "<path>"
// \par Ogre Configure File
// - -c "<path>"               simulator ogre configure file
// - --configure "<path>"
// \par Ogre Log File
// - -l "<path>"               simulator log file
// - --log "<path>"

static const char version[] = "$Id$";

extern ISystem* createSystem();

#ifdef WIN32
INT WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR commandline, int Show )
{


#else  //WIN32 (LINUX)
int main( int argc, char* argv[] )
{
#endif //WIN32


    boost::shared_ptr<ISystem> simulator( createSystem() );

    if( !simulator )
    {
        std::cerr << _("Error: Could not create simulator system program!") << std::endl;
        return 1;
    }

    boost::program_options::variables_map map;

    boost::program_options::options_description visible( _("Visible Options") );

// /////////////////////// Process comand-line options ///////////////////
    try
    {
        visible.add_options()
            ( _("version,v"),    _("print simulator version"))
            ( _("help,h"),       _("print help message"))
            ( _("renderer,r"),   _("select render system"))
            ( _("window,w"),     _("select window mode"))
            ( _("fullscreen,f"), _("select fullscreen mode"))
            ( _("directory,x"),  _("simulator resource directory"))
            ( _("configure,c"),  _("simulator configure file"))
            ( _("log,l"),        _("simulator log file"));

        boost::program_options::options_description hidden( _("Hidden Options") );
        hidden.add_options()( _("share,s"), _("Shared memory with comsole"));

        boost::program_options::options_description command( _("Command-line Options") );
        command.add( hidden ).add( visible );

        #ifdef WIN32
            std::vector<String> args = boost::program_options::split_winmain( commandline );
            store( boost::program_options::command_line_parser( args ).options( command ).run(), map );
        #else  //WIN32 (LINUX)
            store( boost::program_options::command_line_parser( argc, argv ).options( command ).run(), map );
        #endif //WIN32


        if( map.count( _("window")) && map.count( _("fullscreen")) )
            throw std::logic_error( String(_("Conflicting options window and fullscreen")));

        /// \todo copy the command-line map to system(simulator) or put this in system
        /// and send the command-line to system.


    }
    catch( std::exception& e )
    {
        std::string data = "STL Exception:, Commandline ";
        data += e.what();
        data += ", Class: ";
        data += typeid( e ).name();
        EXCEPTION(  "Simulator", "Main", data.c_str() );
        MESSAGE( "Simulator", "Main", "Exit Program - Error" )
        return 1;
    }

    if( map.count("help") != 0 )
    {
        std::cout << visible;
        return 0;
    }

    if( map.count("version") != 0 )
    {
        std::cout << "Version 1.0";
        return 0;
    }

    simulator->setOptions( map );

// ////////////////////// Game Loop ////////////////////////////
    try
    {
        /// Create window

        MESSAGE( "Simulator", "Main", "Starting Game Loop" )

        /// Game Loop.
        simulator->startup();
//      do { ASSERT( false, "Main", "Test continues Break" ); Sleep(1000); }while(true);

        do
        {

            PROFILE_START( Simulator, GameLoop, main )

            simulator->operator()();

            PROFILE_STOP( Simulator, GameLoop, main )

        }while( simulator->anyState() /*simulator->running()*/ );

        MESSAGE( "Simulator", "Main", "Exit Program - Normal" )

        return 0;
    }
    catch(Ogre::Exception& e)
    {
        std::string data = "Ogre Exception: ";
        data += e.getDescription();
        data += ", Class: ";
        data += typeid( e ).name();
        EXCEPTION(  "Simulator", "Main", data.c_str() );
    }
    catch( std::exception& e )
    {
        std::string data = "STL Exception: ";
        data += e.what();
        data += ", Class: ";
        data += typeid( e ).name();
        EXCEPTION(  "Simulator", "Main", data.c_str() );
    }
    catch( ... )
    {
        std::string data = "Unknown Exception";
        EXCEPTION(  "Simulator", "Main", data.c_str() );
    }

    MESSAGE( "Simulator", "Main", "Exit Program - Error" )

//  ASSERT( false, "Simulator", "Main", "Test Break" )

    /// Cleanup.
    return 1;

}
    /// @}   group gameloop
/// @}   group simulator