primTypeIndex.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_PRIM_TYPE_INDEX_H
#define PXR_IMAGING_HD_PRIM_TYPE_INDEX_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hd/types.h"
#include "pxr/imaging/hd/sortedIds.h"
#include "pxr/base/tf/token.h"
#include "pxr/usd/sdf/path.h"
 
#include <set>
#include <vector>
#include <unordered_map>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class HdChangeTracker;
class HdRenderDelegate;
class HdRenderParam;
class HdSceneDelegate;
class SdfPath;
using HdSceneDelegatePtrVector = std::vector<HdSceneDelegate*>;
 
template <class PrimType>
class Hd_PrimTypeIndex {
public:
    Hd_PrimTypeIndex();
    ~Hd_PrimTypeIndex();
 
    void InitPrimTypes(const TfTokenVector &primTypes);
 
    void Clear(HdChangeTracker &tracker, HdRenderDelegate *renderDelegate);
 
    void InsertPrim(const TfToken &typeId,
                    HdSceneDelegate *sceneDelegate,
                    const SdfPath &primId,
                    HdChangeTracker &tracker,
                    HdRenderDelegate *renderDelegate);
 
    void RemovePrim(const TfToken &typeId,
                    const SdfPath &primId,
                    HdChangeTracker &tracker,
                    HdRenderDelegate *renderDelegate);
 
    void RemoveSubtree(const SdfPath &root,
                       HdSceneDelegate* sceneDelegate,
                       HdChangeTracker &tracker,
                       HdRenderDelegate *renderDelegate);
 
    PrimType *GetPrim(const TfToken &typeId,
                      const SdfPath &primId) const;
 
    PrimType *GetFallbackPrim(TfToken const &typeId) const;
 
    void GetPrimSubtree(const TfToken &typeId,
                        const SdfPath &rootPath,
                        SdfPathVector *outPaths);
 
    bool CreateFallbackPrims(HdRenderDelegate *renderDelegate);
 
    void DestroyFallbackPrims(HdRenderDelegate *renderDelegate);
 
    void SyncPrims(HdChangeTracker &tracker,
                   HdRenderParam *renderParam,
                   HdRenderDelegate *renderDelegate);
    
   const HdSceneDelegatePtrVector& GetSceneDelegatesForDirtyPrims();
 
private:
    struct _PrimInfo {
        HdSceneDelegate *sceneDelegate;
        PrimType        *prim;
    };
 
    typedef std::unordered_map<SdfPath, _PrimInfo, SdfPath::Hash> _PrimMap;
 
    struct _PrimTypeEntry
   {
        _PrimMap         primMap;
        Hd_SortedIds     primIds;   // Primarily for sub-tree searching
        PrimType        *fallbackPrim;
 
        _PrimTypeEntry()
         : primMap()
         , primIds()
         , fallbackPrim(nullptr)
        {
        }
    };
 
    typedef std::unordered_map<TfToken, size_t, TfToken::HashFunctor> _TypeIndex;
 
    typedef std::vector<_PrimTypeEntry> _PrimTypeList;
 
    _PrimTypeList _entries;
    _TypeIndex    _index;
    HdSceneDelegatePtrVector _dirtyPrimDelegates;
    TfTokenVector _primTypeNames;
 
 
    // Template methods that are expected to be specialized on PrimType.
    // These are to handle prim type specific function names on called objects.
    static void _TrackerInsertPrim(HdChangeTracker &tracker,
                                   const SdfPath &path,
                                   HdDirtyBits initialDirtyState);
 
    static void _TrackerRemovePrim(HdChangeTracker &tracker,
                                   const SdfPath &path);
 
    static HdDirtyBits _TrackerGetPrimDirtyBits(HdChangeTracker &tracker,
                                                const SdfPath &path);
 
    static void _TrackerMarkPrimClean(HdChangeTracker &tracker,
                                      const SdfPath &path,
                                      HdDirtyBits dirtyBits);
 
    static PrimType *_RenderDelegateCreatePrim(HdRenderDelegate *renderDelegate,
                                               const TfToken &typeId,
                                               const SdfPath &primId);
    static PrimType *_RenderDelegateCreateFallbackPrim(
            HdRenderDelegate *renderDelegate,
            const TfToken &typeId);
 
    static void _RenderDelegateDestroyPrim(HdRenderDelegate *renderDelegate,
                                           PrimType *prim);
 
    // No copying
    Hd_PrimTypeIndex(const Hd_PrimTypeIndex &) = delete;
    Hd_PrimTypeIndex &operator =(const Hd_PrimTypeIndex &) = delete;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HD_PRIM_TYPE_INDEX_H