perspcameracomponent.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"
 
namespace nap
{
    // Forward Declares
    class PerspCameraComponentInstance;
    class TransformComponentInstance;
    class TransformComponent;
 
    struct NAPAPI PerspCameraProperties
    {
        float mFieldOfView              = 50.0f;        
        float mNearClippingPlane        = 1.0f;         
        float mFarClippingPlane         = 1000.0f;      
        glm::ivec2 mGridDimensions      = { 1, 1 };     
        glm::ivec2 mGridLocation        = { 0, 0 };     
    };
    
 
    class NAPAPI PerspCameraComponent : public CameraComponent
    {
        RTTI_ENABLE(CameraComponent)
        DECLARE_COMPONENT(PerspCameraComponent, PerspCameraComponentInstance)
    public:
        PerspCameraProperties mProperties;              
    };
 
 
    class NAPAPI PerspCameraComponentInstance : public CameraComponentInstance
    {
        RTTI_ENABLE(CameraComponentInstance)
    public:
        // Default constructor
        PerspCameraComponentInstance(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;
 
        void setGridDimensions(int numRows, int numColumns);
 
        void setGridLocation(int row, int column);
 
        void setFieldOfView(float fov);
 
        float getFieldOfView() const;
 
        virtual float getNearClippingPlane() const override;
 
        virtual float getFarClippingPlane() const override;
 
        virtual const glm::mat4& getRenderProjectionMatrix() const override;
 
        PerspCameraProperties getProperties() const;
 
        void setProperties(const PerspCameraProperties& props);
 
    private:
 
        void setDirty() { mDirty = true; }
 
        void updateProjectionMatrices() const;
 
    protected:
        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
        PerspCameraProperties           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
 
        bool                            mPerpendicularRenderProjection = true;  // Whether the render projection matrix should be projected onto a perpendicular surface
    };
}