FnGeolibCookInterface.h

#ifndef FnGeolibCookInterface_H
#define FnGeolibCookInterface_H

#include <cstddef>
#include <string>
#include <vector>

#include <FnAttribute/FnAttribute.h>

#include <FnGeolib/FnGeolibAPI.h>
#include <FnGeolib/op/ns.h>
#include <FnGeolib/suite/FnGeolibCookInterfaceSuite.h>

#include <FnPlatform/StringView.h>
#include <FnPlatform/internal/Portability.h>

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

//  This is the GeolibOp client side wrapper for FnGeolibInterfaceSuite_v1.  A
//  reference to an instance of this is handed to the GeolibOp::cook() function.
//
//  This class is not meant to be derived from, just compiled into the Op plug-
//  in as a convenience.


FNGEOLIBOP_NAMESPACE_ENTER
{
    class FNGEOLIB_API GeolibCookInterface
    {
    public:
        class QueryAbortException
        {
        };

        GeolibCookInterface(FnGeolibCookInterfaceHandle interfaceHandle,
            FnGeolibCookInterfaceSuite_v1 *interfaceSuite);

        enum ResetRoot
        {
            ResetRootFalse = kFnKatGeolibCookInterfaceResetRootFalse,

            ResetRootTrue = kFnKatGeolibCookInterfaceResetRootTrue,

            ResetRootAuto = kFnKatGeolibCookInterfaceResetRootAuto
        };

        // @cond FN_INTERNAL_DEV
        typedef enum ResetRoot ResetRoot;
        // @endcond

        std::string getOutputName() const;

        std::string getInputName() const;

        std::string getOutputLocationPath() const;

        std::string getInputLocationPath() const;

        std::string getRelativeOutputLocationPath() const;

        std::string getRelativeInputLocationPath() const;

        std::string getRootLocationPath() const;

        bool atRoot() const;

        int getInputIndex() const;

        int getNumInputs() const;

        std::string getOpType() const;

        FnAttribute::Attribute getOpArg(FnPlatform::StringView specificArgName =
                                            FnPlatform::StringView()) const;

        FnAttribute::Attribute getAttr(
            FnPlatform::StringView attrName,
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput) const;

        bool doesLocationExist(
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput) const;

        FnAttribute::StringAttribute getPotentialChildren(
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput) const;

        void *getPrivateData() const;

        void prefetch(
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput) const;

        FnAttribute::Attribute getOutputAttr(
            FnPlatform::StringView attrName) const;

        void setAttr(FnPlatform::StringView attrName,
                     const FnAttribute::Attribute& value,
                     const bool groupInherit = true);

        void copyAttr(
            FnPlatform::StringView dstAttrName,
            FnPlatform::StringView srcAttrName,
            const bool groupInherit = true,
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput);

        void extendAttr(
            FnPlatform::StringView dstAttrName,
            const FnAttribute::Attribute& value,
            FnPlatform::StringView srcAttrName = FnPlatform::StringView(),
            const bool groupInherit = true,
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput);

        void deleteAttr(FnPlatform::StringView attrName);

        void deleteAttrs();

        void replaceAttrs(
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput);
        typedef void (*FnDeletePrivateDataFunc)(void* privateData);

        void createChild(
            FnPlatform::StringView name,
            FnPlatform::StringView opType = FnPlatform::StringView(),
            const FnAttribute::Attribute& opArgs = FnAttribute::Attribute(),
            ResetRoot resetRoot = ResetRootAuto,
            void* privateData = NULL,
            FnDeletePrivateDataFunc deletePrivateData = NULL);

        void replaceChildren(
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput);

        void deleteChildren();

        void deleteChild(FnPlatform::StringView name);

        void deleteSelf();

        void copyLocationToChild(
            FnPlatform::StringView child,
            FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
            int inputIndex = kFnKatGeolibDefaultInput,
            FnPlatform::StringView orderBefore = FnPlatform::StringView());

        void replaceChildTraversalOp(
            FnPlatform::StringView opType,
            const FnAttribute::GroupAttribute& opArgs,
            void* privateData = NULL,
            FnDeletePrivateDataFunc deletePrivateData = NULL);

        void stopChildTraversal();

        void execOp(FnPlatform::StringView opType,
                    const FnAttribute::GroupAttribute& opArgs,
                    void* privateData = NULL,
                    FnDeletePrivateDataFunc deletePrivateData = NULL);

        void resetRoot();

        // Need ability to pass this interface instance to other C APIs.
        FnGeolibCookInterfaceHandle getHandle() const {return _handle;}
        FnGeolibCookInterfaceSuite_v1 * getSuite() const {return _suite;}

    private:
        FnGeolibCookInterfaceHandle _handle;
        FnGeolibCookInterfaceSuite_v1 *_suite;
    };

    class FNGEOLIB_API GeolibPrivateData
    {
    public:
        GeolibPrivateData() {}
        virtual ~GeolibPrivateData() {}

        static void Delete(void* data)
        {
            delete static_cast<GeolibPrivateData*>(data);
        }
    };

    FNGEOLIB_API
    std::string GetInputLocationType(
        const GeolibCookInterface& interface,
        FnPlatform::StringView location = FnPlatform::StringView(),
        int inputIndex = kFnKatGeolibDefaultInput);

    FNGEOLIB_API
    std::string GetAbsOutputLocationPath(const GeolibCookInterface & interface,
                                  const std::string & outputLocationPath);

    FNGEOLIB_API
    std::string GetAbsInputLocationPath(const GeolibCookInterface & interface,
                                 const std::string & inputLocationPath);

    FNGEOLIB_API
    void RenameChild(GeolibCookInterface & interface,
                     FnPlatform::StringView src, FnPlatform::StringView dst);

    FNGEOLIB_API
    FnAttribute::Attribute GetGlobalAttr(
        const GeolibCookInterface& interface, FnPlatform::StringView name,
        FnPlatform::StringView location = FnPlatform::StringView(),
        int inputIndex = kFnKatGeolibDefaultInput);

    FNGEOLIB_API
    void ReportError(GeolibCookInterface & interface,
                     const std::string & message);

    FNGEOLIB_API
    void ReportWarning(GeolibCookInterface & interface,
                       const std::string & message);

    FNGEOLIB_API
    FnAttribute::GroupAttribute MergeImmediateGroupChildren(
        const std::vector<FnAttribute::GroupAttribute> & attrs);

    FNGEOLIB_API
    FnAttribute::GroupAttribute GetGlobalXFormGroup(
        const GeolibCookInterface & interface,
        const std::string & inputLocationPath=std::string(),
        int inputIndex=kFnKatGeolibDefaultInput);

    FNGEOLIB_API
    float GetCurrentTime(const GeolibCookInterface & interface);

    FNGEOLIB_API
    float GetShutterOpen(const GeolibCookInterface & interface);

    FNGEOLIB_API
    float GetShutterClose(const GeolibCookInterface & interface);

    FNGEOLIB_API
    int GetNumSamples(const GeolibCookInterface & interface);

    FNGEOLIB_API
    FnAttribute::Attribute GetGraphStateVariable(
        const GeolibCookInterface& interface,
        FnPlatform::StringView variableName);

    //
    // WARNING - these are likely to be moved to an alternate library / header
    //

    struct BoundPoint
    {
        BoundPoint() : x(0), y(0), z(0) {}
        BoundPoint(double x_, double y_, double z_)
            : x(x_), y(y_), z(z_) {}

        double x;

        double y;

        double z;
    };

    FNGEOLIB_API
    FnAttribute::DoubleAttribute GetBoundAttr(
        const GeolibCookInterface& interface,
        FnPlatform::StringView inputLocationPath = FnPlatform::StringView(),
        int inputIndex = kFnKatGeolibDefaultInput);

    FNGEOLIB_API
    void GetBoundAttrValue(
        double outMinBound[3], double outMaxBound[3],
        const FnAttribute::DoubleAttribute & boundAttr,
        float sampleTime);

    FNGEOLIB_API
    void GetTransformedBoundAttrValue(
        std::vector<BoundPoint> & outPoints,
        const FnAttribute::DoubleAttribute & boundAttr,
        float sampleTime, const double xform[16]);

    FNGEOLIB_API
    void GetTransformedBoundAttrValue(
        double outMinBound[3], double outMaxBound[3],
        const FnAttribute::DoubleAttribute & boundAttr,
        float sampleTime, const double xform[16]);

    FNGEOLIB_API
    FnAttribute::DoubleAttribute MergeLocalBoundAttrs(
        const std::vector<FnAttribute::DoubleAttribute> & boundAttrs);

    FNGEOLIB_API
    FnAttribute::GroupAttribute FilterNullAttributes(
        const FnAttribute::GroupAttribute & groupAttr);

    FNGEOLIB_API
    FnAttribute::GroupAttribute ResolveReferentialInheritance(
        const FnGeolibOp::GeolibCookInterface& interface,
        FnPlatform::StringView keyAttrName, FnPlatform::StringView attrName,
        const std::string& inputLocationPath = std::string(),
        int inputIndex = kFnKatGeolibDefaultInput);

    //
    // DEPRECATED - Do not use! Pending removal
    //

    struct CreateLocationInfo
    {
        bool atLeaf;
        bool canMatchChildren;
    };

    FNGEOLIB_API
    void CreateLocation(CreateLocationInfo & createLocationInfo,
                        GeolibCookInterface & interface,
                        const std::string & location);

    FNGEOLIB_API
    void CopyTree(
        GeolibCookInterface & interface,
        const std::string & dstLocation,
        const std::string & srcLocation,
        int srcInput=kFnKatGeolibDefaultInput);
}
FNGEOLIBOP_NAMESPACE_EXIT

#endif // FnGeolibCookInterface_H