FnViewportCamera.h

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

#ifndef FNVIEWER_VIEWPORTCAMERA_H
#define FNVIEWER_VIEWPORTCAMERA_H

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

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

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

// Built-in camera types
#define kFnViewportCameraTypeUnknown 0
#define kFnViewportCameraTypePerspective 1
#define kFnViewportCameraTypeOrthographic 2
#define kFnViewportCameraTypeSpherical 3

namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

class ViewportCameraPluginBase
{
public:
    enum CameraDirtyBits
    {
        Clean = 0,
        DirtyParams = 1 << 0,
        AllDirty = (DirtyParams)
    };

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

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

    ViewportWrapperPtr getViewport();

    const double* getViewMatrix();

    Matrix44d getViewMatrix44d();

    void setViewMatrix(const double* matrix);

    const double* getProjectionMatrix();

    Matrix44d getProjectionMatrix44d();

    void setProjectionMatrix(const double* matrix);

    double getCenterOfInterest();

    void setCenterOfInterest(double coi);

    double getFOV();

    void setFOV(double fov);

    double getOrthographicWidth();

    void setOrthographicWidth(double width);

    void getNearFar(double &near, double &far);

    void setNearFar(double near, double far);

    void getScreenWindow(double &left, double &right, double &bottom, double &top);

    void setScreenWindow(double left, double right, double bottom, double top);

    bool hasLocationPath();

    std::string getLocationPath();

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

    Vec3d getOrigin();

    Vec3d getDirection();

    Vec3d getUp();

    Vec3d getLeft();

    bool isInteractionDisabled();

    void disableInteraction(bool disabled);

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

    FnViewportCameraHostHandle getCameraHostHandle() const {
        return m_hostHandle;
    }

protected:
    FnViewportCameraHostSuite_v2* m_hostSuite;
    FnViewportCameraHostHandle m_hostHandle;

    static FnPluginHost* m_host;

private:
    ViewportWrapperPtr m_viewportWrapper;

};


class ViewportCamera : public ViewportCameraPluginBase
{
public:
    ViewportCamera();
    virtual ~ViewportCamera();

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

    static void flush() {}

    virtual int getCameraTypeID() = 0;

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

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

    virtual void startInteraction() = 0;

    virtual void endInteraction() = 0;

    virtual void translate(double x, double y, double z) = 0;

    virtual void rotate(double x, double y, double z) = 0;

    virtual void setup(FnAttribute::GroupAttribute attr) = 0;

    virtual FnAttribute::GroupAttribute asAttribute() = 0;

    virtual bool getPointOnPlane(int x, int y,
        const Vec3d& planeOrigin,
        const Vec3d& planeNormal, Vec3d& intersection) = 0;

    virtual void getRay(int x, int y, Vec3d& pos, Vec3d& dir) = 0;

    virtual Vec3d projectObjectIntoWindow(Vec3d point) = 0;

    virtual Vec3d projectWindowIntoObject(Vec3d point) = 0;

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

    virtual void setDirty(CameraDirtyBits dirtyBits) = 0;

public:
    static FnViewportCameraPluginSuite_v2 createSuite(
        FnViewportCameraPluginHandle (*create)(
            FnViewportCameraHostHandle hostHandle));
    static FnViewportCameraPluginHandle newViewportCameraHandle(
        ViewportCamera* viewportCamera);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnViewportCameraHostHandle m_hostHandle);
    FnViewportCameraHostHandle getHostHandle();

};

class ViewportCameraWrapper : public ViewportCameraPluginBase
{
public:
    ViewportCameraWrapper(
        FnPluginHost* host,
        FnViewportCameraHostHandle hostHandle,
        FnViewportCameraPluginHandle pluginHandle,
        FnViewportCameraPluginSuite_v2* pluginSuite);

    ~ViewportCameraWrapper();

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

    int getCameraTypeID();
    void setViewportDimensions(unsigned int width, unsigned int height);
    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);
    void translate(double x, double y, double z);
    void rotate(double x, double y, double z);
    void startInteraction();
    void endInteraction();
    void setup(FnAttribute::GroupAttribute attr);
    FnAttribute::GroupAttribute asAttribute();
    bool getPointOnPlane(int x, int y, const Vec3d& planeOrigin,
                         const Vec3d& planeNormal, Vec3d& intersection);
    void getRay(int x, int y, Vec3d& pos, Vec3d& dir);
    Vec3d projectObjectIntoWindow(Vec3d point);
    Vec3d projectWindowIntoObject(Vec3d point);
    void setDirty(CameraDirtyBits dirtyBits);

private:
    ViewportCamera* getPluginPointer();

    FnViewportCameraPluginSuite_v2* m_pluginSuite;
    FnViewportCameraPluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ViewportCameraWrapper> ViewportCameraWrapperPtr;

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




// Plugin-side structure to be pointed by the plugin handles.
struct FnViewportCameraPluginStruct
{
public:
    FnViewportCameraPluginStruct(
        Foundry::Katana::ViewerAPI::ViewportCamera* viewportCamera)
    : m_viewportCamera(viewportCamera)
    {}

    ~FnViewportCameraPluginStruct()
    {};

    Foundry::Katana::ViewerAPI::ViewportCamera* getViewportCamera()
    {
        return m_viewportCamera.get();
    }

private:
    std::shared_ptr<Foundry::Katana::ViewerAPI::ViewportCamera>
        m_viewportCamera;
};


// Plugin Registering Macro.
#define DEFINE_VIEWPORT_CAMERA_PLUGIN(VIEWPORT_CAMERA_CLASS)                    \
                                                                              \
    FnPlugin VIEWPORT_CAMERA_CLASS##_plugin;                                   \
                                                                              \
    FnViewportCameraPluginHandle VIEWPORT_CAMERA_CLASS##_create(                \
        FnViewportCameraHostHandle hostHandle)                                 \
    {                                                                         \
        Foundry::Katana::ViewerAPI::ViewportCamera* viewportCamera =            \
            VIEWPORT_CAMERA_CLASS::create();                                   \
                                                                              \
        viewportCamera->setHostHandle(hostHandle);                             \
        return Foundry::Katana::ViewerAPI::ViewportCamera::newViewportCameraHandle(viewportCamera); \
    }                                                                         \
                                                                              \
    FnViewportCameraPluginSuite_v2 VIEWPORT_CAMERA_CLASS##_suite =              \
            Foundry::Katana::ViewerAPI::ViewportCamera::createSuite(           \
                    VIEWPORT_CAMERA_CLASS##_create);                           \
                                                                              \
    const void* VIEWPORT_CAMERA_CLASS##_getSuite()                             \
    {                                                                         \
        return &VIEWPORT_CAMERA_CLASS##_suite;                                 \
    }


#endif