FnGLManipulator.h

// Copyright (c) 2017 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef GLMANIPULATOR_H_
#define GLMANIPULATOR_H_

#include <FnViewer/plugin/FnManipulator.h>
#include <FnViewer/plugin/FnManipulatorHandle.h>
#include <FnViewer/plugin/FnMathTypes.h>
#include <FnViewer/plugin/FnEventWrapper.h>
#include <FnViewer/utils/FnGLShaderProgram.h>

#include <stdint.h>
#include <string>

namespace Foundry
{
namespace Katana
{
namespace ViewerUtils
{

enum RenderMode
{
    kPicking = 0,
    kShadingFlat = 1,
    kShading3D = 2,
    kLineStipple = 3,
    kTextured = 4,
};

// A lot of entities from the ViewerAPI namespace will be accessed.
using namespace Foundry::Katana::ViewerAPI;

class GLManipulator : public Manipulator
{
public:

    GLManipulator();

    virtual ~GLManipulator();

    static const std::string kTechnology;
};

class GLManipulatorHandle : public ManipulatorHandle
{
public:

    GLManipulatorHandle();

    virtual ~GLManipulatorHandle();

   virtual void cancelManipulation();

    virtual void draw();

    virtual void pickerDraw(int64_t pickerID);

    virtual bool event(const FnEventWrapper& eventData);

    virtual FnAttribute::Attribute getOption(
            Foundry::Katana::ViewerAPI::OptionIdGenerator::value_type);

protected:
    GLManipulator* getGLManipulator();

    ViewportWrapperPtr getViewport();

    ViewerDelegateWrapperPtr getViewerDelegate();

    bool isDragging();

    bool hasBeenDragged();

    virtual bool getDraggingPlane(Vec3d& origin, Vec3d& normal);

    virtual void startDrag(const Vec3d& initialPointOnPlane,
                           const Vec2i& initialMousePosition);

    virtual void drag(const Vec3d& initialPointOnPlane,
                      const Vec3d& previousPointOnPlane,
                      const Vec3d& currentPointOnPlane,
                      const Vec2i& initialMousePosition,
                      const Vec2i& previousMousePosition,
                      const Vec2i& currentMousePosition,
                      bool isFinal);

    virtual void endDrag();

    virtual bool canProcessKeyboardModifiers(int modifiers) const
    {
        return modifiers == FnEventWrapper::kNoModifier;
    }

    void useDrawingShader(const Matrix44d& xform, const Vec4f& color,
                          bool isFlat);

    void useSnappingShader(const Matrix44d& xform);

    void useLineStippleDrawingShader(const Matrix44d& xform,
                                     const Vec4f& color, int pattern,
                                     float factor);

    void usePickingShader(const Matrix44d& xform, int handleId,
                          int handlePriority);

    int getLatestKeyboardModifiers() const
    {
        return m_latestKeyboardModifiers;
    }

    const Vec2i& getLatestMousePosition() const
    {
        return m_latestMousePosition;
    }

    const Matrix44d& getInitialHandleXform() const {
        return m_initialHandleXform;
    }
    const Vec3d& getInitialPointOnPlane() const {
        return m_initialPointOnPlane;
    }
    const Vec3d& getLastPointOnPlane() const {
        return m_previousPointOnPlane;
    }
    const Vec2i& getInitialMousePosition() const {
        return m_initialMousePosition;
    }
    const Vec2i& getLastMousePosition() const {
        return m_previousMousePosition;
    }

private:
    static void useShader(ViewportWrapperPtr viewport, const Matrix44d& xform,
                          RenderMode renderMode,
                          GLShaderProgram& shaderProgram);

    bool m_processingManipulation;

    Matrix44d m_localXform;

    GLShaderProgram m_shaderProgram;
    GLShaderProgram m_shaderProgramLineStipple;

    Vec2i m_latestMousePosition;

    int m_latestKeyboardModifiers;

    Matrix44d m_initialHandleXform;

    Vec3d m_initialPointOnPlane;
    Vec3d m_previousPointOnPlane;

    Vec2i m_initialMousePosition;
    Vec2i m_previousMousePosition;

    bool m_isDragging;

    bool m_hasBeenDragged;
};


}
}
}

#endif /* GLMANIPULATOR_H_ */