CUCamera.h

//
//  CUCamera.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the abstract base class for our camera classes.
//  Because it is abstract, it has only a basic constructor.  It has no
//  initializers or allocator.
//
//  This module is based on the original file Camera.java by Mario Zechner,
//  written for LibGDX ( https://libgdx.badlogicgames.com ). It has been
//  modified to support the CUGL framework.
//
//  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_CAMERA_H__
#define __CU_CAMERA_H__

#include <cugl/math/CURect.h>
#include <cugl/math/CUVec2.h>
#include <cugl/math/CUVec3.h>
#include <cugl/math/CUMat4.h>
#include <cugl/math/CUQuaternion.h>
#include <cugl/math/CURay.h>
#include <cugl/util/CUDebug.h>

namespace cugl {
    
class Camera {
#pragma mark Values
protected:
    Vec3 _position;
    Vec3 _direction;
    Vec3 _upwards;
    
    Mat4 _projection;
    Mat4 _modelview;
    Mat4 _combined;
    Mat4 _inverse;
    
    float _near;
    float _far;
    
    Rect _viewport;
    
#pragma mark -
#pragma mark Constructor
public:
    Camera();
    
    ~Camera() { dispose(); }
    
    virtual void dispose();
    
    
#pragma mark -
#pragma mark Attributes

    const Vec3& getPosition() const { return _position; }
    
    const Vec3& getDirection() const { return _direction; }
    
    const Vec3& getUp() const { return _upwards; }
    
    float getNear() const { return _near; }
    
    void setNear(float value) {
        CUAssertLog(value >= 0, "Value is not positive");
        _near = value;
    }
    
    float getFar() const { return _far; }
    
    void setFar(float value) {
        CUAssertLog(value >= 0, "Value is not positive");
        _far = value;
    }
    
    const Rect& getViewport() const { return _viewport; }

    const Mat4& getProjection() const { return _projection; }
    
    const Mat4& getView() const { return _modelview; }
    
    const Mat4& getCombined() const { return _combined; }

    const Mat4& getInverseProjectView() const { return _inverse; }
    
#pragma mark -
#pragma mark Updates

    virtual void update() = 0;
    
    void lookAt(const Vec3& target);

    void lookAt (float x, float y, float z) {
        lookAt(Vec3(x,y,z));
    }
    
    void normalizeUp() {
        _upwards = _direction.cross(_upwards).normalize();
        _upwards.cross(_direction).normalize();
    }
    
#pragma mark -
#pragma mark View Transforms

    void rotate(const Quaternion& quat) {
        Mat4 temp;
        Mat4::createRotation(quat,&temp);
        _direction *= temp;
        _upwards *= temp;
    }
    
    void rotate(const Vec3& axis, float angle) {
        Mat4 temp;
        Mat4::createRotation(axis,angle,&temp);
        _direction *= temp;
        _upwards *= temp;
    }
    
    void rotateX(float angle) {
        Mat4 temp;
        Mat4::createRotationX(angle,&temp);
        _direction *= temp;
        _upwards *= temp;
    }

    void rotateY(float angle) {
        Mat4 temp;
        Mat4::createRotationY(angle,&temp);
        _direction *= temp;
        _upwards *= temp;
    }

    void rotateZ(float angle) {
        Mat4 temp;
        Mat4::createRotationZ(angle,&temp);
        _direction *= temp;
        _upwards *= temp;
    }

    void rotate(float angle) {
        rotate(_direction, angle);
    }

    void rotate(const Mat4& transform) {
        Mat4::transformVector(transform, _direction, &_direction);
        _direction.normalize();
        Mat4::transformVector(transform, _upwards, &_upwards);
        _upwards.normalize();
    }
    
    void rotateAround(const Vec3& point, const Vec3& axis, float angle);
    
    void translate(const Vec3& vec) {
        _position += vec;
    }
    
    void translate (const Vec2& vec) {
        translate(vec.x,vec.y);
    }
    
    void translate(float tx, float ty, float tz) {
        _position.x += tx;
        _position.y += ty;
        _position.z += tz;
    }
    
    void translate (float tx, float ty) {
        _position.x += tx;
        _position.y += ty;
    }
    
    void transform(const Mat4& transform) {
        _position *= transform;
        rotate(transform);
    }
    
#pragma mark -
#pragma mark Coordinate Transforms

    Vec3 unproject(const Vec3& windowCoords) const;
    
    Vec3 unproject(const Vec3& windowCoords, const Rect& viewport) const;

    Vec3 screenToWorldCoords(const Vec2& screenCoords) const {
        return unproject(screenToWindowCoords(screenCoords));
    }
    
    Vec3 project(const Vec3& worldCoords) const;

    Vec3 project(const Vec3& worldCoords, const Rect& viewport) const;

    Vec2 worldToScreenCoords(const Vec3& worldCoords) const {
        return windowToScreenCoords(project(worldCoords));
    }
    
    Ray getPickRay(const Vec3& windowCoords) const;

    Ray getPickRay(const Vec3& windowCoords, const Rect& viewport) const;

    Ray getPickRayFromScreen(const Vec2& screenCoords) const {
        return getPickRay(screenToWindowCoords(screenCoords));
    }
        
    Vec2 windowToScreenCoords(const Vec3& windowCoords) const;

    Vec2 windowToScreenCoords(const Vec3& windowCoords, const Rect& viewport) const;

    Vec3 screenToWindowCoords(const Vec2& screenCoords) const;

    Vec3 screenToWindowCoords(const Vec2& screenCoords, const Rect& viewport) const;
};
    
}

#endif /* __CU_CAMERA_H__ */