HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
primFlags.h
Go to the documentation of this file.
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_USD_PRIM_FLAGS_H
25 #define PXR_USD_USD_PRIM_FLAGS_H
26 
27 /// \file usd/primFlags.h
28 ///
29 /// \anchor Usd_PrimFlags
30 ///
31 /// Provides terms for UsdPrim flags that can be combined to form either a
32 /// conjunction (via &&) or a disjunction (via ||). The result is a
33 /// predicate functor object that tests those flags on the passed prim.
34 /// Currently UsdPrim::GetFilteredChildren(), UsdPrim::GetNextFilteredSibling(),
35 /// UsdPrim::GetFilteredDescendants(), and UsdPrimRange() accept these
36 /// predicates to filter out unwanted prims.
37 ///
38 /// For example:
39 /// \code
40 /// // Get only loaded model children.
41 /// prim.GetFilteredChildren(UsdPrimIsModel && UsdPrimIsLoaded)
42 /// \endcode
43 ///
44 /// For performance, these predicates are implemented by a bitwise test, so
45 /// arbitrary boolean expressions cannot be represented. The set of boolean
46 /// expressions that can be represented are conjunctions with possibly negated
47 /// terms (or disjunctions, by De Morgan's law). Here are some examples of
48 /// valid expressions:
49 /// \code
50 /// // simple conjunction.
51 /// (UsdPrimIsLoaded && UsdPrimIsGroup)
52 /// // conjunction with negated term.
53 /// (UsdPrimIsDefined && !UsdPrimIsAbstract)
54 /// // disjunction with negated term.
55 /// (!UsdPrimIsDefined || !UsdPrimIsActive)
56 /// // negated conjunction gives a disjunction.
57 /// !(UsdPrimIsLoaded && UsdPrimIsModel)
58 /// // negated conjunction gives a disjunction, which is further extended.
59 /// (!(UsdPrimIsLoaded && UsdPrimIsModel) || UsdPrimIsAbstract)
60 /// // equivalent to above.
61 /// (!UsdPrimIsLoaded || !UsdPrimIsModel || UsdPrimIsAbstract)
62 /// \endcode
63 /// Here are some examples of invalid expressions:
64 /// \code
65 /// // error: cannot || a term with a conjunction.
66 /// (UsdPrimIsLoaded && UsdPrimIsModel) || UsdPrimIsAbstract
67 /// // error: cannot && disjunctions.
68 /// (!UsdPrimIsDefined || UsdPrimIsAbstract) && (UsdPrimIsModel || !UsdPrimIsActive)
69 /// \endcode
70 ///
71 ///
72 /// The following variables provide the clauses that can be combined and
73 /// negated to produce predicates:
74 
75 #include "pxr/pxr.h"
76 #include "pxr/usd/usd/api.h"
77 #include "pxr/base/arch/hints.h"
78 #include "pxr/base/tf/bitUtils.h"
79 #include "pxr/base/tf/hash.h"
80 
81 #include <bitset>
82 
84 
85 class SdfPath;
86 
87 // Enum for cached flags on prims.
89  // Flags for use with predicates.
98 
99  // Flags for internal use.
106 
108 };
109 
110 typedef std::bitset<Usd_PrimNumFlags> Usd_PrimFlagBits;
111 
112 // Term class. This class exists merely to allow building up conjunctions or
113 // disjunctions of terms. See Usd_PrimFlagsPredicate, Usd_PrimFlagsConjunction,
114 // Usd_PrimFlagsDisjunction which provide the logcial operators.
115 struct Usd_Term {
116  Usd_Term(Usd_PrimFlags flag) : flag(flag), negated(false) {}
117  Usd_Term(Usd_PrimFlags flag, bool negated) : flag(flag), negated(negated) {}
118  Usd_Term operator!() const { return Usd_Term(flag, !negated); }
119  bool operator==(Usd_Term other) const {
120  return flag == other.flag && negated == other.negated;
121  }
122  bool operator!=(Usd_Term other) const {
123  return !(*this == other);
124  }
126  bool negated;
127 };
128 
129 inline Usd_Term
131  return Usd_Term(flag, /*negated=*/true);
132 }
133 
134 // Predicate functor class that tests a prim's flags against desired values.
136 {
137 public:
138  // Functor result type.
139  typedef bool result_type;
140 
141  // Default ctor produces a tautology.
142  Usd_PrimFlagsPredicate() : _negate(false) {}
143 
145  : _negate(false) {
146  _mask[flag] = 1;
147  _values[flag] = true;
148  }
149 
150  // Implicit conversion from a single term.
152  : _negate(false) {
153  _mask[term.flag] = 1;
154  _values[term.flag] = !term.negated;
155  }
156 
157  // Convenience to produce a tautological predicate. Returns a
158  // default-constructed predicate.
160  return Usd_PrimFlagsPredicate();
161  }
162 
163  // Convenience to produce a contradictory predicate. Returns a negated
164  // default-constructed predicate.
166  return Usd_PrimFlagsPredicate()._Negate();
167  }
168 
169  // Set flag to indicate whether prim traversal functions using this
170  // predicate should traverse beneath instances and return descendants
171  // that pass this predicate as instance proxy prims.
173  if (traverse) {
176  }
177  else {
180  }
181  return *this;
182  }
183 
184  // Returns true if this predicate was explicitly set to include
185  // instance proxies, false otherwise.
187  return !_mask[Usd_PrimInstanceProxyFlag] &&
189  }
190 
191  // Invoke boolean predicate on UsdPrim \p prim.
192  USD_API
193  bool operator()(const class UsdPrim &prim) const;
194 
195 protected:
196 
197  // Return true if this predicate is a tautology, false otherwise.
198  bool _IsTautology() const { return *this == Tautology(); }
199 
200  // Set this predicate to be a tautology.
201  void _MakeTautology() { *this = Tautology(); }
202 
203  // Return true if this predicate is a contradiction, false otherwise.
204  bool _IsContradiction() const { return *this == Contradiction(); }
205 
206  // Set this predicate to be a contradiction.
207  void _MakeContradiction() { *this = Contradiction(); }
208 
209  // Negate this predicate.
211  _negate = !_negate;
212  return *this;
213  }
214 
215  // Return a negated copy of this predicate.
217  return Usd_PrimFlagsPredicate(*this)._Negate();
218  }
219 
220  // Mask indicating which flags are of interest.
222 
223  // Desired values for prim flags.
225 
226 private:
227  // Evaluate this predicate with prim data \p prim. \p isInstanceProxy
228  // should be true if this is being evaluated for an instance proxy prim.
229  template <class PrimPtr>
230  bool _Eval(const PrimPtr &prim, bool isInstanceProxy) const {
231  // Manually set the instance proxy bit, since instance proxy
232  // state is never stored in Usd_PrimData's flags.
233  const Usd_PrimFlagBits primFlags = Usd_PrimFlagBits(prim->_GetFlags())
234  .set(Usd_PrimInstanceProxyFlag, isInstanceProxy);
235 
236  // Mask the prim's flags, compare to desired values, then optionally
237  // negate the result.
238  return ((primFlags & _mask) == (_values & _mask)) ^ _negate;
239  }
240 
241  // Evaluate the predicate \p pred with prim data \p prim. \p isInstanceProxy
242  // should be true if this is being evaluated for an instance proxy prim.
243  template <class PrimPtr>
244  friend bool
245  Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim,
246  bool isInstanceProxy) {
247  return pred._Eval(prim, isInstanceProxy);
248  }
249 
250  // Convenience method for evaluating \p pred using \p prim and
251  // \p proxyPrimPath to determine whether this is for an instance proxy
252  // prim.
253  template <class PrimPtr>
254  friend bool
255  Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim,
256  const SdfPath &proxyPrimPath) {
257  return pred._Eval(prim, Usd_IsInstanceProxy(prim, proxyPrimPath));
258  }
259 
260  // Equality comparison.
261  friend bool
263  const Usd_PrimFlagsPredicate &rhs) {
264  return lhs._mask == rhs._mask &&
265  lhs._values == rhs._values &&
266  lhs._negate == rhs._negate;
267  }
268  // Inequality comparison.
269  friend bool
271  const Usd_PrimFlagsPredicate &rhs) {
272  return !(lhs == rhs);
273  }
274 
275  // hash overload.
276  friend size_t hash_value(const Usd_PrimFlagsPredicate &p) {
277  return TfHash::Combine(
278  p._mask.to_ulong(), p._values.to_ulong(), p._negate
279  );
280  }
281 
282  // Whether or not to negate the predicate's result.
283  bool _negate;
284 
285 };
286 
287 
288 /// Conjunction of prim flag predicate terms.
289 ///
290 /// Usually clients will implicitly create conjunctions by &&-ing together flag
291 /// predicate terms. For example:
292 /// \code
293 /// // Get all loaded model children.
294 /// prim.GetFilteredChildren(UsdPrimIsModel && UsdPrimIsLoaded)
295 /// \endcode
296 ///
297 /// See primFlags.h for more details.
299 public:
300  /// Default constructed conjunction is a tautology.
302 
303  /// Construct with a term.
305  *this &= term;
306  }
307 
308  /// Add an additional term to this conjunction.
310  // If this conjunction is a contradiction, do nothing.
312  return *this;
313 
314  // If we don't have the bit, set it in _mask and _values (if needed).
315  if (!_mask[term.flag]) {
316  _mask[term.flag] = 1;
317  _values[term.flag] = !term.negated;
318  } else if (_values[term.flag] != !term.negated) {
319  // If we do have the bit and the values disagree, then this entire
320  // conjunction becomes a contradiction. If the values agree, it's
321  // redundant and we do nothing.
323  }
324  return *this;
325  }
326 
327  /// Negate this conjunction, producing a disjunction by De Morgan's law.
328  /// For instance:
329  ///
330  /// \code
331  /// !(UsdPrimIsLoaded && UsdPrimIsModel)
332  /// \endcode
333  ///
334  /// Will negate the conjunction in parens to produce a disjunction
335  /// equivalent to:
336  ///
337  /// \code
338  /// (!UsdPrimIsLoaded || !UsdPrimIsModel)
339  /// \endcode
340  ///
341  /// Every expression may be formulated as either a disjunction or a
342  /// conjuction, but allowing both affords increased expressiveness.
343  ///
344  USD_API
345  class Usd_PrimFlagsDisjunction operator!() const;
346 
347 private:
348 
349  // Let Usd_PrimFlagsDisjunction produce conjunctions when negated
352  Usd_PrimFlagsPredicate(base) {}
353 
354  /// Combine two terms to make a conjunction.
356  operator&&(Usd_Term lhs, Usd_Term rhs);
357 
358  /// Create a new conjunction with the term \p rhs added.
360  operator&&(const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs);
361 
362  /// Create a new conjunction with the term \p lhs added.
364  operator&&(Usd_Term lhs, const Usd_PrimFlagsConjunction &conjunction);
365 };
366 
369  // Apparently gcc 4.8.x doesn't like this as:
370  // return (Usd_PrimFlagsConjunction() && lhs) && rhs;
372  return (tmp && lhs) && rhs;
373 }
374 
376 operator&&(const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs) {
377  return Usd_PrimFlagsConjunction(conjunction) &= rhs;
378 }
379 
381 operator&&(Usd_Term lhs, const Usd_PrimFlagsConjunction &conjunction) {
382  return Usd_PrimFlagsConjunction(conjunction) &= lhs;
383 }
384 
387  return Usd_Term(lhs) && Usd_Term(rhs);
388 }
389 
390 
391 /// Disjunction of prim flag predicate terms.
392 ///
393 /// Usually clients will implicitly create disjunctions by ||-ing together flag
394 /// predicate terms. For example:
395 /// \code
396 /// // Get all deactivated or undefined children.
397 /// prim.GetFilteredChildren(!UsdPrimIsActive || !UsdPrimIsDefined)
398 /// \endcode
399 ///
400 /// See primFlags.h for more details.
402 public:
403  // Default constructed disjunction is a contradiction.
405 
406  // Construct with a term.
408  _Negate();
409  *this |= term;
410  }
411 
412  /// Add an additional term to this disjunction.
414  // If this disjunction is a tautology, do nothing.
416  return *this;
417 
418  // If we don't have the bit, set it in _mask and _values (if needed).
419  if (!_mask[term.flag]) {
420  _mask[term.flag] = 1;
421  _values[term.flag] = term.negated;
422  } else if (_values[term.flag] != term.negated) {
423  // If we do have the bit and the values disagree, then this entire
424  // disjunction becomes a tautology. If the values agree, it's
425  // redundant and we do nothing.
426  _MakeTautology();
427  }
428  return *this;
429  }
430 
431  /// Negate this disjunction, producing a disjunction by De Morgan's law.
432  /// For instance:
433  ///
434  /// \code
435  /// !(UsdPrimIsLoaded || UsdPrimIsModel)
436  /// \endcode
437  ///
438  /// Will negate the disjunction in parens to produce a conjunction
439  /// equivalent to:
440  ///
441  /// \code
442  /// (!UsdPrimIsLoaded && !UsdPrimIsModel)
443  /// \endcode
444  ///
445  /// Every expression may be formulated as either a disjunction or a
446  /// conjuction, but allowing both affords increased expressiveness.
447  ///
448  USD_API
449  class Usd_PrimFlagsConjunction operator!() const;
450 
451 private:
452 
453  // Let Usd_PrimFlagsDisjunction produce conjunctions when negated.
456  Usd_PrimFlagsPredicate(base) {}
457 
458  /// Combine two terms to make a disjunction.
460 
461  /// Create a new disjunction with the term \p rhs added.
463  operator||(const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs);
464 
465  /// Create a new disjunction with the term \p lhs added.
467  operator||(Usd_Term lhs, const Usd_PrimFlagsDisjunction &disjunction);
468 };
469 
472  return (Usd_PrimFlagsDisjunction() || lhs) || rhs;
473 }
474 
476 operator||(const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs) {
477  return Usd_PrimFlagsDisjunction(disjunction) |= rhs;
478 }
479 
481 operator||(Usd_Term lhs, const Usd_PrimFlagsDisjunction &disjunction) {
482  return Usd_PrimFlagsDisjunction(disjunction) |= lhs;
483 }
484 
487  return Usd_Term(lhs) || Usd_Term(rhs);
488 }
489 
490 #ifdef doxygen
491 
492 /// Tests UsdPrim::IsActive()
493 extern unspecified UsdPrimIsActive;
494 /// Tests UsdPrim::IsLoaded()
495 extern unspecified UsdPrimIsLoaded;
496 /// Tests UsdPrim::IsModel()
497 extern unspecified UsdPrimIsModel;
498 /// Tests UsdPrim::IsGroup()
499 extern unspecified UsdPrimIsGroup;
500 /// Tests UsdPrim::IsAbstract()
501 extern unspecified UsdPrimIsAbstract;
502 /// Tests UsdPrim::IsDefined()
503 extern unspecified UsdPrimIsDefined;
504 /// Tests UsdPrim::IsInstance()
505 extern unspecified UsdPrimIsInstance;
506 /// Tests UsdPrim::HasDefiningSpecifier()
507 extern unspecified UsdPrimHasDefiningSpecifier;
508 
509 /// The default predicate used for prim traversals in methods like
510 /// UsdPrim::GetChildren, UsdStage::Traverse, and by UsdPrimRange.
511 /// This is a conjunction that includes all active, loaded, defined,
512 /// non-abstract prims, equivalent to:
513 /// \code
514 /// UsdPrimIsActive && UsdPrimIsDefined && UsdPrimIsLoaded && !UsdPrimIsAbstract
515 /// \endcode
516 ///
517 /// This represents the prims on a stage that a processor would typically
518 /// consider present, meaningful, and needful of consideration.
519 ///
520 /// See \ref Usd_PrimFlags "Prim predicate flags" for more information.
521 extern unspecified UsdPrimDefaultPredicate;
522 
523 /// Predicate that includes all prims.
524 ///
525 /// See \ref Usd_PrimFlags "Prim predicate flags" for more information.
526 extern unspecified UsdPrimAllPrimsPredicate;
527 
528 #else
529 
530 static const Usd_PrimFlags UsdPrimIsActive = Usd_PrimActiveFlag;
531 static const Usd_PrimFlags UsdPrimIsLoaded = Usd_PrimLoadedFlag;
532 static const Usd_PrimFlags UsdPrimIsModel = Usd_PrimModelFlag;
533 static const Usd_PrimFlags UsdPrimIsGroup = Usd_PrimGroupFlag;
534 static const Usd_PrimFlags UsdPrimIsAbstract = Usd_PrimAbstractFlag;
535 static const Usd_PrimFlags UsdPrimIsDefined = Usd_PrimDefinedFlag;
536 static const Usd_PrimFlags UsdPrimIsInstance = Usd_PrimInstanceFlag;
537 static const Usd_PrimFlags UsdPrimHasDefiningSpecifier
539 
542 
543 #endif // doxygen
544 
545 /// This function is used to allow the prim traversal functions listed under
546 /// \ref Usd_PrimFlags "Prim predicate flags" to traverse beneath instance
547 /// prims and return descendants that pass the specified \p predicate
548 /// as instance proxy prims. For example:
549 ///
550 /// \code
551 /// // Return all children of the specified prim.
552 /// // If prim is an instance, return all children as instance proxy prims.
553 /// prim.GetFilteredChildren(
554 /// UsdTraverseInstanceProxies(UsdPrimAllPrimsPredicate))
555 ///
556 /// // Return children of the specified prim that pass the default predicate.
557 /// // If prim is an instance, return the children that pass this predicate
558 /// // as instance proxy prims.
559 /// prim.GetFilteredChildren(UsdTraverseInstanceProxies());
560 ///
561 /// // Return all model or group children of the specified prim.
562 /// // If prim is an instance, return the children that pass this predicate
563 /// // as instance proxy prims.
564 /// prim.GetFilteredChildren(UsdTraverseInstanceProxies(UsdPrimIsModel || UsdPrimIsGroup));
565 /// \endcode
566 ///
567 /// Users may also call Usd_PrimFlagsPredicate::TraverseInstanceProxies to
568 /// enable traversal beneath instance prims. This function is equivalent to:
569 /// \code
570 /// predicate.TraverseInstanceProxies(true);
571 /// \endcode
572 ///
573 /// However, this function may be more convenient, especially when calling
574 /// a prim traversal function with a default-constructed tautology predicate.
577 {
578  return predicate.TraverseInstanceProxies(true);
579 }
580 
581 /// \overload
582 /// Convenience method equivalent to calling UsdTraverseInstanceProxies
583 /// with the UsdPrimDefaultPredicate that is used by default for prim
584 /// traversals.
587 {
589 }
590 
592 
593 #endif // PXR_USD_USD_PRIM_FLAGS_H
bool operator!=(Usd_Term other) const
Definition: primFlags.h:122
Usd_Term(Usd_PrimFlags flag, bool negated)
Definition: primFlags.h:117
Usd_PrimFlagsDisjunction & operator|=(Usd_Term term)
Add an additional term to this disjunction.
Definition: primFlags.h:413
bool _IsContradiction() const
Definition: primFlags.h:204
friend Usd_PrimFlagsConjunction operator&&(Usd_Term lhs, Usd_Term rhs)
Combine two terms to make a conjunction.
Definition: primFlags.h:368
#define USD_API
Definition: api.h:40
bool _IsTautology() const
Definition: primFlags.h:198
Usd_PrimFlagsConjunction operator&&(Usd_Term lhs, Usd_Term rhs)
Definition: primFlags.h:368
Usd_PrimFlagsConjunction(Usd_Term term)
Construct with a term.
Definition: primFlags.h:304
friend size_t hash_value(const Usd_PrimFlagsPredicate &p)
Definition: primFlags.h:276
Usd_PrimFlagsPredicate & _Negate()
Definition: primFlags.h:210
Usd_PrimFlagsConjunction()
Default constructed conjunction is a tautology.
Definition: primFlags.h:301
Usd_PrimFlags
Definition: primFlags.h:88
Usd_PrimFlagBits _mask
Definition: primFlags.h:221
Usd_PrimFlagsPredicate _GetNegated() const
Definition: primFlags.h:216
Usd_PrimFlags flag
Definition: primFlags.h:125
Usd_PrimFlagsPredicate & TraverseInstanceProxies(bool traverse)
Definition: primFlags.h:172
friend class Usd_PrimFlagsDisjunction
Definition: primFlags.h:350
Usd_PrimFlagsPredicate(Usd_PrimFlags flag)
Definition: primFlags.h:144
#define ARCH_UNLIKELY(x)
Definition: hints.h:47
Usd_PrimFlagBits _values
Definition: primFlags.h:224
static Usd_PrimFlagsPredicate Tautology()
Definition: primFlags.h:159
bool Usd_IsInstanceProxy(const PrimDataPtr &p, const SdfPath &proxyPrimPath)
Definition: primData.h:481
bool IncludeInstanceProxiesInTraversal() const
Definition: primFlags.h:186
friend bool Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim, const SdfPath &proxyPrimPath)
Definition: primFlags.h:255
Definition: prim.h:135
Usd_PrimFlagsPredicate UsdTraverseInstanceProxies(Usd_PrimFlagsPredicate predicate)
Definition: primFlags.h:576
friend bool Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim, bool isInstanceProxy)
Definition: primFlags.h:245
friend Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs)
Combine two terms to make a disjunction.
Definition: primFlags.h:471
Definition: path.h:291
Usd_Term operator!(Usd_PrimFlags flag)
Definition: primFlags.h:130
static Usd_PrimFlagsPredicate Contradiction()
Definition: primFlags.h:165
static size_t Combine(Args &&...args)
Produce a hash code by combining the hash codes of several objects.
Definition: hash.h:519
USD_API const Usd_PrimFlagsConjunction UsdPrimDefaultPredicate
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1441
Usd_Term(Usd_PrimFlags flag)
Definition: primFlags.h:116
USD_API const Usd_PrimFlagsPredicate UsdPrimAllPrimsPredicate
Usd_PrimFlagsDisjunction(Usd_Term term)
Definition: primFlags.h:407
friend bool operator==(const Usd_PrimFlagsPredicate &lhs, const Usd_PrimFlagsPredicate &rhs)
Definition: primFlags.h:262
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:91
friend bool operator!=(const Usd_PrimFlagsPredicate &lhs, const Usd_PrimFlagsPredicate &rhs)
Definition: primFlags.h:270
Usd_Term operator!() const
Definition: primFlags.h:118
Usd_PrimFlagsConjunction & operator&=(Usd_Term term)
Add an additional term to this conjunction.
Definition: primFlags.h:309
bool operator==(Usd_Term other) const
Definition: primFlags.h:119
USD_API bool operator()(const class UsdPrim &prim) const
GU_API ComputeHierarchyResult traverse(const GU_Detail *gdp, GA_OffsetArray &roots, GA_OffsetArray &nodes, GA_OffsetArray &parents, UT_Map< GA_Offset, GA_OffsetArray > *children=nullptr)
#define const
Definition: zconf.h:214
std::bitset< Usd_PrimNumFlags > Usd_PrimFlagBits
Definition: primFlags.h:110
Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs)
Definition: primFlags.h:471
bool negated
Definition: primFlags.h:126
Usd_PrimFlagsPredicate(Usd_Term term)
Definition: primFlags.h:151
friend class Usd_PrimFlagsConjunction
Definition: primFlags.h:454