CameraComponent.hpp

#ifndef CAMERA_COMPONENT_H
#define CAMERA_COMPONENT_H

#include <string>
#include "Vec3.hpp"
#include "Matrix.hpp"
#include "RenderTexture.hpp"

namespace ae3d
{
    class CameraComponent
    {
    public:
        class GameObject* GetGameObject() const { return gameObject; }

        enum class ProjectionType { Orthographic, Perspective };
        
        enum class ClearFlag { DepthAndColor, Depth, DontClear };
        
        const Matrix44& GetProjection() const { return projectionMatrix; }

        const Matrix44& GetView() const { return viewMatrix; }

        Vec3 GetScreenPoint( const Vec3& worldPoint, float viewWidth, float viewHeight ) const;
        
        ProjectionType GetProjectionType() const { return projectionType; }

        void SetProjectionType( ProjectionType aProjectionType ) { projectionType = aProjectionType; }
        
        void SetProjection( float left, float right, float bottom, float top, float near, float far );

        void SetProjection( float fovDegrees, float aspect, float near, float far );

        void SetProjection( const Matrix44& proj );

        Vec3 GetClearColor() const { return clearColor; }

        RenderTexture* GetTargetTexture() { return targetTexture; }

        RenderTexture& GetDepthNormalsTexture() { return depthNormalsTexture; }

        void SetClearColor( const Vec3& color );

        void SetTargetTexture( RenderTexture* renderTexture );

        void SetClearFlag( ClearFlag aClearFlag ) { clearFlag = aClearFlag; }
        
        void SetLayerMask( unsigned aLayerMask ) { layerMask = aLayerMask; }
        
        unsigned GetRenderOrder() const { return renderOrder; }

        void SetRenderOrder( unsigned order ) { renderOrder = order; }
        
        unsigned GetLayerMask() const { return layerMask; }
        
        ClearFlag GetClearFlag() const { return clearFlag; }
        
        float GetNear() const { return nearp; }

        float GetFar() const { return farp; }

        float GetAspect() const { return aspect; }

        float GetFovDegrees() const { return fovDegrees; }

        std::string GetSerialized() const;

        float GetLeft() const { return orthoParams.left; }

        float GetRight() const { return orthoParams.right; }

        float GetBottom() const { return orthoParams.down; }

        float GetTop() const { return orthoParams.top; }

        void SetView( const Matrix44& view ) { viewMatrix = view; }

    private:
        friend class GameObject;
        friend class Scene;

        static int Type() { return 0; }
        
        static unsigned New();
        
        static CameraComponent* Get( unsigned index );

        Matrix44 projectionMatrix;
        Matrix44 viewMatrix;
        Vec3 clearColor;
        RenderTexture* targetTexture = nullptr;
        RenderTexture depthNormalsTexture;

        struct OrthoParams
        {
            float left = 0;
            float right = 100;
            float top = 0;
            float down = 100;
        } orthoParams;

        float nearp = 0;
        float farp = 1;
        float fovDegrees = 45;
        float aspect = 1;
        unsigned layerMask = 1;
        unsigned renderOrder = 0;
        ProjectionType projectionType = ProjectionType::Orthographic;
        ClearFlag clearFlag = ClearFlag::DepthAndColor;
        GameObject* gameObject = nullptr;
    };
}
#endif