FnBaseLocator.h

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

#ifndef _FNBASELOCATOR_H_
#define _FNBASELOCATOR_H_

#include <FnViewer/plugin/FnViewerDelegate.h>
#include <FnViewer/plugin/FnViewerDelegateComponent.h>
#include <FnViewer/plugin/FnViewport.h>
#include <FnViewer/plugin/FnViewportLayer.h>
#include <FnViewer/utils/FnDrawingHelpers.h>
#include <FnViewer/utils/FnGLShaderProgram.h>
#include <FnViewer/utils/FnImathHelpers.h>

#include <GL/glew.h>

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

namespace Foundry
{
namespace Katana
{
namespace ViewerUtils
{
class FnBaseLocatorVDC;
class FnBaseLocatorViewportLayer;

typedef std::map<std::string, std::set<std::string> > LocatorLocationsMap;

/***** Locator *****/

class FnBaseLocator
{
public:
    typedef std::shared_ptr<FnBaseLocator> Ptr;
    typedef std::weak_ptr<FnBaseLocator> WeakPtr;

    FnBaseLocator();
    virtual ~FnBaseLocator();

    virtual void setup() = 0;

    virtual void cleanup() = 0;

    virtual void locationSetup(const std::string& locationPath,
                               bool isPicking);

    virtual void locationCleanup(const std::string& locationPath,
                                 bool isPicking);

    virtual void draw(const std::string& locationPath) = 0;

    virtual void pickerDraw(const std::string& locationPath) = 0;

    virtual void onFrameBegin(bool isPicking);

    virtual void onFrameEnd(bool isPicking);

public:
    FnBaseLocatorVDC* getViewerDelegateComponent() const;

    void setViewerDelegateComponent(FnBaseLocatorVDC* vdc);

    FnBaseLocatorViewportLayer* getViewportLayer() const;

    void setViewportLayer(FnBaseLocatorViewportLayer* vdc);

    FnAttribute::Attribute getAttribute(const std::string& locationPath,
                                        const std::string& attrName = "");

    bool isLocationSelected(const std::string& locationPath);

    GLShaderProgram* getDefaultShaderProgram() const;

    void setDefaultShaderProgram(GLShaderProgram* shaderProgram);
private:
    FnBaseLocatorVDC* m_viewerDelegateComponent;
    FnBaseLocatorViewportLayer* m_viewportLayer;
    GLShaderProgram* m_shader;
};


/***** Viewer Delegate Component *****/

typedef FnBaseLocator* (*LocatorCreateCallback)();
typedef bool (*LocatorMatchesCallback)(
    const Foundry::Katana::ViewerAPI::ViewerLocationEvent& event);
typedef FnAttribute::DoubleAttribute (*LocatorGetBoundsCallback)(
    const Foundry::Katana::ViewerAPI::ViewerLocationEvent& event);
typedef FnAttribute::DoubleAttribute (*LocatorComputeExtentCallback)(
    const Foundry::Katana::ViewerAPI::ViewerLocationEvent& event);
typedef bool (*OverridesBaseGeometryCallback)(
    const Foundry::Katana::ViewerAPI::ViewerLocationEvent& event);


class FnBaseLocatorVDC : public FnKat::ViewerAPI::ViewerDelegateComponent
{
    struct LocatorContainer
    {
        std::string name;
        LocatorCreateCallback create;
        LocatorMatchesCallback matches;
        OverridesBaseGeometryCallback overridesBaseGeometry;
        LocatorGetBoundsCallback getBounds;
        LocatorComputeExtentCallback computeExtent;
    };
    typedef std::vector<LocatorContainer*> LocatorContainerVector;

    class SceneNode : public std::enable_shared_from_this<SceneNode>
    {
    public:
        enum class InheritableFlag {
            kFalse,
            kTrue,
            kNotSet,
        };

        typedef std::shared_ptr<SceneNode> Ptr;
        typedef std::weak_ptr<SceneNode> WeakPtr;

        explicit SceneNode(const std::string& locationPath);
        virtual ~SceneNode();

        void addChild(const std::string& name, SceneNode::Ptr child);

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

        SceneNode::WeakPtr getChild(const std::string& name);

        std::map<std::string, SceneNode::Ptr> getChildren() const;

        SceneNode::WeakPtr getParent() const;

        void setParent(SceneNode::WeakPtr parent);

        std::string getLocationPath() const;

        void addLocatorName(const std::string& locatorName);

        void removeLocatorName(const std::string& locatorName);

        void clearLocatorNames();

        bool hasLocator() const;

        std::set<std::string> getLocatorNames() const;

        void getDescendantLocatorLocations(
            LocatorLocationsMap& locatorLocations);

        bool isSelected() const;

        void setSelected(bool selected);

        bool isEnabled() const;

        void setEnabled(bool enabled);

        bool isHidden() const;

        void setHidden(InheritableFlag hidden);

        bool isPickable() const;

        void setPickable(InheritableFlag pickable);
    private:
        std::string m_locationPath;
        SceneNode::WeakPtr m_parent;
        std::map<std::string, SceneNode::Ptr> m_children;
        std::set<std::string> m_locatorNames;
        bool m_selected;
        bool m_enabled;
        InheritableFlag m_hidden;
        InheritableFlag m_pickable;
    };

public:
    FnBaseLocatorVDC();
    virtual ~FnBaseLocatorVDC();

    static void flush();

    static FnKat::ViewerAPI::ViewerDelegateComponent* create()
    {
        return new FnBaseLocatorVDC();
    }

    static void registerLocator(
        const std::string& name,
        LocatorCreateCallback create,
        LocatorMatchesCallback matches,
        OverridesBaseGeometryCallback overridesBaseGeometry,
        LocatorGetBoundsCallback getBounds,
        LocatorComputeExtentCallback computeExtent);

    virtual void setup() {}

    virtual void cleanup() {}

    virtual bool locationEvent(
        const Foundry::Katana::ViewerAPI::ViewerLocationEvent& event,
        bool locationHandled);

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

    virtual void* getPrivateData(void* inputData);

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

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

public:
    void removeLocation(const std::string& locationPath);

    virtual SceneNode::Ptr createSceneNode(
        const FnKat::ViewerAPI::ViewerLocationEvent& event);

    void dirtyAllViewports();

    SceneNode::Ptr getRootSceneNode() const { return m_rootSceneNode; }

    std::weak_ptr<LocatorLocationsMap> getLocatorLocations();

    static LocatorContainerVector getRegisteredLocators();

    bool isLocationSelected(const std::string& locationPath);

    bool isLocationHidden(const std::string& locationPath);

private:
    static LocatorContainerVector m_registeredLocators;
    SceneNode::Ptr m_rootSceneNode;
    std::shared_ptr<LocatorLocationsMap> m_locatorLocations;
    std::unordered_set<std::string> m_selectedLocations;
};


/***** Viewport Layer *****/

class FnBaseLocatorViewportLayer : public FnKat::ViewerAPI::ViewportLayer
{
public:
    FnBaseLocatorViewportLayer();
    virtual ~FnBaseLocatorViewportLayer();

    static Foundry::Katana::ViewerAPI::ViewportLayer* create()
    {
        return new FnBaseLocatorViewportLayer();
    }

    virtual void freeze() {}

    virtual void thaw() {}

    virtual void setup();

    virtual void cleanup();

    virtual void draw();

    virtual void pickerDraw(
        unsigned int x,
        unsigned int y,
        unsigned int w,
        unsigned int h,
        const Foundry::Katana::ViewerAPI::PickedAttrsMap& ignoreAttrs);

    virtual bool usesPickingOnHover() { return true; }

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

    virtual void setOption(
        Foundry::Katana::ViewerAPI::OptionIdGenerator::value_type optionId,
        FnAttribute::Attribute attr);

    virtual void initializeLocators();

    virtual void drawLocators(bool isPicking,
                              std::set<std::string>& ignoreLocations);

private:
    FnKat::ViewerAPI::ViewerDelegateWrapperPtr m_viewerDelegate;
    FnKat::ViewerAPI::ViewportWrapperPtr m_viewport;
    FnBaseLocatorVDC* m_viewerDelegateComponent;
    std::weak_ptr<LocatorLocationsMap>
        m_locatorLocations;  //* Deprecate & use the VDC function?
    std::map<std::string, FnBaseLocator::Ptr> m_locators;

    GLShaderProgram m_shader;
    std::string m_vdcName;
    bool m_initialized;

    std::vector<std::string> m_excludedLocationsPicking;
};



#define REGISTER_LOCATOR(CLASS_NAME)                                          \
    FnKat::ViewerUtils::FnBaseLocatorVDC::registerLocator(                    \
        #CLASS_NAME, &CLASS_NAME::create, &CLASS_NAME::matches,               \
        &CLASS_NAME::overridesBaseGeometry, &CLASS_NAME::getBounds,           \
        &CLASS_NAME::computeExtent);


}  // namespace ViewerUtils
}  // namespace Katana
}  // namespace Foundry

#endif