FnViewport.h

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

#ifndef FNVIEWER_VIEWPORT_H
#define FNVIEWER_VIEWPORT_H

#include <FnViewer/suite/FnViewportSuite.h>
#include <FnViewer/plugin/FnEventWrapper.h>
#include <FnViewer/plugin/FnViewerDelegate.h>
#include <FnViewer/plugin/FnViewportCamera.h>
#include <FnViewer/plugin/FnManipulator.h>
#include <FnViewer/plugin/FnOptionIdGenerator.h>
#include <FnViewer/plugin/FnMathTypes.h>
#include <FnViewer/plugin/FnPickingTypes.h>

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

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

namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

// Forward declarations
class ViewportLayerWrapper;
class ManipulatorWrapper;
class ViewportCameraWrapper;
typedef std::shared_ptr<ViewportLayerWrapper> ViewportLayerWrapperPtr;
typedef std::shared_ptr<ManipulatorWrapper> ManipulatorWrapperPtr;
typedef std::shared_ptr<ViewportCameraWrapper> ViewportCameraWrapperPtr;

class ViewportPluginBase
{
public:

    ViewportPluginBase();

    virtual ~ViewportPluginBase();

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

    std::string getName();

    ViewerDelegateWrapperPtr getViewerDelegate();

    unsigned int getWidth();

    unsigned int getHeight();

    ViewportCameraWrapperPtr getActiveCamera();

    ViewportCameraWrapperPtr addCamera(const std::string& pluginName,
                                       const std::string& name);

    ViewportCameraWrapperPtr getCamera(const std::string& name) const;

    ViewportCameraWrapperPtr getCamera(unsigned int index) const;

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

    void removeCamera(unsigned int index);

    unsigned int getNumberOfCameras() const;

    std::string getCameraName(unsigned int index);


    std::string getCameraName(ViewportCameraWrapperPtr camera);

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

    void removeCamera(ViewportCameraWrapperPtr camera);

    void setActiveCamera(ViewportCameraWrapperPtr camera);

    void setViewFrozen(bool isViewFrozen);

    bool isViewFrozen() const;

    const double* getViewMatrix();

    Matrix44d getViewMatrix44d();

    const double* getProjectionMatrix();

    Matrix44d getProjectionMatrix44d();

    bool isDirty();

    void setDirty(bool dirty);

    /* ViewportLayer management Methods */

    ViewportLayerWrapperPtr addLayer(const std::string& pluginName,
                                     const std::string& name);

    ViewportLayerWrapperPtr insertLayer(const std::string& pluginName,
                                        const std::string& name,
                                        unsigned int index);

    ViewportLayerWrapperPtr getLayer(const std::string& name) const;

    ViewportLayerWrapperPtr getLayer(unsigned int index) const;

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

    void removeLayer(unsigned int index);

    unsigned int getNumberOfLayers() const;

    std::string getLayerName(unsigned int index);

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


    /* Active Manipulators Methods */

    void activateManipulator(const std::string& pluginName,
                             const std::vector<std::string>& locationPaths);

    void deactivateManipulator(const std::string& pluginName);

    void deactivateAllManipulators();

    unsigned int getNumberOfActiveManipulators();

    ManipulatorWrapperPtr getActiveManipulator(unsigned int index);

    ManipulatorWrapperPtr getActiveManipulator(const std::string& pluginName);

    bool makeGLContextCurrent();

    bool doneGLContextCurrent();

    bool isGLContextCurrent();

    unsigned int getDefaultFramebufferObject();

    void enableCap(uint32_t cap);

    void disableCap(uint32_t cap);

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

    void setPanAndZoomActive(bool active);

    bool isPanAndZoomActive();

    float getHorizontalOffset();

    float getVerticalOffset();

    float getZoom();

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

protected:
    static FnPluginHost* m_host;

    FnViewportHostSuite_v3* m_hostSuite;
    FnViewportHostHandle m_hostHandle;

private:
    ViewerDelegateWrapperPtr m_viewerDelegateWrapper;

};


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

    Viewport();

    virtual ~Viewport();

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

    virtual void setup() = 0;

    virtual void cleanup() = 0;

    virtual bool event(const FnEventWrapper& eventData);

    virtual void draw();

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

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

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

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

    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 FnViewportPluginSuite_v2 createSuite(
        FnViewportPluginHandle (*create)(FnViewportHostHandle hostHandle));

    static FnViewportPluginHandle newViewportHandle(Viewport* viewport);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnViewportHostHandle m_hostHandle);

};


class ViewportWrapper : public ViewportPluginBase
{
public:
    ViewportWrapper(FnPluginHost* host, FnViewportHostHandle hostHandle,
                    FnViewportPluginHandle pluginHandle,
                    FnViewportPluginSuite_v2* pluginSuite);

    ~ViewportWrapper();

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

    bool event(const 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:
    Viewport* getPluginPointer();

    FnViewportPluginSuite_v2* m_pluginSuite;
    FnViewportPluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ViewportWrapper> ViewportWrapperPtr;

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



// Plugin-side structure to be pointed by the plugin handles.
struct FnViewportPluginStruct
{
public:
    FnViewportPluginStruct(
        Foundry::Katana::ViewerAPI::Viewport* viewport)
    : m_viewport(viewport)
    {}

    ~FnViewportPluginStruct()
    {};

    Foundry::Katana::ViewerAPI::Viewport* getViewport()
    {
        return m_viewport.get();
    }

private:
    std::shared_ptr<Foundry::Katana::ViewerAPI::Viewport> m_viewport;
};

// Plugin Registering Macro.
#define DEFINE_VIEWPORT_PLUGIN(VIEWPORT_CLASS)                                \
                                                                              \
    FnPlugin VIEWPORT_CLASS##_plugin;                                         \
    FnViewportPluginHandle VIEWPORT_CLASS##_create(                           \
        FnViewportHostHandle hostHandle)                                      \
    {                                                                         \
        Foundry::Katana::ViewerAPI::Viewport* viewport =                      \
            VIEWPORT_CLASS::create();                                         \
                                                                              \
        viewport->setHostHandle(hostHandle);                                  \
        return Foundry::Katana::ViewerAPI::Viewport::newViewportHandle(       \
            viewport);                                                        \
    }                                                                         \
                                                                              \
    FnViewportPluginSuite_v2 VIEWPORT_CLASS##_suite =                         \
            Foundry::Katana::ViewerAPI::Viewport::createSuite(                \
                    VIEWPORT_CLASS##_create);                                 \
                                                                              \
    const void* VIEWPORT_CLASS##_getSuite()                                   \
    {                                                                         \
        return &VIEWPORT_CLASS##_suite;                                       \
    }


#endif