SceneObject.hpp

#pragma once
#ifndef __H__OCULAR_CORE_SCENE_OBJECT__H__
#define __H__OCULAR_CORE_SCENE_OBJECT__H__

#include "Object.hpp"

#include "ObjectIO/ObjectIO.hpp"

#include "Math/Transform.hpp"
#include "Math/Bounds/BoundsSphere.hpp"
#include "Math/Bounds/BoundsAABB.hpp"
#include "Math/Bounds/BoundsOBB.hpp"

#include "Graphics/Shader/Uniform/UniformPerObject.hpp"

#include <string>
#include <map>
#include <vector>

#include "Math/Matrix3x3.hpp"

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

namespace Ocular
{
    namespace Math
    {
        class Matrix4x4;
    }

    namespace Core
    {
        class SceneManager;
        class ARoutine;
        class ARenderable;

        class SceneObject : public Object
        {
            friend class SceneManager;

        public:
            
            SceneObject(std::string const& name, SceneObject* parent = nullptr, std::string const& type = "SceneObject");

            SceneObject();

            virtual ~SceneObject();

            //------------------------------------------------------------
            // General Misc. Methods
            //------------------------------------------------------------

            virtual void onVariableModified(std::string const& varName) override;

            Math::Transform& getTransform();

            void setActive(bool active);

            bool isActive() const;

            void setVisible(bool visible);

            bool isVisible() const;

            void setForcedVisible(bool forced);

            bool isForcedVisible() const;

            void setStatic(bool isStatic);

            bool isStatic() const;

            void setPersistent(bool persists);

            bool isPersistent() const;

            Graphics::UniformPerObject const& getUniformData(Math::Matrix4x4 const& viewMatrix, Math::Matrix4x4 const& projMatrix);

            //------------------------------------------------------------
            // Movement and Rotation Methods
            //------------------------------------------------------------

            void setPosition(float x, float y, float z);

            void setPosition(Math::Vector3f const& position);

            Math::Vector3f getPosition(bool local = true) const;

            void translate(Math::Vector3f const& translation, bool local = true);

            void rotate(float angle, Math::Vector3f const& axis);

            void rotate(Math::Quaternion const& rotation);

            void setRotation(Math::Quaternion const& rotation);

            void resetRotation();

            Math::Quaternion const& getRotation() const;

            void setScale(Math::Vector3f const& scale);

            void setScale(float xScale, float yScale, float zScale);

            Math::Vector3f getScale(bool local = true) const;

            void setTransform(Math::Transform const& transform);

            void lookAt(Math::Vector3f const& point);

            Math::Transform const& getTransform() const;

            virtual Math::Matrix4x4 getModelMatrix(bool local = true) const;

            //------------------------------------------------------------
            // Child Object Methods
            //------------------------------------------------------------

            void setParent(SceneObject* parent, bool maintainWorldPos = true);

            SceneObject* getParent() const;

            SceneObject* createChild(std::string const& name);

            void addChild(SceneObject* child, bool maintainWorldPos = true);

            SceneObject* findChild(std::string const& name);

            SceneObject* findChild(UUID const& uuid);

            SceneObject* removeChild(std::string const& name);

            SceneObject* removeChild(UUID const& uuid);

            SceneObject* removeChild(SceneObject const* object);

            uint32_t getNumChildren() const;

            std::vector<SceneObject*> const& getAllChildren() const;

            //------------------------------------------------------------
            // Routine Methods
            //------------------------------------------------------------

            ARoutine* addRoutine(std::string const& name);

            void addRoutine(ARoutine* routine);

            template<class T> T* addRoutine() 
            { 
                T* t = new T();
                ARoutine* routine = dynamic_cast<ARoutine*>(t);

                if(routine)
                {
                    routine->setParent(this);
                    m_Routines.push_back(routine);
                    routine->onCreation();
                }
                else
                {
                    // T is not a routine
                    delete t;
                    t = nullptr;
                }

                return t;
            }

            bool removeRoutine(std::string const& name);

            bool removeRoutine(ARoutine* routine, bool transferring = false);

            void removeAllRoutines();

            ARoutine* getRoutine(std::string const& name);

            std::vector<ARoutine*> const& getAllRoutines() const;

            uint32_t getNumRoutines() const;

            //------------------------------------------------------------
            // Renderable Methods
            //------------------------------------------------------------
            
            ARenderable* setRenderable(std::string const& name);

            void setRenderable(ARenderable* renderable);

            template<class T>
            T* setRenderable()
            {
                T* t = new T();
                ARenderable* renderable = dynamic_cast<ARenderable*>(t);

                if(renderable)
                {
                    removeRenderable();
                    m_Renderable = renderable;
                    m_Renderable->m_Parent = this;
                }
                else
                {
                    delete t;
                    t = nullptr;
                }

                return t;
            }

            void removeRenderable(bool transferring = false);

            ARenderable* getRenderable() const;

            //------------------------------------------------------------
            // Inherited Methods
            //------------------------------------------------------------

            virtual void onLoad(BuilderNode const* node) override;
            virtual void onSave(BuilderNode* node) const override;

            //------------------------------------------------------------
            // Bounds Related
            //------------------------------------------------------------

            void forceBoundsRebuild();

            Math::BoundsSphere getBoundsSphere(bool local);

            Math::BoundsAABB getBoundsAABB(bool local);

            Math::BoundsOBB getBoundsOBB(bool local);

        protected:

            void getModelMatrix(Math::Matrix4x4& matrix);
            virtual void updateBounds(uint32_t dirtyFlags);

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

            SceneObject* m_Parent;
            uint32_t m_Layer;          

            // Physical Characteristics

            Graphics::UniformPerObject m_UniformData;
            Math::Transform m_Transform;

            Math::BoundsSphere m_BoundsSphereLocal;
            Math::BoundsAABB   m_BoundsAABBLocal;
            Math::BoundsOBB    m_BoundsOBBLocal;
            Math::BoundsSphere m_BoundsSphereWorld;
            Math::BoundsAABB   m_BoundsAABBWorld;
            Math::BoundsOBB    m_BoundsOBBWorld;

        private:

            void removeChild(std::vector<SceneObject*>::iterator& child);

            //------------------------------------------------------------
            
            bool m_IsStatic;           
            bool m_IsActive;           
            bool m_IsVisible;          
            bool m_ForcedVisible;      
            bool m_Persists;           

            std::vector<ARoutine*> m_Routines;
            ARenderable* m_Renderable;

            std::vector<SceneObject*> m_Children;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif