FnViewportLayer.h

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

#ifndef FNVIEWER_VIEWPORTLAYER_H
#define FNVIEWER_VIEWPORTLAYER_H

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

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

#include <map>
#include <string>
#include <iostream>
#include <memory>


namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

class ViewportLayerPluginBase
{
public:
    // API methods (to be implemented / used by sub-classes)

    ViewportLayerPluginBase();
    virtual ~ViewportLayerPluginBase();
public: /* Methods to be called by the plugin. */

    ViewportWrapperPtr getViewport();

    void hover(bool isHovering, int x, int y);

    void pick(unsigned int x, unsigned int y,
              unsigned int w, unsigned int h,
              bool deepPicking,
              PickedAttrsMap& pickedAttrs,
              float* singlePointDepth=NULL);

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

protected:
    FnViewportLayerHostSuite_v2* m_hostSuite;
    FnViewportLayerHostHandle m_hostHandle;

    static FnPluginHost* m_host;

private:
    ViewportWrapperPtr m_viewportWrapper;

};

class ViewportLayer : public ViewportLayerPluginBase
{
public:

    ViewportLayer(bool usePickingOnHover=false);

    virtual ~ViewportLayer();

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

    virtual void setup() = 0;

    virtual void cleanup() = 0;

    virtual bool event(const FnEventWrapper& eventData) { return false; }

    virtual void draw() = 0;

    virtual void resize(unsigned int width, unsigned int height) = 0;

    virtual void hover(bool isHovering, int x, int y) {}

    virtual void freeze() = 0;

    virtual void thaw() = 0;

    static void flush() {}

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

    bool usesPickingOnHover() { return m_usesPickingOnHover; }

    virtual void pickerDraw(unsigned int x, unsigned int y,
                            unsigned int w, unsigned int h,
                            const PickedAttrsMap& ignoreAttrs) {}

    virtual bool customPick(unsigned int x, unsigned int y,
                            unsigned int w, unsigned int h,
                            bool deepPicking,
                            PickedAttrsMap& pickedAttrs,
                            float* singlePointDepth=NULL);


    FnPickId addPickableObject(FnAttribute::Attribute attr);

public:
    static FnViewportLayerPluginSuite_v2 createSuite(
        FnViewportLayerPluginHandle (*create)(
            FnViewportLayerHostHandle hostHandle));
    static FnViewportLayerPluginHandle newViewportLayerHandle(
        ViewportLayer* viewportLayer);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnViewportLayerHostHandle m_hostHandle);
    FnViewportLayerHostHandle getHostHandle();

private:
    bool m_usesPickingOnHover;

};

class ViewportLayerWrapper : public ViewportLayerPluginBase
{
public:
    ViewportLayerWrapper(
        FnPluginHost* host,
        FnViewportLayerHostHandle hostHandle,
        FnViewportLayerPluginHandle pluginHandle,
        FnViewportLayerPluginSuite_v2* pluginSuite);

    ~ViewportLayerWrapper();

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

    void draw();

    bool event(FnEventWrapper eventData);

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

    FnViewportLayerPluginSuite_v2* m_pluginSuite;
    FnViewportLayerPluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ViewportLayerWrapper> ViewportLayerWrapperPtr;

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



// Plugin-side structure to be pointed by the plugin handles.
struct FnViewportLayerPluginStruct
{
public:
    FnViewportLayerPluginStruct(
        Foundry::Katana::ViewerAPI::ViewportLayer* viewportLayer)
    : m_viewportLayer(viewportLayer)
    {}

    ~FnViewportLayerPluginStruct()
    {};

    Foundry::Katana::ViewerAPI::ViewportLayer* getViewportLayer()
    {
        return m_viewportLayer.get();
    }

    FnAttribute::GroupAttribute getAttributes(const std::string& locationPath);

private:
    std::shared_ptr<Foundry::Katana::ViewerAPI::ViewportLayer> m_viewportLayer;
};


// Plugin Registering Macro.
#define DEFINE_VIEWPORT_LAYER_PLUGIN(VIEWPORT_LAYER_CLASS)                    \
                                                                              \
    FnPlugin VIEWPORT_LAYER_CLASS##_plugin;                                   \
                                                                              \
    FnViewportLayerPluginHandle VIEWPORT_LAYER_CLASS##_create(                \
        FnViewportLayerHostHandle hostHandle)                                 \
    {                                                                         \
        Foundry::Katana::ViewerAPI::ViewportLayer* viewportLayer =            \
            VIEWPORT_LAYER_CLASS::create();                                   \
                                                                              \
        viewportLayer->setHostHandle(hostHandle);                             \
        return Foundry::Katana::ViewerAPI::ViewportLayer::newViewportLayerHandle(viewportLayer); \
    }                                                                         \
                                                                              \
    FnViewportLayerPluginSuite_v2 VIEWPORT_LAYER_CLASS##_suite =              \
            Foundry::Katana::ViewerAPI::ViewportLayer::createSuite(           \
                    VIEWPORT_LAYER_CLASS##_create);                           \
                                                                              \
    const void* VIEWPORT_LAYER_CLASS##_getSuite()                             \
    {                                                                         \
        return &VIEWPORT_LAYER_CLASS##_suite;                                 \
    }


#endif