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.
//
//  Because this is a singleton, there are no publicly accessible constructors
//  or intializers.  Use the static methods instead.
//
//  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/12/16
// TODO: Orientation detection for mobile devices
#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_600_1024 = 6,
        PORTRAIT_IPAD_PRO = 7,
        LANDSCAPE_4_3 = 8,
        LANDSCAPE_3_2 = 9,
        LANDSCAPE_16_10 = 10,
        LANDSCAPE_5_3 = 11,
        LANDSCAPE_16_9 = 12,
        LANDSCAPE_1024_600 = 13,
        LANDSCAPE_IPAD_PRO = 14,
        UKNOWN = 15
    };

#pragma mark Values
protected:
    static Display* _thedisplay;
    
    Aspect _aspect;

    Rect _bounds;
    Rect _usable;
    Vec2 _scale;
    

#pragma mark -
#pragma mark Constructors

    Display();

    bool init();
    
    void dispose();

    ~Display() { dispose(); }

#pragma mark -
#pragma mark Static Accessors
public:
    static bool start();

    static void stop();

    static Display* get() { return _thedisplay; }

#pragma mark -
#pragma mark Attributes

    const Rect& getBounds() const { return _bounds;   }

    Rect getPixelBounds() const { return Rect(_bounds.origin*_scale,_bounds.size*_scale);   }
    
    const Rect& getUsableBounds() const { return _usable;   }
    
    const 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);
    }

#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)));
    }

};

}

#endif /* __CU_DISPLAY_H__ */