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/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 HdPrimvarsSchema &GetPrimvars() const { return _primvars; }
 
    const UsdSkelImagingResolvedSkeletonSchema &GetResolvedSkeletonSchema() {
        return _resolvedSkeletonSchema;
    }
 
    USDSKELIMAGING_API
    HdMatrixDataSourceHandle GetPrimWorldToLocal() const;
 
    USDSKELIMAGING_API
    std::shared_ptr<UsdSkelImagingBlendShapeData> GetBlendShapeData();
 
    USDSKELIMAGING_API
    std::shared_ptr<UsdSkelImagingJointInfluencesData> GetJointInfluencesData();
 
    const TfToken &GetSkinningMethod() const {
        return _skinningMethod;
    }
 
    bool HasExtComputations() const {
        return
            // Points are only posed if we bind a Skeleton prim (and the
            // UsdSkelImagingSkeletonResolvingSceneIndex has populated the
            // resolved skeleton schema).
            _resolvedSkeletonSchema &&
            // Do not use ext computation if this prim was the Skeleton itself.
            // For the Skeleton prim itself, the
            // UsdSkelImagingSkeletonResolvingSceneIndex has populated the
            // points primvar already (with the points for the mesh guide)
            // and changed the prim type to mesh.
            _primPath != _skeletonPath &&
            // We only skin prims if they are under a SkelRoot.
            //
            // Note that when we bake the points of a skinned prim, we also
            // change the SkelRoot to a different prim type (such as Scope
            // or Xform) so that the baked points are not skinned again.
            _hasSkelRoot;
    }
 
    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);
 
    bool
    _ProcessDirtySkeletonLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * dirtyLocatorsForAggregatorComputation,
        HdDataSourceLocatorSet * dirtyLocatorsForComputation);
 
    bool
    _ProcessDirtySkelBlendShapeLocators(
        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;
};
 
HD_DECLARE_DATASOURCE_HANDLES(UsdSkelImagingDataSourceResolvedPointsBasedPrim);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif