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/dynamicFileFormatDependencyData.h"
31 #include "pxr/usd/pcp/errors.h"
32 #include "pxr/usd/pcp/iterator.h"
33 #include "pxr/usd/pcp/node.h"
34 #include "pxr/usd/pcp/types.h"
36 #include "pxr/usd/sdf/site.h"
38 #include "pxr/base/tf/hashmap.h"
39 #include "pxr/base/tf/hashset.h"
40 
41 #include <tbb/spin_rw_mutex.h>
42 
43 #include <functional>
44 #include <map>
45 #include <memory>
46 #include <unordered_set>
47 
48 PXR_NAMESPACE_OPEN_SCOPE
49 
50 SDF_DECLARE_HANDLES(SdfLayer);
51 SDF_DECLARE_HANDLES(SdfPrimSpec);
52 
54 TF_DECLARE_WEAK_AND_REF_PTRS(PcpPrimIndex_Graph);
55 
56 class ArResolver;
57 class PcpCache;
58 class PcpPrimIndex;
59 class PcpPrimIndexInputs;
61 class SdfPath;
62 
76 {
77 public:
79  PCP_API
80  PcpPrimIndex();
81 
83  PCP_API
84  PcpPrimIndex(const PcpPrimIndex& rhs);
85 
88  PcpPrimIndex(rhs).Swap(*this);
89  return *this;
90  }
91 
93  PCP_API
94  void Swap(PcpPrimIndex& rhs);
95 
97  inline void swap(PcpPrimIndex &rhs) { Swap(rhs); }
98 
101  bool IsValid() const { return bool(_graph); }
102 
103  PCP_API
104  void SetGraph(const PcpPrimIndex_GraphRefPtr& graph);
105  PCP_API
106  PcpPrimIndex_GraphPtr GetGraph() const;
107 
109  PCP_API
110  PcpNodeRef GetRootNode() const;
111 
114  PCP_API
115  const SdfPath& GetPath() const;
116 
119  PCP_API
120  bool HasSpecs() const;
121 
126  PCP_API
127  bool HasAnyPayloads() const;
128 
131  PCP_API
132  bool IsUsd() const;
133 
139  PCP_API
140  bool IsInstanceable() const;
141 
144 
150  PCP_API
151  PcpNodeRange GetNodeRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
152 
155  PCP_API
156  PcpPrimRange GetPrimRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
157 
160  PCP_API
161  PcpPrimRange GetPrimRangeForNode(const PcpNodeRef& node) const;
162 
164 
167 
170  PCP_API
171  PcpNodeRef GetNodeProvidingSpec(const SdfPrimSpecHandle& primSpec) const;
172 
176  PCP_API
178  const SdfLayerHandle& layer, const SdfPath& path) const;
179 
181 
184 
186  PcpErrorVector GetLocalErrors() const {
187  return _localErrors ? *_localErrors.get() : PcpErrorVector();
188  }
189 
191  PCP_API
192  void PrintStatistics() const;
193 
200  PCP_API
201  std::string DumpToString(
202  bool includeInheritOriginInfo = true,
203  bool includeMaps = true) const;
204 
207  PCP_API
208  void DumpToDotGraph(
209  const std::string& filename,
210  bool includeInheritOriginInfo = true,
211  bool includeMaps = false) const;
212 
214 
215 
218 
221  PCP_API
222  void ComputePrimChildNames(TfTokenVector *nameOrder,
223  PcpTokenSet *prohibitedNameSet) const;
224 
228  PCP_API
229  void ComputePrimPropertyNames(TfTokenVector *nameOrder) const;
230 
238  PCP_API
240 
245  PCP_API
247  const std::string &variantSet) const;
248 
250 
251 private:
252  friend class PcpPrimIterator;
253  friend struct Pcp_PrimIndexer;
254  friend void Pcp_RescanForSpecs(PcpPrimIndex*, bool usd,
255  bool updateHasSpecs);
256 
257  // The node graph representing the compositional structure of this prim.
258  PcpPrimIndex_GraphRefPtr _graph;
259 
260  // The prim stack. This is just a derived structure representing
261  // a cached strong-to-weak traversal of the graph collecting specs.
262  Pcp_CompressedSdSiteVector _primStack;
263 
264  // List of errors local to this prim, encountered during computation.
265  // NULL if no errors were found (the expected common case).
266  std::unique_ptr<PcpErrorVector> _localErrors;
267 };
268 
270 inline void swap(PcpPrimIndex &l, PcpPrimIndex &r) { l.swap(r); }
271 
277 {
278 public:
283  enum PayloadState { NoPayload,
284  IncludedByIncludeSet, ExcludedByIncludeSet,
285  IncludedByPredicate, ExcludedByPredicate };
286 
290 
292  PcpErrorVector allErrors;
293 
297 
303 
305  inline void swap(PcpPrimIndexOutputs &r) {
307  allErrors.swap(r.allErrors);
310  }
311 
318  PcpNodeRef Append(PcpPrimIndexOutputs&& childOutputs,
319  const PcpArc& arcToParent,
320  PcpErrorBasePtr *error);
321 };
322 
324 inline void swap(PcpPrimIndexOutputs &l, PcpPrimIndexOutputs &r) { l.swap(r); }
325 
331 public:
333  : cache(nullptr)
334  , variantFallbacks(nullptr)
335  , includedPayloads(nullptr)
336  , includedPayloadsMutex(nullptr)
337  , parentIndex(nullptr)
338  , cull(true)
339  , usd(false)
340  { }
341 
344  bool IsEquivalentTo(const PcpPrimIndexInputs& params) const;
345 
349  { cache = cache_; return *this; }
350 
354  { variantFallbacks = map; return *this; }
355 
358  using PayloadSet = std::unordered_set<SdfPath, SdfPath::Hash>;
359  PcpPrimIndexInputs& IncludedPayloads(const PayloadSet* payloadSet)
360  { includedPayloads = payloadSet; return *this; }
361 
363  PcpPrimIndexInputs &IncludedPayloadsMutex(tbb::spin_rw_mutex *mutex)
364  { includedPayloadsMutex = mutex; return *this; }
365 
371  std::function<bool (const SdfPath &)> predicate)
372  { includePayloadPredicate = predicate; return *this; }
373 
376  PcpPrimIndexInputs& Cull(bool doCulling = true)
377  { cull = doCulling; return *this; }
378 
382  PcpPrimIndexInputs& USD(bool doUSD = true)
383  { usd = doUSD; return *this; }
384 
387  PcpPrimIndexInputs& FileFormatTarget(const std::string& target)
388  { fileFormatTarget = target; return *this; }
389 
390 // private:
391  PcpCache* cache;
392  const PcpVariantFallbackMap* variantFallbacks;
393  const PayloadSet* includedPayloads;
394  tbb::spin_rw_mutex *includedPayloadsMutex;
395  std::function<bool (const SdfPath &)> includePayloadPredicate;
396  const PcpPrimIndex *parentIndex;
397  std::string fileFormatTarget;
398  bool cull;
399  bool usd;
400 };
401 
404 PCP_API
405 void
406 PcpComputePrimIndex(
407  const SdfPath& primPath,
408  const PcpLayerStackPtr& layerStack,
409  const PcpPrimIndexInputs& inputs,
410  PcpPrimIndexOutputs* outputs,
411  ArResolver* pathResolver = NULL);
412 
414 PCP_API
415 bool
416 PcpIsNewDefaultStandinBehaviorEnabled();
417 
418 // Sets the prim stack in \p index.
419 void
420 Pcp_RescanForSpecs(PcpPrimIndex* index, bool usd);
421 
422 // Returns true if \p index should be recomputed due to changes to
423 // any computed asset paths that were used to find or open layers
424 // when originally composing \p index. This may be due to scene
425 // description changes or external changes to asset resolution that
426 // may affect the computation of those asset paths.
427 bool
428 Pcp_NeedToRecomputeDueToAssetPathChange(const PcpPrimIndex& index);
429 
430 PXR_NAMESPACE_CLOSE_SCOPE
431 
432 #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:97
void swap(PcpDynamicFileFormatDependencyData &rhs)
Same as Swap(), but standard name.
Outputs of the prim indexing procedure.
Definition: primIndex.h:276
PcpPrimIndex is an index of the all sites of scene description that contribute opinions to a specific...
Definition: primIndex.h:75
PcpPrimIndex primIndex
Prim index describing the composition structure for the associated prim.
Definition: primIndex.h:289
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:348
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:376
#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:387
PcpErrorVector GetLocalErrors() const
Return the list of errors local to this prim.
Definition: primIndex.h:186
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:330
void swap(UsdStageLoadRules &l, UsdStageLoadRules &r)
Swap the contents of rules l and r.
Single-site composition.
PcpPrimIndex & operator=(const PcpPrimIndex &rhs)
Assignment.
Definition: primIndex.h:87
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:358
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:353
PcpDynamicFileFormatDependencyData dynamicFileFormatDependency
A list of names of fields that were composed to generate dynamic file format arguments for a node in ...
Definition: primIndex.h:302
PayloadState payloadState
Indicates the payload state of this index.
Definition: primIndex.h:296
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:305
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:101
PayloadState
Enumerator whose enumerants describe the payload state of this prim index.
Definition: primIndex.h:283
#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:292
PcpPrimIndexInputs & IncludedPayloadsMutex(tbb::spin_rw_mutex *mutex)
Optional mutex for accessing includedPayloads.
Definition: primIndex.h:363
PcpPrimIndexInputs & IncludePayloadPredicate(std::function< bool(const SdfPath &)> predicate)
Optional predicate evaluated when a not-yet-included payload is discovered while indexing.
Definition: primIndex.h:370
This is a space efficient container that mimics the TfHashSet API that uses a vector for storage when...
Definition: denseHashSet.h:58
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_v2.h:62
PcpPrimIndexInputs & USD(bool doUSD=true)
Whether the prim stack should be computed, and whether relocates, inherits, permissions,...
Definition: primIndex.h:382