OP_NodeChain.h

Go to the documentation of this file.

// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
//
//
//

#ifndef HOUDINI_UTILS_OP_NODECHAIN_HAS_BEEN_INCLUDED
#define HOUDINI_UTILS_OP_NODECHAIN_HAS_BEEN_INCLUDED

#include <OP/OP_Context.h>
#include <OP/OP_Channels.h> // for CH_AutoEvaluateTime
#include <OP/OP_Director.h>
#include <OP/OP_Node.h>
#include <SYS/SYS_Types.h> // for fpreal
#include <UT/UT_String.h>
#include <UT/UT_Thread.h>
#include <algorithm>
#include <string>
#include <vector>
#if defined(PRODDEV_BUILD) || defined(DWREAL_IS_DOUBLE)
  // OPENVDB_HOUDINI_API, which has no meaning in a DWA build environment but
  // must at least exist, is normally defined by including openvdb/Platform.h.
  // For DWA builds (i.e., if either PRODDEV_BUILD or DWREAL_IS_DOUBLE exists),
  // that introduces an unwanted and unnecessary library dependency.
  #ifndef OPENVDB_HOUDINI_API
    #define OPENVDB_HOUDINI_API
  #endif
#else
  #include <openvdb/Platform.h>
#endif


namespace houdini_utils {

template<typename NodeType>
OPENVDB_DEPRECATED
inline std::vector<NodeType*>
getNodeChain(OP_Context& context, NodeType* startNode, bool addInterest = true)
{
    struct Local {
        static inline OP_Node* nextInput(
            fpreal now,
            OP_Node* node)
        {
            OP_Node* input = node->getInput(0, /*mark_used=*/true);
            while (input) {
                OP_Node* passThrough = input->getPassThroughNode(now, /*mark_used=*/true);
                if (!passThrough) break;
                input = passThrough;
            }
            return input;
        }
    }; // struct Local

    const fpreal now = context.getTime();

    std::vector<NodeType*> nodes;
    for (OP_Node* node = startNode; node != NULL; node = Local::nextInput(now, node)) {
        // Stop if the node does not need to cook.
        if (!node->needToCook(context, /*query_only=*/true)) break;

        if (NodeType* candidate = dynamic_cast<NodeType*>(node)) {
            nodes.push_back(candidate);
        } else {
            // Stop if the node is not of the requested type, unless it is a SOP_NULL.
            std::string opname = node->getName().toStdString().substr(0, 4);
            if (opname == "null") continue;
            break; // stop for all other node types
        }
    }
    std::reverse(nodes.begin(), nodes.end());

    if (addInterest && startNode != nodes[0] && nodes[0]->getInput(0)) {
        startNode->addExtraInput(nodes[0]->getInput(0), OP_INTEREST_DATA);
    }

    return nodes;
}




class OP_EvalScope
{
public:
    OPENVDB_DEPRECATED
    OP_EvalScope(OP_Node& node, OP_Context& context):
        mAutoEvaluator(
            *OPgetDirector()->getCommandManager(),
            context.getThread(),
            context.getTime(),
            node.getChannels()),
        mDirector(OPgetDirector()),
        mThread(context.getThread())
    {
        mDirector->pushCwd(mThread, &node);
    }

    OPENVDB_DEPRECATED
    ~OP_EvalScope() { mDirector->popCwd(mThread); }

private:
    CH_AutoEvaluateTime mAutoEvaluator;
    OP_Director* mDirector;
    int mThread;
};

} // namespace houdini_utils

#endif // HOUDINI_UTILS_OP_NODECHAIN_HAS_BEEN_INCLUDED