Loading...
Searching...
No Matches
sceneDelegate.h
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_SCENE_DELEGATE_H
8#define PXR_IMAGING_HD_SCENE_DELEGATE_H
9
10#include "pxr/pxr.h"
11#include "pxr/imaging/hd/api.h"
12#include "pxr/imaging/hd/version.h"
13
14#include "pxr/imaging/hd/aov.h"
15#include "pxr/imaging/hd/basisCurvesTopology.h"
16#include "pxr/imaging/hd/enums.h"
17#include "pxr/imaging/hd/meshTopology.h"
18#include "pxr/imaging/hd/renderIndex.h"
19#include "pxr/imaging/hd/repr.h"
20#include "pxr/imaging/hd/timeSampleArray.h"
21
22#include "pxr/imaging/pxOsd/subdivTags.h"
23
24#include "pxr/base/vt/array.h"
25#include "pxr/base/vt/dictionary.h"
26#include "pxr/base/vt/value.h"
27#include "pxr/usd/sdf/assetPath.h"
28#include "pxr/usd/sdf/path.h"
29
30#include "pxr/base/gf/vec2i.h"
31#include "pxr/base/tf/hash.h"
32
33#include <memory>
34#include <vector>
35
36PXR_NAMESPACE_OPEN_SCOPE
37
38class HdExtComputationContext;
39
41typedef std::shared_ptr<SdfPathVector> HdIdVectorSharedPtr;
42
44typedef std::vector<std::pair<SdfPath, int>> HdInstancerContext;
45
52struct HdSyncRequestVector {
53 // The Prims to synchronize in this request.
54 SdfPathVector IDs;
55
56 // The HdChangeTracker::DirtyBits that are set for each Prim.
57 std::vector<HdDirtyBits> dirtyBits;
58};
59
64struct HdDisplayStyle {
66 int refineLevel;
67
69 bool flatShadingEnabled;
70
72 bool displacementEnabled;
73
76 bool occludedSelectionShowsThrough;
77
80 bool pointsShadingEnabled;
81
84 bool materialIsFinal;
85
92 HdDisplayStyle()
93 : refineLevel(0)
94 , flatShadingEnabled(false)
95 , displacementEnabled(true)
96 , occludedSelectionShowsThrough(false)
97 , pointsShadingEnabled(false)
98 , materialIsFinal(false)
99 { }
100
113 HdDisplayStyle(int refineLevel_,
114 bool flatShading = false,
115 bool displacement = true,
116 bool occludedSelectionShowsThrough_ = false,
117 bool pointsShadingEnabled_ = false,
118 bool materialIsFinal_ = false)
119 : refineLevel(std::max(0, refineLevel_))
120 , flatShadingEnabled(flatShading)
121 , displacementEnabled(displacement)
122 , occludedSelectionShowsThrough(occludedSelectionShowsThrough_)
123 , pointsShadingEnabled(pointsShadingEnabled_)
124 , materialIsFinal(materialIsFinal_)
125 {
126 if (refineLevel_ < 0) {
127 TF_CODING_ERROR("negative refine level is not supported");
128 } else if (refineLevel_ > 8) {
129 TF_CODING_ERROR("refine level > 8 is not supported");
130 }
131 }
132
133 HdDisplayStyle(HdDisplayStyle const& rhs) = default;
134 ~HdDisplayStyle() = default;
135
136 bool operator==(HdDisplayStyle const& rhs) const {
137 return refineLevel == rhs.refineLevel
138 && flatShadingEnabled == rhs.flatShadingEnabled
139 && displacementEnabled == rhs.displacementEnabled
140 && occludedSelectionShowsThrough ==
141 rhs.occludedSelectionShowsThrough
142 && pointsShadingEnabled == rhs.pointsShadingEnabled
143 && materialIsFinal == rhs.materialIsFinal;
144 }
145 bool operator!=(HdDisplayStyle const& rhs) const {
146 return !(*this == rhs);
147 }
148};
149
153struct HdPrimvarDescriptor {
155 TfToken name;
157 HdInterpolation interpolation;
161 TfToken role;
164 bool indexed;
165
166 HdPrimvarDescriptor()
167 : interpolation(HdInterpolationConstant)
168 , role(HdPrimvarRoleTokens->none)
169 , indexed(false)
170 {}
171 HdPrimvarDescriptor(TfToken const& name_,
172 HdInterpolation interp_,
173 TfToken const& role_=HdPrimvarRoleTokens->none,
174 bool indexed_=false)
175 : name(name_), interpolation(interp_), role(role_), indexed(indexed_)
176 { }
177 bool operator==(HdPrimvarDescriptor const& rhs) const {
178 return name == rhs.name && role == rhs.role
179 && interpolation == rhs.interpolation;
180 }
181 bool operator!=(HdPrimvarDescriptor const& rhs) const {
182 return !(*this == rhs);
183 }
184};
185
186typedef std::vector<HdPrimvarDescriptor> HdPrimvarDescriptorVector;
187
200struct HdModelDrawMode {
201 // Alternate imaging mode. Options are origin, bounds, cards, default, and
202 // inherited.
203 TfToken drawMode;
204 // Specifies whether to apply the alternative imaging mode or not.
205 bool applyDrawMode;
206 // The color in which to draw the geometry.
207 GfVec3f drawModeColor;
208 // The specific geometry to use in cards mode. Options are cross, box, and
209 // fromTexture.
210 TfToken cardGeometry;
211 // The textures applied to the respective quads in cards mode.
212 SdfAssetPath cardTextureXPos;
213 SdfAssetPath cardTextureYPos;
214 SdfAssetPath cardTextureZPos;
215 SdfAssetPath cardTextureXNeg;
216 SdfAssetPath cardTextureYNeg;
217 SdfAssetPath cardTextureZNeg;
218
219 HdModelDrawMode()
220 : drawMode(HdModelDrawModeTokens->inherited)
221 , applyDrawMode(false)
222 , drawModeColor(GfVec3f(0.18))
223 , cardGeometry(HdModelDrawModeTokens->cross)
224 {}
225
226 HdModelDrawMode(
227 TfToken const& drawMode_,
228 bool applyDrawMode_=false,
229 GfVec3f drawModeColor_=GfVec3f(0.18),
230 TfToken const& cardGeometry_=HdModelDrawModeTokens->cross,
231 SdfAssetPath cardTextureXPos_=SdfAssetPath(),
232 SdfAssetPath cardTextureYPos_=SdfAssetPath(),
233 SdfAssetPath cardTextureZPos_=SdfAssetPath(),
234 SdfAssetPath cardTextureXNeg_=SdfAssetPath(),
235 SdfAssetPath cardTextureYNeg_=SdfAssetPath(),
236 SdfAssetPath cardTextureZNeg_=SdfAssetPath())
237 : drawMode(drawMode_), applyDrawMode(applyDrawMode_),
238 drawModeColor(drawModeColor_), cardGeometry(cardGeometry_),
239 cardTextureXPos(cardTextureXPos_), cardTextureYPos(cardTextureYPos_),
240 cardTextureZPos(cardTextureZPos_), cardTextureXNeg(cardTextureXNeg_),
241 cardTextureYNeg(cardTextureYNeg_), cardTextureZNeg(cardTextureZNeg_)
242 {}
243
244 bool operator==(HdModelDrawMode const& rhs) const {
245 return drawMode == rhs.drawMode &&
246 applyDrawMode == rhs.applyDrawMode &&
247 drawModeColor == rhs.drawModeColor &&
248 cardGeometry == rhs.cardGeometry &&
249 cardTextureXPos == rhs.cardTextureXPos &&
250 cardTextureYPos == rhs.cardTextureYPos &&
251 cardTextureZPos == rhs.cardTextureZPos &&
252 cardTextureXNeg == rhs.cardTextureXNeg &&
253 cardTextureYNeg == rhs.cardTextureYNeg &&
254 cardTextureZNeg == rhs.cardTextureZNeg;
255 }
256 bool operator!=(HdModelDrawMode const& rhs) const {
257 return !(*this == rhs);
258 }
259};
260
270struct HdExtComputationPrimvarDescriptor : public HdPrimvarDescriptor {
271 SdfPath sourceComputationId;
272 TfToken sourceComputationOutputName;
273 HdTupleType valueType;
274
275 HdExtComputationPrimvarDescriptor() {}
276 HdExtComputationPrimvarDescriptor(
277 TfToken const& name_,
278 HdInterpolation interp_,
279 TfToken const & role_,
280 SdfPath const & sourceComputationId_,
281 TfToken const & sourceComputationOutputName_,
282 HdTupleType const & valueType_)
283 : HdPrimvarDescriptor(name_, interp_, role_, false)
284 , sourceComputationId(sourceComputationId_)
285 , sourceComputationOutputName(sourceComputationOutputName_)
286 , valueType(valueType_)
287 { }
288 bool operator==(HdExtComputationPrimvarDescriptor const& rhs) const {
289 return HdPrimvarDescriptor::operator==(rhs) &&
290 sourceComputationId == rhs.sourceComputationId &&
291 sourceComputationOutputName == rhs.sourceComputationOutputName &&
292 valueType == rhs.valueType;
293 }
294 bool operator!=(HdExtComputationPrimvarDescriptor const& rhs) const {
295 return !(*this == rhs);
296 }
297};
298
299typedef std::vector<HdExtComputationPrimvarDescriptor>
300 HdExtComputationPrimvarDescriptorVector;
301
310struct HdExtComputationInputDescriptor {
311 TfToken name;
312 SdfPath sourceComputationId;
313 TfToken sourceComputationOutputName;
314
315 HdExtComputationInputDescriptor() {}
316 HdExtComputationInputDescriptor(
317 TfToken const & name_,
318 SdfPath const & sourceComputationId_,
319 TfToken const & sourceComputationOutputName_)
320 : name(name_), sourceComputationId(sourceComputationId_)
321 , sourceComputationOutputName(sourceComputationOutputName_)
322 { }
323
324 bool operator==(HdExtComputationInputDescriptor const& rhs) const {
325 return name == rhs.name &&
326 sourceComputationId == rhs.sourceComputationId &&
327 sourceComputationOutputName == rhs.sourceComputationOutputName;
328 }
329 bool operator!=(HdExtComputationInputDescriptor const& rhs) const {
330 return !(*this == rhs);
331 }
332};
333
334typedef std::vector<HdExtComputationInputDescriptor>
335 HdExtComputationInputDescriptorVector;
336
343struct HdExtComputationOutputDescriptor {
344 TfToken name;
345 HdTupleType valueType;
346
347 HdExtComputationOutputDescriptor() {}
348 HdExtComputationOutputDescriptor(
349 TfToken const & name_,
350 HdTupleType const & valueType_)
351 : name(name_), valueType(valueType_)
352 { }
353
354 bool operator==(HdExtComputationOutputDescriptor const& rhs) const {
355 return name == rhs.name &&
356 valueType == rhs.valueType;
357 }
358 bool operator!=(HdExtComputationOutputDescriptor const& rhs) const {
359 return !(*this == rhs);
360 }
361};
362
363typedef std::vector<HdExtComputationOutputDescriptor>
364 HdExtComputationOutputDescriptorVector;
365
370struct HdVolumeFieldDescriptor {
371 TfToken fieldName;
372 TfToken fieldPrimType;
373 SdfPath fieldId;
374
375 HdVolumeFieldDescriptor() {}
376 HdVolumeFieldDescriptor(
377 TfToken const & fieldName_,
378 TfToken const & fieldPrimType_,
379 SdfPath const & fieldId_)
380 : fieldName(fieldName_), fieldPrimType(fieldPrimType_), fieldId(fieldId_)
381 { }
382};
383
384typedef std::vector<HdVolumeFieldDescriptor>
385 HdVolumeFieldDescriptorVector;
386
391class HdSceneDelegate {
392public:
394 HD_API
395 HdSceneDelegate(HdRenderIndex *parentIndex,
396 SdfPath const& delegateID);
397
398 HD_API
399 virtual ~HdSceneDelegate();
400
402 HdRenderIndex& GetRenderIndex() { return *_index; }
403
408 SdfPath const& GetDelegateID() const { return _delegateID; }
409
411 HD_API
412 virtual void Sync(HdSyncRequestVector* request);
413
416 HD_API
417 virtual void PostSyncCleanup();
418
419 // -----------------------------------------------------------------------//
421 // -----------------------------------------------------------------------//
422
424 HD_API
425 virtual bool IsEnabled(TfToken const& option) const;
426
427
428 // -----------------------------------------------------------------------//
430 // -----------------------------------------------------------------------//
431
433 HD_API
434 virtual HdMeshTopology GetMeshTopology(SdfPath const& id);
435
437 HD_API
438 virtual HdBasisCurvesTopology GetBasisCurvesTopology(SdfPath const& id);
439
441 HD_API
442 virtual PxOsdSubdivTags GetSubdivTags(SdfPath const& id);
443
444
452 HD_API
453 virtual GfRange3d GetExtent(SdfPath const & id);
454
456 HD_API
457 virtual GfMatrix4d GetTransform(SdfPath const & id);
458
460 HD_API
461 virtual bool GetVisible(SdfPath const & id);
462
464 HD_API
465 virtual bool GetDoubleSided(SdfPath const & id);
466
468 HD_API
469 virtual HdCullStyle GetCullStyle(SdfPath const &id);
470
472 HD_API
473 virtual VtValue GetShadingStyle(SdfPath const &id);
474
479 HD_API
480 virtual HdDisplayStyle GetDisplayStyle(SdfPath const& id);
481
483 HD_API
484 virtual VtValue Get(SdfPath const& id, TfToken const& key);
485
490 HD_API
491 virtual VtValue GetIndexedPrimvar(SdfPath const& id,
492 TfToken const& key,
493 VtIntArray *outIndices);
494
496 HD_API
497 virtual HdReprSelector GetReprSelector(SdfPath const &id);
498
501 HD_API
502 virtual TfToken GetRenderTag(SdfPath const& id);
503
505 HD_API
506 virtual VtArray<TfToken> GetCategories(SdfPath const& id);
507
509 HD_API
510 virtual std::vector<VtArray<TfToken>>
511 GetInstanceCategories(SdfPath const &instancerId);
512
514 HD_API
515 virtual HdIdVectorSharedPtr GetCoordSysBindings(SdfPath const& id);
516
518 HD_API
519 virtual HdModelDrawMode GetModelDrawMode(SdfPath const& id);
520
521 // -----------------------------------------------------------------------//
523 // -----------------------------------------------------------------------//
524
532 HD_API
533 virtual size_t
534 SampleTransform(SdfPath const & id,
535 size_t maxSampleCount,
536 float *sampleTimes,
537 GfMatrix4d *sampleValues);
538
539 // An overload of SampleTransform that explicitly takes the startTime
540 // and endTime rather than relying on the scene delegate having state
541 // about what the source of the current shutter interval should be.
542 HD_API
543 virtual size_t
544 SampleTransform(SdfPath const & id,
545 float startTime,
546 float endTime,
547 size_t maxSampleCount,
548 float *sampleTimes,
549 GfMatrix4d *sampleValues);
550
554 template <unsigned int CAPACITY>
555 void
556 SampleTransform(SdfPath const & id,
557 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);
558
562 template <unsigned int CAPACITY>
563 void
564 SampleTransform(SdfPath const & id,
565 float startTime,
566 float endTime,
567 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);
568
576 HD_API
577 virtual size_t
578 SampleInstancerTransform(SdfPath const &instancerId,
579 size_t maxSampleCount,
580 float *sampleTimes,
581 GfMatrix4d *sampleValues);
582
583 // An overload of SampleInstancerTransform that explicitly takes the
584 // startTime and endTime rather than relying on the scene delegate
585 // having state about what the source of the current shutter interval
586 // should be.
587 HD_API
588 virtual size_t
589 SampleInstancerTransform(SdfPath const &instancerId,
590 float startTime,
591 float endTime,
592 size_t maxSampleCount,
593 float *sampleTimes,
594 GfMatrix4d *sampleValues);
595
600 template <unsigned int CAPACITY>
601 void
602 SampleInstancerTransform(SdfPath const &instancerId,
603 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);
604
609 template <unsigned int CAPACITY>
610 void
611 SampleInstancerTransform(SdfPath const &instancerId,
612 float startTime, float endTime,
613 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);
614
632 HD_API
633 virtual size_t
634 SamplePrimvar(SdfPath const& id,
635 TfToken const& key,
636 size_t maxSampleCount,
637 float *sampleTimes,
638 VtValue *sampleValues);
639
640 // An overload of SamplePrimvar that explicitly takes the startTime
641 // and endTime rather than relying on the scene delegate having state
642 // about what the source of the current shutter interval should be.
643 HD_API
644 virtual size_t
645 SamplePrimvar(SdfPath const& id,
646 TfToken const& key,
647 float startTime,
648 float endTime,
649 size_t maxSampleCount,
650 float *sampleTimes,
651 VtValue *sampleValues);
652
656 template <unsigned int CAPACITY>
657 void
658 SamplePrimvar(SdfPath const &id,
659 TfToken const& key,
660 HdTimeSampleArray<VtValue, CAPACITY> *sa);
661
665 template <unsigned int CAPACITY>
666 void
667 SamplePrimvar(SdfPath const &id,
668 TfToken const& key,
669 float startTime,
670 float endTime,
671 HdTimeSampleArray<VtValue, CAPACITY> *sa);
672
678 HD_API
679 virtual size_t
680 SampleIndexedPrimvar(SdfPath const& id,
681 TfToken const& key,
682 size_t maxSampleCount,
683 float *sampleTimes,
684 VtValue *sampleValues,
685 VtIntArray *sampleIndices);
686
687 // An overload of SampleIndexedPrimvar that explicitly takes the startTime
688 // and endTime rather than relying on the scene delegate having state
689 // about what the source of the current shutter interval should be.
690 HD_API
691 virtual size_t
692 SampleIndexedPrimvar(SdfPath const& id,
693 TfToken const& key,
694 float startTime,
695 float endTime,
696 size_t maxSampleCount,
697 float *sampleTimes,
698 VtValue *sampleValues,
699 VtIntArray *sampleIndices);
700
701
705 template <unsigned int CAPACITY>
706 void
707 SampleIndexedPrimvar(SdfPath const &id,
708 TfToken const& key,
709 HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa);
710
714 template <unsigned int CAPACITY>
715 void
716 SampleIndexedPrimvar(SdfPath const &id,
717 TfToken const& key,
718 float startTime,
719 float endTime,
720 HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa);
721
722 // -----------------------------------------------------------------------//
724 // -----------------------------------------------------------------------//
725
738 HD_API
739 virtual VtIntArray GetInstanceIndices(SdfPath const &instancerId,
740 SdfPath const &prototypeId);
741
743 HD_API
744 virtual GfMatrix4d GetInstancerTransform(SdfPath const &instancerId);
745
747 HD_API
748 virtual SdfPath GetInstancerId(SdfPath const& primId);
749
754 HD_API
755 virtual SdfPathVector GetInstancerPrototypes(SdfPath const& instancerId);
756
757 // -----------------------------------------------------------------------//
759 // -----------------------------------------------------------------------//
760
765 HD_API
766 virtual SdfPath GetScenePrimPath(SdfPath const& rprimId,
767 int instanceIndex,
768 HdInstancerContext *instancerContext = nullptr);
769
775 HD_API
776 virtual SdfPathVector GetScenePrimPaths(SdfPath const& rprimId,
777 std::vector<int> instanceIndices,
778 std::vector<HdInstancerContext> *instancerContexts = nullptr);
779
780 // -----------------------------------------------------------------------//
782 // -----------------------------------------------------------------------//
783
785 HD_API
786 virtual SdfPath GetMaterialId(SdfPath const &rprimId);
787
788 // Returns a material resource which contains the information
789 // needed to create a material.
790 HD_API
791 virtual VtValue GetMaterialResource(SdfPath const &materialId);
792
793 // -----------------------------------------------------------------------//
795 // -----------------------------------------------------------------------//
796
798 HD_API
799 virtual HdRenderBufferDescriptor GetRenderBufferDescriptor(SdfPath const& id);
800
801 // -----------------------------------------------------------------------//
803 // -----------------------------------------------------------------------//
804
805 // Returns a single value for a given light and parameter.
806 HD_API
807 virtual VtValue GetLightParamValue(SdfPath const &id,
808 TfToken const &paramName);
809
810 // -----------------------------------------------------------------------//
812 // -----------------------------------------------------------------------//
813
816 HD_API
817 virtual VtValue GetCameraParamValue(SdfPath const& cameraId,
818 TfToken const& paramName);
819
820 // -----------------------------------------------------------------------//
822 // -----------------------------------------------------------------------//
823
824 HD_API
825 virtual HdVolumeFieldDescriptorVector
826 GetVolumeFieldDescriptors(SdfPath const &volumeId);
827
828 // -----------------------------------------------------------------------//
830 // -----------------------------------------------------------------------//
831
839 HD_API
840 virtual TfTokenVector
841 GetExtComputationSceneInputNames(SdfPath const& computationId);
842
848 HD_API
849 virtual HdExtComputationInputDescriptorVector
850 GetExtComputationInputDescriptors(SdfPath const& computationId);
851
856 HD_API
857 virtual HdExtComputationOutputDescriptorVector
858 GetExtComputationOutputDescriptors(SdfPath const& computationId);
859
860
868 HD_API
869 virtual HdExtComputationPrimvarDescriptorVector
870 GetExtComputationPrimvarDescriptors(SdfPath const& id,
871 HdInterpolation interpolationMode);
872
875 HD_API
876 virtual VtValue GetExtComputationInput(SdfPath const& computationId,
877 TfToken const& input);
878
886 HD_API
887 virtual size_t SampleExtComputationInput(SdfPath const& computationId,
888 TfToken const& input,
889 size_t maxSampleCount,
890 float *sampleTimes,
891 VtValue *sampleValues);
892
893 // An overload of SampleTransform that explicitly takes the startTime
894 // and endTime rather than relying on the scene delegate having state
895 // about what the source of the current shutter interval should be.
896 HD_API
897 virtual size_t SampleExtComputationInput(SdfPath const& computationId,
898 TfToken const& input,
899 float startTime,
900 float endTime,
901 size_t maxSampleCount,
902 float *sampleTimes,
903 VtValue *sampleValues);
904
909 template <unsigned int CAPACITY>
910 void SampleExtComputationInput(SdfPath const& computationId,
911 TfToken const& input,
912 HdTimeSampleArray<VtValue, CAPACITY> *sa);
913
918 template <unsigned int CAPACITY>
919 void SampleExtComputationInput(SdfPath const& computationId,
920 TfToken const& input,
921 float startTime,
922 float endTime,
923 HdTimeSampleArray<VtValue, CAPACITY> *sa);
924
928 HD_API
929 virtual std::string GetExtComputationKernel(SdfPath const& computationId);
930
941 HD_API
942 virtual void InvokeExtComputation(SdfPath const& computationId,
943 HdExtComputationContext *context);
944
945 // -----------------------------------------------------------------------//
947 // -----------------------------------------------------------------------//
948
950 HD_API
951 virtual HdPrimvarDescriptorVector
952 GetPrimvarDescriptors(SdfPath const& id, HdInterpolation interpolation);
953
954 // -----------------------------------------------------------------------//
956 // -----------------------------------------------------------------------//
957 HD_API
958 virtual TfTokenVector GetTaskRenderTags(SdfPath const& taskId);
959
960private:
961 HdRenderIndex *_index;
962 SdfPath _delegateID;
963
964 HdSceneDelegate() = delete;
965 HdSceneDelegate(HdSceneDelegate &) = delete;
966 HdSceneDelegate &operator=(HdSceneDelegate &) = delete;
967};
968
969template <unsigned int CAPACITY>
970void
971HdSceneDelegate::SampleTransform(SdfPath const & id,
972 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
973 size_t authoredSamples =
974 SampleTransform(id, CAPACITY, sa->times.data(), sa->values.data());
975 if (authoredSamples > CAPACITY) {
976 sa->Resize(authoredSamples);
977 size_t authoredSamplesSecondAttempt =
978 SampleTransform(
979 id,
980 authoredSamples,
981 sa->times.data(),
982 sa->values.data());
983 // Number of samples should be consisntent through multiple
984 // invokations of the sampling function.
985 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
986 }
987 sa->count = authoredSamples;
988}
989
990template <unsigned int CAPACITY>
991void
992HdSceneDelegate::SampleTransform(SdfPath const & id,
993 float startTime,
994 float endTime,
995 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
996 size_t authoredSamples =
997 SampleTransform(id, startTime, endTime, CAPACITY,
998 sa->times.data(), sa->values.data());
999 if (authoredSamples > CAPACITY) {
1000 sa->Resize(authoredSamples);
1001 size_t authoredSamplesSecondAttempt =
1002 SampleTransform(
1003 id,
1004 startTime,
1005 endTime,
1006 authoredSamples,
1007 sa->times.data(),
1008 sa->values.data());
1009 // Number of samples should be consisntent through multiple
1010 // invokations of the sampling function.
1011 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1012 }
1013 sa->count = authoredSamples;
1014}
1015
1016template <unsigned int CAPACITY>
1017void
1018HdSceneDelegate::SampleInstancerTransform(
1019 SdfPath const &instancerId,
1020 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
1021 size_t authoredSamples =
1022 SampleInstancerTransform(
1023 instancerId,
1024 CAPACITY,
1025 sa->times.data(),
1026 sa->values.data());
1027 if (authoredSamples > CAPACITY) {
1028 sa->Resize(authoredSamples);
1029 size_t authoredSamplesSecondAttempt =
1030 SampleInstancerTransform(
1031 instancerId,
1032 authoredSamples,
1033 sa->times.data(),
1034 sa->values.data());
1035 // Number of samples should be consisntent through multiple
1036 // invokations of the sampling function.
1037 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1038 }
1039 sa->count = authoredSamples;
1040}
1041
1042template <unsigned int CAPACITY>
1043void
1044HdSceneDelegate::SampleInstancerTransform(
1045 SdfPath const &instancerId,
1046 float startTime, float endTime,
1047 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
1048 size_t authoredSamples =
1049 SampleInstancerTransform(
1050 instancerId,
1051 startTime,
1052 endTime,
1053 CAPACITY,
1054 sa->times.data(),
1055 sa->values.data());
1056 if (authoredSamples > CAPACITY) {
1057 sa->Resize(authoredSamples);
1058 size_t authoredSamplesSecondAttempt =
1059 SampleInstancerTransform(
1060 instancerId,
1061 startTime,
1062 endTime,
1063 authoredSamples,
1064 sa->times.data(),
1065 sa->values.data());
1066 // Number of samples should be consisntent through multiple
1067 // invokations of the sampling function.
1068 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1069 }
1070 sa->count = authoredSamples;
1071}
1072
1073template <unsigned int CAPACITY>
1074void
1075HdSceneDelegate::SamplePrimvar(SdfPath const &id,
1076 TfToken const& key,
1077 HdTimeSampleArray<VtValue, CAPACITY> *sa) {
1078 size_t authoredSamples =
1079 SamplePrimvar(
1080 id,
1081 key,
1082 CAPACITY,
1083 sa->times.data(),
1084 sa->values.data());
1085 if (authoredSamples > CAPACITY) {
1086 sa->Resize(authoredSamples);
1087 size_t authoredSamplesSecondAttempt =
1088 SamplePrimvar(
1089 id,
1090 key,
1091 authoredSamples,
1092 sa->times.data(),
1093 sa->values.data());
1094 // Number of samples should be consistent through multiple
1095 // invocations of the sampling function.
1096 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1097 }
1098 sa->count = authoredSamples;
1099}
1100
1101template <unsigned int CAPACITY>
1102void
1103HdSceneDelegate::SamplePrimvar(SdfPath const &id,
1104 TfToken const& key,
1105 float startTime,
1106 float endTime,
1107 HdTimeSampleArray<VtValue, CAPACITY> *sa) {
1108 size_t authoredSamples =
1109 SamplePrimvar(
1110 id,
1111 key,
1112 startTime,
1113 endTime,
1114 CAPACITY,
1115 sa->times.data(),
1116 sa->values.data());
1117 if (authoredSamples > CAPACITY) {
1118 sa->Resize(authoredSamples);
1119 size_t authoredSamplesSecondAttempt =
1120 SamplePrimvar(
1121 id,
1122 key,
1123 startTime,
1124 endTime,
1125 authoredSamples,
1126 sa->times.data(),
1127 sa->values.data());
1128 // Number of samples should be consistent through multiple
1129 // invocations of the sampling function.
1130 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1131 }
1132 sa->count = authoredSamples;
1133}
1134
1135template <unsigned int CAPACITY>
1136void
1137HdSceneDelegate::SampleIndexedPrimvar(SdfPath const &id,
1138 TfToken const& key,
1139 HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa) {
1140 size_t authoredSamples =
1141 SampleIndexedPrimvar(
1142 id,
1143 key,
1144 CAPACITY,
1145 sa->times.data(),
1146 sa->values.data(),
1147 sa->indices.data());
1148 if (authoredSamples > CAPACITY) {
1149 sa->Resize(authoredSamples);
1150 size_t authoredSamplesSecondAttempt =
1151 SampleIndexedPrimvar(
1152 id,
1153 key,
1154 authoredSamples,
1155 sa->times.data(),
1156 sa->values.data(),
1157 sa->indices.data());
1158 // Number of samples should be consistent through multiple
1159 // invocations of the sampling function.
1160 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1161 }
1162 sa->count = authoredSamples;
1163}
1164
1165template <unsigned int CAPACITY>
1166void
1167HdSceneDelegate::SampleIndexedPrimvar(SdfPath const &id,
1168 TfToken const& key,
1169 float startTime,
1170 float endTime,
1171 HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa) {
1172 size_t authoredSamples =
1173 SampleIndexedPrimvar(
1174 id,
1175 key,
1176 startTime,
1177 endTime,
1178 CAPACITY,
1179 sa->times.data(),
1180 sa->values.data(),
1181 sa->indices.data());
1182 if (authoredSamples > CAPACITY) {
1183 sa->Resize(authoredSamples);
1184 size_t authoredSamplesSecondAttempt =
1185 SampleIndexedPrimvar(
1186 id,
1187 key,
1188 startTime,
1189 endTime,
1190 authoredSamples,
1191 sa->times.data(),
1192 sa->values.data(),
1193 sa->indices.data());
1194 // Number of samples should be consistent through multiple
1195 // invocations of the sampling function.
1196 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1197 }
1198 sa->count = authoredSamples;
1199}
1200
1201template <unsigned int CAPACITY>
1202void
1203HdSceneDelegate::SampleExtComputationInput(
1204 SdfPath const& computationId,
1205 TfToken const& input,
1206 HdTimeSampleArray<VtValue, CAPACITY> *sa) {
1207 size_t authoredSamples = SampleExtComputationInput(
1208 computationId, input, CAPACITY,
1209 sa->times.data(), sa->values.data());
1210
1211 if (authoredSamples > CAPACITY) {
1212 sa->Resize(authoredSamples);
1213 size_t authoredSamplesSecondAttempt = SampleExtComputationInput(
1214 computationId, input, authoredSamples,
1215 sa->times.data(), sa->values.data());
1216 // Number of samples should be consisntent through multiple
1217 // invokations of the sampling function.
1218 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1219 }
1220 sa->count = authoredSamples;
1221}
1222
1223template <unsigned int CAPACITY>
1224void
1225HdSceneDelegate::SampleExtComputationInput(
1226 SdfPath const& computationId,
1227 TfToken const& input,
1228 float startTime,
1229 float endTime,
1230 HdTimeSampleArray<VtValue, CAPACITY> *sa) {
1231 size_t authoredSamples = SampleExtComputationInput(
1232 computationId, input, startTime, endTime, CAPACITY,
1233 sa->times.data(), sa->values.data());
1234
1235 if (authoredSamples > CAPACITY) {
1236 sa->Resize(authoredSamples);
1237 size_t authoredSamplesSecondAttempt = SampleExtComputationInput(
1238 computationId, input, startTime, endTime, authoredSamples,
1239 sa->times.data(), sa->values.data());
1240 // Number of samples should be consisntent through multiple
1241 // invokations of the sampling function.
1242 TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
1243 }
1244 sa->count = authoredSamples;
1245}
1246
1247PXR_NAMESPACE_CLOSE_SCOPE
1248
1249#endif //PXR_IMAGING_HD_SCENE_DELEGATE_H
GfMatrix4d
Stores a 4x4 matrix of double elements.
Definition: matrix4d.h:71
GfRange3d
Basic type: 3-dimensional floating point range.
Definition: range3d.h:47
GfVec3f
Basic type for a vector of 3 float components.
Definition: vec3f.h:46
HdBasisCurvesTopology
Topology data for basisCurves.
Definition: basisCurvesTopology.h:59
HdExtComputationContext
Interface class that defines the execution environment for the client to run a computation.
Definition: extComputationContext.h:20
HdMeshTopology
Topology data for meshes.
Definition: meshTopology.h:38
HdRenderIndex
The Hydra render index is a flattened representation of the client scene graph, which may be composed...
Definition: renderIndex.h:104
HdReprSelector
Describes one or more authored display representations for an rprim.
Definition: repr.h:32
HdSceneDelegate
Adapter class providing data exchange with the client scene graph.
Definition: sceneDelegate.h:391
HdSceneDelegate::GetRenderBufferDescriptor
virtual HD_API HdRenderBufferDescriptor GetRenderBufferDescriptor(SdfPath const &id)
Returns the allocation descriptor for a given render buffer prim.
HdSceneDelegate::SampleIndexedPrimvar
virtual HD_API size_t SampleIndexedPrimvar(SdfPath const &id, TfToken const &key, size_t maxSampleCount, float *sampleTimes, VtValue *sampleValues, VtIntArray *sampleIndices)
SamplePrimvar() for getting an unflattened primvar and its indices.
HdSceneDelegate::GetRenderTag
virtual HD_API TfToken GetRenderTag(SdfPath const &id)
Returns the render tag that will be used to bucket prims during render pass bucketing.
HdSceneDelegate::SampleExtComputationInput
virtual HD_API size_t SampleExtComputationInput(SdfPath const &computationId, TfToken const &input, size_t maxSampleCount, float *sampleTimes, VtValue *sampleValues)
Return up to maxSampleCount samples for a given computation id and input token.
HdSceneDelegate::GetInstancerId
virtual HD_API SdfPath GetInstancerId(SdfPath const &primId)
Returns the parent instancer of the given rprim or instancer.
HdSceneDelegate::GetTransform
virtual HD_API GfMatrix4d GetTransform(SdfPath const &id)
Returns the object space transform, including all parent transforms.
HdSceneDelegate::GetExtComputationOutputDescriptors
virtual HD_API HdExtComputationOutputDescriptorVector GetExtComputationOutputDescriptors(SdfPath const &computationId)
For the given computation id, returns a list of computation output descriptors.
HdSceneDelegate::GetPrimvarDescriptors
virtual HD_API HdPrimvarDescriptorVector GetPrimvarDescriptors(SdfPath const &id, HdInterpolation interpolation)
Returns descriptors for all primvars of the given interpolation type.
HdSceneDelegate::GetDisplayStyle
virtual HD_API HdDisplayStyle GetDisplayStyle(SdfPath const &id)
Returns the refinement level for the given prim in the range [0,8].
HdSceneDelegate::GetShadingStyle
virtual HD_API VtValue GetShadingStyle(SdfPath const &id)
Returns the shading style for the given prim.
HdSceneDelegate::IsEnabled
virtual HD_API bool IsEnabled(TfToken const &option) const
Returns true if the named option is enabled by the delegate.
HdSceneDelegate::GetInstancerPrototypes
virtual HD_API SdfPathVector GetInstancerPrototypes(SdfPath const &instancerId)
Returns a list of prototypes of this instancer.
HdSceneDelegate::GetInstanceIndices
virtual HD_API VtIntArray GetInstanceIndices(SdfPath const &instancerId, SdfPath const &prototypeId)
Gets the extracted indices array of the prototype id used in the instancer.
HdSceneDelegate::GetCameraParamValue
virtual HD_API VtValue GetCameraParamValue(SdfPath const &cameraId, TfToken const &paramName)
Returns a single value for a given camera and parameter.
HdSceneDelegate::GetMaterialId
virtual HD_API SdfPath GetMaterialId(SdfPath const &rprimId)
Returns the material ID bound to the rprim rprimId.
HdSceneDelegate::GetExtent
virtual HD_API GfRange3d GetExtent(SdfPath const &id)
Gets the axis aligned bounds of a prim.
HdSceneDelegate::SamplePrimvar
virtual HD_API size_t SamplePrimvar(SdfPath const &id, TfToken const &key, size_t maxSampleCount, float *sampleTimes, VtValue *sampleValues)
Store up to maxSampleCount primvar samples in *samplesValues.
HdSceneDelegate::HdSceneDelegate
HD_API HdSceneDelegate(HdRenderIndex *parentIndex, SdfPath const &delegateID)
Constructor used for nested delegate objects which share a RenderIndex.
HdSceneDelegate::GetInstancerTransform
virtual HD_API GfMatrix4d GetInstancerTransform(SdfPath const &instancerId)
Returns the instancer transform.
HdSceneDelegate::GetExtComputationSceneInputNames
virtual HD_API TfTokenVector GetExtComputationSceneInputNames(SdfPath const &computationId)
For the given computation id, returns a list of inputs which will be requested from the scene delegat...
HdSceneDelegate::GetScenePrimPaths
virtual HD_API SdfPathVector GetScenePrimPaths(SdfPath const &rprimId, std::vector< int > instanceIndices, std::vector< HdInstancerContext > *instancerContexts=nullptr)
A vectorized version of GetScenePrimPath that allows the prim adapter to amortize expensive calculati...
HdSceneDelegate::PostSyncCleanup
virtual HD_API void PostSyncCleanup()
Opportunity for the delegate to clean itself up after performing parallel work during sync phase.
HdSceneDelegate::SampleTransform
virtual HD_API size_t SampleTransform(SdfPath const &id, size_t maxSampleCount, float *sampleTimes, GfMatrix4d *sampleValues)
Store up to maxSampleCount transform samples in *sampleValues.
HdSceneDelegate::GetExtComputationPrimvarDescriptors
virtual HD_API HdExtComputationPrimvarDescriptorVector GetExtComputationPrimvarDescriptors(SdfPath const &id, HdInterpolation interpolationMode)
Returns a list of primvar names that should be bound to a generated output from an ExtComputation for...
HdSceneDelegate::GetDelegateID
SdfPath const & GetDelegateID() const
Returns the ID of this delegate, which is used as a prefix for all objects it creates in the RenderIn...
Definition: sceneDelegate.h:408
HdSceneDelegate::GetDoubleSided
virtual HD_API bool GetDoubleSided(SdfPath const &id)
Returns the doubleSided state for the given prim.
HdSceneDelegate::GetCategories
virtual HD_API VtArray< TfToken > GetCategories(SdfPath const &id)
Returns the prim categories.
HdSceneDelegate::Sync
virtual HD_API void Sync(HdSyncRequestVector *request)
Synchronizes the delegate state for the given request vector.
HdSceneDelegate::GetCoordSysBindings
virtual HD_API HdIdVectorSharedPtr GetCoordSysBindings(SdfPath const &id)
Returns the coordinate system bindings, or a nullptr if none are bound.
HdSceneDelegate::GetExtComputationInput
virtual HD_API VtValue GetExtComputationInput(SdfPath const &computationId, TfToken const &input)
Returns a single value for a given computation id and input token.
HdSceneDelegate::SampleInstancerTransform
virtual HD_API size_t SampleInstancerTransform(SdfPath const &instancerId, size_t maxSampleCount, float *sampleTimes, GfMatrix4d *sampleValues)
Store up to maxSampleCount transform samples in *sampleValues.
HdSceneDelegate::GetRenderIndex
HdRenderIndex & GetRenderIndex()
Returns the RenderIndex owned by this delegate.
Definition: sceneDelegate.h:402
HdSceneDelegate::InvokeExtComputation
virtual HD_API void InvokeExtComputation(SdfPath const &computationId, HdExtComputationContext *context)
Requests the scene delegate run the ExtComputation with the given id.
HdSceneDelegate::GetScenePrimPath
virtual HD_API SdfPath GetScenePrimPath(SdfPath const &rprimId, int instanceIndex, HdInstancerContext *instancerContext=nullptr)
Returns the scene address of the prim corresponding to the given rprim/instance index.
HdSceneDelegate::Get
virtual HD_API VtValue Get(SdfPath const &id, TfToken const &key)
Returns a named value.
HdSceneDelegate::GetIndexedPrimvar
virtual HD_API VtValue GetIndexedPrimvar(SdfPath const &id, TfToken const &key, VtIntArray *outIndices)
Returns a named primvar value.
HdSceneDelegate::GetExtComputationInputDescriptors
virtual HD_API HdExtComputationInputDescriptorVector GetExtComputationInputDescriptors(SdfPath const &computationId)
For the given computation id, returns a list of computation input descriptors.
HdSceneDelegate::GetMeshTopology
virtual HD_API HdMeshTopology GetMeshTopology(SdfPath const &id)
Gets the topological mesh data for a given prim.
HdSceneDelegate::GetReprSelector
virtual HD_API HdReprSelector GetReprSelector(SdfPath const &id)
Returns the authored repr (if any) for the given prim.
HdSceneDelegate::GetSubdivTags
virtual HD_API PxOsdSubdivTags GetSubdivTags(SdfPath const &id)
Gets the subdivision surface tags (sharpness, holes, etc).
HdSceneDelegate::GetModelDrawMode
virtual HD_API HdModelDrawMode GetModelDrawMode(SdfPath const &id)
Returns the model draw mode object for the given prim.
HdSceneDelegate::GetBasisCurvesTopology
virtual HD_API HdBasisCurvesTopology GetBasisCurvesTopology(SdfPath const &id)
Gets the topological curve data for a given prim.
HdSceneDelegate::GetVisible
virtual HD_API bool GetVisible(SdfPath const &id)
Returns the authored visible state of the prim.
HdSceneDelegate::GetExtComputationKernel
virtual HD_API std::string GetExtComputationKernel(SdfPath const &computationId)
Returns the kernel source assigned to the computation at the path id.
HdSceneDelegate::GetInstanceCategories
virtual HD_API std::vector< VtArray< TfToken > > GetInstanceCategories(SdfPath const &instancerId)
Returns the categories for all instances in the instancer.
HdSceneDelegate::GetCullStyle
virtual HD_API HdCullStyle GetCullStyle(SdfPath const &id)
Returns the cullstyle for the given prim.
PxOsdSubdivTags
Tags for non-hierarchial subdiv surfaces.
Definition: subdivTags.h:26
SdfAssetPath
Contains an asset path and an optional resolved path.
Definition: assetPath.h:30
SdfPath
A path value used to locate objects in layers or scenegraphs.
Definition: path.h:274
TfSmallVector::data
value_type * data()
Direct access to the underlying array.
Definition: smallVector.h:733
TfToken
Token for efficient comparison, assignment, and hashing of known strings.
Definition: token.h:71
VtArray
Represents an arbitrary dimensional rectangular container class.
Definition: array.h:211
VtValue
Provides a container which may hold any type, and provides introspection and iteration over array typ...
Definition: value.h:147
TF_CODING_ERROR
#define TF_CODING_ERROR(fmt, args)
Issue an internal programming error, but continue execution.
Definition: diagnostic.h:68
TF_VERIFY
#define TF_VERIFY(cond, format,...)
Checks a condition and reports an error if it evaluates false.
Definition: diagnostic.h:266
std
STL namespace.
HdDisplayStyle
Describes how the geometry of a prim should be displayed.
Definition: sceneDelegate.h:64
HdDisplayStyle::flatShadingEnabled
bool flatShadingEnabled
Is the prim flat shaded.
Definition: sceneDelegate.h:69
HdDisplayStyle::displacementEnabled
bool displacementEnabled
Is the prim displacement shaded.
Definition: sceneDelegate.h:72
HdDisplayStyle::pointsShadingEnabled
bool pointsShadingEnabled
Should the prim's points get shaded like surfaces, as opposed to constant shaded?
Definition: sceneDelegate.h:80
HdDisplayStyle::HdDisplayStyle
HdDisplayStyle()
Creates a default DisplayStyle.
Definition: sceneDelegate.h:92
HdDisplayStyle::materialIsFinal
bool materialIsFinal
Is this prim exempt from having its material disabled or overridden, for example, when a renderer cho...
Definition: sceneDelegate.h:84
HdDisplayStyle::HdDisplayStyle
HdDisplayStyle(int refineLevel_, bool flatShading=false, bool displacement=true, bool occludedSelectionShowsThrough_=false, bool pointsShadingEnabled_=false, bool materialIsFinal_=false)
Creates a DisplayStyle.
Definition: sceneDelegate.h:113
HdDisplayStyle::refineLevel
int refineLevel
The prim refine level, in the range [0, 8].
Definition: sceneDelegate.h:66
HdDisplayStyle::occludedSelectionShowsThrough
bool occludedSelectionShowsThrough
Does the prim act "transparent" to allow occluded selection to show through?
Definition: sceneDelegate.h:76
HdExtComputationInputDescriptor
Describes an input to an ExtComputation that takes data from the output of another ExtComputation.
Definition: sceneDelegate.h:310
HdExtComputationOutputDescriptor
Describes an output of an ExtComputation.
Definition: sceneDelegate.h:343
HdExtComputationPrimvarDescriptor
Extends HdPrimvarDescriptor to describe a primvar that takes data from the output of an ExtComputatio...
Definition: sceneDelegate.h:270
HdIndexedTimeSampleArray
An array of a value and its indices sampled over time, in struct-of-arrays layout.
Definition: timeSampleArray.h:218
HdIndexedTimeSampleArray::Resize
void Resize(unsigned int newSize) override
Resize the internal buffers.
Definition: timeSampleArray.h:238
HdModelDrawMode
Describes optional alternative imaging behavior for prims.
Definition: sceneDelegate.h:200
HdPrimvarDescriptor
Describes a primvar.
Definition: sceneDelegate.h:153
HdPrimvarDescriptor::indexed
bool indexed
Optional bool, true if primvar is indexed.
Definition: sceneDelegate.h:164
HdPrimvarDescriptor::interpolation
HdInterpolation interpolation
Interpolation (data-sampling rate) of the primvar.
Definition: sceneDelegate.h:157
HdPrimvarDescriptor::role
TfToken role
Optional "role" indicating a desired interpretation – for example, to distinguish color/vector/point/...
Definition: sceneDelegate.h:161
HdPrimvarDescriptor::name
TfToken name
Name of the primvar.
Definition: sceneDelegate.h:155
HdRenderBufferDescriptor
Describes the allocation structure of a render buffer bprim.
Definition: aov.h:67
HdSyncRequestVector
The SceneDelegate is requested to synchronize prims as the result of executing a specific render pass...
Definition: sceneDelegate.h:52
HdTimeSampleArray
An array of a value sampled over time, in struct-of-arrays layout.
Definition: timeSampleArray.h:156
HdTimeSampleArray::Resize
virtual void Resize(unsigned int newSize)
Resize the internal buffers.
Definition: timeSampleArray.h:177
HdTupleType
HdTupleType represents zero, one, or more values of the same HdType.
Definition: types.h:341
HdVolumeFieldDescriptor
Description of a single field related to a volume primitive.
Definition: sceneDelegate.h:370
TfTokenVector
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:440