FnViewerDelegate.h

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

#ifndef FNVIEWER_VIEWERDELEGATE_H
#define FNVIEWER_VIEWERDELEGATE_H

#include <FnViewer/suite/FnViewerDelegateSuite.h>
#include <FnViewer/plugin/FnOptionIdGenerator.h>
#include <FnViewer/plugin/FnMathTypes.h>
#include <FnViewer/plugin/FnViewerLocationEvent.h>

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

#include <string>
#include <vector>
#include <memory>

namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

// Forward declaration.
class ViewerDelegateComponentWrapper;
typedef std::shared_ptr<ViewerDelegateComponentWrapper>
    ViewerDelegateComponentWrapperPtr;
class ViewportWrapper;
typedef std::shared_ptr<ViewportWrapper> ViewportWrapperPtr;

class ViewerDelegatePluginBase
{
public:

    ViewerDelegatePluginBase();

    virtual ~ViewerDelegatePluginBase();

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

    /* Geolib3 Methods */

    FnAttribute::GroupAttribute getAttributes(
        const std::string& locationPath,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    Matrix44d getLocalXform(
        const std::string& locationPath, bool& isAbsolute,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    Matrix44d getWorldXform(
        const std::string& locationPath,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    Matrix44d getParentXform(
        const std::string& locationPath,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    Matrix44d getPartialXform(
        const std::string& locationPath, const std::string& groupName,
        const std::string& componentName, bool includeComponent,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary,
        bool includeParentXform = true, bool includeBeforeGroup = true,
        bool includeAfterGroup = false);

    /* Location open/close Methods */

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

    void openLocations(const std::vector<std::string>& locationPaths);

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

    void closeLocations(const std::vector<std::string>& locationPaths);

    /* Source activation methods */

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

    void activateSourceLocations(
        const std::vector<std::string>& locationPaths);

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

    void deactivateSourceLocations(
        const std::vector<std::string>& locationPaths);

    /* Location selection functions */

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

    void selectLocations(const std::vector<std::string>& locationPaths);

    void getSelectedLocations(std::vector<std::string>& locationPaths);

    /* ViewerDelegateComponent Management Methods */

    ViewerDelegateComponentWrapperPtr addComponent(
        const std::string& pluginName, const std::string& name);

    ViewerDelegateComponentWrapperPtr insertComponent(
        const std::string& pluginName, const std::string& name,
        unsigned int index);

    ViewerDelegateComponentWrapperPtr getComponent(
        const std::string& name) const;

    ViewerDelegateComponentWrapperPtr getComponent(unsigned int index) const;

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

    void removeComponent(unsigned int index);

    unsigned int getNumberOfComponents() const;

    std::string getComponentName(unsigned int index);

    int getComponentIndex(const std::string& name);

    /* Viewport access methods */

    ViewportWrapperPtr getViewport(const std::string& name);

    ViewportWrapperPtr getViewport(unsigned int index);

    unsigned int getNumberOfViewports();

    std::string getViewportName(unsigned int index);


    /* Other Methods */

    FnAttribute::GroupAttribute getCompatibleManipulatorsInfo(
         const std::vector<std::string>& locationPaths);

    FnAttribute::Attribute callPythonCallback(const std::string& name,
                                              FnAttribute::Attribute message);

    FnAttribute::GroupAttribute getLiveAttributes(
        const std::string& locationPath,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    FnAttribute::GroupAttribute getCookedAttributes(
        const std::string& locationPath,
        FnViewerDelegateSceneView sceneView = kFnViewerDelegatePrimary);

    bool setManipulatedAttribute(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);

    void setBoundingBoxesEnabled(bool enabled);

    void setProxyGeometryEnabled(bool enabled);

    FnAttribute::StringAttribute getDescendantLocations(
        const std::string& location);

    FnAttribute::DoubleAttribute computeMergedExtent(
        const std::vector<std::string>& locations,
        const std::string& excludeLocation);

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

protected:
    static FnPluginHost* m_host;

    FnViewerDelegateHostSuite_v4* m_hostSuite;
    FnViewerDelegateHostHandle m_hostHandle;

};


class ViewerDelegate : public ViewerDelegatePluginBase
{
public:

    ViewerDelegate();

    virtual ~ViewerDelegate();

    virtual void setup() = 0;

    virtual void cleanup() = 0;

    virtual FnAttribute::DoubleAttribute getBounds(
        const std::string& locationPath);

    virtual FnAttribute::DoubleAttribute computeExtent(
        const std::string& locationPath);

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

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

    /* Scene Graph Events */

    virtual void locationEvent(const ViewerLocationEvent& event,
                               bool locationHandled) = 0;

    virtual void sourceLocationEvent(const ViewerLocationEvent& event) = 0;

    virtual void locationsSelected(
        const std::vector<std::string>& locationPaths) = 0;

    virtual bool isProcessing() const { return false; }

    /* 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);

    /* General Methods */

    virtual void freeze() = 0;

    virtual void thaw() = 0;

    static void flush() {}

public:
    static FnViewerDelegatePluginSuite_v3 createSuite(
      FnViewerDelegatePluginHandle (*create)(
          FnViewerDelegateHostHandle hostHandle));

    static FnViewerDelegatePluginHandle newViewerDelegateHandle(
      ViewerDelegate* viewerDelegate);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnViewerDelegateHostHandle hostHandle);

};

class ViewerDelegateWrapper : public ViewerDelegatePluginBase
{
public:
    ViewerDelegateWrapper(
        FnPluginHost* host,
        FnViewerDelegateHostHandle hostHandle,
        FnViewerDelegatePluginHandle pluginHandle,
        FnViewerDelegatePluginSuite_v3* pluginSuite);

    ~ViewerDelegateWrapper();

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

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

    FnViewerDelegatePluginSuite_v3* m_pluginSuite;
    FnViewerDelegatePluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ViewerDelegateWrapper> ViewerDelegateWrapperPtr;

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




// Plugin-side structure to be pointed by the plugin handles.
struct FnViewerDelegatePluginStruct
{
public:
    FnViewerDelegatePluginStruct(
        Foundry::Katana::ViewerAPI::ViewerDelegate* viewerDelegate)
    : m_viewerDelegate(viewerDelegate)
    { }

    ~FnViewerDelegatePluginStruct()
    { };

    Foundry::Katana::ViewerAPI::ViewerDelegate* getViewerDelegate()
    {
        return m_viewerDelegate.get();
    }

private:
    std::shared_ptr<
        Foundry::Katana::ViewerAPI::ViewerDelegate> m_viewerDelegate;
};

// Plugin Registering Macro.
#define DEFINE_VIEWER_DELEGATE_PLUGIN(VIEWER_DELEGATE_CLASS)                  \
                                                                              \
    FnPlugin VIEWER_DELEGATE_CLASS##_plugin;                                  \
                                                                              \
    FnViewerDelegatePluginHandle VIEWER_DELEGATE_CLASS##_create(              \
        FnViewerDelegateHostHandle hostHandle)                                \
    {                                                                         \
        Foundry::Katana::ViewerAPI::ViewerDelegate* viewerDelegate =          \
            VIEWER_DELEGATE_CLASS::create();                                  \
                                                                              \
        viewerDelegate->setHostHandle(hostHandle);                            \
        return Foundry::Katana::ViewerAPI::ViewerDelegate::newViewerDelegateHandle( \
            viewerDelegate);                                                  \
    }                                                                         \
                                                                              \
    FnViewerDelegatePluginSuite_v3 VIEWER_DELEGATE_CLASS##_suite =            \
            Foundry::Katana::ViewerAPI::ViewerDelegate::createSuite(          \
                    VIEWER_DELEGATE_CLASS##_create);                          \
                                                                              \
    const void* VIEWER_DELEGATE_CLASS##_getSuite()                            \
    {                                                                         \
        return &VIEWER_DELEGATE_CLASS##_suite;                                \
    }


#endif