orthocameracomponent.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "cameracomponent.h"
 
// External Includes
#include <utility/dllexport.h>
 
namespace nap
{
    class OrthoCameraComponentInstance;
    class TransformComponentInstance;
    class TransformComponent;
 
    enum class EOrthoCameraMode : nap::uint8
    {
        PixelSpace = 0,         
        CorrectAspectRatio,     
        Custom                  
    };
 
    
    struct NAPAPI OrthoCameraProperties
    {
        EOrthoCameraMode mMode = EOrthoCameraMode::PixelSpace;      
        float mNearClippingPlane = 1.0f;                            
        float mFarClippingPlane = 1000.0f;                          
        float mLeftPlane = 0.0f;                                    
        float mRightPlane = 100.0f;                                 
        float mTopPlane = 100.0f;                                   
        float mBottomPlane = 0.0f;                                  
        math::Rect mClipRect = { {0.0f, 0.0f}, {1.0f, 1.0f} };      
 
        inline float getWidth() const                               { return mRightPlane - mLeftPlane; }
 
        inline float getHeight() const                              { return mTopPlane - mBottomPlane; }
 
        float getRatio() const                                      { return getHeight() / getWidth(); }
 
        void adjust(float ratio)                                    { mTopPlane = ratio * getWidth() + mBottomPlane; }
    };
    
    class NAPAPI OrthoCameraComponent : public CameraComponent
    {
        RTTI_ENABLE(CameraComponent)
        DECLARE_COMPONENT(OrthoCameraComponent, OrthoCameraComponentInstance)
    public:
        OrthoCameraProperties mProperties;      
    };
 
 
    // OrthoCameraComponentInstance
 
    class NAPAPI OrthoCameraComponentInstance : public CameraComponentInstance
    {
        RTTI_ENABLE(CameraComponentInstance)
    public:
 
        // Default constructor
        OrthoCameraComponentInstance(EntityInstance& entity, Component& resource);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void setRenderTargetSize(const glm::ivec2& size) override;
 
        virtual const glm::mat4& getProjectionMatrix() const override;
 
        virtual const glm::mat4 getViewMatrix() const override;
 
        const OrthoCameraProperties& getProperties() const { return mProperties; }
 
        void setProperties(const OrthoCameraProperties& properties);
 
        void setMode(EOrthoCameraMode mode);
 
        void setClipRect(const math::Rect& clipRect);
 
 
        void restoreClipRect();
 
        virtual float getNearClippingPlane() const override;
 
        virtual float getFarClippingPlane() const override;
 
        virtual const glm::mat4& getRenderProjectionMatrix() const override;
 
        static glm::mat4 createRenderProjectionMatrix(float left, float right, float bottom, float top, float zNear, float zFar);
 
        static glm::mat4 createRenderProjectionMatrix(float left, float right, float bottom, float top);
 
    private:
 
        void setDirty()                 { mDirty = true; }
            
        void updateProjectionMatrices() const;
 
    private:
        mutable glm::mat4x4             mViewMatrix;                            // The composed view matrix
        mutable glm::mat4x4             mProjectionMatrix;                      // The composed projection matrix
        mutable glm::mat4x4             mRenderProjectionMatrix;                // The composed projection matrix used by the renderer
        mutable bool                    mDirty = true;                          // If the projection matrix needs to be recalculated
        OrthoCameraProperties           mProperties;                            // These properties are copied from the resource to the instance. When these are changed, only the instance is affected
        TransformComponentInstance*     mTransformComponent;                    // Cached transform component
    };
}