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>
49 PXR_NAMESPACE_OPEN_SCOPE
54 class Pcp_Dependencies;
110 const std::string& fileFormatTarget = std::string(),
158 using PayloadSet = std::unordered_set<SdfPath, SdfPath::Hash>;
160 PayloadSet const &GetIncludedPayloads()
const;
175 const SdfPathSet & pathsToExclude,
217 const std::vector<std::string>& layersToUnmute,
219 std::vector<std::string>* newLayersMuted =
nullptr,
220 std::vector<std::string>* newLayersUnmuted =
235 bool IsLayerMuted(
const std::string& layerIdentifier)
const;
246 const std::string& layerIdentifier,
247 std::string* canonicalMutedLayerIdentifier
268 PcpErrorVector *allErrors);
310 template <
class ChildrenPredicate,
class PayloadPredicate>
312 PcpErrorVector *allErrors,
313 const ChildrenPredicate &childrenPred,
314 const PayloadPredicate &payloadPred) {
316 childrenPred, payloadPred,
317 "Pcp",
"ComputePrimIndexesInParallel");
323 template <
class ChildrenPredicate,
class PayloadPredicate>
325 PcpErrorVector *allErrors,
326 const ChildrenPredicate &childrenPred,
327 const PayloadPredicate &payloadPred,
328 const char *mallocTag1,
329 const char *mallocTag2) {
331 childrenPred, payloadPred,
332 mallocTag1, mallocTag2);
337 template <
class ChildrenPredicate,
class PayloadPredicate>
339 PcpErrorVector *allErrors,
340 const ChildrenPredicate &childrenPred,
341 const PayloadPredicate &payloadPred) {
342 _UntypedIndexingChildrenPredicate cp(&childrenPred);
343 _UntypedIndexingPayloadPredicate pp(&payloadPred);
344 _ComputePrimIndexesInParallel(paths, allErrors, cp, pp,
345 "Pcp",
"ComputePrimIndexesInParallel");
351 template <
class ChildrenPredicate,
class PayloadPredicate>
353 PcpErrorVector *allErrors,
354 const ChildrenPredicate &childrenPred,
355 const PayloadPredicate &payloadPred,
356 const char *mallocTag1,
357 const char *mallocTag2) {
358 _UntypedIndexingChildrenPredicate cp(&childrenPred);
359 _UntypedIndexingPayloadPredicate pp(&payloadPred);
360 _ComputePrimIndexesInParallel(paths, allErrors, cp, pp,
361 mallocTag1, mallocTag2);
372 template <
class Callback>
377 _ForEachPrimIndex(fn);
405 SdfPathVector *paths,
407 const SdfSpecHandle &stopProperty,
408 bool includeStopProperty,
409 SdfPathVector *deletedPaths,
410 PcpErrorVector *allErrors);
424 SdfPathVector *paths,
426 const SdfSpecHandle &stopProperty,
427 bool includeStopProperty,
428 SdfPathVector *deletedPaths,
429 PcpErrorVector *allErrors);
453 const PcpLayerStackPtrVector&
473 PcpDependencyFlags depMask,
476 bool filterForExistingCachesOnly)
const;
491 PcpDependencyFlags depMask,
494 bool filterForExistingCachesOnly)
const;
506 const SdfLayerHandle& layer,
507 SdfPath* allowedPathInLayer)
const;
524 std::map<SdfPath, std::vector<std::string>, SdfPath::FastLessThan>
552 const SdfPath &primIndexPath)
const;
617 friend class Pcp_Statistics;
619 struct _ParallelIndexer;
634 struct _UntypedIndexingChildrenPredicate {
635 _UntypedIndexingChildrenPredicate() : pred(nullptr), invoke(nullptr) {}
636 template <
class Pred>
637 explicit _UntypedIndexingChildrenPredicate(
const Pred *pred)
638 : pred(pred), invoke(_Invoke<Pred>) {}
642 return invoke(pred, index, childNamesToCompose);
645 template <
class Pred>
646 static bool _Invoke(
const void *pred,
const PcpPrimIndex &index,
648 return (*static_cast<const Pred *>(pred))(index, namesToCompose);
656 struct _UntypedIndexingPayloadPredicate {
657 template <
class Pred>
658 explicit _UntypedIndexingPayloadPredicate(
const Pred *pred)
659 : pred(pred), invoke(_Invoke<Pred>) {}
661 inline bool operator()(
const SdfPath &path)
const {
662 return invoke(pred, path);
665 template <
class Pred>
666 static bool _Invoke(
const void *pred,
const SdfPath &path) {
667 return (*static_cast<const Pred *>(pred))(path);
670 bool (*invoke)(
const void *,
const SdfPath &);
675 _ComputePrimIndexWithCompatibleInputs(
677 PcpErrorVector *allErrors);
681 Pcp_ComputePrimIndexWithCompatibleInputs(
684 PcpErrorVector *allErrors);
688 void _ComputePrimIndexesInParallel(
689 const SdfPathVector &paths,
690 PcpErrorVector *allErrors,
691 _UntypedIndexingChildrenPredicate childrenPred,
692 _UntypedIndexingPayloadPredicate payloadPred,
693 const char *mallocTag1,
694 const char *mallocTag2);
697 void _RemovePrimAndPropertyCaches(
const SdfPath& root,
711 void _ForEachPrimIndex(
731 const std::string _fileFormatTarget;
736 PcpLayerStackRefPtr _layerStack;
745 typedef Pcp_LayerStackRegistryRefPtr _LayerStackCache;
750 _LayerStackCache _layerStackCache;
751 _PrimIndexCache _primIndexCache;
752 _PropertyIndexCache _propertyIndexCache;
753 std::unique_ptr<Pcp_Dependencies> _primDependencies;
756 std::unique_ptr<_ParallelIndexer> _parallelIndexer;
759 PXR_NAMESPACE_CLOSE_SCOPE
761 #endif // PXR_USD_PCP_CACHE_H
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 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 void PrintStatistics() const
Prints various statistics about the data stored in this cache.
PCP_API bool IsUsd() const
Return true if the cache is configured in Usd mode.
PcpPrimIndex is an index of the all sites of scene description that contribute opinions to a specific...
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...
Standard pointer typedefs.
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 PcpPrimIndexInputs GetPrimIndexInputs()
Returns parameter object containing all inputs for the prim index computation used by this cache...
Represents a stack of layers that contribute opinions to composition.
PCP_API SdfLayerHandleSet GetUsedRootLayers() const
Returns set of all root layers used by this cache.
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 PcpLayerStackPtr FindLayerStack(const PcpLayerStackIdentifier &identifier) const
Returns the layer stack for identifier if it has been computed and cached, otherwise returns NULL...
PcpNode represents a node in an expression tree for compositing scene description.
PCP_API PcpLayerStackPtr GetLayerStack() const
Get the layer stack for GetLayerStackIdentifier().
PCP_API void Apply(const PcpCacheChanges &changes, PcpLifeboat *lifeboat)
Apply the changes in changes.
PCP_API const PcpLayerStackIdentifier & GetLayerStackIdentifier() const
Get the identifier of the layerStack used for composition.
PcpCache is the context required to make requests of the Pcp composition algorithm and cache the resu...
PCP_API bool IsPayloadIncluded(const SdfPath &path) const
Return true if the payload is included for the given path.
PCP_API SdfLayerHandleSet GetUsedLayers() const
Returns set of all layers used by this cache.
Base class for all Sdf spec classes.
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 bool UsesLayerStack(const PcpLayerStackPtr &layerStack) const
Return true if layerStack is used by this cache in its composition, false otherwise.
PCP_API const std::string & GetFileFormatTarget() const
Returns the file format target this cache is configured for.
#define TF_DECLARE_WEAK_AND_REF_PTRS(type)
Define standard weak, ref, and vector pointer types.
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...
This class provides a non-owning reference to a type-erased callable object with a specified signatur...
void ForEachPrimIndex(const Callback &callback) const
Run the given callback on every prim index in the 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 & ComputePropertyIndex(const SdfPath &propPath, PcpErrorVector *allErrors)
Compute and return a reference to the cached result for the property index for the given path...
void ComputePrimIndexesInParallel(const SdfPathVector &paths, PcpErrorVector *allErrors, const ChildrenPredicate &childrenPred, const PayloadPredicate &payloadPred)
Vectorized form of ComputePrimIndexesInParallel().
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 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...
Token for efficient comparison, assignment, and hashing of known strings.
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 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.
std::unordered_set< SdfPath, SdfPath::Hash > PayloadSet
Returns the payloads requested for inclusion.
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...
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 ...
std::vector< TfToken > TfTokenVector
Convenience types.
A function that maps values from one namespace (and time domain) to another.
A path value used to locate objects in layers or scenegraphs.
PCP_API const std::vector< std::string > & GetMutedLayers() const
Returns the list of canonical identifiers for muted layers in this cache.
Types of changes per cache.
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 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 bool HasAnyDynamicFileFormatArgumentDependencies() const
Returns true if any prim index in this cache has a dependency on a dynamic file format argument field...
PCP_API const PcpLayerStackPtrVector & FindAllLayerStacksUsingLayer(const SdfLayerHandle &layer) const
Returns every computed & cached layer stack that includes layer.
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 bool IsLayerMuted(const std::string &layerIdentifier) const
Returns true if the layer specified by layerIdentifier is muted in this cache, false otherwise...
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 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 bool IsInvalidAssetPath(const std::string &resolvedAssetPath) const
Returns true if resolvedAssetPath was used by a prim (e.g.
PcpPropertyIndex is an index of all sites in scene description that contribute opinions to a specific...
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 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...
PCP_API PcpVariantFallbackMap GetVariantFallbacks() const
Get the list of fallbacks to attempt to use when evaluating variant sets that lack an authored select...
Structure used to temporarily retain layers and layerStacks within a code block.
std::map< std::string, std::vector< std::string > > PcpVariantFallbackMap
typedef std::map<std::string, std::vector<std::string>> PcpVariantFallbackMap
Arguments used to identify a layer stack.