dataSourceResolvedSkeletonPrim.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_SKELETON_PRIM_H
#define PXR_USD_IMAGING_USD_SKEL_IMAGING_DATA_SOURCE_RESOLVED_SKELETON_PRIM_H
 
#include "pxr/imaging/hd/sceneIndex.h"
 
#include "pxr/usdImaging/usdSkelImaging/animationSchema.h"
#include "pxr/usdImaging/usdSkelImaging/dataSourceUtils.h"
#include "pxr/usdImaging/usdSkelImaging/skeletonSchema.h"
#include "pxr/usdImaging/usdSkelImaging/xformResolver.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct UsdSkelImagingSkelData;
struct UsdSkelImagingSkelGuideData;
 
class UsdSkelImagingDataSourceResolvedSkeletonPrim
    : public HdContainerDataSource
    , public std::enable_shared_from_this<
                        UsdSkelImagingDataSourceResolvedSkeletonPrim>
{
public:
    HD_DECLARE_DATASOURCE(UsdSkelImagingDataSourceResolvedSkeletonPrim);
 
    USDSKELIMAGING_API
    ~UsdSkelImagingDataSourceResolvedSkeletonPrim();
 
    USDSKELIMAGING_API
    TfTokenVector GetNames() override;
 
    USDSKELIMAGING_API
    HdDataSourceBaseHandle Get(const TfToken &name) override;
 
    const SdfPath &GetAnimationSource() const {
        return _animationSource;
    }
 
    const VtArray<SdfPath> &GetInstanceAnimationSources() const {
        return _instanceAnimationSources;
    }
 
    const VtArray<SdfPath> &GetInstancerPaths() const {
        return _xformResolver.GetInstancerPaths();
    }
 
    const UsdSkelImagingAnimationSchema &GetAnimationSchema() const {
        return _animationSchema;
    }
 
    const VtArray<UsdSkelImagingAnimationSchema> 
        &GetInstanceAnimationSchemas() const {
        return _instanceAnimationSchemas;
    }
 
    // TODO:
    // Maybe consider removing or making the direct access APIs (
    // GetAnimationXXX()/GetInstanceAnimationXXX()) private?
    const VtArray<SdfPath> GetResolvedAnimationSources() const;
    const VtArray<UsdSkelImagingAnimationSchema>
        GetResolvedAnimationSchemas() const;
 
    HdMatrixDataSourceHandle GetSkelLocalToCommonSpace() const;
 
    HdMatrix4fArrayDataSourceHandle GetSkinningTransforms();
 
    HdTokenArrayDataSourceHandle GetBlendShapes() const;
 
    HdFloatArrayDataSourceHandle GetBlendShapeWeights() const;
 
    HdVec2iArrayDataSourceHandle GetBlendShapeRanges() const;
 
    std::shared_ptr<UsdSkelImagingSkelData> GetSkelData() {
        return _skelDataCache.Get();
    }
 
    std::shared_ptr<UsdSkelImagingSkelGuideData> GetSkelGuideData() {
        return _skelGuideDataCache.Get();
    }
 
    static const HdDataSourceLocatorSet &
    GetDependendendOnDataSourceLocators();
 
    USDSKELIMAGING_API
    bool ProcessDirtyLocators(
        const TfToken &dirtiedPrimType,
        const HdDataSourceLocatorSet &dirtyLocators,
        HdSceneIndexObserver::DirtiedPrimEntries * entries);
 
private:
    USDSKELIMAGING_API
    UsdSkelImagingDataSourceResolvedSkeletonPrim(
        HdSceneIndexBaseRefPtr const &sceneIndex,
        const SdfPath &primPath,
        HdContainerDataSourceHandle const &primSource);
 
    bool _ShouldResolveInstanceAnimation() const;
 
    bool _ProcessSkeletonDirtyLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * newDirtyLocators);
 
    bool _ProcessSkelAnimationDirtyLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * newDirtyLocators);
 
    bool _ProcessInstancerDirtyLocators(
        const HdDataSourceLocatorSet &dirtyLocators,
        HdDataSourceLocatorSet * newDirtyLocators);
 
    // Path to this skeleton prim.
    const SdfPath _primPath;
    // Input data source for this skeleton prim.
    HdContainerDataSourceHandle const _primSource;
    // Path of skel animation prim.
    const SdfPath _animationSource;
    // Animation schema from the above skel animation prim.
    const UsdSkelImagingAnimationSchema _animationSchema;
 
    class _SkelDataCache
        : public UsdSkelImagingSharedPtrThunk<UsdSkelImagingSkelData>
    {
    public:
        _SkelDataCache(HdSceneIndexBaseRefPtr const &sceneIndex,
                       const SdfPath &primPath);
    protected:
        Handle _Compute() override;
    private:
        HdSceneIndexBaseRefPtr const _sceneIndex;
        const SdfPath _primPath;
    };
    _SkelDataCache _skelDataCache;
 
    class _SkelGuideDataCache
        : public UsdSkelImagingSharedPtrThunk<UsdSkelImagingSkelGuideData>
    {
    public:
        _SkelGuideDataCache(
            UsdSkelImagingDataSourceResolvedSkeletonPrim * resolvedSkeleton);
    protected:
        Handle _Compute() override;
    private:
        UsdSkelImagingDataSourceResolvedSkeletonPrim * const _resolvedSkeleton;
    };
    _SkelGuideDataCache _skelGuideDataCache;
 
    // Converts rest transforms to VtArray<GfMatrix4f>.
    //
    // Note that rest transforms is only needed if there is no animation or the
    // animation is not sparse. Thus, this data source lazily reads it from the
    // skeleton schema.
    //
    class _RestTransformsDataSource;
    std::shared_ptr<_RestTransformsDataSource> const _restTransformsDataSource;
 
    // Serves GetSkelLocalToWorld - taking instancing into account.
    UsdSkelImagingDataSourceXformResolver _xformResolver;
 
    // Paths of skel animation prims bound to the instancer.
    // They came in as skel:animationSource primvar on the instancer.
    const VtArray<SdfPath> _instanceAnimationSources;
    // Animation schema from the above skel animation prims.
    const VtArray<UsdSkelImagingAnimationSchema> _instanceAnimationSchemas;
};
 
HD_DECLARE_DATASOURCE_HANDLES(UsdSkelImagingDataSourceResolvedSkeletonPrim);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif