24#ifndef PXR_USD_PCP_CACHE_H
25#define PXR_USD_PCP_CACHE_H
28#include "pxr/usd/pcp/api.h"
29#include "pxr/usd/pcp/dependency.h"
30#include "pxr/usd/pcp/errors.h"
31#include "pxr/usd/pcp/mapFunction.h"
32#include "pxr/usd/pcp/primIndex.h"
33#include "pxr/usd/pcp/propertyIndex.h"
35#include "pxr/usd/sdf/path.h"
36#include "pxr/usd/sdf/pathTable.h"
38#include "pxr/usd/ar/ar.h"
41#include "pxr/base/tf/functionRef.h"
42#include "pxr/base/tf/hashset.h"
46#include <unordered_set>
49PXR_NAMESPACE_OPEN_SCOPE
54class Pcp_Dependencies;
110 const std::string& fileFormatTarget = std::string(),
135 return layerStack == _layerStack;
170 using PayloadSet = std::unordered_set<SdfPath, SdfPath::Hash>;
172 PayloadSet const &GetIncludedPayloads()
const;
187 const SdfPathSet & pathsToExclude,
223 const std::vector<std::string>& layersToUnmute,
225 std::vector<std::string>* newLayersMuted =
nullptr,
226 std::vector<std::string>* newLayersUnmuted =
252 const std::string& layerIdentifier,
253 std::string* canonicalMutedLayerIdentifier
274 PcpErrorVector *allErrors);
316 template <
class ChildrenPredicate,
class PayloadPredicate>
318 PcpErrorVector *allErrors,
319 const ChildrenPredicate &childrenPred,
320 const PayloadPredicate &payloadPred) {
322 childrenPred, payloadPred,
323 "Pcp",
"ComputePrimIndexesInParallel");
329 template <
class ChildrenPredicate,
class PayloadPredicate>
331 PcpErrorVector *allErrors,
332 const ChildrenPredicate &childrenPred,
333 const PayloadPredicate &payloadPred,
334 const char *mallocTag1,
335 const char *mallocTag2) {
337 childrenPred, payloadPred,
338 mallocTag1, mallocTag2);
343 template <
class ChildrenPredicate,
class PayloadPredicate>
345 PcpErrorVector *allErrors,
346 const ChildrenPredicate &childrenPred,
347 const PayloadPredicate &payloadPred) {
348 _UntypedIndexingChildrenPredicate cp(&childrenPred);
349 _UntypedIndexingPayloadPredicate pp(&payloadPred);
350 _ComputePrimIndexesInParallel(paths, allErrors, cp, pp,
351 "Pcp",
"ComputePrimIndexesInParallel");
357 template <
class ChildrenPredicate,
class PayloadPredicate>
359 PcpErrorVector *allErrors,
360 const ChildrenPredicate &childrenPred,
361 const PayloadPredicate &payloadPred,
362 const char *mallocTag1,
363 const char *mallocTag2) {
364 _UntypedIndexingChildrenPredicate cp(&childrenPred);
365 _UntypedIndexingPayloadPredicate pp(&payloadPred);
366 _ComputePrimIndexesInParallel(paths, allErrors, cp, pp,
367 mallocTag1, mallocTag2);
378 template <
class Callback>
383 _ForEachPrimIndex(fn);
411 SdfPathVector *paths,
413 const SdfSpecHandle &stopProperty,
414 bool includeStopProperty,
415 SdfPathVector *deletedPaths,
416 PcpErrorVector *allErrors);
430 SdfPathVector *paths,
432 const SdfSpecHandle &stopProperty,
433 bool includeStopProperty,
434 SdfPathVector *deletedPaths,
435 PcpErrorVector *allErrors);
459 const PcpLayerStackPtrVector&
465 template <
class Callback>
470 _ForEachLayerStack(fn);
490 PcpDependencyFlags depMask,
493 bool filterForExistingCachesOnly)
const;
508 PcpDependencyFlags depMask,
511 bool filterForExistingCachesOnly)
const;
523 const SdfLayerHandle& layer,
524 SdfPath* allowedPathInLayer)
const;
541 std::map<SdfPath, std::vector<std::string>, SdfPath::FastLessThan>
572 const TfToken &attributeName)
const;
581 const SdfPath &primIndexPath)
const;
587 const PcpLayerStackPtr &layerStack)
const;
592 const std::unordered_set<std::string>&
595 const PcpLayerStackPtr &layerStack)
const;
660 friend class Pcp_Dependencies;
661 friend class Pcp_Statistics;
663 struct _ParallelIndexer;
678 struct _UntypedIndexingChildrenPredicate {
679 _UntypedIndexingChildrenPredicate() : pred(nullptr), invoke(nullptr) {}
680 template <
class Pred>
681 explicit _UntypedIndexingChildrenPredicate(
const Pred *pred)
682 : pred(pred), invoke(_Invoke<Pred>) {}
686 return invoke(pred, index, childNamesToCompose);
689 template <
class Pred>
690 static bool _Invoke(
const void *pred,
const PcpPrimIndex &index,
692 return (*
static_cast<const Pred *
>(pred))(index, namesToCompose);
700 struct _UntypedIndexingPayloadPredicate {
701 template <
class Pred>
702 explicit _UntypedIndexingPayloadPredicate(
const Pred *pred)
703 : pred(pred), invoke(_Invoke<Pred>) {}
705 inline bool operator()(
const SdfPath &path)
const {
706 return invoke(pred, path);
709 template <
class Pred>
710 static bool _Invoke(
const void *pred,
const SdfPath &path) {
711 return (*
static_cast<const Pred *
>(pred))(path);
714 bool (*invoke)(
const void *,
const SdfPath &);
719 _ComputePrimIndexWithCompatibleInputs(
721 PcpErrorVector *allErrors);
725 Pcp_ComputePrimIndexWithCompatibleInputs(
728 PcpErrorVector *allErrors);
732 void _ComputePrimIndexesInParallel(
733 const SdfPathVector &paths,
734 PcpErrorVector *allErrors,
735 _UntypedIndexingChildrenPredicate childrenPred,
736 _UntypedIndexingPayloadPredicate payloadPred,
737 const char *mallocTag1,
738 const char *mallocTag2);
741 void _RemovePrimAndPropertyCaches(
const SdfPath& root,
755 void _ForEachPrimIndex(
759 void _ForEachLayerStack(
760 const TfFunctionRef<
void(
const PcpLayerStackPtr&)>& fn)
const;
779 const std::string _fileFormatTarget;
784 PcpLayerStackRefPtr _layerStack;
793 typedef Pcp_LayerStackRegistryRefPtr _LayerStackCache;
798 _LayerStackCache _layerStackCache;
799 _PrimIndexCache _primIndexCache;
800 _PropertyIndexCache _propertyIndexCache;
801 std::unique_ptr<Pcp_Dependencies> _primDependencies;
804 std::unique_ptr<_ParallelIndexer> _parallelIndexer;
807PXR_NAMESPACE_CLOSE_SCOPE
Types of changes per cache.
PcpCache is the context required to make requests of the Pcp composition algorithm and cache the resu...
std::unordered_set< SdfPath, SdfPath::Hash > PayloadSet
Returns the payloads requested for inclusion.
void ComputePrimIndexesInParallel(const SdfPathVector &paths, PcpErrorVector *allErrors, const ChildrenPredicate &childrenPred, const PayloadPredicate &payloadPred, const char *mallocTag1, const char *mallocTag2)
This is an overloaded member function, provided for convenience. It differs from the above function o...
PCP_API void ReloadReferences(PcpChanges *changes, const SdfPath &primPath)
Reload every layer used by the prim at primPath that's across a reference or payload.
PCP_API const std::unordered_set< std::string > & GetExpressionVariablesFromLayerStackUsedByPrim(const SdfPath &primIndexPath, const PcpLayerStackPtr &layerStack) const
Returns the set of expression variables in layerStack that are used by the prim index at primIndexPat...
void ForEachPrimIndex(const Callback &callback) const
Run the given callback on every prim index in the cache.
PCP_API void Reload(PcpChanges *changes)
Reload the layers of the layer stack, except session layers and sublayers of session layers.
PCP_API void RequestPayloads(const SdfPathSet &pathsToInclude, const SdfPathSet &pathsToExclude, PcpChanges *changes=NULL)
Request payloads to be included or excluded from composition.
PCP_API const PcpPropertyIndex & ComputePropertyIndex(const SdfPath &propPath, PcpErrorVector *allErrors)
Compute and return a reference to the cached result for the property index for the given path.
PCP_API const PcpLayerStackIdentifier & GetLayerStackIdentifier() const
Get the identifier of the layerStack used for composition.
PCP_API const PcpPrimIndex & ComputePrimIndex(const SdfPath &primPath, PcpErrorVector *allErrors)
Compute and return a reference to the cached result for the prim index for the given path.
PCP_API void ComputeAttributeConnectionPaths(const SdfPath &attributePath, SdfPathVector *paths, bool localOnly, const SdfSpecHandle &stopProperty, bool includeStopProperty, SdfPathVector *deletedPaths, PcpErrorVector *allErrors)
Compute the attribute connection paths for the attribute at attributePath into paths.
void ComputePrimIndexesInParallel(const SdfPath &path, PcpErrorVector *allErrors, const ChildrenPredicate &childrenPred, const PayloadPredicate &payloadPred, const char *mallocTag1, const char *mallocTag2)
This is an overloaded member function, provided for convenience. It differs from the above function o...
PCP_API PcpVariantFallbackMap GetVariantFallbacks() const
Get the list of fallbacks to attempt to use when evaluating variant sets that lack an authored select...
PCP_API SdfLayerHandleSet GetUsedRootLayers() const
Returns set of all root layers used by this cache.
PCP_API PcpLayerStackPtr GetLayerStack() const
Get the layer stack for GetLayerStackIdentifier().
PCP_API PcpLayerStackRefPtr ComputeLayerStack(const PcpLayerStackIdentifier &identifier, PcpErrorVector *allErrors)
Returns the layer stack for identifier if it exists, otherwise creates a new layer stack for identifi...
PCP_API void Apply(const PcpCacheChanges &changes, PcpLifeboat *lifeboat)
Apply the changes in changes.
PCP_API void RequestLayerMuting(const std::vector< std::string > &layersToMute, const std::vector< std::string > &layersToUnmute, PcpChanges *changes=nullptr, std::vector< std::string > *newLayersMuted=nullptr, std::vector< std::string > *newLayersUnmuted=nullptr)
Request layers to be muted or unmuted in this cache.
PCP_API const PcpPrimIndex * FindPrimIndex(const SdfPath &primPath) const
Returns a pointer to the cached computed prim index for the given path, or NULL if it has not been co...
PCP_API bool IsPossibleDynamicFileFormatArgumentField(const TfToken &field) const
Returns true if the given field is the name of a field that was composed while generating dynamic fil...
PCP_API const std::vector< std::string > & GetMutedLayers() const
Returns the list of canonical identifiers for muted layers in this cache.
PCP_API bool IsPossibleDynamicFileFormatArgumentAttribute(const TfToken &attributeName) const
Returns true if the given attributeName is the name of an attribute whose default value field was com...
PCP_API const PcpLayerStackPtrVector & FindAllLayerStacksUsingLayer(const SdfLayerHandle &layer) const
Returns every computed & cached layer stack that includes layer.
PCP_API bool IsLayerMuted(const std::string &layerIdentifier) const
Returns true if the layer specified by layerIdentifier is muted in this cache, false otherwise.
bool HasRootLayerStack(PcpLayerStackRefPtr const &layerStack) const
Return true if this cache's root layer stack is layerStack, false otherwise.
PCP_API void SetVariantFallbacks(const PcpVariantFallbackMap &map, PcpChanges *changes=NULL)
Set the list of fallbacks to attempt to use when evaluating variant sets that lack an authored select...
void ComputePrimIndexesInParallel(const SdfPath &path, PcpErrorVector *allErrors, const ChildrenPredicate &childrenPred, const PayloadPredicate &payloadPred)
Compute PcpPrimIndexes in the subtree rooted at path in parallel, recursing to children based on the ...
PCP_API PcpLayerStackPtr FindLayerStack(const PcpLayerStackIdentifier &identifier) const
Returns the layer stack for identifier if it has been computed and cached, otherwise returns NULL.
PCP_API PcpPrimIndexInputs GetPrimIndexInputs()
Returns parameter object containing all inputs for the prim index computation used by this cache.
PCP_API std::vector< std::string > GetInvalidSublayerIdentifiers() const
Returns a vector of sublayer asset paths used in the layer stack that didn't resolve to valid assets.
PCP_API const PcpPropertyIndex * FindPropertyIndex(const SdfPath &propPath) const
Returns a pointer to the cached computed property index for the given path, or NULL if it has not bee...
PCP_API bool UsesLayerStack(const PcpLayerStackPtr &layerStack) const
Return true if layerStack is used by this cache in its composition, false otherwise.
PCP_API bool IsUsd() const
Return true if the cache is configured in Usd mode.
PCP_API bool HasRootLayerStack(PcpLayerStackPtr const &layerStack) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
PCP_API bool IsInvalidAssetPath(const std::string &resolvedAssetPath) const
Returns true if resolvedAssetPath was used by a prim (e.g.
PCP_API const SdfPathVector & GetPrimsUsingExpressionVariablesFromLayerStack(const PcpLayerStackPtr &layerStack) const
Returns the list of prim index paths that depend on one or more expression variables from layerStack.
PCP_API size_t GetUsedLayersRevision() const
Return a number that can be used to determine whether or not the set of layers used by this cache may...
PCP_API bool CanHaveOpinionForSite(const SdfPath &localPcpSitePath, const SdfLayerHandle &layer, SdfPath *allowedPathInLayer) const
Returns true if an opinion for the site at localPcpSitePath in the cache's layer stack can be provide...
PCP_API const PcpDynamicFileFormatDependencyData & GetDynamicFileFormatArgumentDependencyData(const SdfPath &primIndexPath) const
Returns the dynamic file format dependency data object for the prim index with the given primIndexPat...
PCP_API bool HasAnyDynamicFileFormatArgumentFieldDependencies() const
Returns true if any prim index in this cache has a dependency on a dynamic file format argument field...
PCP_API void ComputeRelationshipTargetPaths(const SdfPath &relationshipPath, SdfPathVector *paths, bool localOnly, const SdfSpecHandle &stopProperty, bool includeStopProperty, SdfPathVector *deletedPaths, PcpErrorVector *allErrors)
Compute the relationship target paths for the relationship at relationshipPath into paths.
void ComputePrimIndexesInParallel(const SdfPathVector &paths, PcpErrorVector *allErrors, const ChildrenPredicate &childrenPred, const PayloadPredicate &payloadPred)
Vectorized form of ComputePrimIndexesInParallel().
PCP_API PcpDependencyVector FindSiteDependencies(const SdfLayerHandle &siteLayer, const SdfPath &sitePath, PcpDependencyFlags depMask, bool recurseOnSite, bool recurseOnIndex, bool filterForExistingCachesOnly) const
Returns dependencies on the given site of scene description, as discovered by the cached index comput...
PCP_API PcpCache(const PcpLayerStackIdentifier &layerStackIdentifier, const std::string &fileFormatTarget=std::string(), bool usd=false)
Construct a PcpCache to compose results for the layer stack identified by layerStackIdentifier.
PCP_API SdfLayerHandleSet GetUsedLayers() const
Returns set of all layers used by this cache.
PCP_API bool IsPayloadIncluded(const SdfPath &path) const
Return true if the payload is included for the given path.
PCP_API std::map< SdfPath, std::vector< std::string >, SdfPath::FastLessThan > GetInvalidAssetPaths() const
Returns a map of prim paths to asset paths used by that prim (e.g.
PCP_API void PrintStatistics() const
Prints various statistics about the data stored in this cache.
PCP_API bool IsInvalidSublayerIdentifier(const std::string &identifier) const
Returns true if identifier was used as a sublayer path in a layer stack but did not identify a valid ...
PCP_API bool IsLayerMuted(const SdfLayerHandle &anchorLayer, const std::string &layerIdentifier, std::string *canonicalMutedLayerIdentifier=nullptr) const
Returns true if the layer specified by layerIdentifier is muted in this cache, false otherwise.
void ForEachLayerStack(const Callback &callback) const
Run the given callbcack on every layer stack used by prim indexes in the cache.
PCP_API PcpDependencyVector FindSiteDependencies(const PcpLayerStackPtr &siteLayerStack, const SdfPath &sitePath, PcpDependencyFlags depMask, bool recurseOnSite, bool recurseOnIndex, bool filterForExistingCachesOnly) const
Returns dependencies on the given site of scene description, as discovered by the cached index comput...
PCP_API bool HasAnyDynamicFileFormatArgumentAttributeDependencies() const
Returns true if any prim index in this cache has a dependency on a dynamic file format argument attri...
PCP_API const std::string & GetFileFormatTarget() const
Returns the file format target this cache is configured for.
Represents a stack of layers that contribute opinions to composition.
Arguments used to identify a layer stack.
Structure used to temporarily retain layers and layerStacks within a code block.
A function that maps values from one namespace (and time domain) to another.
PcpNode represents a node in an expression tree for compositing scene description.
PcpPrimIndex is an index of the all sites of scene description that contribute opinions to a specific...
PcpPropertyIndex is an index of all sites in scene description that contribute opinions to a specific...
A path value used to locate objects in layers or scenegraphs.
A mapping from SdfPath to MappedType, somewhat similar to map<SdfPath, MappedType> and TfHashMap<SdfP...
Base class for all Sdf spec classes.
This class provides a non-owning reference to a type-erased callable object with a specified signatur...
Token for efficient comparison, assignment, and hashing of known strings.
Standard pointer typedefs.
#define TF_DECLARE_WEAK_AND_REF_PTRS(type)
Define standard weak, ref, and vector pointer types.
std::vector< TfToken > TfTokenVector
Convenience types.
std::map< std::string, std::vector< std::string > > PcpVariantFallbackMap
typedef std::map<std::string, std::vector<std::string>> PcpVariantFallbackMap