sceneDelegate.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HD_SCENE_DELEGATE_H
#define PXR_IMAGING_HD_SCENE_DELEGATE_H

#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/version.h"

#include "pxr/imaging/hd/aov.h"
#include "pxr/imaging/hd/basisCurvesTopology.h"
#include "pxr/imaging/hd/enums.h"
#include "pxr/imaging/hd/meshTopology.h"
#include "pxr/imaging/hd/renderIndex.h"
#include "pxr/imaging/hd/repr.h"
#include "pxr/imaging/hd/timeSampleArray.h"

#include "pxr/imaging/pxOsd/subdivTags.h"

#include "pxr/base/vt/array.h"
#include "pxr/base/vt/dictionary.h"
#include "pxr/base/vt/value.h"
#include "pxr/usd/sdf/assetPath.h"
#include "pxr/usd/sdf/path.h"

#include "pxr/base/gf/vec2i.h"
#include "pxr/base/tf/hash.h"

#include <memory>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class HdExtComputationContext;

typedef std::shared_ptr<SdfPathVector> HdIdVectorSharedPtr;

typedef std::vector<std::pair<SdfPath, int>> HdInstancerContext;

struct HdSyncRequestVector {
    // The Prims to synchronize in this request.
    SdfPathVector IDs;

    // The HdChangeTracker::DirtyBits that are set for each Prim.
    std::vector<HdDirtyBits> dirtyBits;
};

struct HdDisplayStyle {
    int refineLevel;
    
    bool flatShadingEnabled;
    
    bool displacementEnabled;

    bool displayInOverlay;

    bool occludedSelectionShowsThrough;

    bool pointsShadingEnabled;

    bool materialIsFinal;
    
    HdDisplayStyle()
        : refineLevel(0)
        , flatShadingEnabled(false)
        , displacementEnabled(true)
        , displayInOverlay(false)
        , occludedSelectionShowsThrough(false)
        , pointsShadingEnabled(false)
        , materialIsFinal(false)
    { }
    
    HdDisplayStyle(int refineLevel_,
                   bool flatShading = false,
                   bool displacement = true,
                   bool displayInOverlay_ = false,
                   bool occludedSelectionShowsThrough_ = false,
                   bool pointsShadingEnabled_ = false,
                   bool materialIsFinal_ = false)
        : refineLevel(std::max(0, refineLevel_))
        , flatShadingEnabled(flatShading)
        , displacementEnabled(displacement)
        , displayInOverlay(displayInOverlay_)
        , occludedSelectionShowsThrough(occludedSelectionShowsThrough_)
        , pointsShadingEnabled(pointsShadingEnabled_)
        , materialIsFinal(materialIsFinal_)
    {
        if (refineLevel_ < 0) {
            TF_CODING_ERROR("negative refine level is not supported");
        } else if (refineLevel_ > 8) {
            TF_CODING_ERROR("refine level > 8 is not supported");
        }
    }
    
    HdDisplayStyle(HdDisplayStyle const& rhs) = default;
    ~HdDisplayStyle() = default;
    
    bool operator==(HdDisplayStyle const& rhs) const {
        return refineLevel == rhs.refineLevel
            && flatShadingEnabled == rhs.flatShadingEnabled
            && displacementEnabled == rhs.displacementEnabled
            && displayInOverlay == rhs.displayInOverlay
            && occludedSelectionShowsThrough ==
                rhs.occludedSelectionShowsThrough
            && pointsShadingEnabled == rhs.pointsShadingEnabled
            && materialIsFinal == rhs.materialIsFinal;
    }
    bool operator!=(HdDisplayStyle const& rhs) const {
        return !(*this == rhs);
    }
};

struct HdPrimvarDescriptor {
    TfToken name;
    HdInterpolation interpolation;
    TfToken role;
    bool indexed;
    int elementSize;

    HdPrimvarDescriptor()
    : interpolation(HdInterpolationConstant)
    , role(HdPrimvarRoleTokens->none)
    , indexed(false)
    , elementSize(1)
    {}
    HdPrimvarDescriptor(TfToken const& name_,
                        HdInterpolation interp_,
                        TfToken const& role_=HdPrimvarRoleTokens->none,
                        bool indexed_=false, int elementSize_=1)
        : name(name_), interpolation(interp_), role(role_), indexed(indexed_),
          elementSize(elementSize_)
    { }
    bool operator==(HdPrimvarDescriptor const& rhs) const {
        return name == rhs.name && role == rhs.role
            && interpolation == rhs.interpolation
            && elementSize == rhs.elementSize;
    }
    bool operator!=(HdPrimvarDescriptor const& rhs) const {
        return !(*this == rhs);
    }
};

typedef std::vector<HdPrimvarDescriptor> HdPrimvarDescriptorVector;

struct HdModelDrawMode {
    // Alternate imaging mode. Options are origin, bounds, cards, default, and 
    // inherited.
    TfToken drawMode;
    // Specifies whether to apply the alternative imaging mode or not.
    bool applyDrawMode;
    // The color in which to draw the geometry.
    GfVec3f drawModeColor;
    // The specific geometry to use in cards mode. Options are cross, box, and 
    // fromTexture. 
    TfToken cardGeometry;
    // The textures applied to the respective quads in cards mode.
    SdfAssetPath cardTextureXPos;
    SdfAssetPath cardTextureYPos;
    SdfAssetPath cardTextureZPos;
    SdfAssetPath cardTextureXNeg;
    SdfAssetPath cardTextureYNeg;
    SdfAssetPath cardTextureZNeg;

    HdModelDrawMode()
    : drawMode(HdModelDrawModeTokens->inherited)
    , applyDrawMode(false)
    , drawModeColor(GfVec3f(0.18))
    , cardGeometry(HdModelDrawModeTokens->cross)
    {}

    HdModelDrawMode(
        TfToken const& drawMode_,
        bool applyDrawMode_=false,
        GfVec3f drawModeColor_=GfVec3f(0.18),
        TfToken const& cardGeometry_=HdModelDrawModeTokens->cross,
        SdfAssetPath cardTextureXPos_=SdfAssetPath(),
        SdfAssetPath cardTextureYPos_=SdfAssetPath(),
        SdfAssetPath cardTextureZPos_=SdfAssetPath(),
        SdfAssetPath cardTextureXNeg_=SdfAssetPath(),
        SdfAssetPath cardTextureYNeg_=SdfAssetPath(),
        SdfAssetPath cardTextureZNeg_=SdfAssetPath())
        : drawMode(drawMode_), applyDrawMode(applyDrawMode_),
          drawModeColor(drawModeColor_), cardGeometry(cardGeometry_),
          cardTextureXPos(cardTextureXPos_), cardTextureYPos(cardTextureYPos_),
          cardTextureZPos(cardTextureZPos_), cardTextureXNeg(cardTextureXNeg_),
          cardTextureYNeg(cardTextureYNeg_), cardTextureZNeg(cardTextureZNeg_)
    {}

    bool operator==(HdModelDrawMode const& rhs) const {
        return drawMode == rhs.drawMode && 
               applyDrawMode == rhs.applyDrawMode &&
               drawModeColor == rhs.drawModeColor &&
               cardGeometry == rhs.cardGeometry &&
               cardTextureXPos == rhs.cardTextureXPos &&
               cardTextureYPos == rhs.cardTextureYPos &&
               cardTextureZPos == rhs.cardTextureZPos &&
               cardTextureXNeg == rhs.cardTextureXNeg &&
               cardTextureYNeg == rhs.cardTextureYNeg &&
               cardTextureZNeg == rhs.cardTextureZNeg;
    }
    bool operator!=(HdModelDrawMode const& rhs) const {
        return !(*this == rhs);
    }
};

struct HdExtComputationPrimvarDescriptor : public HdPrimvarDescriptor {
    SdfPath sourceComputationId;
    TfToken sourceComputationOutputName;
    HdTupleType valueType;

    HdExtComputationPrimvarDescriptor() {}
    HdExtComputationPrimvarDescriptor(
        TfToken const& name_,
        HdInterpolation interp_,
        TfToken const & role_,
        SdfPath const & sourceComputationId_,
        TfToken const & sourceComputationOutputName_,
        HdTupleType const & valueType_)
        : HdPrimvarDescriptor(name_, interp_, role_, false)
        , sourceComputationId(sourceComputationId_)
        , sourceComputationOutputName(sourceComputationOutputName_)
        , valueType(valueType_)
    { }
    bool operator==(HdExtComputationPrimvarDescriptor const& rhs) const {
        return HdPrimvarDescriptor::operator==(rhs) &&
            sourceComputationId == rhs.sourceComputationId &&
            sourceComputationOutputName == rhs.sourceComputationOutputName &&
            valueType == rhs.valueType;
    }
    bool operator!=(HdExtComputationPrimvarDescriptor const& rhs) const {
        return !(*this == rhs);
    }
};

typedef std::vector<HdExtComputationPrimvarDescriptor>
        HdExtComputationPrimvarDescriptorVector;

struct HdExtComputationInputDescriptor {
    TfToken name;
    SdfPath sourceComputationId;
    TfToken sourceComputationOutputName;

    HdExtComputationInputDescriptor() {}
    HdExtComputationInputDescriptor(
        TfToken const & name_,
        SdfPath const & sourceComputationId_,
        TfToken const & sourceComputationOutputName_)
    : name(name_), sourceComputationId(sourceComputationId_)
    , sourceComputationOutputName(sourceComputationOutputName_)
    { }

    bool operator==(HdExtComputationInputDescriptor const& rhs) const {
        return name == rhs.name &&
               sourceComputationId == rhs.sourceComputationId &&
               sourceComputationOutputName == rhs.sourceComputationOutputName;
    }
    bool operator!=(HdExtComputationInputDescriptor const& rhs) const {
        return !(*this == rhs);
    }
};

typedef std::vector<HdExtComputationInputDescriptor>
        HdExtComputationInputDescriptorVector;

struct HdExtComputationOutputDescriptor {
    TfToken name;
    HdTupleType valueType;

    HdExtComputationOutputDescriptor() {}
    HdExtComputationOutputDescriptor(
        TfToken const & name_,
        HdTupleType const & valueType_)
    : name(name_), valueType(valueType_)
    { }

    bool operator==(HdExtComputationOutputDescriptor const& rhs) const {
        return name == rhs.name &&
               valueType == rhs.valueType;
    }
    bool operator!=(HdExtComputationOutputDescriptor const& rhs) const {
        return !(*this == rhs);
    }
};

typedef std::vector<HdExtComputationOutputDescriptor>
        HdExtComputationOutputDescriptorVector;

struct HdVolumeFieldDescriptor {
    TfToken fieldName;
    TfToken fieldPrimType;
    SdfPath fieldId;

    HdVolumeFieldDescriptor() {}
    HdVolumeFieldDescriptor(
        TfToken const & fieldName_,
        TfToken const & fieldPrimType_,
        SdfPath const & fieldId_)
    : fieldName(fieldName_), fieldPrimType(fieldPrimType_), fieldId(fieldId_)
    { }
};

typedef std::vector<HdVolumeFieldDescriptor>
        HdVolumeFieldDescriptorVector;

class HdSceneDelegate {
public:
    HD_API
    HdSceneDelegate(HdRenderIndex *parentIndex,
                    SdfPath const& delegateID);

    HD_API
    virtual ~HdSceneDelegate();

    HdRenderIndex& GetRenderIndex() { return *_index; }

    SdfPath const& GetDelegateID() const { return _delegateID; }

    HD_API
    virtual void Sync(HdSyncRequestVector* request);

    HD_API
    virtual void PostSyncCleanup();

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual bool IsEnabled(TfToken const& option) const;


    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual HdMeshTopology GetMeshTopology(SdfPath const& id);

    HD_API
    virtual HdBasisCurvesTopology GetBasisCurvesTopology(SdfPath const& id);

    HD_API
    virtual PxOsdSubdivTags GetSubdivTags(SdfPath const& id);


    HD_API
    virtual GfRange3d GetExtent(SdfPath const & id);

    HD_API
    virtual GfMatrix4d GetTransform(SdfPath const & id);

    HD_API
    virtual bool GetVisible(SdfPath const & id);

    HD_API
    virtual bool GetDoubleSided(SdfPath const & id);

    HD_API
    virtual HdCullStyle GetCullStyle(SdfPath const &id);

    HD_API
    virtual VtValue GetShadingStyle(SdfPath const &id);

    HD_API
    virtual HdDisplayStyle GetDisplayStyle(SdfPath const& id);

    HD_API
    virtual VtValue Get(SdfPath const& id, TfToken const& key);

    HD_API
    virtual VtValue GetIndexedPrimvar(SdfPath const& id, 
                                      TfToken const& key, 
                                      VtIntArray *outIndices);

    HD_API
    virtual HdReprSelector GetReprSelector(SdfPath const &id);

    HD_API
    virtual TfToken GetRenderTag(SdfPath const& id);

    HD_API
    virtual VtArray<TfToken> GetCategories(SdfPath const& id);

    HD_API
    virtual std::vector<VtArray<TfToken>>
    GetInstanceCategories(SdfPath const &instancerId);

    HD_API
    virtual HdIdVectorSharedPtr GetCoordSysBindings(SdfPath const& id);

    HD_API
    virtual HdModelDrawMode GetModelDrawMode(SdfPath const& id);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual size_t
    SampleTransform(SdfPath const & id, 
                    size_t maxSampleCount,
                    float *sampleTimes, 
                    GfMatrix4d *sampleValues);

    HD_API
    virtual size_t
    SampleTransform(SdfPath const & id,
                    float startTime,
                    float endTime,
                    size_t maxSampleCount,
                    float *sampleTimes,
                    GfMatrix4d *sampleValues);

    template <unsigned int CAPACITY>
    void
    SampleTransform(SdfPath const & id,
                    HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);

    template <unsigned int CAPACITY>
    void
    SampleTransform(SdfPath const & id,
                    float startTime,
                    float endTime,
                    HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);

    HD_API
    virtual size_t
    SampleInstancerTransform(SdfPath const &instancerId,
                             size_t maxSampleCount, 
                             float *sampleTimes,
                             GfMatrix4d *sampleValues);

    HD_API
    virtual size_t
    SampleInstancerTransform(SdfPath const &instancerId,
                             float startTime,
                             float endTime,
                             size_t maxSampleCount, 
                             float *sampleTimes,
                             GfMatrix4d *sampleValues);

    template <unsigned int CAPACITY>
    void
    SampleInstancerTransform(SdfPath const &instancerId,
                             HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);

    template <unsigned int CAPACITY>
    void
    SampleInstancerTransform(SdfPath const &instancerId,
                             float startTime, float endTime,
                             HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa);

    HD_API
    virtual size_t
    SamplePrimvar(SdfPath const& id, 
                  TfToken const& key,
                  size_t maxSampleCount, 
                  float *sampleTimes, 
                  VtValue *sampleValues);

    HD_API
    virtual size_t
    SamplePrimvar(SdfPath const& id, 
                  TfToken const& key,
                  float startTime,
                  float endTime,
                  size_t maxSampleCount, 
                  float *sampleTimes, 
                  VtValue *sampleValues);

    template <unsigned int CAPACITY>
    void 
    SamplePrimvar(SdfPath const &id, 
                  TfToken const& key,
                  HdTimeSampleArray<VtValue, CAPACITY> *sa);

    template <unsigned int CAPACITY>
    void 
    SamplePrimvar(SdfPath const &id, 
                  TfToken const& key,
                  float startTime,
                  float endTime,
                  HdTimeSampleArray<VtValue, CAPACITY> *sa);

    HD_API
    virtual size_t
    SampleIndexedPrimvar(SdfPath const& id, 
                         TfToken const& key,
                         size_t maxSampleCount, 
                         float *sampleTimes, 
                         VtValue *sampleValues,
                         VtIntArray *sampleIndices);

    HD_API
    virtual size_t
    SampleIndexedPrimvar(SdfPath const& id, 
                         TfToken const& key,
                         float startTime,
                         float endTime,
                         size_t maxSampleCount, 
                         float *sampleTimes, 
                         VtValue *sampleValues,
                         VtIntArray *sampleIndices);

    template <unsigned int CAPACITY>
    void 
    SampleIndexedPrimvar(SdfPath const &id, 
                         TfToken const& key,
                         HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa);

    template <unsigned int CAPACITY>
    void 
    SampleIndexedPrimvar(SdfPath const &id, 
                         TfToken const& key,
                         float startTime,
                         float endTime,
                         HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual VtIntArray GetInstanceIndices(SdfPath const &instancerId,
                                          SdfPath const &prototypeId);

    HD_API
    virtual GfMatrix4d GetInstancerTransform(SdfPath const &instancerId);

    HD_API
    virtual SdfPath GetInstancerId(SdfPath const& primId);

    HD_API
    virtual SdfPathVector GetInstancerPrototypes(SdfPath const& instancerId);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual SdfPath GetScenePrimPath(SdfPath const& rprimId,
                                     int instanceIndex,
                                     HdInstancerContext *instancerContext = nullptr);

    HD_API
    virtual SdfPathVector GetScenePrimPaths(SdfPath const& rprimId,
                                     std::vector<int> instanceIndices,
                                     std::vector<HdInstancerContext> *instancerContexts = nullptr);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//
    
    HD_API
    virtual SdfPath GetMaterialId(SdfPath const &rprimId);

    // Returns a material resource which contains the information 
    // needed to create a material.
    HD_API 
    virtual VtValue GetMaterialResource(SdfPath const &materialId);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual HdRenderBufferDescriptor GetRenderBufferDescriptor(SdfPath const& id);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    // Returns a single value for a given light and parameter.
    HD_API
    virtual VtValue GetLightParamValue(SdfPath const &id, 
                                       TfToken const &paramName);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual VtValue GetCameraParamValue(SdfPath const& cameraId,
                                        TfToken const& paramName);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    // Returns a single value for a given volume and parameter.
    HD_API
    virtual VtValue GetVolumeParamValue(SdfPath const &id, 
                                        TfToken const &paramName);

    HD_API
    virtual HdVolumeFieldDescriptorVector
    GetVolumeFieldDescriptors(SdfPath const &volumeId);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual TfTokenVector
    GetExtComputationSceneInputNames(SdfPath const& computationId);

    HD_API
    virtual HdExtComputationInputDescriptorVector
    GetExtComputationInputDescriptors(SdfPath const& computationId);

    HD_API
    virtual HdExtComputationOutputDescriptorVector
    GetExtComputationOutputDescriptors(SdfPath const& computationId);


    HD_API
    virtual HdExtComputationPrimvarDescriptorVector
    GetExtComputationPrimvarDescriptors(SdfPath const& id,
                                        HdInterpolation interpolationMode);

    HD_API
    virtual VtValue GetExtComputationInput(SdfPath const& computationId,
                                           TfToken const& input);

    HD_API
    virtual size_t SampleExtComputationInput(SdfPath const& computationId,
                                             TfToken const& input,
                                             size_t maxSampleCount,
                                             float *sampleTimes,
                                             VtValue *sampleValues);

    // An overload of SampleTransform that explicitly takes the startTime
    // and endTime rather than relying on the scene delegate having state
    // about what the source of the current shutter interval should be.
    HD_API
    virtual size_t SampleExtComputationInput(SdfPath const& computationId,
                                             TfToken const& input,
                                             float startTime,
                                             float endTime,
                                             size_t maxSampleCount,
                                             float *sampleTimes,
                                             VtValue *sampleValues);

    template <unsigned int CAPACITY>
    void SampleExtComputationInput(SdfPath const& computationId,
                                   TfToken const& input,
                                   HdTimeSampleArray<VtValue, CAPACITY> *sa);

    template <unsigned int CAPACITY>
    void SampleExtComputationInput(SdfPath const& computationId,
                                   TfToken const& input,
                                   float startTime,
                                   float endTime,
                                   HdTimeSampleArray<VtValue, CAPACITY> *sa);

    HD_API
    virtual std::string GetExtComputationKernel(SdfPath const& computationId);

    HD_API
    virtual void InvokeExtComputation(SdfPath const& computationId,
                                      HdExtComputationContext *context);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//

    HD_API
    virtual HdPrimvarDescriptorVector
    GetPrimvarDescriptors(SdfPath const& id, HdInterpolation interpolation);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//
    HD_API
    virtual TfTokenVector GetTaskRenderTags(SdfPath const& taskId);

    // -----------------------------------------------------------------------//
    // -----------------------------------------------------------------------//
    HD_API
    virtual int32_t GetPrimId(SdfPath const &id);

private:
    HdRenderIndex *_index;
    SdfPath _delegateID;

    HdSceneDelegate() = delete;
    HdSceneDelegate(HdSceneDelegate &) =  delete;
    HdSceneDelegate &operator=(HdSceneDelegate &) =  delete;
};

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SampleTransform(SdfPath const & id,
                                 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleTransform(id, CAPACITY, sa->times.data(), sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleTransform(
                id, 
                authoredSamples, 
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SampleTransform(SdfPath const & id,
                                 float startTime,
                                 float endTime,
                                 HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleTransform(id, startTime, endTime, CAPACITY,
                        sa->times.data(), sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleTransform(
                id, 
                startTime,
                endTime,
                authoredSamples,
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void
HdSceneDelegate::SampleInstancerTransform(
        SdfPath const &instancerId,
        HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleInstancerTransform(
            instancerId, 
            CAPACITY, 
            sa->times.data(), 
            sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleInstancerTransform(
                instancerId, 
                authoredSamples, 
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void
HdSceneDelegate::SampleInstancerTransform(
        SdfPath const &instancerId,
        float startTime, float endTime,
        HdTimeSampleArray<GfMatrix4d, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleInstancerTransform(
            instancerId,
            startTime,
            endTime,
            CAPACITY, 
            sa->times.data(), 
            sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleInstancerTransform(
                instancerId,
                startTime,
                endTime,
                authoredSamples, 
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SamplePrimvar(SdfPath const &id, 
                               TfToken const& key,
                               HdTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = 
        SamplePrimvar(
            id, 
            key,
            CAPACITY, 
            sa->times.data(), 
            sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SamplePrimvar(
                id, 
                key,
                authoredSamples, 
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consistent through multiple
        // invocations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SamplePrimvar(SdfPath const &id, 
                               TfToken const& key,
                               float startTime,
                               float endTime,
                               HdTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = 
        SamplePrimvar(
            id, 
            key,
            startTime,
            endTime,
            CAPACITY, 
            sa->times.data(), 
            sa->values.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SamplePrimvar(
                id, 
                key,
                startTime,
                endTime,
                authoredSamples, 
                sa->times.data(), 
                sa->values.data());
        // Number of samples should be consistent through multiple
        // invocations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SampleIndexedPrimvar(SdfPath const &id,
                         TfToken const& key,
                         HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleIndexedPrimvar(
            id, 
            key,
            CAPACITY, 
            sa->times.data(), 
            sa->values.data(),
            sa->indices.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleIndexedPrimvar(
                id, 
                key,
                authoredSamples, 
                sa->times.data(), 
                sa->values.data(),
                sa->indices.data());
        // Number of samples should be consistent through multiple
        // invocations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void 
HdSceneDelegate::SampleIndexedPrimvar(SdfPath const &id,
                         TfToken const& key,
                         float startTime,
                         float endTime,
                         HdIndexedTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = 
        SampleIndexedPrimvar(
            id, 
            key,
            startTime,
            endTime,
            CAPACITY, 
            sa->times.data(), 
            sa->values.data(),
            sa->indices.data());
    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = 
            SampleIndexedPrimvar(
                id, 
                key,
                startTime,
                endTime,
                authoredSamples, 
                sa->times.data(), 
                sa->values.data(),
                sa->indices.data());
        // Number of samples should be consistent through multiple
        // invocations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void
HdSceneDelegate::SampleExtComputationInput(
        SdfPath const& computationId,
        TfToken const& input,
        HdTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = SampleExtComputationInput(
        computationId, input, CAPACITY,
        sa->times.data(), sa->values.data());

    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = SampleExtComputationInput(
            computationId, input, authoredSamples,
            sa->times.data(), sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

template <unsigned int CAPACITY>
void
HdSceneDelegate::SampleExtComputationInput(
        SdfPath const& computationId,
        TfToken const& input,
        float startTime,
        float endTime,
        HdTimeSampleArray<VtValue, CAPACITY> *sa) {
    size_t authoredSamples = SampleExtComputationInput(
        computationId, input, startTime, endTime, CAPACITY,
        sa->times.data(), sa->values.data());

    if (authoredSamples > CAPACITY) {
        sa->Resize(authoredSamples);
        size_t authoredSamplesSecondAttempt = SampleExtComputationInput(
            computationId, input, startTime, endTime, authoredSamples,
            sa->times.data(), sa->values.data());
        // Number of samples should be consisntent through multiple
        // invokations of the sampling function.
        TF_VERIFY(authoredSamples == authoredSamplesSecondAttempt);
    }
    sa->count = authoredSamples;
}

PXR_NAMESPACE_CLOSE_SCOPE

#endif //PXR_IMAGING_HD_SCENE_DELEGATE_H