CameraManipulator.hpp

#pragma once
#include <Gui/RaGui.hpp>
 
#include <memory>
 
#include <QKeyEvent>
#include <QMouseEvent>
#include <QObject>
 
#include <Core/CoreMacros.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Log.hpp>
 
#include <Core/Asset/Camera.hpp>
#include <Engine/Scene/CameraComponent.hpp>
#include <Gui/Utils/KeyMappingManager.hpp>
 
namespace Ra {
namespace Engine {
namespace Scene {
class Light;
}
 
} // namespace Engine
 
namespace Gui {
 
class RA_GUI_API CameraManipulator : public QObject
{
    Q_OBJECT
 
  public:
    CameraManipulator();
 
    explicit CameraManipulator( const CameraManipulator& other );
 
    virtual ~CameraManipulator();
 
    virtual KeyMappingManager::Context mappingContext();
 
    virtual bool handleMousePressEvent( QMouseEvent* event,
                                        const Qt::MouseButtons& buttons,
                                        const Qt::KeyboardModifiers& modifiers,
                                        int key );
    virtual bool handleMouseReleaseEvent( QMouseEvent* event );
    virtual bool handleMouseMoveEvent( QMouseEvent* event,
                                       const Qt::MouseButtons& buttons,
                                       const Qt::KeyboardModifiers& modifiers,
                                       int key );
    virtual bool handleWheelEvent( QWheelEvent* event,
                                   const Qt::MouseButtons& buttons,
                                   const Qt::KeyboardModifiers& modifiers,
                                   int key );
 
    virtual bool handleKeyPressEvent( QKeyEvent* event,
                                      const KeyMappingManager::KeyMappingAction& action );
    virtual bool handleKeyReleaseEvent( QKeyEvent* event,
                                        const KeyMappingManager::KeyMappingAction& action );
 
    const Core::Asset::Camera* getCamera() const { return m_camera; }
 
    Core::Asset::Camera* getCamera() { return m_camera; }
 
    virtual void updateCamera();
 
    void attachLight( Engine::Scene::Light* light );
 
    bool hasLightAttached() const { return m_light != nullptr; }
 
    Engine::Scene::Light* getLight() { return m_light; }
 
  public slots:
    void setCameraSensitivity( Scalar sensitivity );
    void setCameraFov( Scalar fov );
    void setCameraFovInDegrees( Scalar fov );
    void setCameraZNear( Scalar zNear );
    void setCameraZFar( Scalar zFar );
 
    void mapCameraBehaviourToAabb( const Core::Aabb& aabb );
 
    void unmapCameraBehaviourToAabb();
 
    virtual void fitScene( const Core::Aabb& aabb ) = 0;
 
    virtual void setCameraPosition( const Core::Vector3& position ) = 0;
 
    virtual void setCameraTarget( const Core::Vector3& target ) = 0;
 
    virtual void resetCamera() = 0;
 
  signals:
 
  protected:
    std::pair<Scalar, Scalar> computeDeltaMouseMove( const QMouseEvent* mouseEvent ) {
        return { ( mouseEvent->pos().x() - m_lastMouseX ) / m_camera->getWidth(),
                 ( mouseEvent->pos().y() - m_lastMouseY ) / m_camera->getHeight() };
    }
 
    Scalar m_lastMouseX { 0_ra };
 
    Scalar m_lastMouseY { 0_ra };
 
    Scalar m_cameraSensitivity { 1_ra };
    Scalar m_quickCameraModifier { 1_ra };
    Scalar m_wheelSpeedModifier { 0.02_ra };
 
    Core::Aabb m_targetedAabb;                 
    Scalar m_targetedAabbVolume { 0_ra };      
    bool m_mapCameraBahaviourToAabb { false }; 
 
    Core::Vector3 m_target { 0_ra, 0_ra, 0_ra };
 
    Core::Asset::Camera* m_camera { nullptr }; 
    Engine::Scene::Light* m_light { nullptr }; 
};
 
} // namespace Gui
} // namespace Ra