FnManipulator.h

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

#ifndef FNMANIPULATOR_H_
#define FNMANIPULATOR_H_

#include <FnViewer/suite/FnManipulatorSuite.h>
#include <FnViewer/plugin/FnViewport.h>
#include <FnViewer/plugin/FnEventWrapper.h>
#include <FnViewer/plugin/FnMathTypes.h>

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

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


namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

// Forward declarations
class ViewportWrapper;
class ManipulatorHandleWrapper;
typedef std::shared_ptr<ViewportWrapper> ViewportWrapperPtr;
typedef std::shared_ptr<ManipulatorHandleWrapper> ManipulatorHandleWrapperPtr;

class ManipulatorPluginBase
{
public:

    ManipulatorPluginBase();

    virtual ~ManipulatorPluginBase();

public: /* Constants */

    // Some standard tag keys
    static const char kTagName[];
    static const char kTagShortcut[];
    static const char kTagGroup[];
    static const char kTagTechnology[];
    static const char kTagAlwaysAvailable[];
    static const char kTagExclusiveInGroup[];
    static const char kTagPriorityInGroup[];

    // Some standard group tag values
    static const char kTagGroup_TRANSFORM[];  // Translate, Rotate, etc.
    static const char kTagGroup_LIGHT[];  // Light related manipulators.


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

    std::string getPluginName();

    ViewportWrapperPtr getViewport();

    void getLocationPaths(std::vector<std::string>& paths);

    Matrix44d getXform();

    void setXform(const Matrix44d& xformMatrix);

    Matrix44d calculateAveragePositionXform();

    bool setValue(const std::string& locationPath, const std::string& attrName,
                  FnAttribute::Attribute valueAttr, bool isFinal);

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

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

    FnAttribute::Attribute getValue(const std::string& locationPath,
                                    const std::string& attrName);

    ManipulatorHandleWrapperPtr addManipulatorHandle(
        const std::string& pluginName, const std::string& name);

    ManipulatorHandleWrapperPtr getManipulatorHandle(const std::string& name);

    ManipulatorHandleWrapperPtr getManipulatorHandle(unsigned int index);

    void removeManipulatorHandle(const std::string& name);

    void removeManipulatorHandle(unsigned int index);

    unsigned int getNumberOfManipulatorHandles() const;

    std::string getManipulatorHandleName(unsigned int index);

    static FnAttribute::GroupAttribute GetRegisteredManipulatorsInfo();

    bool isInteractive() const;

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

protected:
    static FnPluginHost* m_host;

    FnManipulatorHostSuite_v2* m_hostSuite;
    FnManipulatorHostHandle m_hostHandle;

    static const FnManipulatorHostSuite_v2* _manipulatorSuite;

};

class Manipulator : public ManipulatorPluginBase
{
public:
    Manipulator();

    virtual ~Manipulator();

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

    static bool matches(const FnAttribute::GroupAttribute& locationAttrs);

    static FnAttribute::GroupAttribute getTags();

    virtual void setup() = 0;

    virtual bool event(const FnEventWrapper& eventData);

    virtual void draw();

    virtual void pickerDraw(int64_t pickerId);

    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 FnManipulatorPluginSuite_v1 createSuite(
        FnManipulatorPluginHandle (*create)(FnManipulatorHostHandle hostHandle),
        int (*matches)(FnAttributeHandle locationAttributes),
        FnAttributeHandle (*getTags)());

    static FnManipulatorPluginHandle newManipulatorPluginHandle(
        Manipulator* viewport);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnManipulatorHostHandle m_hostHandle);

};

class ManipulatorWrapper : public ManipulatorPluginBase
{
public:
    ManipulatorWrapper(FnPluginHost* host, FnManipulatorHostHandle hostHandle,
                       FnManipulatorPluginHandle pluginHandle,
                       FnManipulatorPluginSuite_v1* pluginSuite);

    ~ManipulatorWrapper();

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

    bool matches(const FnAttribute::GroupAttribute& locationAttrs);

    FnAttribute::GroupAttribute getTags();

    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:
    Manipulator* getPluginPointer();

    FnManipulatorPluginSuite_v1* m_pluginSuite;
    FnManipulatorPluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ManipulatorWrapper>
    ManipulatorWrapperPtr;

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


// Plugin-side structure to be pointed by the plugin handles.
struct FnManipulatorPluginStruct
{
public:
    FnManipulatorPluginStruct(
        Foundry::Katana::ViewerAPI::Manipulator* manipulator)
    : m_manipulator(manipulator)
    {}

    ~FnManipulatorPluginStruct()
    {};

    Foundry::Katana::ViewerAPI::Manipulator* getManipulator()
    {
        return m_manipulator.get();
    }

private:
    std::shared_ptr<
        Foundry::Katana::ViewerAPI::Manipulator> m_manipulator;
};


// Plugin Registering Macro.
#define DEFINE_MANIPULATOR_PLUGIN(MANIPULATOR_CLASS)                          \
                                                                              \
FnPlugin MANIPULATOR_CLASS##_plugin;                                          \
                                                                              \
FnManipulatorPluginHandle MANIPULATOR_CLASS##_create(                         \
    FnManipulatorHostHandle hostHandle)                                       \
{                                                                             \
    Foundry::Katana::ViewerAPI::Manipulator* manipulator =                    \
        MANIPULATOR_CLASS::create();                                          \
                                                                              \
    manipulator->setHostHandle(hostHandle);                                   \
    return Foundry::Katana::ViewerAPI::Manipulator::newManipulatorPluginHandle( \
        manipulator);                                                         \
}                                                                             \
                                                                              \
int MANIPULATOR_CLASS##_matches(FnAttributeHandle locationAttributesHandle)   \
{                                                                             \
    return MANIPULATOR_CLASS::matches(                                        \
        FnAttribute::Attribute::CreateAndRetain(locationAttributesHandle));   \
}                                                                             \
                                                                              \
FnAttributeHandle MANIPULATOR_CLASS##_getTags()                               \
{                                                                             \
    return MANIPULATOR_CLASS::getTags().getRetainedHandle();                  \
}                                                                             \
                                                                              \
FnManipulatorPluginSuite_v1 MANIPULATOR_CLASS##_suite =                       \
        Foundry::Katana::ViewerAPI::Manipulator::createSuite(                 \
                MANIPULATOR_CLASS##_create,                                   \
                MANIPULATOR_CLASS##_matches,                                  \
                MANIPULATOR_CLASS##_getTags);                                 \
                                                                              \
const void* MANIPULATOR_CLASS##_getSuite()                                    \
{                                                                             \
    return &MANIPULATOR_CLASS##_suite;                                        \
}

#endif /* FNMANIPULATOR_H_ */