FnManipulatorHandle.h

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

#ifndef FNMANIPULATORHANDLE_H_
#define FNMANIPULATORHANDLE_H_

#include <FnViewer/suite/FnManipulatorHandleSuite.h>
#include <FnViewer/plugin/FnEventWrapper.h>
#include <FnViewer/plugin/FnManipulator.h>
#include <FnViewer/plugin/FnMathTypes.h>

#include <FnPluginSystem/FnPluginSystem.h>
#include <FnPluginSystem/FnPlugin.h>
#include <FnAttribute/FnAttribute.h>

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

#ifndef FNKAT_UNUSED
    #define FNKAT_UNUSED(x) (void)x
#endif



namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

class ManipulatorHandlePluginBase
{
public:

    ManipulatorHandlePluginBase();

    virtual ~ManipulatorHandlePluginBase();

public: /* Methods to be called by the plugin. */

    ManipulatorWrapperPtr getManipulator();

    Matrix44d getXform();

    void setLocalXform(const Matrix44d& xform);

    Matrix44d getLocalXform();

    bool isActive();

    bool isHovered();

public:
    static FnPlugStatus setHost(FnPluginHost* host);
    static FnPluginHost* getHost();

protected:
    FnManipulatorHandleHostSuite_v1* m_hostSuite;
    FnManipulatorHandleHostHandle m_hostHandle;

    static FnPluginHost* m_host;

private:
    ManipulatorWrapperPtr m_manipulatorWrapper;

};


class ManipulatorHandle : public ManipulatorHandlePluginBase
{
public:
    ManipulatorHandle();
    virtual ~ManipulatorHandle();

public: /* Virtual functions to be extended by the plugin. */

    virtual void cancelManipulation() = 0;

    virtual void draw() = 0;

    virtual void pickerDraw(int64_t pickerId) = 0;

    virtual bool event(const FnEventWrapper& eventData);

    virtual void* getPrivateData(void* inputData) { return 0x0; }

    /* Options setting and getting. */

    virtual void setOption(OptionIdGenerator::value_type optionId,
                           FnAttribute::Attribute attr) {}

    virtual FnAttribute::Attribute getOption(
        OptionIdGenerator::value_type optionId);

    void setOption(const std::string& name, FnAttribute::Attribute attr);

    FnAttribute::Attribute getOption(const std::string& name);

public:
    static FnManipulatorHandlePluginSuite_v1 createSuite(
        FnManipulatorHandlePluginHandle (*create)(
            FnManipulatorHandleHostHandle hostHandle));
    static FnManipulatorHandlePluginHandle newManipulatorHandleHandle(
        ManipulatorHandle* manipulatorHandle);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnManipulatorHandleHostHandle m_hostHandle);
    FnManipulatorHandleHostHandle getHostHandle();

};


class ManipulatorHandleWrapper : public ManipulatorHandlePluginBase
{
public:
    ManipulatorHandleWrapper(
        FnPluginHost* host,
        FnManipulatorHandleHostHandle hostHandle,
        FnManipulatorHandlePluginHandle pluginHandle,
        FnManipulatorHandlePluginSuite_v1* pluginSuite);

    ~ManipulatorHandleWrapper();

    template<class T> T* getPluginInstance()
    {
        return dynamic_cast<T*>(getPluginPointer());
    }

    void setActive(bool active);

    void setHovered(bool hovered);

    void cancelManipulation();

    void draw();

    bool event(FnEventWrapper eventData);

    void pickerDraw(int64_t pickerId);

    void setOption(OptionIdGenerator::value_type optionId,
        FnAttribute::Attribute attr);
    FnAttribute::Attribute getOption(OptionIdGenerator::value_type optionId);
    void setOption(const std::string& name, FnAttribute::Attribute attr);
    FnAttribute::Attribute getOption(const std::string& name);

private:
    ManipulatorHandle* getPluginPointer();

    FnManipulatorHandlePluginSuite_v1* m_pluginSuite;
    FnManipulatorHandlePluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ManipulatorHandleWrapper> ManipulatorHandleWrapperPtr;

} // ViewerAPI
} // Katana
} // Foundry




// Plugin-side structure to be pointed by the plugin handles.
struct FnManipulatorHandlePluginStruct
{
public:
    FnManipulatorHandlePluginStruct(
        Foundry::Katana::ViewerAPI::ManipulatorHandle* manipulatorHandle)
    : m_manipulatorHandle(manipulatorHandle)
    {}

    ~FnManipulatorHandlePluginStruct()
    {
        if (m_manipulatorHandle)
            m_manipulatorHandle->cancelManipulation();
    };

    Foundry::Katana::ViewerAPI::ManipulatorHandle* getManipulatorHandle()
    {
        return m_manipulatorHandle.get();
    }

private:
    std::shared_ptr<
        Foundry::Katana::ViewerAPI::ManipulatorHandle> m_manipulatorHandle;
};


// Plugin Registering Macro.
#define DEFINE_MANIPULATOR_HANDLE_PLUGIN(MANIPULATOR_HANDLE_CLASS)            \
                                                                              \
FnPlugin MANIPULATOR_HANDLE_CLASS##_plugin;                                   \
                                                                              \
FnManipulatorHandlePluginHandle MANIPULATOR_HANDLE_CLASS##_create(            \
    FnManipulatorHandleHostHandle hostHandle)                                 \
{                                                                             \
    Foundry::Katana::ViewerAPI::ManipulatorHandle* manipulatorHandle =        \
        MANIPULATOR_HANDLE_CLASS::create();                                   \
                                                                              \
    manipulatorHandle->setHostHandle(hostHandle);                             \
    return Foundry::Katana::ViewerAPI::ManipulatorHandle::newManipulatorHandleHandle(manipulatorHandle); \
}                                                                             \
                                                                              \
FnManipulatorHandlePluginSuite_v1 MANIPULATOR_HANDLE_CLASS##_suite =          \
        Foundry::Katana::ViewerAPI::ManipulatorHandle::createSuite(           \
                MANIPULATOR_HANDLE_CLASS##_create);                           \
                                                                              \
const void* MANIPULATOR_HANDLE_CLASS##_getSuite()                             \
{                                                                             \
    return &MANIPULATOR_HANDLE_CLASS##_suite;                                 \
}


#endif /* FNMANIPULATORHANDLE_H_ */