HOM_OpNode.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 __HOM_OpNode_h__
#define __HOM_OpNode_h__

#include "HOM_API.h"
#include "HOM_Node.h"

SWIGOUT(%rename(OpNode) HOM_OpNode;)

class HOM_API HOM_OpNode : public HOM_Node
{
public:
    HOM_OpNode()
        : HOM_Node()
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_OpNode(const HOM_OpNode &node)
        : HOM_Node(node)
        , HOM_NetworkMovableItem(node)
    { HOM_CONSTRUCT_OBJECT(this) }
    ~HOM_OpNode() override
    { HOM_DESTRUCT_OBJECT(this) }

    virtual std::vector<std::string> _getArgumentAutoComplete(
            const char *method_name, const char *arguments,
            bool meta_info_only = false) = 0;

    int __hash__() override = 0;
    std::string __repr__() override = 0;

    // We need a quick way to get the OP_OpTypeId from C++ code so we know
    // which subclass of HOM_Node we should cast to, so that's why
    // opTypeIdAsInt() exists.
    SWIGOUT(%ignore opTypeIdAsInt;)
    virtual int opTypeIdAsInt() = 0;
    // Further, we need a quick way to get the OBJ_OBJECT_TYPE from C++ code
    // so we know which subclass of HOM_ObjNode we should cast to.
    // That's why  objTypeAsInt() exists.
    SWIGOUT(%ignore objTypeAsInt;)
    virtual int objTypeAsInt() = 0;

    virtual std::string creatorState() = 0;
    virtual void setCreatorState(const char *state) = 0;

    virtual bool isBuiltExplicitly() = 0;
    virtual void setBuiltExplicitly(bool built_explicitly) = 0;

    virtual HOM_EnumValue *expressionLanguage() = 0;
    virtual void setExpressionLanguage(HOM_EnumValue &language) = 0;

    SWIGOUT(%newobject parm;)
    virtual HOM_Parm *parm(const char* parm_path) = 0;

    SWIGOUT(%newobject parmTuple;)
    virtual HOM_ParmTuple *parmTuple(const char* parm_path) = 0;

    SWIGOUT(%kwargs globParms;)
    virtual std::vector<HOM_ElemPtr<HOM_Parm> > globParms(
            const char *pattern, bool ignore_case=false,
            bool search_label=false,
            bool single_pattern=false) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Parm> > parms() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsReferencingThis() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuples() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Parm> > spareParms() = 0;
    virtual void removeSpareParms() = 0;

    virtual void revertParmInterface() = 0;

    virtual void syncNodeVersionIfNeeded(const std::string &from_version) = 0;

    SWIGOUT(%kwargs setParmTemplateGroup;)
    virtual void setParmTemplateGroup(
            HOM_ParmTemplateGroup &parm_template_group,
            bool rename_conflicting_parms=false) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuplesInFolder(
            const std::vector<std::string> &folder_names) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsInFolder(
            const std::vector<std::string> &folder_names) = 0;

    SWIGOUT(%newobject parmTemplateGroup;)
    virtual HOM_ParmTemplateGroup *parmTemplateGroup() = 0;

    virtual std::vector<std::string> localVariables() = 0;
    virtual std::vector<std::string> localAttributes() = 0;

    SWIGOUT(%kwargs reorderChild;)
    virtual void reorderChild(int src, int dest) = 0;

    // Dependency information.
    SWIGOUT(%kwargs references;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> >
        references(bool include_children=true) = 0;
    SWIGOUT(%kwargs dependents;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> >
        dependents(bool include_children=true) = 0;
    SWIGOUT(%kwargs fileReferences;)
    SWIGOUT(%newobject fileReferences;)
    virtual std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> >
        fileReferences(bool recurse = true,
            const char* project_dir_variable = "HIP",
            bool include_all_refs = true) = 0;
    virtual bool isTimeDependent(bool for_last_cook=false) = 0;

    // If propagate==true, unlock will be propagated to ancestors
    SWIGOUT(%kwargs allowEditingOfContents;)
    virtual void allowEditingOfContents(bool propagate=false) = 0;
    virtual void matchCurrentDefinition() = 0;
    virtual bool matchesCurrentDefinition() = 0;

    virtual void syncDelayedDefinition() = 0;
    virtual bool isDelayedDefinition() = 0;

    SWIGOUT(%kwargs parmAliases;)
    virtual std::map<HOM_ElemPtr<HOM_Parm>, std::string>
    parmAliases(bool recurse=false) = 0;

    virtual void clearParmAliases() = 0;

    SWIGOUT(%kwargs createCompiledDigitalAsset);
    virtual void createCompiledDigitalAsset(const char *name=NULL,
            const char *hda_file_name=NULL, const char *description=NULL) = 0;
    virtual bool isInsideLockedHDA() = 0;
    virtual bool isEditableInsideLockedHDA() = 0;
    virtual bool isLockedHDA() = 0;
    virtual bool isCompiled() = 0;
    virtual bool isMaterialManager() = 0;

    virtual std::string outputLabel(int output_index) = 0;

    virtual int outputForViewFlag() = 0;
    virtual void setOutputForViewFlag(int output) = 0;
    SWIGOUT(%newobject hdaModule;)
    virtual HOM_HDAModule *hdaModule() = 0;
    SWIGOUT(%newobject hdaViewerStateModule;)
    virtual HOM_HDAViewerStateModule *hdaViewerStateModule() = 0;
    SWIGOUT(%newobject hdaViewerHandleModule;)
    virtual HOM_HDAViewerHandleModule *hdaViewerHandleModule() = 0;
    // hm is an alias for hdaModule.
    SWIGOUT(%newobject hm;)
    virtual HOM_HDAModule *hm()
    { return hdaModule(); }
    SWIGOUT(%kwargs createDigitalAsset);
    SWIGOUT(%newobject createDigitalAsset;)
    virtual HOM_Node *createDigitalAsset(const char *name=NULL,
            const char *hda_file_name=NULL, const char *description=NULL,
            int min_num_inputs=0, int max_num_inputs=0,
            bool compress_contents=false, const char *comment=NULL,
            const char *version=NULL, bool save_as_embedded=false,
            bool ignore_external_references=false,
            bool compile_asset = false,
            bool change_node_type = true,
            bool create_backup = true,
            const char *install_path=NULL) = 0;

    SWIGOUT(%kwargs changeNodeType);
    SWIGOUT(%newobject changeNodeType;)
    virtual HOM_Node *changeNodeType(const char *new_node_type,
        bool keep_name=true, bool keep_parms=true, 
        bool keep_network_contents=true,
        bool force_change_on_node_type_match=false) = 0;


    // TOPs work item navigation, these are here
    // so both TopNode and SopNode (for sop top networks)
    // can call them
    virtual void selectNextVisibleWorkItem() = 0;
    virtual void selectPreviousVisibleWorkItem() = 0;
    virtual void deselectWorkItem() = 0;
    virtual void setCurrentTOPPage(int page) = 0;

    virtual bool canGenerateCookCode(bool check_parent=false,
                                     bool check_auto_shader=true) = 0;
    SWIGOUT(%newobject cookCodeGeneratorNode;)
    virtual HOM_Node *cookCodeGeneratorNode() = 0;
    virtual std::string cookCodeLanguage() = 0;
    virtual bool supportsMultiCookCodeContexts() = 0;

    SWIGOUT(%kwargs saveCookCodeToFile;)
    virtual void saveCookCodeToFile(
            const char *file_name, bool skip_header=false,
            const char *context_name = NULL) = 0;

    // This method is deprecated.
    void saveCodeToFile(const char *file_name, bool skip_header=false,
                        const char *context_name = NULL)
    { saveCookCodeToFile(file_name, skip_header, context_name); }

    virtual void saveCompiledCookCodeToFile(const char *file_name,
            const char *context_name = NULL) = 0;

    // This method is deprecated.
    void saveToCompiledVexFile(const char *file_name,
                               const char *context_name = NULL)
    { saveCompiledCookCodeToFile(file_name, context_name); }

    SWIGOUT(%kwargs cook;)
    virtual void cook(
            bool force = false,
            const std::vector<double> frame_range = std::vector<double>()) = 0;

    SWIGOUT(%kwargs cookNoInterruptInternal;)
    virtual void _cookNoInterruptInternal(
            bool force = false,
            const std::vector<double> frame_range = std::vector<double>()) = 0;

    /// Determine if this node to cook at the current evaluation time
    virtual bool needsToCook() = 0;
    /// Determine if this node to cook at the given time
    virtual bool needsToCook(double time) = 0;

    virtual void invalidateOutput() = 0;

    virtual int cookCount() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node> > cookPathNodes() = 0;

    SWIGOUT(%kwargs infoTree;)
    virtual HOM_NodeInfoTree infoTree(
            bool verbose = false,
            bool debug = false,
            int output_index = 0,
            bool force_cook = false) = 0;

    virtual std::map<std::string, hboost::any> infoData() = 0;

    virtual void updateParmStates() = 0;

    virtual void runInitScripts() = 0;
    virtual std::string deleteScript() = 0;
    virtual void setDeleteScript(const std::string &script_text,
            HOM_EnumValue &language = HOM_scriptLanguage::Python) = 0;

    SWIGOUT(%newobject addNodeGroup;)
    virtual HOM_NodeGroup *addNodeGroup(const char *name = NULL) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_NodeGroup> > nodeGroups() = 0;

    SWIGOUT(%newobject nodeGroup;)
    virtual HOM_NodeGroup *nodeGroup(const char *name) = 0;

    virtual std::string motionEffectsNetworkPath() = 0;
    SWIGOUT(%newobject findOrCreateMotionEffectsNetwork;)
    virtual HOM_Node *findOrCreateMotionEffectsNetwork(bool create=true) = 0;
    virtual void createOrMoveVisualizer(int output_index) = 0;

    SWIGOUT(%kwargs saveItemsToFile;)
    virtual void saveItemsToFile(
            const std::vector<HOM_NetworkMovableItem *> &items,
            const char *file_name,
            bool save_hda_fallbacks = false) = 0;
    SWIGOUT(%kwargs loadItemsFromFile;)
    virtual void loadItemsFromFile(
            const char *file_name, bool ignore_load_warnings=false) = 0;

    SWIGOUT(%ignore addOpaqueEventCallback;)
    virtual void addOpaqueEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            void *py_callback) = 0;
    SWIGOUT(%ignore addOpaqueParmCallback;)
    virtual void addOpaqueParmCallback(
            void *py_callback,
            const std::vector<std::string> &names) = 0;
    SWIGOUT(%ignore removeOpaqueEventCallback;)
    virtual void removeOpaqueEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            void *py_callback) = 0;
    virtual void removeAllEventCallbacks() = 0;
    SWIGOUT(%ignore opaqueEventCallbacks;)
    virtual std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
        opaqueEventCallbacks() = 0;

    SWIGOUT(%ignore getUniqueId;)
    virtual int getUniqueId() = 0;

    virtual double stampValue(const char *name, double default_value) = 0;
    virtual std::string stampValue(
            const char *name, const char *default_value) = 0;

    // asCode methods:
    SWIGOUT(%kwargs asCode;)
    virtual std::string asCode(bool brief=false,
                               bool recurse=false,
                               bool save_channels_only=false,
                               bool save_creation_commands=true,
                               bool save_keys_in_frames=false,
                               bool save_outgoing_wires=false,
                               bool save_parm_values_only=false,
                               bool save_spare_parms=true,
                               bool save_box_membership=true,
                               const char *function_name=NULL) = 0;

    // Data Block methods (like user data, but bigger blobs with associated
    // data types).
    virtual std::vector<std::string> dataBlockKeys(
            const char *blocktype = nullptr) = 0;
    virtual std::string dataBlockType(const char *key) = 0;
    virtual HOM_BinaryString dataBlock(const char *key) = 0;
    SWIGOUT(%kwargs setDataBlock;)
    virtual void setDataBlock(const char *key, HOM_BinaryString data,
            const char *block_type = nullptr) = 0;
    virtual void removeDataBlock(const char *key) = 0;

    // Cached user data methods:
    SWIGOUT(%ignore setOpaqueCachedUserData;)
    virtual void setOpaqueCachedUserData(
            const char *name, void *opaque_py_object) = 0;
    SWIGOUT(%ignore opaqueCachedUserData;)
    virtual void *opaqueCachedUserData(const char *name) = 0;
    virtual void destroyCachedUserData(
            const char *name, bool must_exist=true) = 0;
    virtual void clearCachedUserDataDict() = 0;
    virtual std::map<std::string, PY_OpaqueObject> cachedUserDataDict() = 0;

#ifdef SWIG
%extend
{
    void setCachedUserData(const char *name, InterpreterObject value)
    { return self->setOpaqueCachedUserData(name, value); }

    InterpreterObject cachedUserData(const char *name)
    { return HOMincRef((InterpreterObject)self->opaqueCachedUserData(name)); }
}
#endif

    SWIGOUT(%newobject simulation;)
    virtual HOM_DopSimulation *simulation() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node> >
    findNodesThatProcessedObject(HOM_DopObject &dop_object) = 0;

    virtual HOM_BinaryString _parmClipData(double start,
                                           double end,
                                           bool binary = true,
                                           bool use_blosc_compression = true,
                                           double sample_rate = 0,
                                           bool scoped_only = false) = 0;

    SWIGOUT(%kwargs _setParmClipData;)
    virtual void _setParmClipData(HOM_BinaryString data,
                                  bool binary = true,
                                  bool blosc_compressed = true,
                                  double sample_rate = 0,
                                  double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;

    virtual void _saveParmClip(std::string file_name,
                               double start,
                               double end,
                               double sample_rate = 0,
                               bool scoped_only = false) = 0;

    SWIGOUT(%kwargs _loadParmClip;)
    virtual void _loadParmClip(std::string file_name,
                               double sample_rate = 0,
                               double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;

    virtual int __creationTime() = 0;
    virtual int __modificationTime() = 0;
    virtual void *_asVoidPointer() = 0;

    SWIGOUT(%kwargs addError;)
    virtual void addError(const char *message = 0,
            const HOM_EnumValue &severity = HOM_severityType::Error) = 0;
    SWIGOUT(%kwargs addWarning;)
    virtual void addWarning(const char *message = 0) = 0;
    SWIGOUT(%kwargs addMessage;)
    virtual void addMessage(const char *message = 0) = 0;

    virtual float lastCookTime() = 0;
    virtual std::map<std::string, hboost::any> lastCookContextOptions(
            bool only_used_options = false) = 0;

#ifdef SWIG
%extend
{
    // evalParm() and evalParmTuple() need to be special methods because
    // their return types can vary.
    InterpreterObject evalParm(const char *parm_path)
    {
        HOM_Parm *parm = self->parm(parm_path);

        if (!parm)
            throw HOM_OperationFailed("Invalid parm name");

        InterpreterObject result = HOMevalParm(*parm);
        delete parm;
        return result;
    }

    InterpreterObject evalParmTuple(const char *parm_path)
    {
        HOM_ParmTuple *parm_tuple = self->parmTuple(parm_path);

        if (!parm_tuple)
            throw HOM_OperationFailed("Invalid parm tuple name");

        InterpreterObject result = HOMevalParmTuple(*parm_tuple);
        delete parm_tuple;
        return result;
    }

    void addEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            InterpreterObject callback)
    { self->addOpaqueEventCallback(event_types, callback); }

    void addParmCallback(
            InterpreterObject callback,
            const std::vector<std::string> &names)
    { self->addOpaqueParmCallback(callback,names); }

    void removeEventCallback(
            const std::vector<HOM_EnumValue *> &event_types,
            InterpreterObject callback)
    { self->removeOpaqueEventCallback(event_types, callback); }


    std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
        eventCallbacks()
    {
        std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
            opaque_callbacks(self->opaqueEventCallbacks());

        std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
            callbacks;
        for (int i=0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back(std::make_pair(
                opaque_callbacks[i].first,
                (InterpreterObject)opaque_callbacks[i].second));
        return callbacks;
    }
}
#endif
};

#endif