dataSourceResolvedPointsBasedPrim.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_IMAGING_USD_SKEL_IMAGING_DATA_SOURCE_RESOLVED_POINTS_BASED_PRIM_H
#define PXR_USD_IMAGING_USD_SKEL_IMAGING_DATA_SOURCE_RESOLVED_POINTS_BASED_PRIM_H
 
#include "pxr/usdImaging/usdSkelImaging/api.h"
#include "pxr/usdImaging/usdSkelImaging/dataSourceUtils.h"
#include "pxr/usdImaging/usdSkelImaging/resolvedSkeletonSchema.h"
#include "pxr/usdImaging/usdSkelImaging/xformResolver.h"
 
#include "pxr/imaging/hd/primvarsSchema.h"
#include "pxr/imaging/hd/sceneIndexObserver.h"
 
#include "pxr/base/tf/declarePtrs.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct UsdSkelImagingBlendShapeData;
struct UsdSkelImagingJointInfluencesData;
TF_DECLARE_REF_PTRS(HdSceneIndexBase);
 
class UsdSkelImagingDataSourceResolvedPointsBasedPrim
    : public HdContainerDataSource
    , public std::enable_shared_from_this<
                        UsdSkelImagingDataSourceResolvedPointsBasedPrim>
{
public:
    HD_DECLARE_DATASOURCE(UsdSkelImagingDataSourceResolvedPointsBasedPrim);
 
    USDSKELIMAGING_API
    static
    Handle New(
        HdSceneIndexBaseRefPtr const &sceneIndex,
        SdfPath primPath,
        HdContainerDataSourceHandle primSource);
 
    USDSKELIMAGING_API
    ~UsdSkelImagingDataSourceResolvedPointsBasedPrim();
 
    USDSKELIMAGING_API
    TfTokenVector GetNames() override;
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle Get(const TfToken &name) override;
 
    const SdfPath &GetPrimPath() const { return _primPath; }
 
    const SdfPath &GetSkeletonPath() const { return _skeletonPath; }
 
    const VtArray<SdfPath> &GetBlendShapeTargetPaths() const {
        return _blendShapeTargetPaths;
    }
 
    const VtArray<SdfPath> &GetInstancerPaths() const {
        return _xformResolver.GetInstancerPaths();
    }
    
    const HdPrimvarsSchema &GetPrimvars() const { return _primvars; }
 
    const UsdSkelImagingResolvedSkeletonSchema &GetResolvedSkeletonSchema() {
        return _resolvedSkeletonSchema;
    }
 
    USDSKELIMAGING_API
    HdMatrix4fArrayDataSourceHandle GetSkinningTransforms();
 
    USDSKELIMAGING_API
    HdMatrix3fArrayDataSourceHandle GetSkinningScaleTransforms();
 
    USDSKELIMAGING_API
    HdVec4fArrayDataSourceHandle GetSkinningDualQuats();
 
    USDSKELIMAGING_API
    HdFloatArrayDataSourceHandle GetBlendShapeWeights();
 
    USDSKELIMAGING_API
    HdMatrixDataSourceHandle GetCommonSpaceToPrimLocal() const;
 
    USDSKELIMAGING_API
    HdSampledDataSourceHandle GetPoints();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetGeomBindTransform();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetHasConstantInfluences();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetNumInfluencesPerComponent();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetInfluences();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetBlendShapeOffsets();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetBlendShapeOffsetRanges();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetNumBlendShapeOffsetRanges();
 
    USDSKELIMAGING_API
    HdSampledDataSourceHandle GetNormals();
 
    USDSKELIMAGING_API
    HdSampledDataSourceHandle GetFaceVertexIndices();
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle GetHasFaceVaryingNormals();
 
    USDSKELIMAGING_API
    std::shared_ptr<UsdSkelImagingBlendShapeData> GetBlendShapeData();
 
    USDSKELIMAGING_API
    std::shared_ptr<UsdSkelImagingJointInfluencesData> GetJointInfluencesData();
 
    const TfToken &GetSkinningMethod() const {
        return _skinningMethod;
    }
 
    bool HasExtComputations() const;
 
    USDSKELIMAGING_API
    static const HdDataSourceLocatorSet &
    GetDependendendOnDataSourceLocators();
 
    USDSKELIMAGING_API
    bool ProcessDirtyLocators(
        const TfToken &dirtiedPrimType,
        const HdDataSourceLocatorSet &dirtyLocators,
        HdSceneIndexObserver::DirtiedPrimEntries * entries);
 
private:
    USDSKELIMAGING_API
    UsdSkelImagingDataSourceResolvedPointsBasedPrim(
        HdSceneIndexBaseRefPtr const &sceneIndex,
        SdfPath primPath,
        HdContainerDataSourceHandle primSource,
        bool hasSkelRoot,
        VtArray<SdfPath> blendShapeTargetPaths,
        SdfPath skelPath,
        HdContainerDataSourceHandle skeletonPrimSource,
        UsdSkelImagingResolvedSkeletonSchema resolvedSkeletonSchema);
 
    bool
    _ProcessDirtyLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * dirtyLocatorsForAggregatorComputation,
        HdDataSourceLocatorSet * dirtyLocatorsForComputation,
        TfTokenVector * dirtyPrimvars);
 
    bool
    _ProcessDirtySkeletonLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * dirtyLocatorsForAggregatorComputation,
        HdDataSourceLocatorSet * dirtyLocatorsForComputation,
        TfTokenVector * dirtyPrimvars);
 
    bool
    _ProcessDirtySkelBlendShapeLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * dirtyLocatorsForAggregatorComputation,
        HdDataSourceLocatorSet * dirtyLocatorsForComputation,
        TfTokenVector * dirtyPrimvars);
 
    bool
    _ProcessDirtyInstancerLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * dirtyLocatorsForAggregatorComputation,
        HdDataSourceLocatorSet * dirtyLocatorsForComputation);
    
    // Input scene.
    HdSceneIndexBaseRefPtr const _sceneIndex;
    // Path of prim in the input scene.
    const SdfPath _primPath;
    // Data source for _primPath from input scene _sceneIndex.
    HdContainerDataSourceHandle const _primSource;
    const bool _hasSkelRoot;
    // From prim at _primPath in input scene _sceneIndex.
    HdPrimvarsSchema const _primvars;
    const TfToken _skinningMethod;
    VtArray<SdfPath> _blendShapeTargetPaths;
    const SdfPath _skeletonPath;
    HdContainerDataSourceHandle const _skeletonPrimSource;
    const UsdSkelImagingResolvedSkeletonSchema _resolvedSkeletonSchema;
 
    class _BlendShapeDataCache
        : public UsdSkelImagingSharedPtrThunk<UsdSkelImagingBlendShapeData>
    {
    public:
        _BlendShapeDataCache(
            HdSceneIndexBaseRefPtr const &sceneIndex,
            const SdfPath &primPath);
    protected:
        Handle _Compute() override;
    private:
        HdSceneIndexBaseRefPtr const _sceneIndex;
        const SdfPath _primPath;
    };
    _BlendShapeDataCache _blendShapeDataCache;
 
    class _JointInfluencesDataCache
        : public UsdSkelImagingSharedPtrThunk<UsdSkelImagingJointInfluencesData>
    {
    public:
        _JointInfluencesDataCache(
            HdContainerDataSourceHandle const &primSource,
            HdContainerDataSourceHandle const &skeletonPrimSource);
    protected:
        Handle _Compute() override;
    private:
        HdContainerDataSourceHandle const _primSource;
        HdContainerDataSourceHandle const _skeletonPrimSource;
    };
    _JointInfluencesDataCache _jointInfluencesDataCache;
 
    // Serves GetPrimWorldToLocal - taking instancing into account.
    UsdSkelImagingDataSourceXformResolver _xformResolver;
};
 
HD_DECLARE_DATASOURCE_HANDLES(UsdSkelImagingDataSourceResolvedPointsBasedPrim);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif