OP_NodeParms.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        OP_NodeParms.h ( OP Library, C++)
 *
 * COMMENTS:
 *      Marshalled parms for OP cooking mechanisms.  OPs can return
 *      one of these objects to describe their parms
 */

#ifndef __OP_NodeParms_h__
#define __OP_NodeParms_h__

#include "OP_API.h"
#include <OP/OP_Context.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_Assert.h>
#include <UT/UT_Error.h>
#include <UT/UT_ErrorManager.h>
#include <UT/UT_Matrix2.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Vector2.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_Ramp.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_Types.h>

#include <initializer_list>

class DEP_MicroNode;
class OP_GraphProxy;
class OP_Node;
class UT_Options;
class UT_SourceLocation;

enum OP_CookEngine
{
    OP_COOK_TRADITIONAL,
    OP_COOK_COMPILED,
};


class OP_API OP_NodeCache
{
public:
             OP_NodeCache() 
             {
             }
    virtual ~OP_NodeCache();

    virtual int64        getMemoryUsage(bool inclusive) const;

protected:
    OP_NodeCache(const OP_NodeCache &) = default;
    OP_NodeCache &operator=(const OP_NodeCache &) = default;

    friend class OP_NodeParms;
};

class OP_API OP_NodeParms
{
public:
             OP_NodeParms() {}
    virtual ~OP_NodeParms() {}

    class OP_API LoadParms
    {
    public:
        LoadParms(OP_CookEngine cookengine,
                  const OP_GraphProxy *graph,
                  exint nodeidx,
                  const OP_Context &context,
                  OP_NodeCache *cache, 
                  UT_ErrorManager *error,
                  DEP_MicroNode *depnode)
        : myCookEngine(cookengine)
        , myGraph(graph)
        , myNodeIdx(nodeidx)
        , myContext(context)
        , myCache(cache)
        , myError(error)
        , myDepNode(depnode)
        {
        }
        ~LoadParms() {}

        const OP_Node           *node() const;
        const OP_GraphProxy    *graph() const { return myGraph; }
        exint                    nodeIdx() const { return myNodeIdx; }
        OP_NodeCache            *cache() const { return myCache; }
        const OP_Context        &context() const { return myContext; }
        UT_ErrorManager         *error() const { return myError; }
        DEP_MicroNode           *depnode() const { return myDepNode; }

        /// Methods to wire directly to the optional depnode.
        void                     addExplicitInput(DEP_MicroNode &inp, bool check_dup)
        { if (myDepNode) myDepNode->addExplicitInput(inp, check_dup); }
        void                     addExplicitInput(DEP_MicroNode &inp)
        { addExplicitInput(inp, /*check_dup*/true); }

        /// Methods to add directly to any present error manager.
        UT_ErrorSeverity addMessage (const char *type, int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { if (myError) return myError->addMessage(type, code, formatError(msg), loc); 
          return UT_ERROR_MESSAGE; }
        UT_ErrorSeverity addWarning (const char *type, int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { if (myError) return myError->addWarning(type, code, formatError(msg), loc); 
          return UT_ERROR_WARNING; }
        UT_ErrorSeverity addError   (const char *type, int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { if (myError) return myError->addError(type, code, formatError(msg), loc); 
          return UT_ERROR_ABORT; }

        UT_ErrorSeverity sopAddMessage (int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { return addMessage("SOP", code, msg, loc); }
        UT_ErrorSeverity sopAddWarning (int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { return addWarning("SOP", code, msg, loc); }
        UT_ErrorSeverity sopAddError   (int code, const char *msg=0,
                                     const UT_SourceLocation *loc=0) const
        { return addError("SOP", code, msg, loc); }

        void            stealErrors(UT_ErrorManager &src,
                                    bool borrow_only = false) const
        { if (myError) myError->stealErrors(src,0, -1, UT_ERROR_NONE, borrow_only); }

    protected:
        /// Prefix errors so we can get sensible results.
        UT_StringHolder         formatError(const char *msg) const;

        bool                     myCookEngine;
        const OP_GraphProxy    *myGraph;
        exint                    myNodeIdx;
        const OP_Context        &myContext;
        OP_NodeCache            *myCache;
        UT_ErrorManager         *myError;
        DEP_MicroNode           *myDepNode;
    };

    void         loadFromOp(const LoadParms &loadparms);


    /// Overloads all the parmaeters according to matching entries in
    /// the provided options table.
    bool         applyOptionsOverride(const UT_Options *options);

    virtual void        copyFrom(const OP_NodeParms *src) { }

                            
    enum ParmType
    {
        PARM_INTEGER,
        PARM_FLOAT,
        PARM_VECTOR2,
        PARM_VECTOR3,
        PARM_VECTOR4,
        PARM_MATRIX2,
        PARM_MATRIX3,
        PARM_MATRIX4,
        PARM_STRING,
        PARM_RAMP,
        PARM_DATA,
        PARM_MULTIPARM,
        PARM_UNSUPPORTED
    };

    /// Marshalling interface to rest of world
    /// These all use index based notation.
    virtual exint       getNumParms() const { return getNestNumParms({}); }
    virtual const char *getParmName(exint idx) const { return getNestParmName({idx}); }
    virtual ParmType    getParmType(exint idx) const { return getNestParmType({idx}); }

    virtual bool isParmColorRamp(exint idx) const { return false; }

    virtual void        getParmValue(exint idx, exint &value) const 
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, fpreal &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Vector2D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Vector3D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Vector4D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Matrix2D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Matrix3D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_Matrix4D &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_StringHolder &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, UT_SharedPtr<UT_Ramp> &value) const
    { getNestParmValue( {idx}, {}, value ); }
    virtual void        getParmValue(exint idx, PRM_DataItemHandle &value) const
    { getNestParmValue( {idx}, {}, value ); }

    virtual void        setParmValue(exint idx, const exint &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const fpreal &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Vector2D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Vector3D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Vector4D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Matrix2D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Matrix3D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_Matrix4D &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_StringHolder &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const UT_SharedPtr<UT_Ramp> &value)
    { setNestParmValue( {idx}, {}, value ); }
    virtual void        setParmValue(exint idx, const PRM_DataItemHandle &value)
    { setNestParmValue( {idx}, {}, value ); }

    /// This makes a temporary index structure out of either an
    /// initializer list or an exint array.  It does *NOT* own
    /// the data so should never be explicitly constructed.
    class TempIndex
    {
    public:
        TempIndex(std::initializer_list<exint> list)
        {
            if (list.size())
                myVec = &*list.begin();
            else
                myVec = 0;
            mySize = list.size();
        }
        TempIndex(const UT_ExintArray &list)
        {
            myVec = list.data();
            mySize = list.size();
        }

        const exint *begin() const { return myVec; }
        exint size() const { return mySize; }
        exint operator[](const exint off) const
        {
            UT_ASSERT_P(off >= 0 && off < mySize);
            return myVec[off];
        }
    protected:
        const exint     *myVec;
        exint            mySize;
    };

    virtual exint       getNestNumParms(TempIndex idx) const { return 0; }
    virtual const char *getNestParmName(TempIndex idx) const { return 0; }
    virtual ParmType    getNestParmType(TempIndex idx) const { return PARM_UNSUPPORTED; }

    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const {}
    virtual void        getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const {}

    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) {}
    virtual void        setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) {}

    virtual int64       getMemoryUsage(bool inclusive) const
                            { return inclusive ? sizeof(*this) : 0; }
                                
protected:
    virtual void loadFromOpSubclass(const LoadParms &loadparms) = 0;

    // These are needed to implement copyFrom() in subclasses
    OP_NodeParms(const OP_NodeParms &) = default;
    OP_NodeParms &operator=(const OP_NodeParms &) = default;

    // Used for coercing one type to another
    template <typename T, typename S> 
    void coerceValue(T &result, const S &src) const
    {
        UT_ASSERT(!"Unimplemented OP_NodeParms::coerceValue() called!");
        result = T{};
    }

    template <typename T> 
    T clampMinValue(fpreal minvalue, const T &src) const
    {
        UT_ASSERT(!"Unimplemented OP_NodeParms::clampMinValue() called!");
        return src;
    }

    template <typename T> 
    T clampMaxValue(fpreal maxvalue, const T &src) const
    {
        UT_ASSERT(!"Unimplemented OP_NodeParms::clampMaxValue() called!");
        return src;
    }

};

template <> 
void inline OP_NodeParms::coerceValue(exint &result, const exint &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(bool &result, const exint &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(exint &result, const bool &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(bool &result, const bool &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(fpreal &result, const fpreal &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector2D &result, const UT_Vector2D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector3D &result, const UT_Vector3D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector4D &result, const UT_Vector4D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Matrix2D &result, const UT_Matrix2D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Matrix3D &result, const UT_Matrix3D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Matrix4D &result, const UT_Matrix4D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_StringHolder &result, const UT_StringHolder &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_SharedPtr<UT_Ramp> &result, const UT_SharedPtr<UT_Ramp> &src) const
{ result = src; }
template <>
void inline OP_NodeParms::coerceValue(PRM_DataItemHandle &result, const PRM_DataItemHandle &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector2I &result, const UT_Vector2D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector2D &result, const UT_Vector2I &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector3I &result, const UT_Vector3D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector3D &result, const UT_Vector3I &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector4I &result, const UT_Vector4D &src) const
{ result = src; }
template <> 
void inline OP_NodeParms::coerceValue(UT_Vector4D &result, const UT_Vector4I &src) const
{ result = src; }

template <> 
exint inline OP_NodeParms::clampMinValue(fpreal clamp, const exint &src) const
{ return SYSmax((exint)clamp, src); }
template <> 
bool inline OP_NodeParms::clampMinValue(fpreal clamp, const bool &src) const
{ return SYSmax((exint)clamp, src); }
template <> 
fpreal inline OP_NodeParms::clampMinValue(fpreal clamp, const fpreal &src) const
{ return SYSmax(clamp, src); }
template <> 
UT_Vector2D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector2D &src) const
{ return SYSmax(UT_Vector2D(clamp, clamp), src); }
template <> 
UT_Vector3D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector3D &src) const
{ return SYSmax(UT_Vector3D(clamp, clamp, clamp), src); }
template <> 
UT_Vector4D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector4D &src) const
{ return SYSmax(UT_Vector4D(clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix2D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Matrix2D &src) const
{ return SYSmax(UT_Matrix2D(clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix3D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Matrix3D &src) const
{ return SYSmax(UT_Matrix3D(clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix4D inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Matrix4D &src) const
{ return SYSmax(UT_Matrix4D(clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp), src); }
template <> 
UT_Vector2I inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector2I &src) const
{ return SYSmax(UT_Vector2I(clamp, clamp), src); }
template <> 
UT_Vector3I inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector3I &src) const
{ return SYSmax(UT_Vector3I(clamp, clamp, clamp), src); }
template <> 
UT_Vector4I inline OP_NodeParms::clampMinValue(fpreal clamp, const UT_Vector4I &src) const
{ return SYSmax(UT_Vector4I(clamp, clamp, clamp, clamp), src); }
template <>
UT_SharedPtr<UT_Ramp> inline OP_NodeParms::clampMinValue(
        fpreal clamp,
        const UT_SharedPtr<UT_Ramp> &src) const
{
    const int number_of_new_nodes_needed = static_cast<int>(clamp) - src->getNodeCount();
    if (number_of_new_nodes_needed <= 0)
    {
        return src;
    }

    const fpreal spacing_between_new_nodes
            = 0.5f / static_cast<fpreal>(number_of_new_nodes_needed);
    const auto *last_node = src->getClosestNode(1);
    fpreal last_node_pos = last_node ? last_node->t : 0;

    // Move all nodes to the first half of the src
    if (last_node_pos > 0.5f)
    {
        fpreal scaler = 0.5f / last_node_pos;
        for (int i = 0, n = src->getNodeCount(); i < n; ++i)
        {
            src->moveNode(i, src->getNode(i)->t * scaler);
        }
    }

    // Add new nodes to second half of the src
    fpreal current_position = 0.5f + spacing_between_new_nodes;
    for (int i = 0; i < number_of_new_nodes_needed; ++i)
    {
        src->addNode(current_position);
        current_position += spacing_between_new_nodes;
    }
    return src;
}

template <> 
exint inline OP_NodeParms::clampMaxValue(fpreal clamp, const exint &src) const
{ return SYSmin((exint)clamp, src); }
template <> 
bool inline OP_NodeParms::clampMaxValue(fpreal clamp, const bool &src) const
{ return SYSmin((exint)clamp, src); }
template <> 
fpreal inline OP_NodeParms::clampMaxValue(fpreal clamp, const fpreal &src) const
{ return SYSmin(clamp, src); }
template <> 
UT_Vector2D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector2D &src) const
{ return SYSmin(UT_Vector2D(clamp, clamp), src); }
template <> 
UT_Vector3D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector3D &src) const
{ return SYSmin(UT_Vector3D(clamp, clamp, clamp), src); }
template <> 
UT_Vector4D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector4D &src) const
{ return SYSmin(UT_Vector4D(clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix2D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Matrix2D &src) const
{ return SYSmin(UT_Matrix2D(clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix3D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Matrix3D &src) const
{ return SYSmin(UT_Matrix3D(clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp), src); }
template <> 
UT_Matrix4D inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Matrix4D &src) const
{ return SYSmin(UT_Matrix4D(clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp, clamp), src); }
template <> 
UT_Vector2I inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector2I &src) const
{ return SYSmin(UT_Vector2I(clamp, clamp), src); }
template <> 
UT_Vector3I inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector3I &src) const
{ return SYSmin(UT_Vector3I(clamp, clamp, clamp), src); }
template <> 
UT_Vector4I inline OP_NodeParms::clampMaxValue(fpreal clamp, const UT_Vector4I &src) const
{ return SYSmin(UT_Vector4I(clamp, clamp, clamp, clamp), src); }


#endif