orbitcontroller.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
 
#include <component.h>
#include <componentptr.h>
#include "perspcameracomponent.h"
#include <glm/glm.hpp>
 
namespace nap
{
    class OrbitControllerInstance;
    class KeyPressEvent;
    class KeyReleaseEvent;
    class PointerPressEvent;
    class PointerMoveEvent;
    class PointerReleaseEvent;
    class TransformComponentInstance;
    class TransformComponent;
    class KeyInputComponent;
    class KeyInputComponent;
 
    class NAPAPI OrbitController : public Component
    {
        RTTI_ENABLE(Component)
        DECLARE_COMPONENT(OrbitController, OrbitControllerInstance)
    public:
        virtual void getDependentComponents(std::vector<rtti::TypeInfo>& components) const override;
 
        float       mMovementSpeed = 0.5f;          
        float       mRotateSpeed = 0.005f;          
        float       mMinZoomDistance = 0.5f;        
        bool        mLimitZoomDistance = false;     
        glm::vec3   mLookAtPos;                     
 
        ComponentPtr<PerspCameraComponent>  mPerspCameraComponent;  
    };
 
 
    class NAPAPI OrbitControllerInstance : public ComponentInstance
    {
        RTTI_ENABLE(ComponentInstance)
    public:
        OrbitControllerInstance(EntityInstance& entity, Component& resource);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        void enable(const glm::vec3& cameraPos, const glm::vec3& lookAtPos);
 
        void enable(const glm::vec3& lookAtPos);
 
        void disable()                                      { mEnabled = false; }
 
        const glm::vec3 getLookAtPos() const                { return mLookAtPos; }
 
        float getMovementSpeed() const                      { return mMovementSpeed; }
 
        void setMovementSpeed(float speed)                  { mMovementSpeed = speed; }
 
        float getRotateSpeed() const                        { return mRotateSpeed; }
 
        void setRotateSpeed(float speed)                    { mRotateSpeed = speed; }
 
        CameraComponentInstance& getCameraComponent();
 
    private:
        void onMouseDown(const PointerPressEvent& pointerPressEvent);
 
        void onMouseMove(const PointerMoveEvent& pointerMoveEvent);
 
        void onMouseUp(const PointerReleaseEvent& pointerReleaseEvent);
 
    private:
        // Camera mode
        enum class EMode
        {
            Idle,           
            Rotating,       
            Zooming         
        };
 
        ComponentInstancePtr<PerspCameraComponent>      mPerspCameraComponent = { this, &OrbitController::mPerspCameraComponent };
        TransformComponentInstance*                     mTransformComponent = nullptr;      // The transform component used to move the entity
        EMode                                           mMode = EMode::Idle;                // Camera mode
        glm::vec3                                       mLookAtPos;                         // Target position to orbit around
        bool                                            mEnabled = false;                   // Enables responding to input
        float                                           mMovementSpeed = 0.5f;              
        float                                           mRotateSpeed = 0.005f;              
    };
 
}