CUApplication.h

//
//  CUApplication.h
//  Cornell University Game Library (CUGL)
//
//  This class provides the core application class.  In initializes both the
//  SDL and CUGL settings, and creates the core loop.  You should inherit from
//  this class to make your root game class.
//
//  This class is always intended to be used on the stack of the main function.
//  Thererfore, this class has no allocators.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/1/16
//
#ifndef __CU_APPLICATION_H__
#define __CU_APPLICATION_H__
#include <cugl/util/CUTimestamp.h>
#include <cugl/math/CUColor4.h>
#include <cugl/math/CURect.h>
#include <unordered_map>
#include <functional>
#include <deque>
#include <mutex>

namespace cugl {

typedef struct {
    std::function<bool()> callback;
    Uint32 period;
    Uint32 timer;
} scheduable;
    
class Application {
#pragma mark Values
public:
    enum class State : unsigned int {
        NONE = 0,
        STARTUP = 1,
        FOREGROUND = 2,
        BACKGROUND = 3,
        SHUTDOWN = 4
    };
    
    
protected:
    std::string _name;
    std::string _org;

    std::string _assetdir;
    std::string _savesdir;

    SDL_Window*   _window;
    SDL_GLContext _glContext;
    
    State _state;

    Rect _display;
    bool _fullscreen;
    bool _highdpi;
    bool _multisamp;
    
    float _fps;
    Color4f _clearColor;
    
    static Application* _theapp;

    
private:
    unsigned int _delay;
    
    std::deque<float> _fpswindow;

    Uint32 _start;
    Uint32 _finish;
    
    Uint32 _funcid;
    
    std::unordered_map<Uint32, scheduable> _callbacks;
    std::mutex _queueMutex;
    void processCallbacks(Uint32 millis);
    
#pragma mark -
#pragma mark Constructors
public:
    Application();
    
    ~Application() { dispose(); }
    
    virtual void dispose();
    
    bool init();
    
    static Application* get() { return _theapp; }
    
    
#pragma mark -
#pragma mark Virtual Methods

    virtual void onStartup();
    
    virtual void onShutdown();
    
    virtual void onLowMemory() { }

    virtual void onSuspend() { }
    
    virtual void onResume()  { }
    
    virtual void update(float timestep) { }

    virtual void draw() { }

    
#pragma mark -
#pragma mark Application Loop

    bool getInput();

    bool step();
    
    void quit();
    
    Uint32 schedule(std::function<bool()> callback, Uint32 time=0);

    Uint32 schedule(std::function<bool()> callback, Uint32 time, Uint32 period);
    
    void unschedule(Uint32 id);

    
#pragma mark -
#pragma mark Initialization Attributes

    void setSize(int width, int height);

    int getDisplayWidth()  const { return (int)_display.size.width; }
    
    int getDisplayHeight() const { return (int)_display.size.height; }
    
    const Size& getDisplaySize() const { return _display.size; }

    const Rect& getDisplayBounds() const { return _display; }

    void setFullscreen(bool value);
    
    bool isFullscreen() const { return _fullscreen; }

    void setHighDPI(bool highDPI);
    
    bool isHighDPI() const { return _highdpi; }
  
    void setMultiSampled(bool flag);

    bool isMultiSampled() const { return _multisamp; }

#pragma mark -
#pragma mark Runtime Attributes

    void setName(const char* name);
    
    void setName(const std::string& name);
    
    const std::string& getName() const { return _name; }
    
    void setOrganization(const char* name);
    
    void setOrganization(const std::string& name);
    
    const std::string& getOrganization() const { return _org; }
    
    void setFPS(float fps);
    
    float getFPS() const { return _fps; }
    
    float getAverageFPS() const;
    
    void setClearColor(Color4 color) { _clearColor = color; }

    Color4 getClearColor() const { return (Color4)_clearColor; }

    State getState() const { return _state; }
    
    const std::string getOpenGLDescription() const;
    
#pragma mark -
#pragma mark File Directories

    std::string getAssetDirectory();
    
    std::string getSaveDirectory();
    
#pragma mark -
#pragma mark Internal Helpers
private:
    bool prepareOpenGL();

    bool initOpenGL();
};

}


#endif /* __CU_APPLICATION_H__ */