PDG_NodeTypes.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.
 *
 * COMMENTS:
 */

#ifndef __PDG_NODE_TYPES_H__
#define __PDG_NODE_TYPES_H__

#include <UT/UT_Array.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_UniquePtr.h>

class PDG_Dependency;
class PDG_Node;
class PDG_NodeCallback;
class PDG_Port;

/// Type defs for registered type objects
using PDG_DependencyPtr         = UT_SharedPtr<PDG_Dependency>;
using PDG_NodeCallbackPtr       = UT_SharedPtr<PDG_NodeCallback>;

/// Node ID type
using PDG_NodeID                = int;
using PDG_CacheID               = int;

/// Array, set and map of nodes
using PDG_NodePtr               = UT_UniquePtr<PDG_Node>;
using PDG_NodePtrMap            = UT_ArrayStringMap<PDG_NodePtr>;

using PDG_NodeArray             = UT_Array<PDG_Node*>;
using PDG_NodeSet               = UT_ArraySet<PDG_Node*>;
using PDG_NodeMap               = UT_ArrayStringMap<PDG_Node*>;

/// Array of input/output/parameter ports
using PDG_PortArray             = UT_Array<PDG_Port*>;

using PDG_NodePortPair          = std::pair<UT_StringHolder, UT_StringHolder>;
using PDG_NodePortArray         = UT_Array<PDG_NodePortPair>;
using PDG_NodePortMap           = UT_StringMap<PDG_NodePortArray>;

/// Enumeration of callback return types
enum class PDG_CallbackResult
{
    /// The callback failed to execute
    eFailure,

    /// The callback executed successfully
    eSuccess,

    /// The callback is missing or undefined
    eMissing,

    /// Special "None" case -- the callback took no action or returned no
    /// results
    eNone,

    /// Special "All" case -- the callback returned all results
    eAll,
};

/// Node state, used for UI/progress reporting.
enum class PDG_NodeState
{
    /// The node is uncooked, either because it wasn't on the cook path or
    /// because it chose to generate no items
    eUncooked,

    /// The node is actively cooking work items
    eCooking,

    /// The node is completely cooked
    eCooked,

    /// One or more work items failed during the cook
    eFailed,

    /// One or more work items were canceled during the cook
    eCanceled,

    /// The node is waiting on upstream nodes to make progress
    eWaiting,

    /// The node is partially cooked, and likely won't make any progress
    /// during the rest of the active cook
    eIncomplete
};

/// Enumeration of node types in a PDG graph
enum class PDG_NodeType
{
    /// Mapper nodes -- add dependencies between upstream and downstream
    /// work items [Deprecated]
    eMapper,

    /// Partitioner nodes -- group multiple upstream work items into
    /// partitions with a common property
    ePartitioner,

    /// Processor nodes -- generate zero more more new work items from
    /// upstream work items that perform real work
    eProcessor,

    /// Scheduler nodes -- submits work items to some sort of scheduling
    /// or farm system
    eScheduler,

    /// Placeholder/undefined node type
    eUndefined
};

/// Enumeration of node subtypes
enum class PDG_NodeSubtype
{
    /// A regular node -- default value
    eRegular,

    /// A feedback begin node -- part of a feedback block
    eFeedbackBegin,

    /// A feedback end node -- part of a feedback block
    eFeedbackEnd,

    /// A utility node, such as a null or switch
    eUtility,

    /// Placeholder/undefined node subtype
    eUndefined
};

/// Enumeration of reasons why a node may need to regenerate its work items
/// Regeneration reasons
enum class PDG_NodeRegenerateReason
{
    /// No regeneration necessary
    eNone,

    /// The node should regenerate work items because of a node option
    /// that indicates it always regenerates.
    eAlways,

    /// The node should regenerate work items
    eFull,

    /// The node should regenerate work items, and any downstream nodes
    /// that try to cook will also inherit the state from this node
    ePropagate,

    /// The node will be dirtied.
    eDirty,

    /// The node will be dirtied and caches invalidated
    eDirtyInvalidate,
};

/// Enumeration of node port display type, e.g. menus or toggles, for
/// parameters
enum class PDG_PortDisplayType
{
    /// Default display type
    eDefault    = 0x0,

    /// Dropdown menu display
    eMenu       = 0x01,

    /// Toggle display
    eToggle     = 0x02,

    /// Join-next display
    eJoin       = 0x04,

    /// Separator display
    eSeparator  = 0x08,

    /// No label display
    eNoLabel    = 0x10,

    /// Operator path display
    eOperator   = 0x20,
};

/// Enumeration of node port types
enum class PDG_PortType
{
    /// Input connection
    eInput,

    /// Output connection
    eOutput,

    /// Parameter
    eParameter,

    /// Port type guard/count
    eCount
};

#endif /* __PDG_NODE_TYPES_H__ */