PDG_NodeOptions.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_OPTIONS_H__
#define __PDG_NODE_OPTIONS_H__

#include "PDG_API.h"

#include "PDG_AttributeInfo.h"
#include "PDG_AttributeData.h"
#include "PDG_Types.h"

#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>

class PDG_Node;
class PDG_NodeInterface;
class PDG_WorkItem;

/**
 * Configuration options for a node instance, based on the current parms of
 * the node before a cook begins. Filled in by the onConfigureNode callback.
 */
class PDG_API PDG_NodeOptions
{
public:
    using StateFilter   = UT_Array<PDG_WorkItemState>;

public:
                                PDG_NodeOptions()
                                    : myServiceBlockCookType(
                                        PDG_ServiceBlockCookType::eMatch)
                                    , myRequiresGeneratedInputs(false) 
                                    , myRequiresCookedInputs(false)
                                    , myRequiresEndBlock(false)
                                    , myRequiresSceneFile(false)
                                    , myRequiresInputData(false)
                                    , myIsCompressWorkItemData(true)
                                    , myIsAlwaysRegenerate(false)
                                    , myIsDirtyOnRegenerate(false)
                                    , myIsDirtyOnIncomplete(false)
                                    , myIsClearFailures(false)
                                    , myAllowDuplicateOutputs(false)
                                    , myUsesSharedServers(false)
                                    , myUsesDynamicBatching(false)
                                    , myIsValid(true) {}

    /// Returns the work item state filter for the node. An empty filter means
    /// the node will generate from all successful work items, and not generate
    /// from any failed items.
    const StateFilter&          stateFilter() const
                                    { return myStateFilter; }

    /// Returns true if the node has at least one state in its state filter
    bool                        hasStateFilter() const
                                    { return (myStateFilter.size() > 0); }

    /// Returns true if the state filter contains the specified state
    bool                        filterState(PDG_WorkItemState state) const
                                    { return (myStateFilter.find(state) >= 0); }

    /// Returns true if the node can generate from the specified work item
    bool                        filterState(const PDG_WorkItem* work_item) const;

    /// Returns the UI description for the node, based on the current parms.
    /// The string is filled out by the onConfigureNode callback, based on 
    /// the state of the node.
    const UT_StringHolder&      description() const
                                    { return myDescription; }

    /// Returns true if a description has been set.
    bool                        hasDescription() const
                                    { return myDescription.isstring() && 
                                      !myDescription.isEmpty(); }

    /// Returns the service block cook type for this node
    PDG_ServiceBlockCookType    serviceBlockCookType() const
                                    { return myServiceBlockCookType; }

    /// Returns true if the node requires all input work items to be 
    /// generated before it can generate.
    bool                        requiresGeneratedInputs() const
                                    { return myRequiresGeneratedInputs; }

    /// Returns true if the node requires input work items to be cooked.
    /// Unliked requiresGeneratedInputs, this does not necessarily mean
    /// the node waits for ALL inputs -- it just makes it dynamic.
    bool                        requiresCookedInputs() const
                                    { return myRequiresCookedInputs; }

    /// Returns true if this node requires an end block to cook correctly
    bool                        requiresEndBlock() const
                                    { return myRequiresEndBlock; }

    /// Returns true if this node requires the scene file (e.g. a .hip) to
    /// cook correctly.
    bool                        requiresSceneFile() const
                                    { return myRequiresSceneFile; }

    /// Returns true if the node reads input file data during work item
    /// generation, instead of just using the file path
    bool                        requiresInputData() const
                                    { return myRequiresInputData; }

    /// Returns true if this node supports compression of work item .json
    /// data for out of process tasks.
    bool                        isCompressWorkItemData() const
                                    { return myIsCompressWorkItemData; }

    /// Returns true if the node should always regenerate work items each
    /// cook
    bool                        isAlwaysRegenerate() const
                                    { return myIsAlwaysRegenerate; }

    /// Returns true if the node should always dirty itself when regenerating
    /// work items.
    bool                        isDirtyOnRegenerate() const
                                    { return myIsDirtyOnRegenerate; }

    /// Returns true if the node should dirty itself on the next cook, if it
    /// has any uncooked work items
    bool                        isDirtyOnIncomplete() const
                                    { return myIsDirtyOnIncomplete; }

    /// Returns true iof the node should reset failure states back to success,
    /// when generating from failed nputs.
    bool                        isClearFailures() const
                                    { return myIsClearFailures; }

    /// Returns true if the the node should allow multiple work items to have
    /// the same output file
    bool                        allowDuplicateOutputs() const
                                    { return myAllowDuplicateOutputs; }

    /// Returns true if this node creates work items that use shared servers
    bool                        usesSharedServers() const
                                    { return myUsesSharedServers; }

    /// Returns true if thise node creates work items that use dynamic batching
    bool                        usesDynamicBatching() const
                                    { return myUsesDynamicBatching; }

    /// Returns true if the node options are valid
    bool                        isValid() const
                                    { return myIsValid; }

    /// Sets the state filter
    void                        setStateFilter(const StateFilter& filter)
                                    { myStateFilter = filter; }

    /// Sets the UI description for the node.
    void                        setDescription(const UT_StringHolder& desc)
                                    { myDescription = desc; }

    /// Sets the service block cook type for this node
    void                        setServiceBlockCookType(
                                    PDG_ServiceBlockCookType cook_type)
                                    { myServiceBlockCookType = cook_type; }

    /// Indicates whether or not the node requires all inputs to be generated
    /// before it can generate.
    void                        setRequiresGeneratedInputs(bool requires_all)
                                    { myRequiresGeneratedInputs = requires_all; }

    /// Indicates whether or not the node requires inputs to be cooked before
    /// it can generate.
    void                        setRequiresCookedInputs(bool requires_cooked)
                                    { myRequiresCookedInputs = requires_cooked; }

    /// Indicates whether or not this node requires an end block in order to
    /// cook properly. This only applies to feedback begin nodes.
    void                        setRequiresEndBlock(bool requires_block)
                                    { myRequiresEndBlock = requires_block; }

    /// Indicates whether or not this node requires the current scene file
    void                        setRequiresSceneFile(bool requires_scene)
                                    { myRequiresSceneFile = requires_scene; }


    /// Indicates whether or not this node needs to read input file data
    /// when generating work items
    void                        setRequiresInputData(bool requires_data)
                                    { myRequiresInputData = requires_data; }

    /// Indicates whether or not work items created by this node should 
    /// store compressed .json data when running out of process.
    void                        setIsCompressWorkItemData(bool compress)
                                    { myIsCompressWorkItemData = compress; }

    /// Indicates whether or not the node should regenerate work items
    /// every cook. If the node has a custom onRegenerate implementation
    /// it will always be called -- this option is only for nodes that don't
    /// define their own implementation.
    void                        setIsAlwaysRegenerate(bool always_regenerate)
                                    { myIsAlwaysRegenerate = always_regenerate; }

    /// Indicates whether or not the node should always dirty if it requires
    /// regeneration.
    void                        setDirtyOnRegenerate(bool dirty_node)
                                    { myIsDirtyOnRegenerate = dirty_node; }

    /// Indicates whether or not the node should always dirty itself if it
    /// has incomplete work items
    void                        setDirtyOnIncomplete(bool dirty_node)
                                    { myIsDirtyOnIncomplete = dirty_node; }

    /// Indicates whether or not the node should clear failure states when
    /// the state filter is configured to include failed work items
    void                        setClearFailures(bool clear_failures)
                                    { myIsClearFailures = clear_failures; }

    /// Indicates whether or not the work items in the node should be 
    /// allowed to have duplicate output files
    void                        setAllowDuplicateOutputs(bool allow_dupes)
                                    { myAllowDuplicateOutputs = allow_dupes; }

    /// Indicates whether or not this node creates work items that use
    /// shared servers
    void                        setUsesSharedServers(bool uses_servers)
                                    { myUsesSharedServers = uses_servers; }

    /// Indicates whether or not this node creates work items that use
    /// dynamic batching
    void                        setUsesDynamicBatching(bool uses_batching)
                                    { myUsesDynamicBatching = uses_batching; }

    /// Sets the valid flag
    void                        setIsValid(bool is_valid)
                                    { myIsValid = is_valid; }

    /// Returns the service name for the node
    /// The string is filled out by the onConfigureNode callback
    const UT_StringHolder&      serviceName() const
                                    { return myServiceName; }

    /// Returns true if a service name has been set
    bool                        hasServiceName() const
                                    { return myServiceName.isstring() &&
                                      !myServiceName.isEmpty(); }

    /// Sets the service name
    void                        setServiceName(const UT_StringHolder& name)
                                    { myServiceName = name; }

    /// Adds an attribute name and origin type to the attribute origin map.
    /// This should be used for instant-specific attributes, which differ
    /// from the ones in the node template. The origin can be the ORed value
    /// of an of the enum entries in PDG_AttributeInfo::AttribOrigin.
    void                        setOutputAttrib(const UT_StringHolder& name,
                                                int origin)
                                    {
                                        if (!name.isstring() || name.isEmpty())
                                            return;
                                        if (!PDG_AttributeData::validName(name, true))
                                            return;
                                        myOutputAttribs.myOrigins[name] = origin;
                                    }
    void                        setInputAttrib(const UT_StringHolder& name,
                                               int origin)
                                    {
                                        if (!name.isstring() || name.isEmpty())
                                            return;
                                        if (!PDG_AttributeData::validName(name, true))
                                            return;
                                        myInputAttribs.myOrigins[name] = origin;
                                    }

    /// Updates the evaluation origin for a port on this specific node
    /// instance
    void                        setPortOrigin(const UT_StringHolder& name,
                                              int origin)
                                    {
                                        if (!name.isstring() || name.isEmpty())
                                            return;
                                        myPortOrigins[name] = origin;
                                    }

    /// Sets the default origin for the attribute type
    void                        setOutputAttribDefault(int origin)
                                    { myOutputAttribs.myDefaultOrigin = origin; }
    void                        setInputAttribDefault(int origin)
                                    { myInputAttribs.myDefaultOrigin = origin; }

    /// Returns the current output attribute origin map
    const PDG_AttributeInfo::Config&
                                outputAttribs() const
                                    { return myOutputAttribs; }

    const PDG_AttributeInfo::Config&
                                inputAttribs() const
                                    { return myInputAttribs; }

    /// Returns the evaluation origin overrides for ports on this instance
    const UT_ArrayStringMap<int>&
                                portOrigins() const
                                    { return myPortOrigins; }

    /// Resets the node options back to their default values
    void                        reset(const PDG_NodeInterface& node_template,
                                      const PDG_Node* node_instance);

private:
    PDG_AttributeInfo::Config   myOutputAttribs;
    PDG_AttributeInfo::Config   myInputAttribs;
    UT_ArrayStringMap<int>      myPortOrigins;
                            
    StateFilter                 myStateFilter;
    UT_StringHolder             myDescription;
    UT_StringHolder             myServiceName;

    PDG_ServiceBlockCookType    myServiceBlockCookType;

    bool                        myRequiresGeneratedInputs;
    bool                        myRequiresCookedInputs;
    bool                        myRequiresEndBlock;
    bool                        myRequiresSceneFile;
    bool                        myRequiresInputData;

    bool                        myIsCompressWorkItemData;

    bool                        myIsAlwaysRegenerate;
    bool                        myIsDirtyOnRegenerate;
    bool                        myIsDirtyOnIncomplete;
    bool                        myIsClearFailures;

    bool                        myAllowDuplicateOutputs;

    bool                        myUsesSharedServers;
    bool                        myUsesDynamicBatching;

    bool                        myIsValid;
};

#endif