camera.h

Go to the documentation of this file.

/*!****************************************************************//*!*
 * \file   camera.h
 * \brief  Renderer virtual camer class definiton module.
 * 
 * \author Sabitov Kirill
 * \date   02 July 2022
 *********************************************************************/
 
#pragma once
 
#include "base.h"
 
namespace scl
{
    class frame_buffer;
 
    enum class camera_projection_type
    {
        ORTHOGRAPHIC,
        PERSPECTIVE,
    };
 
    struct camera_effects
    {
        bool HDR { false };    
        float Exposure { 0 };  
        bool Bloom { false };  
        int BloomAmount { 0 }; 
        camera_effects(bool HDR = false, float Exposure = 0, bool Bloom = false, int BloomAmount = 0) :
            HDR(HDR), Exposure(Exposure), Bloom(Bloom), BloomAmount(BloomAmount) {}
    };
 
    class camera
    {
    private: 
        matr4 Projection {};
        matr4 View {};
        matr4 ViewProjection {};
 
        camera_projection_type ProjectionType;
        float FieldOfView { 0.1f };
        float ProjectionDistance { 0.1f };
        float FarClip { 1000.0f };
        int ViewportWidth {};
        int ViewportHeight {};
        float ViewportProjectionWidth {};
        float ViewportProjectionHeight {};
 
        vec3 UpDirection {};
        vec3 LookDirection {};
        vec3 RightDirection {};
        vec3 Position {};
        vec3 Focus {};
 
        shared<frame_buffer> MainFrameBuffer {};     
        shared<frame_buffer> GBuffer {};             
        shared<frame_buffer> HDRFrameBuffer {};      
        shared<frame_buffer> BlurFrameBuffers[2] {}; 
    public:
        camera_effects Effects {};
 
    public: 
        const matr4 &GetProjection() const { return Projection; }
        const matr4 &GetView() const { return View; }
        const matr4 &GetViewProjection() const { return ViewProjection; }
 
        camera_projection_type GetProjectionType() const { return ProjectionType; }
        float GetFieldOfView() const { return FieldOfView; }
        float GetProjectionDistance() const { return ProjectionDistance; };
        float GetFarClip() const { return FarClip; };
        int GetViewportWidth() const { return ViewportWidth; };
        int GetViewportHeight() const { return ViewportHeight; };
        float GetViewportProjectionWidth() const { return ViewportProjectionWidth; }
        float GetViewportProjectionHeight() const { return ViewportProjectionHeight; }
 
        const vec3 &GetUpDirection() const { return UpDirection; }
        const vec3 &GetDirection() const { return LookDirection; }
        const vec3 &GetRightDirection() const { return RightDirection; }
        const vec3 &GetPosition() const { return Position; }
        const vec3 &GetFocus() const { return Focus; }
 
        const shared<frame_buffer> &GetMainFrameBuffer() const { return MainFrameBuffer; }
        const shared<frame_buffer> &GetGBuffer() const { return GBuffer; }
        const shared<frame_buffer> &GetHDRFrameBuffer() const { return HDRFrameBuffer; }
        const shared<frame_buffer> &GetBlurFrameBuffers(int Index = 0) const { return BlurFrameBuffers[Index]; }
 
        void SetProjectionType(camera_projection_type ProjectionType);
        void SetFieldOfView(float FieldOfView);
        void SetProjectionDistance(float ProjectionDistance);
        void SetFarClip(float FarClip);
        void SetViewportWidth(int ViewportWidth);
        void SetViewportHeight(int ViewportHeight);
 
        void SetUpDirection(const vec3 &UpDirection);
        void SetDirection(const vec3 &Direction);
        void SetPosition(const vec3 &Position);
        void SetFocus(const vec3 &Focus);
 
        /*!*
         * Set view matrix by camera translation parametrs.
         * 
         * \param Position - camera position.
         * \param Focus - camera focusing point.
         * \param UpDirection - camera up direction.
         */
        void SetView(const vec3 &Position, const vec3 &Focus, const vec3 &UpDirection);
 
        /*!*
         * Set flag, showing wheather camera main buffer is swap chain target or not.
         *
         * \param IsSwapChainTarget - flag, showing wheather camera main buffer is swap chain target or not
         * \return None.
         */
        void SetRenderToSwapChain(bool IsSwapChainTarget);
 
    private:
        /*!*
         * Invalidate camera view projection matrix function.
         * 
         * \param None.
         * \retrun None.
         */
        void InvalidateViewProjection();
 
        /*!*
         * Invalidate camera projection matrix function.
         * 
         * \param None.
         * \return None.
         */
        void InvalidateProjection();
 
        /*!*
         * Invalidate camera view matrix function.
         * 
         * \param None.
         * \return None.
         */
        void InvalidateView();
 
        /*!*
         * Invalidate camera frame buffers function.
         * Creates uncreated ones, and resizes if needed.
         * 
         * \param None.
         * \return None.
         */
        void InvalidateBuffers();
 
        /*!***********************************************************************************
         * Frame buffers resize functions.
         * Call actual resize only if specifed viewport size is diffrent with buffer current.
         ************************************************************************************/
 
        void ResizeMainFrameBuffer();
        void ResizeGBuffer();
        void ResizeHDRFrameBuffer();
        void ResizeBlurFrameBuffers();
 
    public:
        /*!*
         * Render camera controller default constructor.
         * 
         * \param ProjectionType - render camera projection type.
         */
        camera(camera_projection_type ProjectionType, camera_effects Effects = {});
 
        ~camera() {}
 
        /*!*
         * Set camera project pixel size function..
         *
         * \param ViewportWidth, ViewportHeight - new projection plane size in pixels.
         * \return - self reference.
         */
        camera &Resize(int ViewportWidth, int ViewportHeight);
 
        /*!*
         * Camera rotate function..
         *
         * \param Axis - rotation axis.
         * \param Angle - rotation angle (in degree).
         * \return self reference.
         */
        camera &Rotate(const vec3 &Axis, degrees Angle);
 
        /*!*
         * Camera movement function.
         *
         * \param MoveVector - movement directions.
         * \return self reference.
         */
        camera &Move(const vec3 &MoveVector);
    };
}