FnGLTransformManipulator.h

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

#ifndef GLTRANSFORMMANIPULATOR_H_
#define GLTRANSFORMMANIPULATOR_H_

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

#include <FnViewer/utils/FnGLManipulator.h>
#include <FnViewer/plugin/FnMathTypes.h>

#include <ImathVec.h>
#include <ImathMatrix.h>
#include <ImathEuler.h>
#include <ImathMatrixAlgo.h>

namespace Foundry
{
namespace Katana
{
namespace ViewerUtils
{
using namespace Foundry::Katana::ViewerAPI;

enum Orientation { OBJECT = 0, WORLD, VIEW };

static constexpr std::size_t kSnappingMappingSize = 6;
static const std::array<IMATH_NAMESPACE  ::V3d, kSnappingMappingSize>
    kSnappingMappingFromIndexToAxis = {
        // clang-tidy off
        IMATH_NAMESPACE  ::V3d(1.0, 0.0, 0.0),
       
        IMATH_NAMESPACE  ::V3d(-1.0, 0.0, 0.0),
        IMATH_NAMESPACE  ::V3d(0.0, 1.0, 0.0),
       
        IMATH_NAMESPACE  ::V3d(0.0, -1.0, 0.0),
        IMATH_NAMESPACE  ::V3d(0.0, 0.0, 1.0),
       
        IMATH_NAMESPACE  ::V3d(0.0, 0.0, -1.0),
        // clang-tidy on
};

enum TransformMode {
    kObject,                  // Transform applies to objects (default mode).
    kCenterOfInterest,        // Transform applies to the center of interest.
    kAroundCenterOfInterest,  // Transform applies to objects, which will remain
                              // oriented towards the center of interest.
};

struct SnappingData
{
    SnappingData() : snap(false) {}
    bool snap;     // Whether the manipulator handle should snap or not.
    Vec3d point;   // The point the manipulator handle should snap to.
    Vec3d normal;  // The orientation the manipulator handle should adopt.
};

class GLTransformManipulator : public GLManipulator
{

public:

    GLTransformManipulator();

    virtual ~GLTransformManipulator();

    IMATH_NAMESPACE::Eulerd::Order getRotationOrder(
        const std::string& locationPath);

    std::string getLastLocationPath();

    virtual void setOption(
        Foundry::Katana::ViewerAPI::OptionIdGenerator::value_type optionId,
        FnAttribute::Attribute attr);

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

    double getFixedSizeScale(IMATH_NAMESPACE::V3d point);

    IMATH_NAMESPACE::M44d getInitialTranslateXformFromLocation(
        const std::string& locationPath);
    IMATH_NAMESPACE::M44d getTranslateXformFromLocation(
        const std::string& locationPath);
    IMATH_NAMESPACE::M44d getInitialRotateXformFromLocation(
        const std::string& locationPath);
    IMATH_NAMESPACE::M44d getRotateXformFromLocation(
        const std::string& locationPath);
    IMATH_NAMESPACE::M44d getInitialScaleXformFromLocation(
        const std::string& locationPath);
    IMATH_NAMESPACE::M44d getScaleXformFromLocation(
        const std::string& locationPath);

    IMATH_NAMESPACE::V3d getInitialPositionFromLocation(
        const std::string& locationPath);

    IMATH_NAMESPACE::V3d getInitialDirectionFromLocation(
        const std::string& locationPath);

    IMATH_NAMESPACE::V3d getInitialCoiFromLocation(
        const std::string& locationPath);

    IMATH_NAMESPACE::V3d getInitialShadowFallPositionFromLocation(
        const std::string& locationPath);

    IMATH_NAMESPACE::M44d getInitialOrientationXform(
        const std::string& locationPath,
        Orientation orientation);

    IMATH_NAMESPACE::M44d getOrientationXform(const std::string& locationPath,
                                              Orientation orientation);

    void applyRotationAroundCoiToAllLocations(double angle,
                                              const IMATH_NAMESPACE::V3d& axis,
                                              Orientation orientation,
                                              bool isFinal);

    void applyCoiTranslationToAllLocations(const IMATH_NAMESPACE::V3d& delta,
                                           double distance,
                                           Orientation orientation,
                                           bool isFinal);

    void applyTranslationAroundCoiToAllLocations(bool isFinal);

    void applyOrientationToLocation(const std::string& locationPath,
                                    const IMATH_NAMESPACE::M44d& rotateMatrix,
                                    bool isFinal);

    void setLocationOrientation(const std::string& locationPath,
                                const IMATH_NAMESPACE::M44d& rotateMatrix,
                                bool isFinal);

    void setInteractiveRotation(const std::string& locationPath,
                                const IMATH_NAMESPACE::M44d& rotateMatrix,
                                bool isFinal);

    void applyTranslationToLocation(const std::string& locationPath,
                                    const IMATH_NAMESPACE::V3d& deltaWorldSpace,
                                    bool isFinal);

    unsigned int getSnappingHitAreaSize() const
    {
        return m_snappingHitAreaSize;
    }

    IMATH_NAMESPACE::V3d getAxisNormalOrientation() const
    {
        // Assert that the index is not out of bounds
        assert(m_snappingAxisNormalOrientationIndex <
               kSnappingMappingSize);
        return kSnappingMappingFromIndexToAxis
            [m_snappingAxisNormalOrientationIndex];
    }

    IMATH_NAMESPACE::V3d getAxisUpOrientation() const
    {
        // Assert that the index is not out of bounds
        assert(m_snappingAxisUpOrientationIndex <
               kSnappingMappingSize);
        return kSnappingMappingFromIndexToAxis
            [m_snappingAxisUpOrientationIndex];
    }

    // Returns a matrix that rotates the "fromDir" vector
    // so that it points towards "toDir".  You may also
    // specify that you want the "fromUpDir" vector to be pointing
    // in a certain direction "toUpDir".
    // This has been taken from Imath/ImathMatrixAlgo.h:rotationMatrixWithUpDir
    // and modified to accept an arbitrary source 'up' direction.
    static IMATH_NAMESPACE::M44d rotationMatrixWithUpDir(
        const IMATH_NAMESPACE::V3d& fromDir,
        const IMATH_NAMESPACE::V3d& toDir,
        const IMATH_NAMESPACE::V3d& fromUpDir,
        const IMATH_NAMESPACE::V3d& toUpDir = {0.0, 1.0, 0.0});

protected:
    ViewerDelegateWrapperPtr getViewerDelegate();

private:
    void setSnappingAxisNormalOrientation(const FnAttribute::Attribute& attr);

    void setSnappingAxisUpOrientation(const FnAttribute::Attribute& attr);

private:
    double m_globalScale;

    unsigned int m_snappingHitAreaSize = 100;

    std::size_t m_snappingAxisNormalOrientationIndex = 4;

    std::size_t m_snappingAxisUpOrientationIndex = 2;
};

class GLTransformManipulatorHandle : public GLManipulatorHandle
{
public:
    explicit GLTransformManipulatorHandle(bool alwaysAtLocationOrigin);

    virtual ~GLTransformManipulatorHandle();

    virtual void cancelManipulation();

    virtual void draw();

    virtual void pickerDraw(int64_t pickerID);

    virtual Orientation getOrientation();

    Vec4f getDisplayColor(const Vec4f& color);

    virtual std::string getComponentName() = 0;

    double getScale() { return m_manipScale; }

    IMATH_NAMESPACE::V3d getOrigin() { return m_manipOrigin; }

    void placeOnCenterOfInterest(bool placeOnCoi)
    {
        m_placeOnCoi = placeOnCoi;
    }

    bool isPlacedOnCenterOfInterest() const
    {
        return m_placeOnCoi;
    }

    void setTransformMode(TransformMode transformMode)
    {
        m_transformMode = transformMode;
    }

    TransformMode getTransformMode() { return m_transformMode; }

protected:
    static bool isSnapWithOrientation(const SnappingData& snappingData);

protected:

    GLTransformManipulator* getGLTransformManipulator();

    bool isParallelToCamera(const IMATH_NAMESPACE::V3d& axis);

    bool isPerpendicularToCamera(const IMATH_NAMESPACE::V3d& axis);

    IMATH_NAMESPACE::V3d getCameraRayDirection();

    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) {}

    void endDrag();

    void applyXformToAllLocations(const IMATH_NAMESPACE::M44d& xform,
                                  bool isFinal);

    virtual void applyXformToLocation(const std::string& locationPath,
                                      const IMATH_NAMESPACE::M44d& xform,
                                      bool isFinal) = 0;

    virtual IMATH_NAMESPACE::M44d applyManipulationXform(
        const IMATH_NAMESPACE::M44d& xform,
        const std::string& locationPath);

    int m_handlePriority;

    IMATH_NAMESPACE::M44d calculateXform(const std::string& locationPath,
                                         bool includeComponent = false);

    virtual void calculateAndSetLocalXform(const std::string& locationPath);

    SnappingData pickSnappingTarget(const Vec2i& mousePosition);

    void setAllLocationsOrientation(const IMATH_NAMESPACE::M44d& rotateMatrix,
                                    bool isFinal);

    void restoreAllLocationsXform();

private:
    virtual IMATH_NAMESPACE::M44d getOrientationXform(
        const std::string& location);

    void restoreLocationXform(const std::string& locationPath);

    void copyLocationAttr(const std::string& locationPath,
                             const char* attrSrc,
                             const char* attrDst);
    bool m_alwaysAtObjectOrigin;

    // Caches the scale of the manipulator. Set by calculateXform().
    double m_manipScale;

    // Caches the origin of the manipulator. Set by calculateXform().
    IMATH_NAMESPACE::V3d m_manipOrigin;

    bool m_placeOnCoi;

    TransformMode m_transformMode;
};


}
}
}

#endif /* GLTRANSFORMMANIPULATOR_H_ */