SDLApp.hpp

/******************************************************************************
 
  nomlib - C++11 cross-platform game engine
 
Copyright (c) 2013, 2014 Jeffrey Carpenter <i8degrees@gmail.com>
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
******************************************************************************/
#ifndef NOMLIB_SYSTEM_SDLAPP_HPP
#define NOMLIB_SYSTEM_SDLAPP_HPP
 
#include <string>
#include <memory>
 
#include "nomlib/config.hpp"
#include "nomlib/system/Timer.hpp"
 
namespace nom {
 
// Forward declarations
struct Event;
class EventHandler;
class RenderWindow;
class IState;
class StateMachine;

class SDLApp
{
  public:
    typedef SDLApp self_type;
 
    typedef self_type* raw_ptr;
    typedef std::shared_ptr<self_type> shared_ptr;

    enum Hints
    {
      OSX_DISABLE_MINIMIZE_ON_LOSS_FOCUS = 0x1,

      OSX_DISABLE_FULLSCREEN_SPACES = 0x2
    };

    SDLApp( void );

    SDLApp( uint32 flags );
 
    virtual ~SDLApp( void );
 
    bool app_state( void ) const;
 
    virtual bool on_init( void );

    virtual sint Run( void );

    virtual void on_update( float );

    virtual void on_draw( RenderWindow& );

    virtual bool running( void );

    uint32 ticks ( void );

    virtual void quit( void );
 
    void set_app_state( bool state );
 
    bool show_fps ( void ) const;
    void set_show_fps ( bool toggle );

    bool toggle_fps ( void );
 
    StateMachine* state( void ) const;
 
    void set_state_machine( StateMachine* mech );

    void set_event_handler(EventHandler& evt_handler);
 
  protected:
    virtual void on_input_event(const Event& ev);

    virtual void on_app_quit(const Event& ev);
 
    virtual void on_window_shown(const Event& ev);
 
    virtual void on_window_hidden(const Event& ev);
 
    virtual void on_window_exposed(const Event& ev);
 
    virtual void on_window_moved(const Event& ev);
 
    virtual void on_window_resized(const Event& ev);
 
    virtual void on_window_size_changed(const Event& ev);
 
    virtual void on_window_minimized(const Event& ev);
 
    virtual void on_window_maximized(const Event& ev);
 
    virtual void on_window_restored(const Event& ev);
 
    virtual void on_window_mouse_focus(const Event& ev);
 
    virtual void on_window_mouse_focus_lost(const Event& ev);
 
    virtual void on_window_keyboard_focus(const Event& ev);
 
    virtual void on_window_keyboard_focus_lost(const Event& ev);

    virtual void on_window_close(const Event& ev);

    virtual void on_drag_drop(const Event& ev);

    virtual void on_render_targets_reset(const Event& ev);

 
// NOTE: Not available until the release of SDL 2.0.4
#if 0
    virtual void on_render_device_reset(const Event& ev);
#endif
 
    // NOTE: Proposed naming scheme for iOS / Android event handlers
    // virtual void on_app_destroy(const Event& ev);
    // virtual void on_app_low_memory(const Event& ev);
    // virtual void on_app_enter_background(const Event& ev);
    // virtual void on_app_background(const Event& ev);
    // virtual void on_app_enter_foreground(const Event& ev);
    // virtual void on_app_foreground(const Event& ev);

    virtual void on_user_event(const Event& ev);
 
  private:
    bool initialize( uint32 flags );
 
    void on_app_event(const Event& ev);
 
    void process_event(const Event& ev);
 
    // Non-owned pointer
    EventHandler* event_handler_ = nullptr;

    std::unique_ptr<StateMachine> state_;

    bool app_state_;

    bool show_fps_;

    Timer app_timer_;
};
 
} // namespace nom
 
#endif // include guard defined