CUPerspectiveCamera.h

//
//  CUPerspectiveCamera.h
//  Cornell University Game Library (CUGL)
//
//  This module provides an perspective camera class. While 3d is not a primary
//  use case for cugl, it is nice to have the support.
//
//  This module is based on the original file PerspectiveCamera by
//  Mario Zechner, written for LibGDX ( https://libgdx.badlogicgames.com ). It
//  has been modified to support the CUGL framework.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  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: 6/24/16

#ifndef __CU_PERSPECTIVE_CAMERA_H__
#define __CU_PERSPECTIVE_CAMERA_H__


#endif /* __CU_PERSPECTIVE_CAMERA_H__ */

#define DEFAULT_CAMERA_FOV 67

#include "CUCamera.h"

namespace cugl {
    
class PerspectiveCamera : public Camera {
protected:
    float _fieldOfView = 67;
 
    bool _initialized;
    
#pragma mark -
#pragma mark Constructors
public:
    PerspectiveCamera() : Camera() {
        _fieldOfView = 0; _initialized = false;
    }
    
    ~PerspectiveCamera() { dispose(); }
    
    
    void dispose() override;
    
    bool init(const Size& size, float fieldOfView = DEFAULT_CAMERA_FOV) {
        return init(0,0,size.width,size.height,fieldOfView);
    }

    bool init(float width, float height, float fieldOfView = DEFAULT_CAMERA_FOV) {
        return init(0,0,width,height,fieldOfView);
    }

    bool init(const Rect& rect, float fieldOfView = DEFAULT_CAMERA_FOV) {
        return init(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height,fieldOfView);
    }

    bool init(const Vec2& origin, const Size& size, float fieldOfView = DEFAULT_CAMERA_FOV) {
        return init(origin.x, origin.y, size.width, size.height,fieldOfView);
    }
    
    bool init(float x, float y, float width, float height, float fieldOfView = DEFAULT_CAMERA_FOV);
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<PerspectiveCamera> alloc(const Size& size, float fieldOfView = DEFAULT_CAMERA_FOV) {
        std::shared_ptr<PerspectiveCamera> result = std::make_shared<PerspectiveCamera>();
        return (result->init(size,fieldOfView) ? result : nullptr);
    }
    
    static std::shared_ptr<PerspectiveCamera> alloc(float width, float height,
                                                    float fieldOfView = DEFAULT_CAMERA_FOV) {
        std::shared_ptr<PerspectiveCamera> result = std::make_shared<PerspectiveCamera>();
        return (result->init(width,height,fieldOfView) ? result : nullptr);
    }
    
    static std::shared_ptr<PerspectiveCamera> alloc(const Rect& rect, float fieldOfView = DEFAULT_CAMERA_FOV) {
        std::shared_ptr<PerspectiveCamera> result = std::make_shared<PerspectiveCamera>();
        return (result->init(rect,fieldOfView) ? result : nullptr);
    }
    
    static std::shared_ptr<PerspectiveCamera> alloc(const Vec2& origin, const Size& size,
                                                    float fieldOfView = DEFAULT_CAMERA_FOV) {
        std::shared_ptr<PerspectiveCamera> result = std::make_shared<PerspectiveCamera>();
        return (result->init(origin,size,fieldOfView) ? result : nullptr);
    }
    
    static std::shared_ptr<PerspectiveCamera> alloc(float x, float y, float width, float height,
                                                    float fieldOfView = DEFAULT_CAMERA_FOV) {
        std::shared_ptr<PerspectiveCamera> result = std::make_shared<PerspectiveCamera>();
        return (result->init(x,y,width,height,fieldOfView) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Setters

    void set(const Size& size, float fieldOfView = DEFAULT_CAMERA_FOV) {
        set(0, 0, size.width, size.height, fieldOfView);
    }
    
    void set(float width, float height, float fieldOfView = DEFAULT_CAMERA_FOV) {
        set(0, 0, width, height, fieldOfView);
    }
    
    void set(const Rect& rect, float fieldOfView = DEFAULT_CAMERA_FOV) {
        set(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height, fieldOfView);
    }
    
    void set(const Vec2& origin, const Size& size, float fieldOfView = DEFAULT_CAMERA_FOV) {
        set(origin.x, origin.y, size.width, size.height, fieldOfView);
    }
    
    void set(float x, float y, float width, float height, float fieldOfView = DEFAULT_CAMERA_FOV);
    
    void update() override;
    
#pragma mark -
#pragma mark Attributes

    float getFieldOfView() const { return _fieldOfView; }

    void setFieldOfView(float fov);
    
};

}