RenderCamera.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "VectorMath.h"
#include "Frustum.h"

namespace Eegeo
{
    namespace Camera
    {
        class RenderCamera
        {
        public:
            
            RenderCamera();
            ~RenderCamera();
            
            void SetEcefLocation(const Eegeo::dv3& ecefLocation);
            
            const Eegeo::dv3& GetEcefLocation() const { return m_ecefLocation; }
            
            float GetAltitude() const { return m_altitude; }
            
            void SetOrientationMatrix(const Eegeo::m33& m);
            
            void SetViewport(float x, float y, float width, float height);
            
            void SetProjection (float nominalVerticalFovRadians, float nearZ, float farZ);
            
            void SetProjectionMatrix (m44& projectionMatrix);
            
            void Project(const Eegeo::v3& cameraRelativeWorldPosition, Eegeo::v3& screenPosition) const;
 
            void Project360(const Eegeo::v3& cameraRelativeWorldPosition, Eegeo::v3& screenPosition) const;

            void UnProject(const Eegeo::v3& screenPosition, Eegeo::v3& cameraRelativeWorldPosition) const;

            const Eegeo::m44& GetModelMatrix() const    { return m_modelMatrix; }
            
            const Eegeo::m44& GetViewMatrix() const;
            
            const Eegeo::m44& GetProjectionMatrix() const;
            
            const Eegeo::m44& GetViewProjectionMatrix() const;
            
            const Eegeo::m44& GetInverseViewProjectionMatrix() const;

            float GetNearClip() const   { return m_nearZ; }
            
            float GetFarClip() const    { return m_farZ; }
            
            float GetNearClipRatio() const;
            
            float GetFOV() const    { return m_fov; }
            
            float GetAspect() const     { return m_aspect; }
            
            float GetViewportWidth() const { return m_viewportWidth; }
            
            float GetViewportHeight() const { return m_viewportHeight; }
            
            v2 GetViewportOrigin() const { return v2(m_viewportX, m_viewportY); }
            
            const Eegeo::Geometry::Frustum& GetFrustum() const;

            float CalculateEffectiveFOV() const;
            
            const static float NominalAspectRatio;
            const static float MinAspectRatioForPortraitMode;
            
        private:
            float       m_nearZ;
            float       m_farZ;
            
            float       m_fov;
            float       m_aspect;
            
            Eegeo::dv3 m_ecefLocation;
            Eegeo::m44 m_modelMatrix;

            
            float m_viewportX;
            float m_viewportY;
            float m_viewportWidth;
            float m_viewportHeight;
            float m_altitude;
            
            class CachedState
            {
            private:
                Eegeo::m44  m_viewMatrix;
                Eegeo::m44  m_projMatrix;
                Eegeo::m44  m_viewProjMatrix;
                Eegeo::m44  m_inverseViewProjMatrix;
                Eegeo::Geometry::Frustum m_frustum;
                std::vector<Geometry::Plane> m_scratchFrustumPlanes;
                
                bool m_projectionDirty;
                bool m_viewDirty;
                bool m_viewProjectionDirty;
                bool m_frustumDirty;
            public:
                
                CachedState();
                
                void InvalidateProjection() { m_projectionDirty = true; }
                void InvalidateView() { m_viewDirty = true; }
                
                void InvalidateCachedTransforms();

                void SetExplicitProjection(Eegeo::m44& projectionMatrix);

                const Eegeo::m44& GetViewMatrix(const RenderCamera& camera);
                const Eegeo::m44& GetProjectionMatrix(const RenderCamera& camera);
                const Eegeo::m44& GetViewProjectionMatrix(const RenderCamera& camera);
                const Eegeo::m44& GetInverseViewProjectionMatrix(const RenderCamera& camera);
                const Eegeo::Geometry::Frustum& GetFrustum(const RenderCamera& camera);
                
            };
            
            mutable CachedState m_cachedState;
            
            void CalculateViewMatrix(Eegeo::m44& viewMatrix) const;
            void CalculateProjectionMatrix(Eegeo::m44& projectionMatrix) const;
            void ClipSpaceToScreenSpace(const Eegeo::v4& clipPosition, Eegeo::v3& screenPosition) const;
            float CalculateTweakedNearPlaneHalfHeight() const;
        };
    }
}