HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
changeTracker.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the terms set forth in the LICENSE.txt file available at
5 // https://openusd.org/license.
6 //
7 #ifndef PXR_IMAGING_HD_CHANGE_TRACKER_H
8 #define PXR_IMAGING_HD_CHANGE_TRACKER_H
9 
10 #include "pxr/pxr.h"
11 #include "pxr/imaging/hd/api.h"
12 #include "pxr/imaging/hd/version.h"
14 #include "pxr/imaging/hd/types.h"
15 #include "pxr/usd/sdf/path.h"
16 #include "pxr/base/tf/hashmap.h"
17 
18 #include <tbb/concurrent_hash_map.h>
19 #include <atomic>
20 
22 
24 
25 /// \class HdChangeTracker
26 ///
27 /// Tracks changes from the HdSceneDelegate, providing invalidation cues to the
28 /// render engine.
29 ///
30 /// Changes flagged here are accumulated until the next time resource associated
31 /// with the change is required, at which point the resource is updated and the
32 /// flag is cleared.
33 ///
35 {
36 public:
37 
38  // Common dirty bits for Rprims
39  // XXX: Move this to HdRprim
41  Clean = 0,
42  InitRepr = 1 << 0,
43  Varying = 1 << 1,
45  DirtyPrimID = 1 << 2,
46  DirtyExtent = 1 << 3,
48  DirtyPoints = 1 << 5,
49  DirtyPrimvar = 1 << 6,
50  DirtyMaterialId = 1 << 7,
51  DirtyTopology = 1 << 8,
52  DirtyTransform = 1 << 9,
53  DirtyVisibility = 1 << 10,
54  DirtyNormals = 1 << 11,
55  DirtyDoubleSided = 1 << 12,
56  DirtyCullStyle = 1 << 13,
57  DirtySubdivTags = 1 << 14,
58  DirtyWidths = 1 << 15,
59  DirtyInstancer = 1 << 16,
60  DirtyInstanceIndex = 1 << 17,
61  DirtyRepr = 1 << 18,
62  DirtyRenderTag = 1 << 19,
64  DirtyCategories = 1 << 21,
65  DirtyVolumeField = 1 << 22,
66  AllSceneDirtyBits = ((1<<23) - 1),
67 
68  NewRepr = 1 << 23,
69 
70  CustomBitsBegin = 1 << 24,
71  CustomBitsEnd = 1 << 30,
72  CustomBitsMask = 0x7f << 24,
73  };
74 
75  // InstancerDirtybits are a subset of rprim dirty bits right now:
76  // DirtyPrimvar, DirtyTransform, DirtyInstanceIndex, DirtyInstancer.
77 
78  // Dirty bits for Tasks
79  // XXX: Move this to HdTask
81  DirtyParams = 1 << 2,
82  DirtyCollection = 1 << 3,
83  DirtyRenderTags = 1 << 4,
84  };
85 
86  HD_API
88  HD_API
89  virtual ~HdChangeTracker();
90 
91  // ---------------------------------------------------------------------- //
92  /// \name Rprim Object Tracking
93  /// @{
94  // ---------------------------------------------------------------------- //
95 
96  /// Start tracking Rprim with the given \p id.
97  HD_API
98  void RprimInserted(SdfPath const& id, HdDirtyBits initialDirtyState);
99 
100  /// Stop tracking Rprim with the given \p id.
101  HD_API
102  void RprimRemoved(SdfPath const& id);
103 
104  // ---------------------------------------------------------------------- //
105  /// @}
106  /// \name Rprim State Tracking
107  /// @{
108  // ---------------------------------------------------------------------- //
109 
110  /// Returns the dirty bits for the rprim with \p id.
111  HD_API
112  HdDirtyBits GetRprimDirtyBits(SdfPath const& id) const;
113 
114  /// Flag the Rprim with the given \p id as being dirty. Multiple calls with
115  /// different dirty bits accumulate.
116  HD_API
117  void MarkRprimDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
118 
119  /// Clear the dirty flags for an HdRprim. if inSync is true, set OutOfSync
120  /// flag to notify dirtyList will discover the prim to sync the residual
121  /// data for new repr.
122  HD_API
123  void MarkRprimClean(SdfPath const& id, HdDirtyBits newBits=Clean);
124 
125  /// Mark the primvar for the rprim with \p id as being dirty.
126  HD_API
127  void MarkPrimvarDirty(SdfPath const& id, TfToken const& name);
128 
129  /// Flag all the Rprim with the given \p id as being dirty. Multiple calls
130  /// with different dirty bits accumulate.
131  /// Doesn't touch varying state.
132  HD_API
133  void MarkAllRprimsDirty(HdDirtyBits bits);
134 
135  /// Clear Varying bit of all prims.
136  ///
137  /// The idea is that from frame to frame (update iteration), the set of
138  /// dirty rprims and their dirty bits do not change; that is, the same
139  /// rprims get dirtied with the same dirty bits.. The change tracker can
140  /// leverage this help build a stable dirty list and reduce the
141  /// overall cost of an update iteration.
142  HD_API
143  void ResetVaryingState();
144 
145  /// Reset the varying state on one Rprim
146  /// This is done for Rprims, where we choose not to clean them
147  /// (due to state like invisibility).
148  HD_API
149  void ResetRprimVaryingState(SdfPath const& id);
150 
151 
152  // ---------------------------------------------------------------------- //
153 
154  /// Returns true if the rprim identified by \p id has any dirty flags set.
155  HD_API
156  bool IsRprimDirty(SdfPath const& id);
157 
158  /// Returns true if the rprim identified by \p id has a dirty extent.
159  HD_API
160  bool IsExtentDirty(SdfPath const& id);
161 
162  /// Returns true if the rprim identified by \p id has a dirty display style.
163  HD_API
164  bool IsDisplayStyleDirty(SdfPath const& id);
165 
166  /// Returns true if the rprim identified by \p id with primvar \p name is
167  /// dirty.
168  HD_API
169  bool IsPrimvarDirty(SdfPath const& id, TfToken const& name);
170 
171  /// Returns true if the rprim identified by \p id has any dirty primvars.
172  HD_API
173  bool IsAnyPrimvarDirty(SdfPath const& id);
174 
175  /// Returns true if the rprim identified by \p id has a dirty topology.
176  HD_API
177  bool IsTopologyDirty(SdfPath const& id);
178 
179  /// Returns true if the rprim identified by \p id has dirty doubleSided state.
180  HD_API
181  bool IsDoubleSidedDirty(SdfPath const& id);
182 
183  /// Returns true if the rprim identified by \p id has dirty cullstyle.
184  HD_API
185  bool IsCullStyleDirty(SdfPath const& id);
186 
187  /// Returns true if the rprim identified by \p id has a dirty subdiv tags.
188  HD_API
189  bool IsSubdivTagsDirty(SdfPath const& id);
190 
191  /// Returns true if the rprim identified by \p id has a dirty transform.
192  HD_API
193  bool IsTransformDirty(SdfPath const& id);
194 
195  /// Returns true if the rprim identified by \p id has dirty visibility.
196  HD_API
197  bool IsVisibilityDirty(SdfPath const& id);
198 
199  /// Returns true if the rprim identified by \p id has a dirty primID.
200  HD_API
201  bool IsPrimIdDirty(SdfPath const& id);
202 
203  /// Returns true if the dirtyBits has any flags set other than the varying
204  /// flag.
205  static bool IsDirty(HdDirtyBits dirtyBits) {
206  return (dirtyBits & AllDirty) != 0;
207  }
208 
209  /// Returns true if the dirtyBits has no flags set except the varying flag.
210  static bool IsClean(HdDirtyBits dirtyBits) {
211  return (dirtyBits & AllDirty) == 0;
212  }
213 
214  /// Returns true if the varying flag is set.
215  static bool IsVarying(HdDirtyBits dirtyBits) {
216  return (dirtyBits & Varying) != 0;
217  }
218 
219  /// Returns true if the dirtyBits has a dirty extent. id is for perflog.
220  HD_API
221  static bool IsExtentDirty(HdDirtyBits dirtyBits, SdfPath const& id);
222 
223  /// Returns true if the dirtyBits has a dirty display style. id is for perflog.
224  HD_API
225  static bool IsDisplayStyleDirty(HdDirtyBits dirtyBits, SdfPath const& id);
226 
227  /// Returns true if the dirtyBits has a dirty subdiv tags. id is for perflog.
228  HD_API
229  static bool IsSubdivTagsDirty(HdDirtyBits dirtyBits, SdfPath const& id);
230 
231  /// Returns true if the dirtyBits has a dirty primvar \p name.
232  /// id is for perflog.
233  HD_API
234  static bool IsPrimvarDirty(HdDirtyBits dirtyBits, SdfPath const& id,
235  TfToken const& name);
236 
237  /// Returns true if the dirtyBits has any dirty primvars.
238  /// id is for perflog.
239  HD_API
240  static bool IsAnyPrimvarDirty(HdDirtyBits dirtyBits, SdfPath const& id);
241 
242  /// Returns true if the dirtyBits has a dirty topology. id is for perflog.
243  HD_API
244  static bool IsTopologyDirty(HdDirtyBits dirtyBits, SdfPath const& id);
245 
246  /// Returns true if the dirtyBits has dirty doubleSided state. id is for perflog.
247  HD_API
248  static bool IsDoubleSidedDirty(HdDirtyBits dirtyBits, SdfPath const& id);
249 
250  /// Returns true if the dirtyBits has dirty cullstyle. id is for perflog.
251  HD_API
252  static bool IsCullStyleDirty(HdDirtyBits dirtyBits, SdfPath const& id);
253 
254  /// Returns true if the dirtyBits has a dirty transform. id is for perflog.
255  HD_API
256  static bool IsTransformDirty(HdDirtyBits dirtyBits, SdfPath const& id);
257 
258  /// Returns true if the dirtyBits has dirty visibility. id is for perflog.
259  HD_API
260  static bool IsVisibilityDirty(HdDirtyBits dirtyBits, SdfPath const& id);
261 
262  /// Returns true if the dirtyBits has a dirty primID. id is for perflog.
263  HD_API
264  static bool IsPrimIdDirty(HdDirtyBits dirtyBits, SdfPath const& id);
265 
266  /// Returns true if the dirtyBits has a dirty instancer. id is for perflog.
267  HD_API
268  static bool IsInstancerDirty(HdDirtyBits dirtyBits, SdfPath const& id);
269 
270  /// Returns true if the dirtyBits has a dirty instance index. id is for perflog.
271  HD_API
272  static bool IsInstanceIndexDirty(HdDirtyBits dirtyBits, SdfPath const& id);
273 
274  HD_API
275  static bool IsReprDirty(HdDirtyBits dirtyBits, SdfPath const &id);
276 
277  // ---------------------------------------------------------------------- //
278 
279  /// Set the primvar dirty flag to \p dirtyBits.
280  HD_API
281  static void MarkPrimvarDirty(HdDirtyBits *dirtyBits, TfToken const &name);
282 
283  // ---------------------------------------------------------------------- //
284  /// @}
285  /// \name Task Object Tracking
286  /// @{
287  // ---------------------------------------------------------------------- //
288 
289  /// Start tracking Task with the given \p id.
290  HD_API
291  void TaskInserted(SdfPath const& id, HdDirtyBits initialDirtyState);
292 
293  /// Stop tracking Task with the given \p id.
294  HD_API
295  void TaskRemoved(SdfPath const& id);
296 
297  /// Set the dirty flags to \p bits.
298  HD_API
299  void MarkTaskDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
300 
301  /// Get the dirty bits for Task with the given \p id.
302  HD_API
304 
305  /// Set the dirty flags to \p newBits.
306  HD_API
307  void MarkTaskClean(SdfPath const& id, HdDirtyBits newBits=Clean);
308 
309  /// Retrieve the current version number of the rprim render tag set
310  /// XXX Rename to GetRprimRenderTagVersion
311  HD_API
312  unsigned GetRenderTagVersion() const;
313 
314  /// Retrieve the current version number of the task's render tags opinion.
315  HD_API
316  unsigned GetTaskRenderTagsVersion() const;
317 
318  // ---------------------------------------------------------------------- //
319  /// @}
320  /// \name Instancer State Tracking
321  /// @{
322  // ---------------------------------------------------------------------- //
323 
324  /// Start tracking Instancer with the given \p id.
325  HD_API
326  void InstancerInserted(SdfPath const& id, HdDirtyBits initialDirtyState);
327 
328  /// Stop tracking Instancer with the given \p id.
329  HD_API
330  void InstancerRemoved(SdfPath const& id);
331 
332  /// Returns the dirty bits for the instancer with \p id.
333  HD_API
335 
336  /// Flag the Instancer with the given \p id as being dirty. Multiple calls
337  /// with different dirty bits accumulate.
338  HD_API
339  void MarkInstancerDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
340 
341  /// Clean the specified dirty bits for the instancer with \p id.
342  HD_API
343  void MarkInstancerClean(SdfPath const& id, HdDirtyBits newBits=Clean);
344 
345  /// Insert a dependency between \p rprimId and parent instancer
346  /// \p instancerId. Changes to the latter mark the former with
347  /// DirtyInstancer.
348  HD_API
349  void AddInstancerRprimDependency(SdfPath const& instancerId,
350  SdfPath const& rprimId);
351 
352  /// Remove a dependency between \p rprimId and parent instancer
353  /// \p instancerId.
354  HD_API
355  void RemoveInstancerRprimDependency(SdfPath const& instancerId,
356  SdfPath const& rprimId);
357 
358  /// Insert a dependency between \p instancerId and parent instancer
359  /// \p parentInstancerId. Changes to the latter mark the former with
360  /// DirtyInstancer.
361  HD_API
362  void AddInstancerInstancerDependency(SdfPath const& parentInstancerId,
363  SdfPath const& instancerId);
364 
365  /// Remove a dependency between \p instancerId and parent instancer
366  /// \p parentInstancerId.
367  HD_API
368  void RemoveInstancerInstancerDependency(SdfPath const& parentInstancerId,
369  SdfPath const& instancerId);
370 
371  // ---------------------------------------------------------------------- //
372  /// @}
373  /// \name Sprim (scene state prim: camera, light, ...) state Tracking
374  /// @{
375  // ---------------------------------------------------------------------- //
376 
377  /// Start tracking sprim with the given \p id.
378  HD_API
379  void SprimInserted(SdfPath const& id, HdDirtyBits initialDirtyState);
380 
381  /// Stop tracking sprim with the given \p id.
382  HD_API
383  void SprimRemoved(SdfPath const& id);
384 
385  /// Get the dirty bits for sprim with the given \p id.
386  HD_API
388 
389  /// Set the dirty flags to \p bits.
390  HD_API
391  void MarkSprimDirty(SdfPath const& id, HdDirtyBits bits);
392 
393  /// Set the dirty flags to \p newBits.
394  HD_API
395  void MarkSprimClean(SdfPath const& id, HdDirtyBits newBits=Clean);
396 
397  /// Insert a dependency between \p sprimId and parent instancer
398  /// \p instancerId. Changes to the latter mark the former with
399  /// DirtyInstancer.
400  HD_API
401  void AddInstancerSprimDependency(SdfPath const& instancerId,
402  SdfPath const& sprimId);
403 
404  /// Remove a dependency between \p sprimId and parent instancer
405  /// \p instancerId.
406  HD_API
407  void RemoveInstancerSprimDependency(SdfPath const& instancerId,
408  SdfPath const& sprimId);
409 
410  /// Insert a dependency between \p sprimId and parent sprim
411  /// \p parentSprimId.
412  HD_API
413  void AddSprimSprimDependency(SdfPath const& parentSprimId,
414  SdfPath const& sprimId);
415 
416  /// Remove a dependency between \p sprimId and parent sprim
417  /// \p parentSprimId.
418  HD_API
419  void RemoveSprimSprimDependency(SdfPath const& parentSprimId,
420  SdfPath const& sprimId);
421 
422  /// Remove all dependencies involving \p sprimId as a parent or child.
423  HD_API
424  void RemoveSprimFromSprimSprimDependencies(SdfPath const& sprimId);
425 
426  // ---------------------------------------------------------------------- //
427  /// @}
428  /// \name Bprim (buffer prim: texture, buffer, ...) state Tracking
429  /// @{
430  // ---------------------------------------------------------------------- //
431 
432  /// Start tracking bprim with the given \p id.
433  HD_API
434  void BprimInserted(SdfPath const& id, HdDirtyBits initialDirtyState);
435 
436  /// Stop tracking bprim with the given \p id.
437  HD_API
438  void BprimRemoved(SdfPath const& id);
439 
440  /// Get the dirty bits for bprim with the given \p id.
441  HD_API
443 
444  /// Set the dirty flags to \p bits.
445  HD_API
446  void MarkBprimDirty(SdfPath const& id, HdDirtyBits bits);
447 
448  /// Set the dirty flags to \p newBits.
449  HD_API
450  void MarkBprimClean(SdfPath const& id, HdDirtyBits newBits=Clean);
451 
452  // ---------------------------------------------------------------------- //
453  /// @}
454  /// \name RprimCollection Tracking
455  /// @{
456  // ---------------------------------------------------------------------- //
457 
458  /// Adds a named collection for tracking.
459  HD_API
460  void AddCollection(TfToken const& collectionName);
461 
462  /// Marks a named collection as being dirty, this bumps the version of the
463  /// collection.
464  HD_API
465  void MarkCollectionDirty(TfToken const& collectionName);
466 
467  /// Returns the current version of the named collection.
468  HD_API
469  unsigned GetCollectionVersion(TfToken const& collectionName) const;
470 
471  /// Returns the number of changes to visibility. This is intended to be used
472  /// to detect when visibility has changed for *any* Rprim.
473  HD_API
474  unsigned GetVisibilityChangeCount() const;
475 
476  /// Returns the number of changes to instance index. This is intended to be used
477  /// to detect when instance indices changed for *any* Rprim. Use in with
478  /// GetInstancerIndexVersion() to detect all changes to instance indices.
479  HD_API
480  unsigned GetInstanceIndicesChangeCount() const;
481 
482  /// Returns the current version of varying state. This is used to refresh
483  /// cached DirtyLists
484  unsigned GetVaryingStateVersion() const {
485  return _varyingStateVersion;
486  }
487 
488  // ---------------------------------------------------------------------- //
489  /// @}
490  /// \name Render Index Versioning
491  /// @{
492  // ---------------------------------------------------------------------- //
493 
494  /// Returns the current version of the Render Index's RPrim set.
495  /// This version number changes when Rprims are inserted or removed
496  /// from the render index. Invalidating any cached gather operations.
497  unsigned GetRprimIndexVersion() const {
498  return _rprimIndexVersion;
499  }
500 
501  /// Returns the current version of the Render Index's SPrim set.
502  /// This version number changes when Sprims are inserted or removed
503  /// from the render index. Invalidating any cached gather operations.
504  unsigned GetSprimIndexVersion() const {
505  return _sprimIndexVersion;
506  }
507 
508  /// Returns the current version of the Render Index's BPrim set.
509  /// This version number changes when Bprims are inserted or removed
510  /// from the render index. Invalidating any cached gather operations.
511  unsigned GetBprimIndexVersion() const {
512  return _bprimIndexVersion;
513  }
514 
515  /// Returns the current version of the Render Index's Instancer set.
516  /// This version number changes when Instancers are inserted or removed
517  /// from the render index. Invalidating any cached gather operations.
518  unsigned GetInstancerIndexVersion() const {
519  return _instancerIndexVersion;
520  }
521 
522 
523  /// Returns the current version of the scene state.
524  /// This version number changes whenever any prims are inserted, removed
525  /// or marked dirty.
526  /// The use case is to detect that nothing has changed, so the Sync
527  /// phase can be avoided.
528  unsigned GetSceneStateVersion() const {
529  return _sceneStateVersion;
530  }
531 
532  // ---------------------------------------------------------------------- //
533  /// @}
534  /// \name General state tracking
535  /// @{
536  // ---------------------------------------------------------------------- //
537 
538  /// Adds a named state for tracking.
539  HD_API
540  void AddState(TfToken const& name);
541 
542  /// Marks a named state as being dirty., this bumps the version of the
543  /// state.
544  HD_API
545  void MarkStateDirty(TfToken const& name);
546 
547  /// Returns the current version of the named state.
548  HD_API
549  unsigned GetStateVersion(TfToken const &name) const;
550 
551  // ---------------------------------------------------------------------- //
552  /// @}
553  /// \name Debug
554  /// @{
555  // ---------------------------------------------------------------------- //
556  HD_API
557  static std::string StringifyDirtyBits(HdDirtyBits dirtyBits);
558 
559  HD_API
560  static void DumpDirtyBits(HdDirtyBits dirtyBits);
561 
562  /// @}
563 
564 private:
565 
566  // Don't allow copies
567  HdChangeTracker(const HdChangeTracker &) = delete;
568  HdChangeTracker &operator=(const HdChangeTracker &) = delete;
569 
570 
571  static void _LogCacheAccess(TfToken const& cacheName,
572  SdfPath const& id, bool hit);
573 
575  typedef TfHashMap<TfToken, int, TfToken::HashFunctor> _CollectionStateMap;
577 
578  struct _PathHashCompare {
579  static bool equal(const SdfPath& a, const SdfPath& b)
580  { return a == b; }
581 
582  static size_t hash(const SdfPath& path)
583  { return hash_value(path); }
584  };
585  typedef tbb::concurrent_hash_map<SdfPath, SdfPathSet, _PathHashCompare>
586  _DependencyMap;
587 
588  // Core dirty state.
589  _IDStateMap _rprimState;
590  _IDStateMap _instancerState;
591  _IDStateMap _taskState;
592  _IDStateMap _sprimState;
593  _IDStateMap _bprimState;
594  _GeneralStateMap _generalState;
595 
596  // Collection versions / state.
597  _CollectionStateMap _collectionState;
598 
599  // Provides reverse-association between instancers and the child
600  // instancers/prims that use them.
601  _DependencyMap _instancerRprimDependencies;
602  _DependencyMap _instancerSprimDependencies;
603  _DependencyMap _instancerInstancerDependencies;
604 
605  // Provides forward and reverse-association between sprims and the child
606  // sprims that reference them. For example, a light prim (child) who needs
607  // to know when its light filter (parent) is modified.
608  // Maps parent sprim to child sprim.
609  _DependencyMap _sprimSprimTargetDependencies;
610  // Maps child sprim to parent sprim.
611  _DependencyMap _sprimSprimSourceDependencies;
612 
613  // Dependency map helpers
614  void _AddDependency(_DependencyMap &depMap,
615  SdfPath const& parent, SdfPath const& child);
616  void _RemoveDependency(_DependencyMap &depMap,
617  SdfPath const& parent, SdfPath const& child);
618 
619  // Typically the Rprims that get marked dirty per update iteration end up
620  // being a stable set of objects; to leverage this fact, we require the
621  // delegate notify the change tracker when that state changes, which bumps
622  // the varyingStateVersion, which triggers downstream invalidation.
623  unsigned _varyingStateVersion;
624 
625  // Tracks changes (insertions/removals) of prims in the render index.
626  // This is used to indicating that cached gather operations need to be
627  // re-evaluated, such as dirty lists or batch building.
628  unsigned _rprimIndexVersion;
629  unsigned _sprimIndexVersion;
630  unsigned _bprimIndexVersion;
631  unsigned _instancerIndexVersion;
632 
633  // The following tracks any changes of state. As a result it is very broad.
634  // The use case to detect, when no changes have been made, as to
635  // avoid the need to sync or reset progressive renderers.
636  unsigned _sceneStateVersion;
637 
638  // Used to detect that visibility changed somewhere in the render index.
639  unsigned _visChangeCount;
640 
641  // Used to detect that instance indices changed somewhere in the render index.
642  unsigned _instanceIndicesChangeCount;
643 
644  // Used to detect changes to the render tag opinion of rprims.
645  unsigned _rprimRenderTagVersion;
646 
647  // Used to detect changes to the render tags opinion of tasks.
648  unsigned _taskRenderTagsVersion;
649 
650  // Allow HdRenderIndex to provide a scene index to forward dirty
651  // information. This is necessary to accommodate legacy HdSceneDelegate
652  // based applications that rely on the HdChangeTracker for invalidating
653  // state on Hydra prims.
654  friend class HdRenderIndex;
655  // Does not take ownership. The HdRenderIndex manages the lifetime of this
656  // scene index.
657  HdRetainedSceneIndex * _emulationSceneIndex;
658  void _SetTargetSceneIndex(HdRetainedSceneIndex *emulationSceneIndex);
659 
660  // Private methods which implement the behaviors of their public
661  // equivalents. The public versions check to see if legacy emulation is
662  // active. If so, they dirty the HdRetainedSceneIndex member instead
663  // of directly acting. If legacy render delegate emulation is active, these
664  // will eventually make their way back to the private methods via
665  // HdSceneIndexAdapterSceneDelegate. This prevents dirtying cycles while
666  // allowing single HdRenderIndex/HdChangeTracker instances to be used for
667  // both ends of emulation.
669  void _MarkRprimDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
670  void _MarkSprimDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
671  void _MarkBprimDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
672  void _MarkInstancerDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
673  void _MarkTaskDirty(SdfPath const& id, HdDirtyBits bits=AllDirty);
674 };
675 
676 
678 
679 #endif //PXR_IMAGING_HD_CHANGE_TRACKER_H
HD_API void AddInstancerRprimDependency(SdfPath const &instancerId, SdfPath const &rprimId)
HD_API void RprimRemoved(SdfPath const &id)
Stop tracking Rprim with the given id.
HD_API unsigned GetTaskRenderTagsVersion() const
Retrieve the current version number of the task's render tags opinion.
HD_API void RemoveSprimFromSprimSprimDependencies(SdfPath const &sprimId)
Remove all dependencies involving sprimId as a parent or child.
HD_API bool IsSubdivTagsDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty subdiv tags.
HD_API bool IsExtentDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty extent.
HD_API void SprimRemoved(SdfPath const &id)
Stop tracking sprim with the given id.
HD_API void RemoveInstancerInstancerDependency(SdfPath const &parentInstancerId, SdfPath const &instancerId)
HD_API void RemoveInstancerSprimDependency(SdfPath const &instancerId, SdfPath const &sprimId)
HD_API void ResetRprimVaryingState(SdfPath const &id)
virtual HD_API ~HdChangeTracker()
uint32_t HdDirtyBits
Definition: types.h:143
static HD_API bool IsInstanceIndexDirty(HdDirtyBits dirtyBits, SdfPath const &id)
Returns true if the dirtyBits has a dirty instance index. id is for perflog.
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
static bool IsDirty(HdDirtyBits dirtyBits)
unsigned GetSceneStateVersion() const
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
#define HD_API
Definition: api.h:23
HD_API void MarkTaskClean(SdfPath const &id, HdDirtyBits newBits=Clean)
Set the dirty flags to newBits.
IMATH_HOSTDEVICE constexpr bool equal(T1 a, T2 b, T3 t) IMATH_NOEXCEPT
Definition: ImathFun.h:105
HD_API bool IsPrimIdDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty primID.
HD_API HdDirtyBits GetInstancerDirtyBits(SdfPath const &id)
Returns the dirty bits for the instancer with id.
HD_API unsigned GetVisibilityChangeCount() const
HD_API void MarkInstancerClean(SdfPath const &id, HdDirtyBits newBits=Clean)
Clean the specified dirty bits for the instancer with id.
HD_API void MarkAllRprimsDirty(HdDirtyBits bits)
HD_API void BprimRemoved(SdfPath const &id)
Stop tracking bprim with the given id.
HD_API void MarkCollectionDirty(TfToken const &collectionName)
HD_API bool IsTransformDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty transform.
static bool IsClean(HdDirtyBits dirtyBits)
Returns true if the dirtyBits has no flags set except the varying flag.
HD_API void RprimInserted(SdfPath const &id, HdDirtyBits initialDirtyState)
Start tracking Rprim with the given id.
HD_API unsigned GetStateVersion(TfToken const &name) const
Returns the current version of the named state.
HD_API void MarkSprimDirty(SdfPath const &id, HdDirtyBits bits)
Set the dirty flags to bits.
HD_API HdChangeTracker()
HD_API void MarkPrimvarDirty(SdfPath const &id, TfToken const &name)
Mark the primvar for the rprim with id as being dirty.
HD_API void MarkTaskDirty(SdfPath const &id, HdDirtyBits bits=AllDirty)
Set the dirty flags to bits.
HD_API HdDirtyBits GetBprimDirtyBits(SdfPath const &id)
Get the dirty bits for bprim with the given id.
Definition: token.h:70
HD_API void BprimInserted(SdfPath const &id, HdDirtyBits initialDirtyState)
Start tracking bprim with the given id.
HD_API bool IsPrimvarDirty(SdfPath const &id, TfToken const &name)
HD_API bool IsRprimDirty(SdfPath const &id)
Returns true if the rprim identified by id has any dirty flags set.
HD_API void MarkBprimDirty(SdfPath const &id, HdDirtyBits bits)
Set the dirty flags to bits.
static HD_API bool IsReprDirty(HdDirtyBits dirtyBits, SdfPath const &id)
Returns the dirty bits for the rprim with id.
HD_API HdDirtyBits GetTaskDirtyBits(SdfPath const &id)
Get the dirty bits for Task with the given id.
HD_API bool IsTopologyDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty topology.
HD_API HdDirtyBits GetRprimDirtyBits(SdfPath const &id) const
Returns the dirty bits for the rprim with id.
HD_API void MarkRprimDirty(SdfPath const &id, HdDirtyBits bits=AllDirty)
HD_API void AddCollection(TfToken const &collectionName)
Adds a named collection for tracking.
HD_API void AddInstancerSprimDependency(SdfPath const &instancerId, SdfPath const &sprimId)
static bool IsVarying(HdDirtyBits dirtyBits)
Returns true if the varying flag is set.
HD_API void RemoveInstancerRprimDependency(SdfPath const &instancerId, SdfPath const &rprimId)
GLuint const GLchar * name
Definition: glcorearb.h:786
unsigned GetRprimIndexVersion() const
Definition: path.h:273
HD_API void TaskInserted(SdfPath const &id, HdDirtyBits initialDirtyState)
Start tracking Task with the given id.
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1222
unsigned GetVaryingStateVersion() const
HD_API void TaskRemoved(SdfPath const &id)
Stop tracking Task with the given id.
HD_API void SprimInserted(SdfPath const &id, HdDirtyBits initialDirtyState)
Start tracking sprim with the given id.
HD_API unsigned GetRenderTagVersion() const
HD_API void RemoveSprimSprimDependency(SdfPath const &parentSprimId, SdfPath const &sprimId)
static HD_API void DumpDirtyBits(HdDirtyBits dirtyBits)
unsigned GetBprimIndexVersion() const
HD_API void MarkRprimClean(SdfPath const &id, HdDirtyBits newBits=Clean)
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1425
HD_API unsigned GetInstanceIndicesChangeCount() const
HD_API void MarkInstancerDirty(SdfPath const &id, HdDirtyBits bits=AllDirty)
HD_API void AddState(TfToken const &name)
Adds a named state for tracking.
HD_API void AddInstancerInstancerDependency(SdfPath const &parentInstancerId, SdfPath const &instancerId)
static HD_API std::string StringifyDirtyBits(HdDirtyBits dirtyBits)
HD_API void AddSprimSprimDependency(SdfPath const &parentSprimId, SdfPath const &sprimId)
unsigned GetInstancerIndexVersion() const
HD_API bool IsCullStyleDirty(SdfPath const &id)
Returns true if the rprim identified by id has dirty cullstyle.
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:74
HD_API HdDirtyBits GetSprimDirtyBits(SdfPath const &id)
Get the dirty bits for sprim with the given id.
static HD_API bool IsInstancerDirty(HdDirtyBits dirtyBits, SdfPath const &id)
Returns true if the dirtyBits has a dirty instancer. id is for perflog.
HD_API void MarkStateDirty(TfToken const &name)
HD_API void InstancerRemoved(SdfPath const &id)
Stop tracking Instancer with the given id.
HD_API unsigned GetCollectionVersion(TfToken const &collectionName) const
Returns the current version of the named collection.
HD_API bool IsVisibilityDirty(SdfPath const &id)
Returns true if the rprim identified by id has dirty visibility.
HD_API bool IsAnyPrimvarDirty(SdfPath const &id)
Returns true if the rprim identified by id has any dirty primvars.
HD_API void MarkBprimClean(SdfPath const &id, HdDirtyBits newBits=Clean)
Set the dirty flags to newBits.
HD_API bool IsDisplayStyleDirty(SdfPath const &id)
Returns true if the rprim identified by id has a dirty display style.
size_t hash_value(const CH_ChannelRef &ref)
HD_API void InstancerInserted(SdfPath const &id, HdDirtyBits initialDirtyState)
Start tracking Instancer with the given id.
unsigned GetSprimIndexVersion() const
HD_API void MarkSprimClean(SdfPath const &id, HdDirtyBits newBits=Clean)
Set the dirty flags to newBits.
HD_API void ResetVaryingState()
HD_API bool IsDoubleSidedDirty(SdfPath const &id)
Returns true if the rprim identified by id has dirty doubleSided state.