primIndex.h
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef PXR_USD_PCP_PRIM_INDEX_H
25 #define PXR_USD_PCP_PRIM_INDEX_H
26 
27 #include "pxr/pxr.h"
28 #include "pxr/usd/pcp/api.h"
30 #include "pxr/usd/pcp/dependency.h"
31 #include "pxr/usd/pcp/dynamicFileFormatDependencyData.h"
32 #include "pxr/usd/pcp/errors.h"
33 #include "pxr/usd/pcp/iterator.h"
34 #include "pxr/usd/pcp/node.h"
35 #include "pxr/usd/pcp/types.h"
37 #include "pxr/usd/sdf/site.h"
39 #include "pxr/base/tf/hashmap.h"
40 #include "pxr/base/tf/hashset.h"
41 
42 #include <tbb/spin_rw_mutex.h>
43 
44 #include <functional>
45 #include <map>
46 #include <memory>
47 #include <unordered_set>
48 
49 PXR_NAMESPACE_OPEN_SCOPE
50 
51 SDF_DECLARE_HANDLES(SdfLayer);
52 SDF_DECLARE_HANDLES(SdfPrimSpec);
53 
55 TF_DECLARE_WEAK_AND_REF_PTRS(PcpPrimIndex_Graph);
56 
57 class ArResolver;
58 class PcpCache;
59 class PcpPrimIndex;
60 class PcpPrimIndexInputs;
62 class SdfPath;
63 
77 {
78 public:
80  PCP_API
81  PcpPrimIndex();
82 
84  PCP_API
85  PcpPrimIndex(const PcpPrimIndex& rhs);
86 
88  PcpPrimIndex(PcpPrimIndex &&rhs) noexcept = default;
89 
92  PcpPrimIndex(rhs).Swap(*this);
93  return *this;
94  }
95 
96  // Move-assignment.
97  PcpPrimIndex &operator=(PcpPrimIndex &&rhs) noexcept = default;
98 
100  PCP_API
101  void Swap(PcpPrimIndex& rhs);
102 
104  inline void swap(PcpPrimIndex &rhs) { Swap(rhs); }
105 
108  bool IsValid() const { return bool(_graph); }
109 
110  void SetGraph(const PcpPrimIndex_GraphRefPtr& graph) {
111  _graph = graph;
112  }
113 
114  const PcpPrimIndex_GraphRefPtr &GetGraph() const {
115  return _graph;
116  }
117 
119  PCP_API
120  PcpNodeRef GetRootNode() const;
121 
124  PCP_API
125  const SdfPath& GetPath() const;
126 
129  PCP_API
130  bool HasSpecs() const;
131 
136  PCP_API
137  bool HasAnyPayloads() const;
138 
141  PCP_API
142  bool IsUsd() const;
143 
149  PCP_API
150  bool IsInstanceable() const;
151 
154 
160  PCP_API
161  PcpNodeRange GetNodeRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
162 
167  PCP_API
169 
172  PCP_API
173  PcpPrimRange GetPrimRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
174 
177  PCP_API
178  PcpPrimRange GetPrimRangeForNode(const PcpNodeRef& node) const;
179 
181 
184 
187  PCP_API
188  PcpNodeRef GetNodeProvidingSpec(const SdfPrimSpecHandle& primSpec) const;
189 
193  PCP_API
195  const SdfLayerHandle& layer, const SdfPath& path) const;
196 
198 
201 
203  PcpErrorVector GetLocalErrors() const {
204  return _localErrors ? *_localErrors.get() : PcpErrorVector();
205  }
206 
208  PCP_API
209  void PrintStatistics() const;
210 
217  PCP_API
218  std::string DumpToString(
219  bool includeInheritOriginInfo = true,
220  bool includeMaps = true) const;
221 
224  PCP_API
225  void DumpToDotGraph(
226  const std::string& filename,
227  bool includeInheritOriginInfo = true,
228  bool includeMaps = false) const;
229 
231 
232 
235 
238  PCP_API
239  void ComputePrimChildNames(TfTokenVector *nameOrder,
240  PcpTokenSet *prohibitedNameSet) const;
241 
245  PCP_API
246  void ComputePrimPropertyNames(TfTokenVector *nameOrder) const;
247 
255  PCP_API
257 
262  PCP_API
264  const std::string &variantSet) const;
265 
267 
268 private:
269  friend class PcpPrimIterator;
270  friend struct Pcp_PrimIndexer;
271  friend void Pcp_RescanForSpecs(PcpPrimIndex*, bool usd,
272  bool updateHasSpecs);
273 
274  // The node graph representing the compositional structure of this prim.
275  PcpPrimIndex_GraphRefPtr _graph;
276 
277  // The prim stack. This is just a derived structure representing
278  // a cached strong-to-weak traversal of the graph collecting specs.
279  Pcp_CompressedSdSiteVector _primStack;
280 
281  // List of errors local to this prim, encountered during computation.
282  // NULL if no errors were found (the expected common case).
283  std::unique_ptr<PcpErrorVector> _localErrors;
284 };
285 
287 inline void swap(PcpPrimIndex &l, PcpPrimIndex &r) { l.swap(r); }
288 
294 {
295 public:
300  enum PayloadState { NoPayload,
301  IncludedByIncludeSet, ExcludedByIncludeSet,
302  IncludedByPredicate, ExcludedByPredicate };
303 
307 
309  PcpErrorVector allErrors;
310 
314 
320 
322  std::vector<PcpCulledDependency> culledDependencies;
323 
325  inline void swap(PcpPrimIndexOutputs &r) {
327  allErrors.swap(r.allErrors);
331  }
332 
339  PcpNodeRef Append(PcpPrimIndexOutputs&& childOutputs,
340  const PcpArc& arcToParent,
341  PcpErrorBasePtr *error);
342 };
343 
345 inline void swap(PcpPrimIndexOutputs &l, PcpPrimIndexOutputs &r) { l.swap(r); }
346 
352 public:
354  : cache(nullptr)
355  , variantFallbacks(nullptr)
356  , includedPayloads(nullptr)
357  , includedPayloadsMutex(nullptr)
358  , parentIndex(nullptr)
359  , cull(true)
360  , usd(false)
361  { }
362 
365  bool IsEquivalentTo(const PcpPrimIndexInputs& params) const;
366 
370  { cache = cache_; return *this; }
371 
375  { variantFallbacks = map; return *this; }
376 
379  using PayloadSet = std::unordered_set<SdfPath, SdfPath::Hash>;
380  PcpPrimIndexInputs& IncludedPayloads(const PayloadSet* payloadSet)
381  { includedPayloads = payloadSet; return *this; }
382 
384  PcpPrimIndexInputs &IncludedPayloadsMutex(tbb::spin_rw_mutex *mutex)
385  { includedPayloadsMutex = mutex; return *this; }
386 
392  std::function<bool (const SdfPath &)> predicate)
393  { includePayloadPredicate = predicate; return *this; }
394 
397  PcpPrimIndexInputs& Cull(bool doCulling = true)
398  { cull = doCulling; return *this; }
399 
403  PcpPrimIndexInputs& USD(bool doUSD = true)
404  { usd = doUSD; return *this; }
405 
408  PcpPrimIndexInputs& FileFormatTarget(const std::string& target)
409  { fileFormatTarget = target; return *this; }
410 
411 // private:
412  PcpCache* cache;
413  const PcpVariantFallbackMap* variantFallbacks;
414  const PayloadSet* includedPayloads;
415  tbb::spin_rw_mutex *includedPayloadsMutex;
416  std::function<bool (const SdfPath &)> includePayloadPredicate;
417  const PcpPrimIndex *parentIndex;
418  std::string fileFormatTarget;
419  bool cull;
420  bool usd;
421 };
422 
425 PCP_API
426 void
427 PcpComputePrimIndex(
428  const SdfPath& primPath,
429  const PcpLayerStackPtr& layerStack,
430  const PcpPrimIndexInputs& inputs,
431  PcpPrimIndexOutputs* outputs,
432  ArResolver* pathResolver = NULL);
433 
435 PCP_API
436 bool
437 PcpIsNewDefaultStandinBehaviorEnabled();
438 
439 // Sets the prim stack in \p index.
440 void
441 Pcp_RescanForSpecs(PcpPrimIndex* index, bool usd);
442 
443 // Returns true if \p index should be recomputed due to changes to
444 // any computed asset paths that were used to find or open layers
445 // when originally composing \p index. This may be due to scene
446 // description changes or external changes to asset resolution that
447 // may affect the computation of those asset paths.
448 bool
449 Pcp_NeedToRecomputeDueToAssetPathChange(const PcpPrimIndex& index);
450 
451 PXR_NAMESPACE_CLOSE_SCOPE
452 
453 #endif // PXR_USD_PCP_PRIM_INDEX_H
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
Definition: assetInfo.h:61
Represents an arc connecting two nodes in the prim index.
Definition: arc.h:44
PCP_API PcpNodeRef GetRootNode() const
Returns the root node of the prim index graph.
A scene description container that can combine with other such containers to form simple component as...
Definition: layer.h:94
PCP_API void ComputePrimChildNames(TfTokenVector *nameOrder, PcpTokenSet *prohibitedNameSet) const
Compute the prim child names for the given path.
PCP_API PcpPrimRange GetPrimRangeForNode(const PcpNodeRef &node) const
Returns range of iterators that encompasses all prims from the site of node.
PCP_API void Swap(PcpPrimIndex &rhs)
Swap the contents of this prim index with index.
void swap(PcpPrimIndex &rhs)
Same as Swap(), but standard name.
Definition: primIndex.h:104
void swap(PcpDynamicFileFormatDependencyData &rhs)
Same as Swap(), but standard name.
Outputs of the prim indexing procedure.
Definition: primIndex.h:293
PcpPrimIndex is an index of the all sites of scene description that contribute opinions to a specific...
Definition: primIndex.h:76
PcpPrimIndex primIndex
Prim index describing the composition structure for the associated prim.
Definition: primIndex.h:306
Standard pointer typedefs.
Represents a stack of layers that contribute opinions to composition.
Definition: layerStack.h:65
PcpPrimIndexInputs & Cache(PcpCache *cache_)
If supplied, the given PcpCache will be used where possible to compute needed intermediate results.
Definition: primIndex.h:369
PcpNode represents a node in an expression tree for compositing scene description.
Definition: node.h:67
PCP_API PcpPrimIndex()
Default construct an empty, invalid prim index.
PcpCache is the context required to make requests of the Pcp composition algorithm and cache the resu...
Definition: cache.h:93
std::map< std::string, std::string > SdfVariantSelectionMap
A map of reference variant set names to variants in those sets.
Definition: types.h:284
PcpPrimIndexInputs & Cull(bool doCulling=true)
Whether subtrees that contribute no opinions should be culled from the index.
Definition: primIndex.h:397
PCP_API PcpNodeIterator GetNodeIteratorAtNode(const PcpNodeRef &node) const
Returns the node iterator that points to the given node if the node is in the prim index graph.
std::vector< PcpCulledDependency > culledDependencies
Site dependencies from nodes in the prim index that have been culled.
Definition: primIndex.h:322
#define TF_DECLARE_WEAK_AND_REF_PTRS(type)
Define standard weak, ref, and vector pointer types.
Definition: declarePtrs.h:89
PCP_API bool IsInstanceable() const
Returns true if this prim index is instanceable.
PcpPrimIndexInputs & FileFormatTarget(const std::string &target)
The file format target for scene description layers encountered during prim index computation.
Definition: primIndex.h:408
PcpErrorVector GetLocalErrors() const
Return the list of errors local to this prim.
Definition: primIndex.h:203
PCP_API PcpNodeRange GetNodeRange(PcpRangeType rangeType=PcpRangeTypeAll) const
Returns range of iterators that encompass all children of the root node with the given arc type as we...
PcpNodeRef Append(PcpPrimIndexOutputs &&childOutputs, const PcpArc &arcToParent, PcpErrorBasePtr *error)
Appends the outputs from childOutputs to this object, using arcToParent to connect childOutputs' prim...
Inputs for the prim indexing procedure.
Definition: primIndex.h:351
void swap(UsdStageLoadRules &l, UsdStageLoadRules &r)
Swap the contents of rules l and r.
Single-site composition.
Object used to iterate over nodes in the prim index graph in strong-to-weak order.
Definition: iterator.h:51
PcpPrimIndex & operator=(const PcpPrimIndex &rhs)
Assignment.
Definition: primIndex.h:91
PCP_API SdfVariantSelectionMap ComposeAuthoredVariantSelections() const
Compose the authored prim variant selections.
PCP_API bool IsUsd() const
Returns true if this prim index was composed in USD mode.
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:442
std::unordered_set< SdfPath, SdfPath::Hash > PayloadSet
Set of paths to prims that should have their payloads included during composition.
Definition: primIndex.h:379
PCP_API std::string GetSelectionAppliedForVariantSet(const std::string &variantSet) const
Return the variant selection applied for the named variant set.
PCP_API std::string DumpToString(bool includeInheritOriginInfo=true, bool includeMaps=true) const
Dump the prim index contents to a string.
PCP_API void PrintStatistics() const
Prints various statistics about this prim index.
A path value used to locate objects in layers or scenegraphs.
Definition: path.h:290
PCP_API PcpNodeRef GetNodeProvidingSpec(const SdfPrimSpecHandle &primSpec) const
Returns the node that brings opinions from primSpec into this prim index.
PCP_API void DumpToDotGraph(const std::string &filename, bool includeInheritOriginInfo=true, bool includeMaps=false) const
Dump the prim index in dot format to the file named filename.
Object used to iterate over prim specs in the prim index graph in strong-to-weak order.
Definition: iterator.h:113
PcpPrimIndexInputs & VariantFallbacks(const PcpVariantFallbackMap *map)
Ordered list of variant names to use for the "standin" variant set if there is no authored opinion in...
Definition: primIndex.h:374
PcpDynamicFileFormatDependencyData dynamicFileFormatDependency
A list of names of fields that were composed to generate dynamic file format arguments for a node in ...
Definition: primIndex.h:319
PayloadState payloadState
Indicates the payload state of this index.
Definition: primIndex.h:313
Represents a prim description in an SdfLayer object.
Definition: primSpec.h:74
PCP_API const SdfPath & GetPath() const
Returns the path of the prim whose opinions are represented by this prim index.
PCP_API void ComputePrimPropertyNames(TfTokenVector *nameOrder) const
Compute the prim property names for the given path.
void swap(PcpPrimIndexOutputs &r)
Swap content with r.
Definition: primIndex.h:325
PCP_API bool HasSpecs() const
Returns true if this prim index contains any scene description opinions.
bool IsValid() const
Return true if this index is valid.
Definition: primIndex.h:108
PayloadState
Enumerator whose enumerants describe the payload state of this prim index.
Definition: primIndex.h:300
#define TF_DECLARE_REF_PTRS(type)
Define standard ref pointer types.
Definition: declarePtrs.h:75
PcpErrorVector allErrors
List of all errors encountered during indexing.
Definition: primIndex.h:309
PcpPrimIndexInputs & IncludedPayloadsMutex(tbb::spin_rw_mutex *mutex)
Optional mutex for accessing includedPayloads.
Definition: primIndex.h:384
Implementation of a hash set using open-addressing and the robin hood hashing algorithm with backward...
Definition: robin_set.h:95
PcpPrimIndexInputs & IncludePayloadPredicate(std::function< bool(const SdfPath &)> predicate)
Optional predicate evaluated when a not-yet-included payload is discovered while indexing.
Definition: primIndex.h:391
PCP_API PcpPrimRange GetPrimRange(PcpRangeType rangeType=PcpRangeTypeAll) const
Returns range of iterators that encompasses all prims, in strong-to-weak order.
bool IsEquivalentTo(const PcpPrimIndexInputs &params) const
Returns true if prim index computations using this parameters object would be equivalent to computati...
std::map< std::string, std::vector< std::string > > PcpVariantFallbackMap
typedef std::map<std::string, std::vector<std::string>> PcpVariantFallbackMap
Definition: types.h:188
Contains the necessary information for storing a prim index's dependency on dynamic file format argum...
PCP_API bool HasAnyPayloads() const
Returns true if the prim has any authored payload arcs.
Interface for the asset resolution system.
Definition: resolver.h:59
PcpPrimIndexInputs & USD(bool doUSD=true)
Whether the prim stack should be computed, and whether relocates, inherits, permissions,...
Definition: primIndex.h:403