CUDisplay.h

//
//  CUDisplay.h
//  Cornell University Game Library (CUGL)
//
//  This module is a singleton providing display information about the device.
//  Originally, we had made this part of Application.  However, we discovered
//  that we needed platform specfic code for this, so we factored it out.
//
//  This singleton is also responsible for initializing (and disposing) the
//  OpenGL context.  That is because that context is tightly coupled to the
//  orientation information, which is provided by this class.
//
//  Because this is a singleton, there are no publicly accessible constructors
//  or intializers.  Use the static methods instead.
//
//  CUGL MIT 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: 12/12/18
#ifndef __CU_DISPLAY_H__
#define __CU_DISPLAY_H__
#include <cugl/math/CURect.h>
 
namespace cugl {
    
class Display {
public:
    enum class Aspect : unsigned int {
        SQUARE = 0,
        PORTRAIT_3_4 = 1,
        PORTRAIT_2_3 = 2,
        PORTRAIT_10_16 = 3,
        PORTRAIT_3_5  = 4,
        PORTRAIT_9_16 = 5,
        PORTRAIT_9_19p5 = 6,
        PORTRAIT_600_1024 = 7,
        PORTRAIT_IPAD_PRO_LARGE = 8,
        PORTRAIT_IPAD_PRO_SMALL_2017 = 9,
        PORTRAIT_IPAD_PRO_SMALL_2018 = 10,
        LANDSCAPE_4_3 = 11,
        LANDSCAPE_3_2 = 12,
        LANDSCAPE_16_10 = 13,
        LANDSCAPE_5_3 = 14,
        LANDSCAPE_16_9 = 15,
        LANDSCAPE_19p5_19 = 16,
        LANDSCAPE_1024_600 = 17,
        LANDSCAPE_IPAD_PRO_LARGE = 18,
        LANDSCAPE_IPAD_PRO_SMALL_2017 = 19,
        LANDSCAPE_IPAD_PRO_SMALL_2018 = 20,
        UNKNOWN = 21
    };
    
    enum class Orientation : unsigned int {
        FIXED = 0,
        LANDSCAPE = 1,
        PORTRAIT  = 2,
        LANDSCAPE_REVERSED = 3,
        UPSIDE_DOWN = 4,
        FACE_UP = 5,
        FACE_DOWN = 6,
        UNKNOWN = 7,
    };
    
    typedef std::function<void(Orientation previous, Orientation current, bool display)> Listener;
    
    // Flags for the device initialization
    static Uint32 INIT_FULLSCREEN;
    static Uint32 INIT_HIGH_DPI;
    static Uint32 INIT_MULTISAMPLED;
    static Uint32 INIT_CENTERED;
    
#pragma mark Values
protected:
    static Display* _thedisplay;
 
    std::string _title;
    
    SDL_Window*   _window;
    SDL_GLContext _glContext;
    
    Aspect _aspect;
    
    Rect _bounds;
    Rect _usable;
    Vec2 _scale;
    
    bool _notched;
    
    Listener _orientationListener;
    Orientation _initialOrientation;
    Orientation _displayOrientation;
    Orientation _deviceOrientation;
    Orientation _defaultOrientation;
 
#pragma mark -
#pragma mark Constructors
 
    Display();
    
    bool init(std::string title, Rect bounds, Uint32 flags);
    
    void dispose();
    
    ~Display() { dispose(); }
    
#pragma mark -
#pragma mark Static Accessors
public:
    static bool start(std::string title, Rect bounds, Uint32 flags);
 
    static void stop();
    
    static Display* get() { return _thedisplay; }
    
#pragma mark -
#pragma mark Window Management
 
    std::string getTitle() const { return _title; }
    
    void setTitle(const std::string& title) {
        setTitle(title.c_str());
    }
    
    void setTitle(const char* title);
    
    void show();
 
    void hide();
 
#pragma mark -
#pragma mark Attributes
 
    Rect getBounds() const { return _bounds;   }
    
    Rect getPixelBounds() const { return Rect(_bounds.origin*_scale,_bounds.size*_scale);   }
    
    Rect getUsableBounds(bool display=true);
    
    Vec2 getPixelDensity() const { return _scale;    }
    
    Aspect getAspect() const { return _aspect;   }
    
    bool isLandscape() const {
        return (int)_aspect >= (int)Aspect::LANDSCAPE_4_3;
    }
    
    bool isPortrait() const {
        return ((int)_aspect < (int)Aspect::LANDSCAPE_4_3 &&
                _aspect != Aspect::SQUARE);
    }
    
    bool hasNotch() const {
        return _notched;
    }
 
#pragma mark -
#pragma mark Orientation
 
    Orientation getInitialOrientation() const { return _initialOrientation; }
    
    Orientation getDisplayOrientation() const { return _displayOrientation; }
    
    Orientation getDeviceOrientation() const  { return _deviceOrientation; }
    
    Orientation getDefaultOrientation() const  { return _defaultOrientation; }
    
    bool hasOrientationListener() const { return _orientationListener != nullptr; }
    
    const Listener getOrientationListener() const { return _orientationListener; }
    
    void setOrientationListener(Listener listener) { _orientationListener = listener; }
    
    bool removeOrientationListener();
    
#pragma mark -
#pragma mark Aspect Utilities
 
    float getAspectRatio() const { return getAspectRatio(_aspect); }
    
    const std::string getAspectName() const { return getAspectName(_aspect); }
    
    int widthForHeight(int height) const {
        return (int)(ceilf(getAspectRatio(_aspect)/height));
    }
    
    int heightForWidth(int width) const {
        return (int)(ceilf(width/getAspectRatio(_aspect)));
    }
    
    static Aspect getAspect(float ratio);
    
    static float getAspectRatio(Aspect aspect);
    
    static const std::string getAspectName(Aspect aspect);
    
    static int widthForHeight(int height, Aspect aspect) {
        return (int)(ceilf(getAspectRatio(aspect)/height));
    }
    
    static int heightForWidth(int width, Aspect aspect) {
        return (int)(ceilf(width/getAspectRatio(aspect)));
    }
    
#pragma mark -
#pragma mark OpenGL Management
//private:
    void refresh();
 
    bool prepareOpenGL(bool multisample);
    
    bool initOpenGL(bool multisample);
    
    friend class Application;
};
    
}
 
#endif /* __CU_DISPLAY_H__ */