Gizmo.hpp

#pragma once
 
#include <vector>
 
#include <Core/Types.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/Index.hpp>
 
#include <Core/Asset/Camera.hpp>
#include <Engine/Data/RenderParameters.hpp>
#include <Engine/RadiumEngine.hpp>
#include <Engine/Rendering/RenderObject.hpp>
#include <Engine/Scene/CameraComponent.hpp>
 
namespace Ra {
namespace Engine {
 
namespace Data {
class PlainMaterial;
} // namespace Data
 
namespace Scene {
class Component;
} // namespace Scene
 
namespace Rendering {
class RenderTechnique;
class RenderObject;
} // namespace Rendering
} // namespace Engine
 
namespace Gui {
class Gizmo
{
  public:
    enum Mode {
        LOCAL,
        GLOBAL,
    };
 
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    Gizmo( Engine::Scene::Component* c,
           const Core::Transform& worldTo,
           const Core::Transform& t,
           Mode mode );
 
    virtual ~Gizmo();
 
    // shows or hides the gizmos drawables.
    void show( bool on );
 
    virtual void
    updateTransform( Mode mode, const Core::Transform& worldTo, const Core::Transform& t ) = 0;
 
    virtual void selectConstraint( int drawableIndex ) = 0;
 
    virtual bool isSelected() = 0;
 
    virtual void setInitialState( const Core::Asset::Camera& cam,
                                  const Core::Vector2& initialXY ) = 0;
 
    virtual Core::Transform mouseMove( const Core::Asset::Camera& cam,
                                       const Core::Vector2& nextXY,
                                       bool stepped = false,
                                       bool whole   = false ) = 0;
 
  protected:
    static bool findPointOnAxis( const Core::Asset::Camera& cam,
                                 const Core::Vector3& origin,
                                 const Core::Vector3& axis,
                                 const Core::Vector2& pix,
                                 Core::Vector3& pointOut,
                                 std::vector<Scalar>& hits );
 
    static bool findPointOnPlane( const Core::Asset::Camera& cam,
                                  const Core::Vector3& origin,
                                  const Core::Vector3& axis,
                                  const Core::Vector2& pix,
                                  Core::Vector3& pointOut,
                                  std::vector<Scalar>& hits );
 
    inline const std::vector<Engine::Rendering::RenderObject*>& ros() const { return m_ros; }
 
    void addRenderObject( Engine::Rendering::RenderObject* ro );
 
    static std::shared_ptr<Engine::Rendering::RenderTechnique> makeRenderTechnique( int color );
 
    static std::array<std::shared_ptr<Ra::Engine::Data::PlainMaterial>, 3> s_material;
 
  protected:
    Core::Transform m_worldTo;        
    Core::Transform m_transform;      
    Engine::Scene::Component* m_comp; 
    Mode m_mode;                      
 
    class UiSelectionControler final : public Engine::Data::ShaderParameterProvider
    {
      public:
        explicit UiSelectionControler(
            std::shared_ptr<Ra::Engine::Data::PlainMaterial>& material,
            const Core::Utils::Color& selectedColor = Core::Utils::Color::Yellow() );
        UiSelectionControler()                              = delete;
        UiSelectionControler( const UiSelectionControler& ) = delete;
        ~UiSelectionControler() override                    = default;
        void updateGL() override;
        void toggleState();
        void setState();
        void clearState();
 
      private:
        std::shared_ptr<Ra::Engine::Data::PlainMaterial> m_associatedMaterial;
        Core::Utils::Color m_selectedColor;
        bool m_selected { false };
    };
 
    Gizmo::UiSelectionControler* getControler( int ro );
 
  private:
    std::vector<Engine::Rendering::RenderObject*> m_ros; 
};
} // namespace Gui
} // namespace Ra