OP_DataTypes.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 library (C++)
 *
 * COMMENTS:    Data types for cooked data
 *
 */

#ifndef __OP_DataTypes_h__
#define __OP_DataTypes_h__

#include <SYS/SYS_Deprecated.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_UniquePtr.h>

/// Enabling these types can catch unwanted implicit conversions for node port
/// indices, and are helpful in catching misuse of these types (see r499653 for
/// an example that was caught using these types). This is especially helpful to
/// use if you are trying to remove uses of `unsigned` for input/output indices,
/// since negative values can refer to spare inputs/outputs.
///
/// TODO: This currently only builds for OP and COP. It would be nice to sweep
/// the rest of the code to use these type aliases instead of `int`,
/// `unsigned`, etc.
#define OP_USE_STRICT_IDX_TYPES 0
#if OP_USE_STRICT_IDX_TYPES
    // Includes needed for OP_IdxType wrapper
    #include <SYS/SYS_Hash.h>
    #include <UT/UT_Format.h>
    #include <ostream>
#endif // OP_USE_STRICT_IDX_TYPES

class OP_NetworkBoxItem;
class OP_Node;
class OP_DataBlock;

typedef UT_ValArray<OP_NetworkBoxItem *> OP_NetworkBoxItemList;
typedef UT_Array<OP_Node *> OP_NodeList;
typedef UT_IntrusivePtr<OP_DataBlock> OP_DataBlockPtr;

#if OP_USE_STRICT_IDX_TYPES

#define OP_ARITHMETIC(TEMPLATE, __VA_ARGS__) \
    TEMPLATE(+, __VA_ARGS__) \
    TEMPLATE(-, __VA_ARGS__) \
    TEMPLATE(*, __VA_ARGS__) \
    TEMPLATE(/, __VA_ARGS__) \
    TEMPLATE(%, __VA_ARGS__)

#define OP_COMPARISON(TEMPLATE, __VA_ARGS__) \
    TEMPLATE(<,  __VA_ARGS__) \
    TEMPLATE(<=, __VA_ARGS__) \
    TEMPLATE(>,  __VA_ARGS__) \
    TEMPLATE(>=, __VA_ARGS__) \
    TEMPLATE(==, __VA_ARGS__) \
    TEMPLATE(!=, __VA_ARGS__)

template <typename Tag>
struct OP_IdxType
{
    exint myValue;

    constexpr OP_IdxType() noexcept = default;
    constexpr OP_IdxType(int v)   : myValue(v) {}
    constexpr OP_IdxType(exint v) : myValue(v) {}
    constexpr OP_IdxType(const OP_IdxType &) noexcept = default;
    constexpr OP_IdxType(OP_IdxType &&)      noexcept = default;

    constexpr OP_IdxType &operator=(const OP_IdxType &) = default;
    constexpr OP_IdxType &operator=(OP_IdxType &&)      = default;

    /// Explicit conversion between different types of indices (i.e. between
    /// an index to an input port and an index to an output port).
    template <typename OtherTag>
    constexpr explicit OP_IdxType(const OP_IdxType<OtherTag> &other)
        : myValue(other.myValue) {}

    /// We should not be using `unsigned` as indices, so we require an explicit
    /// conversion to ensure correctness.
    constexpr explicit OP_IdxType(unsigned v) : myValue(v) {}

    // Allowed conversions:
    constexpr OP_IdxType &operator=(int v)    { myValue = v; return *this; }
    constexpr OP_IdxType &operator=(exint v)  { myValue = v; return *this; }
    constexpr explicit operator int()   const { return myValue; }
    constexpr explicit operator bool()  const { return myValue; }
    constexpr          operator exint() const { return myValue; }
    constexpr          operator UT::Format::ArgValue() const { return myValue; }

    // Delete any other implicit conversions:
    template <typename T> constexpr             OP_IdxType(T)       = delete;
    template <typename T> constexpr OP_IdxType &operator=(T v)      = delete;
    template <typename T> constexpr             operator T() const  = delete;

    // Increment/decrement operators needed for an index type:
    constexpr OP_IdxType   &operator++() { ++myValue; return *this; }
    constexpr OP_IdxType   &operator--() { --myValue; return *this; }
    constexpr OP_IdxType    operator++(int)
                            { OP_IdxType tmp = *this; ++myValue; return tmp; }
    constexpr OP_IdxType    operator--(int)
                            { OP_IdxType tmp = *this; --myValue; return tmp; }
    constexpr OP_IdxType   &operator+=(int other)
                            { myValue += other; return *this; }
    constexpr OP_IdxType   &operator+=(OP_IdxType other)
                            { myValue += other; return *this; }

    /// Get the address of the internal index value
    /// @{
    constexpr const exint *operator&() const { return &myValue; }
    constexpr       exint *operator&()       { return &myValue; }
    /// @}

    // Define arithmetic with same index type:
#define OP_IDXTYPE_ARITHMETIC_TEMPLATE(OPERATOR) \
    constexpr OP_IdxType operator OPERATOR (OP_IdxType other) const \
                         { return OP_IdxType(myValue OPERATOR other.myValue); }
    OP_ARITHMETIC(OP_IDXTYPE_ARITHMETIC_TEMPLATE)
#undef OP_IDXTYPE_ARITHMETIC_TEMPLATE

    // Define comparison with same index type:
#define OP_IDXTYPE_COMPARISON_TEMPLATE(OPERATOR) \
    constexpr bool operator OPERATOR (OP_IdxType other) const \
                   { return myValue OPERATOR other.myValue; }
    OP_COMPARISON(OP_IDXTYPE_COMPARISON_TEMPLATE)
#undef OP_IDXTYPE_COMPARISON_TEMPLATE
};

// Define arithmetic with integral types:
#define OP_IDXTYPE_ARITHMETIC_TEMPLATE(OPERATOR, TYPE) \
    template <typename Tag> \
    constexpr TYPE operator OPERATOR (TYPE lhs, OP_IdxType<Tag> rhs) \
                   { return lhs OPERATOR rhs.myValue; } \
    template <typename Tag> \
    constexpr TYPE operator OPERATOR (OP_IdxType<Tag> lhs, TYPE rhs) \
                   { return lhs.myValue OPERATOR rhs; }
OP_ARITHMETIC(OP_IDXTYPE_ARITHMETIC_TEMPLATE, int)
OP_ARITHMETIC(OP_IDXTYPE_ARITHMETIC_TEMPLATE, exint)
OP_ARITHMETIC(OP_IDXTYPE_ARITHMETIC_TEMPLATE, unsigned)
#undef OP_IDXTYPE_ARITHMETIC_TEMPLATE

// Define comparison with integral types:
#define OP_IDXTYPE_COMPARISON_TEMPLATE(OPERATOR, TYPE) \
    template <typename Tag> \
    constexpr bool operator OPERATOR (TYPE lhs, OP_IdxType<Tag> rhs) \
                   { return lhs OPERATOR rhs.myValue; } \
    template <typename Tag> \
    constexpr bool operator OPERATOR (OP_IdxType<Tag> lhs, TYPE rhs) \
                   { return lhs.myValue OPERATOR rhs; }
OP_COMPARISON(OP_IDXTYPE_COMPARISON_TEMPLATE, int)
OP_COMPARISON(OP_IDXTYPE_COMPARISON_TEMPLATE, exint)
OP_COMPARISON(OP_IDXTYPE_COMPARISON_TEMPLATE, unsigned)
#undef OP_IDXTYPE_COMPARISON_TEMPLATE

#undef OP_ARITHMETIC
#undef OP_COMPARISON

template <typename Tag>
constexpr std::ostream &operator<<(std::ostream &os, OP_IdxType<Tag> idx)
{ return os << idx.myValue; }

template <typename Tag>
inline SYS_HashType hash_value(OP_IdxType<Tag> idx)
{ return SYShash(idx.myValue); }

/// Tags used to distinguish between different index types.
/// @see OP_IdxType
/// @{
struct OP_IdxTypeInputTag {};
struct OP_IdxTypeOutputTag {};
/// @}
using OP_InputIdx = OP_IdxType<OP_IdxTypeInputTag>;
using OP_OutputIdx = OP_IdxType<OP_IdxTypeOutputTag>;

#else
/// Type aliases that should be used for indices referencing node input/output
/// ports. These types should really be `exint`, but for compatibility with the
/// hundreds of places we use these indices, these are `int` for now. For that
/// reason you might see `static_cast<int>(...)` despite this type being `int`.
/// @{
using OP_InputIdx = int;
using OP_OutputIdx = int;
/// @}
#endif // OP_USE_STRICT_IDX_TYPES

enum OP_DataType 
{
    OP_NO_DATA,                 // No cooked data associated with the node
    OP_GEOMETRY_DATA,           // Cooked data in geometry format
    OP_TRANSFORM_DATA,          // Cooked data as a transform
    OP_OTHER_DATA,              // Generic catch all
    OP_CHANNEL_DATA,            // Channel collection output
    OP_SHADER_DATA,             // Shader data
    OP_SIM_DATA,                // Dynamics data
    OP_RASTER_DATA,             // Raster data
    OP_SCENE_DATA,              // Scene description
    OP_LAYER_DATA,              // IMX Layer data
    OP_NUM_DATA_TYPES           // sentinel
};
// For backwards
typedef SYS_DEPRECATED(13.0) OP_DataType OP_DATA_TYPE;

enum OP_InterestType
{
    OP_INTEREST_NONE    = 0x00, // I'm not interested
    OP_INTEREST_PARM    = 0x01, // interested in a parameter changes (rare)
    OP_INTEREST_DATA    = 0x02, // interested in op data changes (usual)
    OP_INTEREST_FLAG    = 0x04, // interested in flag changes (e.g.display flg)

    // OP_INTEREST_NAME should NOT be used with addExtraInput().
    // It should only be used with addOpReference() or addOpNameReference().
    OP_INTEREST_NAME    = 0x08, // interested in OP name changes

    OP_INTEREST_INPUT   = 0x10, // interested when inputs change
    OP_INTEREST_OUTPUT  = 0x20, // interested when outputs change
    OP_INTEREST_INPUTREF= 0x40, // used for resolving input references

    OP_INTEREST_CHANNEL = 0x80, // used for cached channel reference

    // OP_INTEREST_NAME should NOT be used with addExtraInput().
    // It should only be used with addOpReference() or addOpNameReference().
                                // interested in name & data:
    OP_INTEREST_NAMEDATA        = OP_INTEREST_NAME|OP_INTEREST_DATA,
    OP_INTEREST_NAME_INPUT      = OP_INTEREST_NAME|OP_INTEREST_INPUT,
    OP_INTEREST_NAME_OUTPUT     = OP_INTEREST_NAME|OP_INTEREST_OUTPUT,
    OP_INTEREST_NAME_CHANNEL    = OP_INTEREST_NAME|OP_INTEREST_CHANNEL,

    // The following acts as a sentinal
    OP_INTEREST_ALL     = 0xFFFFFFFF    // Use this to match all interests
};

/// An enumeration that indicates to the user, what aspect of a OP_Node's UI 
/// representation changed, that caused the OP_UI_CHANGED event for that node  
/// to be sent.
enum OP_UIChangeType
{
    /// The change type wasn't set, so it could be any of them.
    OP_UICHANGE_ANY             = 0,    
    /// Errors/warnings got set/cleared.
    OP_UICHANGE_ERROR_STATE,
    /// The pick/selection state changed
    OP_UICHANGE_PICK,
    /// The node's color changed
    OP_UICHANGE_COLOR,
    /// The node's delete script changed
    OP_UICHANGE_DELETE_SCRIPT,
    /// The node's comment changed
    OP_UICHANGE_COMMENT,
    /// The node's lock flag
    OP_UICHANGE_LOCK_FLAG,
    /// The node's compress (thumbnail) flag changed
    OP_UICHANGE_COMPRESS_FLAG,
    /// The node's OTL definition match state changed 
    OP_UICHANGE_OTL_MATCH_STATE,
    /// The active input changed
    OP_UICHANGE_ACTIVE_INPUT,
    /// The input/output connections have changed
    OP_UICHANGE_CONNECTIONS,
    /// The expression language changed
    OP_UICHANGE_EXPR_LANGUAGE,
    
    /// A network box owned by this network changed
    OP_UICHANGE_NETWORKBOX,
    /// A post-it owned by this network changed
    OP_UICHANGE_POSTIT,
    /// A dot owned by this network changed
    OP_UICHANGE_DOT,

     /// Preview has changed
    OP_UICHANGE_PREVIEW,
    
    OP_UICHANGE_OPTYPE_OBJ      = 1 << 8,
    
    OP_UICHANGE_OPTYPE_SOP      = 2 << 8,
    /// \sa COP2_UIChangeType
    OP_UICHANGE_OPTYPE_COP2     = 9 << 8,
    /// \sa VOP_UIChangeType
    OP_UICHANGE_OPTYPE_VOP      = 11 << 8,
};

// When loading data into an existing network, this enum defines the possible
// actions to take when loading items with names that are already in use.
enum OP_OverwriteAction
{
    // Always create a new item with a new name. Existing item is unaffected.
    OP_NO_OVERWRITE,
    // Delete the existing item, and create a new one with the same name.
    OP_OVERWRITE_DELETE_EXISTING,
    // Keep the existing item, and just load the data into this item.
    OP_OVERWRITE_USE_EXISTING
};

#endif