HOM_lop.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_lop_h__
#define __HOM_lop_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_EnumModules.h"
#include <UT/UT_Options.h>

#include <map>
#include <string>
#include <vector>

class HOM_Geometry;
class HOM_Node;
class HOM_NodeType;
class HOM_LopNode;
class HOM_ParmTuple;
class HOM_ParmTemplate;
class HOM_ParmTemplateGroup;

SWIGOUT(%rename(lop) HOM_lop;)

class HOM_API HOM_lop
{
public:
    virtual ~HOM_lop()
    { }

    virtual std::string __repr__() = 0;

    virtual std::string defaultNewPrimPath() = 0;
    virtual void setDefaultNewPrimPath(const char *path) = 0;

    virtual std::string defaultCollectionsPrimPath() = 0;
    virtual void setDefaultCollectionsPrimPath(const char *path) = 0;

    virtual std::string defaultCollectionsPrimType() = 0;
    virtual void setDefaultCollectionsPrimType(const char *primtype) = 0;

    virtual std::string defaultLightsPrimPath() = 0;
    virtual void setDefaultLightsPrimPath(const char *path) = 0;

    virtual std::string defaultCamerasPrimPath() = 0;
    virtual void setDefaultCamerasPrimPath(const char *path) = 0;

    virtual std::string defaultTransformSuffix() = 0;
    virtual void setDefaultTransformSuffix(const char *suffix) = 0;

    virtual bool showResolvedPaths() = 0;
    virtual void setShowResolvedPaths(bool show_resolved_paths) = 0;

    virtual bool panesFollowCurrentNode() = 0;
    virtual void setPanesFollowCurrentNode(bool follow_current_node) = 0;

    virtual bool panesShowViewportStage() = 0;
    virtual void setPanesShowViewportStage(bool show_viewport_stage) = 0;

    virtual bool panesShowPostLayers() = 0;
    virtual void setPanesShowPostLayers(bool show_post_layers) = 0;

    virtual bool autoSetAssetResolverContext() = 0;
    virtual void setAutoSetAssetResolverContext(bool auto_set_context) = 0;

    virtual bool updateRendererInBackground() = 0;
    virtual void setUpdateRendererInBackground(bool update_in_background) = 0;

    virtual bool loadPayloadsByDefault() = 0;
    virtual void setLoadPayloadsByDefault(bool load_payloads) = 0;

    virtual bool allowViewportOnlyPayloads() = 0;
    virtual void setAllowViewportOnlyPayloads(
            bool allow_viewport_only_payloads) = 0;

    virtual bool pathParameterCompletion() = 0;
    virtual void setPathParameterCompletion(
            bool path_parameter_completion) = 0;

    virtual double defaultMetersPerUnit() = 0;
    virtual void setDefaultMetersPerUnit(double meters_per_unit) = 0;

    virtual std::string defaultUpAxis() = 0;
    virtual void setDefaultUpAxis(const char *up_axis) = 0;

    virtual bool savePreferences() = 0;

    virtual void reloadLayer(const char *layer_path,
            bool recursive = false) = 0;

    virtual std::string mutingIdentifier(const char *identifier) = 0;

    virtual std::string makeValidPrimName(const char *name) = 0;
    SWIGOUT(%kwargs makeValidPrimPath;)
    virtual std::string makeValidPrimPath(const char *path,
            bool allow_relative = false) = 0;

    virtual HOM_ParmTemplateGroup *createParmsForProperty(HOM_LopNode *source,
            const char *primpath,
            const char *propertyname,
            const char *parametername = nullptr,
            bool prepend_control_parm = true,
            bool prefix_xform_parms = true) = 0;
    virtual HOM_ParmTemplateGroup *createParmsForProperty(const char *source,
            const char *primpath,
            const char *propertyname,
            const char *parametername = nullptr,
            bool prepend_control_parm = true,
            bool prefix_xform_parms = true) = 0;
    virtual HOM_ParmTemplateGroup *createParmsForParameter(
            HOM_ParmTemplate *source,
            const char *parametername = nullptr,
            const char *usdvaluetype = nullptr,
            bool prepend_control_parm = true,
            const char *propertyname = nullptr) = 0;

    virtual HOM_ParmTemplateGroup *createConnectionParmsForProperty(
            HOM_LopNode *source,
            const char *primpath,
            const char *propertyname,
            const char *parametername = nullptr,
            bool prepend_control_parm = true) = 0;
    virtual HOM_ParmTemplateGroup *createConnectionParmsForProperty(
            const char *source,
            const char *primpath,
            const char *propertyname,
            const char *parametername = nullptr,
            bool prepend_control_parm = true) = 0;

    virtual void setParmTupleFromProperty(HOM_ParmTuple *parmtuple,
            HOM_LopNode *source,
            const char *primpath,
            const char *propertyname) = 0;
    virtual void setParmTupleFromProperty(HOM_ParmTuple *parmtuple,
            const char *source,
            const char *primpath,
            const char *propertyname) = 0;

    virtual int shaderTranslatorID(HOM_Node &node) = 0;
    virtual std::string shaderRenderContextName(
            HOM_Node &node, const char *node_output_name) = 0;
    virtual std::string translateShader(
            HOM_Node &node, const char *node_output_name,
            const char *material_prim_path,
            const char *shader_parent_prim_path,
            const char *shader_prim_name = nullptr,
            HOM_OptionalDouble frame = HOM_OptionalDouble()) = 0;
    virtual void reportShaderTranslation(HOM_Node &node,
            const char *usd_shader_path) = 0;
    virtual HOM_NodeType *shaderNodeType(const char *shader_name) = 0;

    virtual std::vector<std::string> availableRendererNames() = 0;
    virtual std::vector<std::string> availableRendererLabels() = 0;

    SWIGOUT(%ignore availableRendererInfos);
    virtual std::vector<UT_Options>
            availableRendererInfos() = 0;

    virtual std::vector<std::pair<std::string, std::string> >
            outputProcessors() = 0;
    SWIGOUT(%newobject outputProcessorParms);
    virtual HOM_ParmTemplateGroup *outputProcessorParms(
            const char *name) = 0;

    virtual std::map<std::string, std::string> usdVersionInfo() = 0;

    virtual HOM_EnumValue &usdOutputMinimumSeverity() = 0;
    virtual void setUsdOutputMinimumSeverity(HOM_EnumValue &severity) = 0;

    virtual std::string addLockedGeometry(
            const char *identifier,
            HOM_Geometry &geo,
            const std::map<std::string, std::string> &args = {}) = 0;
    virtual bool removeLockedGeometry(const char *identifier) = 0;

    SWIGOUT(%ignore addOpaquePreferenceChangeCallback;)
    virtual void addOpaquePreferenceChangeCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaquePreferenceChangeCallback;)
    virtual void removeOpaquePreferenceChangeCallback(void *callback) = 0;

    virtual void forceReloadAllFilesFromDisk(bool reload_viewports=false) = 0;

    virtual bool _isProceduralSigned(const char *filepath) = 0;

#ifdef SWIG
    %extend
    {
        InterpreterObject availableRendererInfo()
        {
            auto infos = self->availableRendererInfos();
            return HOMoptionsListToInterpreterObject(infos);
        }

        void addPreferenceChangeCallback(InterpreterObject callback)
        { self->addOpaquePreferenceChangeCallback(callback); }

        void removePreferenceChangeCallback(InterpreterObject callback)
        { self->removeOpaquePreferenceChangeCallback(callback); }
    }
#endif
};

#endif