application.h

/***************************************************************************
 *   Copyright (C) 2004 by Reality Rift Studios                            *
 *   http://www.realityrift.com  -  mattias@realityrift.com                *
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef neo_application_application_h
#define neo_application_application_h

#include "base.h"
#include "../core/array.h"
#include "../core/timer.h"
#include "../core/pointer.h"

namespace neo {
namespace render { class Device; class Resolution; }
namespace input { class Device; class Event; }
namespace gui { NEO_DECLARE_SMARTPOINTER( Font ) }
namespace application {

class WindowEventListener;


class Application
{
    public:


                                                            Application( const std::string& name );

    virtual                                                ~Application();


    void                                                    start();


    void                                                    stop();


    static Application*                                     createApplication();

    protected:


    virtual void                                            initialize();


    void                                                    run();


    virtual void                                            shutdown();


    bool                                                    isInitialized() const;


    virtual void                                            processInput();


    virtual void                                            updateFrame( float deltaTime ) = 0;


    virtual void                                            renderFrame() = 0;


    virtual void                                            input( const input::Event* p_event );


    render::Resolution*                                     getPrevResolution( const render::Resolution& res );


    render::Resolution*                                     getNextResolution( const render::Resolution& res, bool same = false );
    
    std::string                                             _name;

    bool                                                    _useSetupDialog;
    
    bool                                                    _run;

    int                                                     _fixedUpdate;

    core::Timer                                             _timer;

    float                                                   _timeacc;

    render::Device*                                         _p_deviceRender;

    input::Device*                                          _p_deviceInput;
    
    core::Array< unsigned int >                             _programPriority;
    
    core::Array< unsigned int >                             _shaderPriority;

    core::Array< render::Resolution >                       _resAvailable;
    
    WindowEventListener*                                    _p_listenerWindow;

    core::Timer                                             _timerFPS;

    unsigned int                                            _numFrames;

    float                                                   _fps;

    bool                                                    _showFPS;

    gui::FontPtr                                            _p_fontDefault;

    private:

    bool                                                    _initialized;

    friend int ::real_main();
};

#if NEO_PLATFORM_WINDOWS && NEO_COMPILER_GCC && !defined( _CONSOLE )

#define _neo_application_implement( T, name ) neo::application::Application* neo::application::Application::createApplication() { return new T( name ); } \
extern "C" { int __stdcall WinMain( HINSTANCE, HINSTANCE, const char*, int ); } \
int __stdcall (*pfnExtWinMain)( HINSTANCE, HINSTANCE, const char*, int ) = WinMain;

#else

#define _neo_application_implement( T, name ) neo::application::Application* neo::application::Application::createApplication() { return new T( name ); }

#endif

}
}

#endif

---