LOP_PRMShared.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.
 *
 * NAME:        LOP_PRMShared.h
 *
 * COMMENTS:
 *              This enum defines common LOP parameters and callbacks.
 *
*/

#include "LOP_API.h"

#ifndef __LOP_PRMShared__
#define __LOP_PRMShared__

#include <HUSD/HUSD_Merge.h>
#include <OP/OP_Error.h>
#include <PRM/PRM_ChoiceList.h>
#include <PRM/PRM_Default.h>
#include <PRM/PRM_Name.h>
#include <PRM/PRM_SpareData.h>
#include <PRM/PRM_Template.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Matrix4.h>

class LOP_Node;
class HUSD_AutoAnyLock;
class HUSD_FindPrims;
class HUSD_FindProps;
class OP_Node;
class OP_Context;
class OP_ContextOptionsWriteScope;
class PRM_Parm;
class UT_String;

enum {
    LOP_SETSTAGEMETADATA_AUTO,
    LOP_SETSTAGEMETADATA_YES,
    LOP_SETSTAGEMETADATA_NO
};

extern LOP_API const UT_StringHolder lopAttrControlNoneToken;
extern LOP_API const UT_StringHolder lopAttrControlSetToken;
extern LOP_API const UT_StringHolder lopAttrControlAddToken;
extern LOP_API const UT_StringHolder lopAttrControlAppendToken;
extern LOP_API const UT_StringHolder lopAttrControlPrependToken;
extern LOP_API const UT_StringHolder lopAttrControlRemoveToken;
extern LOP_API const UT_StringHolder lopAttrControlMultiplyToken;
extern LOP_API const UT_StringHolder lopAttrControlSetExistingToken;
extern LOP_API const UT_StringHolder lopAttrControlSetNotAuthoredToken;
extern LOP_API const UT_StringHolder lopAttrControlBlockToken;
extern LOP_API const UT_StringHolder lopAttrControlConnectInputToken;
extern LOP_API const UT_StringHolder lopAttrControlDisconnectInputToken;
extern LOP_API const UT_StringHolder lopMultiPrimSelectTooltip;
extern LOP_API const UT_StringHolder lopSinglePrimSelectTooltip;

extern LOP_API const UT_StringHolder lopErrorOnMissingFilesToken;
extern LOP_API const UT_StringHolder lopWarnOnMissingFilesToken;
extern LOP_API const UT_StringHolder lopIgnoreMissingFilesToken;
extern LOP_API const UT_StringHolder lopAllowMissingFilesToken;

extern LOP_API PRM_Name          lopResolverContextAssetPathName;
extern LOP_API PRM_Name          lopInsertionPointDescriptorName;
extern LOP_API PRM_Name          lopModifiedPrimCountToStartNewLayerName;
extern LOP_API PRM_Name          lopPrimPatternName;
extern LOP_API PRM_Name          lopPathName;
extern LOP_API PRM_Name          lopPrimPathName;
extern LOP_API PRM_Name          lopPropPatternName;
extern LOP_API PRM_Name          lopPrimKindName;
extern LOP_API PRM_Name          lopPrimCountName;
extern LOP_API PRM_Name          lopPrimSpecifierName;
extern LOP_API PRM_Name          lopParentPrimTypeName;
extern LOP_API PRM_Name          lopCollectionCollapserName;
extern LOP_API PRM_Name          lopCollectionName;
extern LOP_API PRM_Name          lopHandleMissingFilesName;
extern LOP_API PRM_Name          lopLoadPayloadsName;
extern LOP_API PRM_Name          lopSetStageMetadataName;
extern LOP_API PRM_Name          lopEditRootLayerName;
extern LOP_API PRM_Name          lopShowLopStageName;
extern LOP_API PRM_Name          lopInEditLayerBlockLabelName;

extern LOP_API PRM_Default       lopAddPrimPathDefault;
extern LOP_API PRM_Default       lopEditPrimPathDefault;
extern LOP_API PRM_Default       lopRefPrimDefault;
extern LOP_API PRM_Default       lopPrimPatternDefault;
extern LOP_API PRM_Default       lopPrimKindDefault;
extern LOP_API PRM_Default       lopPrimKindWithAutoDefault;
extern LOP_API PRM_Default       lopPrimKindQueryDefault;
extern LOP_API PRM_Default       lopPrimPurposeDefault;
extern LOP_API PRM_Default       lopPrimSpecifierDefault;
extern LOP_API PRM_Default       lopParentPrimTypeDefault;
extern LOP_API PRM_Default       lopParentPrimTypeScopeDefault;
extern LOP_API PRM_Default       lopHandleMissingFilesDefault;
extern LOP_API PRM_Default       lopSetStageMetadataDefault;
extern LOP_API PRM_Default       lopInEditLayerBlockLabelDefault;

extern LOP_API PRM_ChoiceList    lopPrimPathMenu;
extern LOP_API PRM_ChoiceList    lopPrimSpecifierMenu;
extern LOP_API PRM_ChoiceList    lopPrimKindMenu;
extern LOP_API PRM_ChoiceList    lopPrimKindWithAutoMenu;
extern LOP_API PRM_ChoiceList    lopPrimKindQueryMenu;
extern LOP_API PRM_ChoiceList    lopPrimPurposeMenu;
extern LOP_API PRM_ChoiceList    lopPrimDrawModeMenu;
extern LOP_API PRM_ChoiceList    lopFirstInputCollectionsMenu;
extern LOP_API PRM_ChoiceList    lopSecondInputCollectionsMenu;
extern LOP_API PRM_ChoiceList    lopParentPrimTypeMenu;
extern LOP_API PRM_ChoiceList    lopConcretePrimTypeMenu;
extern LOP_API PRM_ChoiceList    lopAllPrimTypeMenu;
extern LOP_API PRM_ChoiceList    lopAttributeColorSpaceMenu;
extern LOP_API PRM_ChoiceList    lopAttributeInterpolationMenu;
extern LOP_API PRM_ChoiceList    lopAttributeTypeMenu;
extern LOP_API PRM_ChoiceList    lopHandleMissingFilesMenu;
extern LOP_API PRM_ChoiceList    lopRefPrimMenu;
extern LOP_API PRM_ChoiceList    lopMergeStyleMenu;
extern LOP_API PRM_ChoiceList    lopSetStageMetadataMenu;
extern LOP_API PRM_ChoiceList    lopTargetLayerMenu;
extern LOP_API PRM_ChoiceList    lopParentLayerMenu;

// Select a single primitive in the viewport or using the prim picker dialog.
extern LOP_API PRM_SpareData     lopPrimPathSpareData;
// Select a single primitive using only the prim picker dialog.
extern LOP_API PRM_SpareData     lopNonVisualPrimPathSpareData;
// Spare data for a parameter that supports multiple primitive path strings.
extern LOP_API PRM_SpareData     lopMultiPrimPathSpareData;
// Select multiple primitives using the viewport or prim picker dialog.
extern LOP_API PRM_SpareData     lopPrimPatternSpareData;
// As above, but with a multiline text editor.
extern LOP_API PRM_SpareData     lopMultilinePrimPatternSpareData;
// Select multiple primitives using only the prim picker dialog.
extern LOP_API PRM_SpareData     lopNonVisualPrimPatternSpareData;
// Select multiple primitives using the viewport or prim picker dialog,
// including allowing selecting instance proxy prims.
extern LOP_API PRM_SpareData     lopPrimPatternWithProxiesSpareData;
// As above, but with a multiline text editor.
extern LOP_API PRM_SpareData     lopMultilinePrimPatternWithProxiesSpareData;
// Spare data indicating a file parameter specifies a USD file for reading.
extern LOP_API PRM_SpareData     lopUsdReadFilePathSpareData;
// Spare data indicating a file parameter specifies a USD file for writing.
extern LOP_API PRM_SpareData     lopUsdWriteFilePathSpareData;

// Version of lopPrimPathSpareData that only supports selection using the
// primitive picker dialog. This can be used for nodes in other contexts that
// reference a LOP using a parameter called "loppath".
extern LOP_API PRM_SpareData     lopPrimPathDialogSpareData;

// Material LOPs
extern LOP_API PRM_Name          lopMatBindPurposeMultiName;
extern LOP_API PRM_Default       lopMatBindPurposeDefault;
extern LOP_API PRM_ChoiceList    lopMatBindPurposeMenu;
extern LOP_API PRM_Name          lopRefRenderVarsName;

extern LOP_API void      lopBuildUsdPrimVariantSetsMenu(LOP_Node &node,
                                int which_input,
                                bool allow_instance_proxies,
                                const UT_String &primpattern,
                                PRM_Name *menu_entries,
                                int max_menu_entries);

extern LOP_API void      lopBuildUsdPrimVariantsMenu(LOP_Node &node,
                                int which_input,
                                bool allow_instance_proxies,
                                const UT_String &primpattern,
                                const UT_String &variantset,
                                PRM_Name *menu_entries,
                                int max_menu_entries);

extern LOP_API void      lopBuildUsdExpansionRulesMenu(void *,
                                PRM_Name *menu_entries,
                                int max_menu_entries,
                                const PRM_SpareData *,
                                const PRM_Parm *);

extern LOP_API HUSD_MergeStyle lopMergeStyleFromString(
                                const UT_StringRef &merge_style_str);

enum LOP_XformParms {
    LOP_XFORM_TRS,
    LOP_XFORM_RXYZ,
    LOP_XFORM_T,
    LOP_XFORM_R,
    LOP_XFORM_S,
    LOP_XFORM_SHEAR,
    LOP_XFORM_USCALE,
    LOP_XFORM_PIVOTCONTAINER,
    LOP_XFORM_PIVOT,
    LOP_XFORM_PIVOTROT,
};

class LOP_XformComponents {
public:
    static const LOP_XformComponents &identity();

    void                 combine(const LOP_XformComponents &other);
    void                 applyXform(UT_Matrix4D &xform);

    UT_XformOrder        myOrder;
    UT_Vector3D          myT;
    UT_Vector3D          myR;
    UT_Vector3D          myS;
    UT_Vector3D          myShear;
    UT_Vector3D          myP;
    UT_Vector3D          myPR;
};
extern LOP_API const PRM_Template *lopXformTemplates();
extern LOP_API const PRM_Template *lopMultiparmXformTemplates();
extern LOP_API UT_Matrix4D lopBuildXform(OP_Node &node,
        fpreal t, LOP_XformComponents *accumulate = nullptr);
extern LOP_API UT_Matrix4D lopBuildMultiparmXform(OP_Node &node, int inst,
        fpreal t, LOP_XformComponents *accumulate = nullptr);

// Evaluate the lopSetStageMetadataName parameter on the node, and return true
// if the parm is set to "on", or set to "auto" and the node has no input.
extern LOP_API bool lopSetStageMetadata(LOP_Node *node, fpreal t);

// Parm templates for setting arbitrary context options.
extern LOP_API const PRM_Template &lopContextOptionsTemplate();
extern LOP_API void lopSetContextOptions(OP_Node &node,
        OP_Context &context,
        OP_ContextOptionsWriteScope &options);
extern LOP_API const PRM_Template &lopTimeBasedContextOptionsTemplate();
// Return true if there are any time dependent context options, even if we
// don't set them. We still need to be time dependent.
extern LOP_API bool lopSetTimeBasedContextOptions(OP_Node &node,
        OP_Context &context,
        OP_ContextOptionsWriteScope &options);
extern LOP_API const PRM_Template &lopPatternMatchingContextOptionsTemplate();
extern LOP_API void lopSetPatternMatchingContextOptions(OP_Node &node,
        OP_Context &context,
        OP_ContextOptionsWriteScope &options);

// Parm templates for defining a collection using every available algorithm,
// rather than just a primitive pattern string.
extern LOP_API PRM_Template lopCollectionCollapserParmTemplate(
        PRM_Name &collapser_parm_name);
extern LOP_API PRM_Template lopCollectionParmTemplate(
        PRM_Name &collection_parm_name,
        const char *multiparm_prefix = nullptr,
        const char *default_prim_pattern = nullptr);

// Class to hold evaluated parm templates so we can evaluate all our parms
// before using the parm values to populate an HUSD_FindPrims.
class LOP_CollectionParmSet
{
public:
    UT_StringHolder                      myTargetMethod;
    // Find by pattern string.
    UT_StringHolder                      myPattern;
    // Find by bounding box.
    UT_BoundingBoxD                      myBBox;
    UT_StringHolder                      myContainmentStr;
    // Find by primitive type.
    UT_StringHolder                      myPrimType;
    // Find by primitive type.
    UT_StringHolder                      myPrimPurpose;
    // Find by VEXpression.
    UT_StringHolder                      myVexExpr;;
    // Find by primitive kind.
    UT_StringHolder                      myPrimKind;
};
typedef UT_Array<LOP_CollectionParmSet> LOP_CollectionParms;

// Evaluate an adhoc collection multiparm and use it to fill in a
// LOP_CollectionParms array.
extern LOP_API void lopGetCollectionParms(LOP_Node &node,
        const PRM_Template &collection_parm_template,
        fpreal t, LOP_CollectionParms &collection_parms);
// Take a populated LOP_CollectionParms array and use it to fill in an
// HUSD_FindParms object.
extern LOP_API bool lopGetCollection(LOP_Node &node,
        const LOP_CollectionParms &collection_parms,
        fpreal t, HUSD_FindPrims &findprims);

// Return a template for a multiparm that lets the user configure an asset
// resolver using strings.
extern LOP_API const PRM_Template &lopResolverContextStringsTemplate();
// Populate a map of asset resolver configuration strings from the
// lopResolverStringsTemplate multiparm on the specified node.
extern LOP_API bool lopGetResolverContextStringsFromMultiparm(OP_Node &node,
        UT_StringMap<UT_StringHolder> &resolverstrings,
        const PRM_Name *asset_path_parm);

// Return a template for a multiparm that lets the user configure the variant
// selection fallback rules for a stage.
extern LOP_API const PRM_Template &lopVariantSelectionFallbackTemplate();
// Populate a map of variant sets to an array of variant set selection values
// that should be used for that variant set if no explicit selections has been
// authored on a prim.
extern LOP_API bool lopApplyVariantSelectionFallbacksFromMultiparm(OP_Node &node,
        UT_StringMap<UT_StringArray> &variantselections,
        bool add_empty_selections = false);

// Checks if the layer at a given file path exists, using the resolver context
// of the supplied data lock.
extern LOP_API OP_ERROR lopCheckForMissingFile(LOP_Node &node,
        HUSD_AutoAnyLock &lock,
        const UT_StringRef &filepath,
        const UT_StringRef &handle_missing_files,
        bool *skip_this_file);

// Take a single string, tokenize it, and return an array of valid USD
// primitive path strings. Return true if any paths are being returned.
extern LOP_API bool lopTokenizePrimitivePaths(const UT_StringRef &str,
        UT_StringArray &primpaths,
        UT_StringSet *uniqueprimpaths = nullptr);

#endif