Camera.hpp

#pragma once
#ifndef __H__OCULAR_CORE_SCENE_CAMERA__H__
#define __H__OCULAR_CORE_SCENE_CAMERA__H__

#include "Priority.hpp"
#include "Scene/SceneObject.hpp"

#include "Graphics/Texture/RenderTexture.hpp"
#include "Graphics/Texture/DepthTexture.hpp"
#include "Graphics/Viewport.hpp"

#include "Events/AEventListener.hpp"

#include "Math/Geometry/Frustum.hpp"
#include "Math/Bounds/Ray.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        enum class ProjectionType
        {
            Unknown = 0,
            Perspective,
            Orthographic
        };

        struct PerspectiveProjection
        {
            float fieldOfView;
            float aspectRatio;
            float nearClip;
            float farClip;

            PerspectiveProjection();
        };

        struct OrthographicProjection
        {
            float xMin;
            float xMax;
            float yMin;
            float yMax;
            float nearClip;
            float farClip;

            OrthographicProjection();
        };

        class Camera : public SceneObject, AEventListener
        {
        public:

            Camera(std::string const& name, SceneObject* parent = nullptr);

            Camera();

            virtual ~Camera();
            
            void setRenderTexture(Graphics::RenderTexture* renderTexture);
            
            Graphics::RenderTexture* getRenderTexture();
            
            void setDepthTexture(Graphics::DepthTexture* depthTexture);
            
            Graphics::DepthTexture* getDepthTexture();
            
            ProjectionType getProjectionType() const;
            
            PerspectiveProjection getPerspectiveProjection() const;
            
            OrthographicProjection getOrthographicProjection() const;
            
            void setProjectionOrthographic(float xMin, float xMax, float yMin, float yMax, float nearClip, float farClip);

            void setProjectionOrthographic(OrthographicProjection const& projection);
            
            void setProjectionPerspective(float fov, float aspectRatio, float nearClip, float farClip);

            void setProjectionPerspective(PerspectiveProjection const& projection);
            
            void setProjectionMatrix(Math::Matrix4x4 const& matrix);
            
            Math::Matrix4x4 const& getViewMatrix();
            
            Math::Matrix4x4 const& getProjectionMatrix() const;
            
            Math::Frustum const& getFrustum(bool updateFrustum = true);
            
            void setPriority(Priority priority);
            
            Priority getPriority() const;
            
            void setViewport(float x, float y, float width, float height, float minDepth = 0.0f, float maxDepth = 1.0f, bool updateMatrix = true);
            
            Graphics::Viewport* getViewport() const;

            void setFixedViewport(bool fixed);

            bool getIsFixedViewport() const;
            
            void setFixedProjection(bool fixed);
            
            bool getIsFixedProjection() const;

            void setClearColor(Core::Color const& color);

            Color const& getClearColor() const;
            
            Math::Vector3f screenToWorld(Math::Vector2i const& screenPos);

            Math::Vector2i worldToScreen(Math::Vector3f const& worldPos);

            Math::Ray getPickRay(Math::Vector2i const& screenPos);

            virtual bool onEvent(std::shared_ptr<AEvent> event) override;

        protected:

            void onCreation();
            void exposeVariables();

            void updateViewport(float width, float height);

            //------------------------------------------------------------

            ProjectionType m_ProjType;

            PerspectiveProjection m_PerspectiveProj;
            OrthographicProjection m_OrthographicProj;

            Math::Matrix4x4 m_ViewMatrix;
            Math::Matrix4x4 m_ProjMatrix;

            Math::Frustum m_Frustum;

            Graphics::RenderTexture* m_RenderTexture;
            Graphics::DepthTexture* m_DepthTexture;
            Graphics::Viewport* m_Viewport;

            Core::Color m_ClearColor;

            Priority m_Priority;

            bool m_IsFixedViewport;
            bool m_IsFixedProjection;
            bool m_IsFrustumDirty;

        private:
        };
    }
}
//------------------------------------------------------------------------------------------

#endif