primIndex.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_PCP_PRIM_INDEX_H
#define PXR_USD_PCP_PRIM_INDEX_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/composeSite.h"
#include "pxr/usd/pcp/dependency.h"
#include "pxr/usd/pcp/dynamicFileFormatDependencyData.h"
#include "pxr/usd/pcp/expressionVariablesDependencyData.h"
#include "pxr/usd/pcp/errors.h"
#include "pxr/usd/pcp/iterator.h"
#include "pxr/usd/pcp/node.h"
#include "pxr/usd/pcp/types.h"
#include "pxr/usd/sdf/declareHandles.h"
#include "pxr/usd/sdf/site.h"
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/tf/hashmap.h"
#include "pxr/base/tf/hashset.h"
 
#include <tbb/spin_rw_mutex.h>
 
#include <functional>
#include <map>
#include <memory>
#include <unordered_set>
 
PXR_NAMESPACE_OPEN_SCOPE
 
SDF_DECLARE_HANDLES(SdfLayer);
SDF_DECLARE_HANDLES(SdfPrimSpec);
 
TF_DECLARE_REF_PTRS(PcpLayerStack);
TF_DECLARE_WEAK_AND_REF_PTRS(PcpPrimIndex_Graph);
 
class ArResolver;
class PcpCache;
class PcpPrimIndex;
class PcpPrimIndexInputs;
class PcpPrimIndexOutputs;
class SdfPath;
 
class PcpPrimIndex
{
public:
    PCP_API
    PcpPrimIndex();
 
    PCP_API
    PcpPrimIndex(const PcpPrimIndex& rhs);
 
    PcpPrimIndex(PcpPrimIndex &&rhs) noexcept = default;
 
    PcpPrimIndex &operator=(const PcpPrimIndex &rhs) {
        PcpPrimIndex(rhs).Swap(*this);
        return *this;
    }
 
    // Move-assignment.
    PcpPrimIndex &operator=(PcpPrimIndex &&rhs) noexcept = default;
 
    PCP_API
    void Swap(PcpPrimIndex& rhs);
 
    inline void swap(PcpPrimIndex &rhs) { Swap(rhs); }
 
    bool IsValid() const { return bool(_graph); }
 
    void SetGraph(const PcpPrimIndex_GraphRefPtr& graph) {
        _graph = graph;
    }
 
    PcpNodeRef AddChildPrimIndex(
        const PcpArc &arcToParent, 
        PcpPrimIndex &&childPrimIndex,
        PcpErrorBasePtr *error);
 
    const PcpPrimIndex_GraphRefPtr &GetGraph() const {
        return _graph;
    }
 
    PCP_API
    PcpNodeRef GetRootNode() const;
 
    PCP_API
    const SdfPath& GetPath() const;
 
    PCP_API
    bool HasSpecs() const;
 
    PCP_API
    bool HasAnyPayloads() const;
 
    PCP_API
    bool IsUsd() const;
 
    PCP_API
    bool IsInstanceable() const;
 
 
    PCP_API
    PcpNodeRange GetNodeRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
 
    PCP_API
    PcpNodeIterator GetNodeIteratorAtNode(const PcpNodeRef &node) const;
 
    PCP_API
    PcpNodeRange GetNodeSubtreeRange(const PcpNodeRef &node) const;
 
    PCP_API
    PcpPrimRange GetPrimRange(PcpRangeType rangeType = PcpRangeTypeAll) const;
 
    PCP_API
    PcpPrimRange GetPrimRangeForNode(const PcpNodeRef& node) const;
 
 
 
    PCP_API
    PcpNodeRef GetNodeProvidingSpec(const SdfPrimSpecHandle& primSpec) const;
 
    PCP_API
    PcpNodeRef GetNodeProvidingSpec(
        const SdfLayerHandle& layer, const SdfPath& path) const;
 
 
 
    PcpErrorVector GetLocalErrors() const {
        return _localErrors ? *_localErrors.get() : PcpErrorVector();
    }
 
    PCP_API
    void PrintStatistics() const;
 
    PCP_API
    std::string DumpToString(
        bool includeInheritOriginInfo = true,
        bool includeMaps = true) const;
 
    PCP_API
    void DumpToDotGraph(
        const std::string& filename,
        bool includeInheritOriginInfo = true,
        bool includeMaps = false) const;
 
 
 
 
    PCP_API
    void ComputePrimChildNames(TfTokenVector *nameOrder,
                               PcpTokenSet *prohibitedNameSet) const;
 
    PCP_API
    void ComputePrimPropertyNames(TfTokenVector *nameOrder) const;
 
    PCP_API
    SdfVariantSelectionMap ComposeAuthoredVariantSelections() const;
 
    PCP_API
    std::string GetSelectionAppliedForVariantSet(
        const std::string &variantSet) const;
 
 
private:
    friend class PcpPrimIterator;
    friend struct Pcp_PrimIndexer;
    friend void Pcp_RescanForSpecs(PcpPrimIndex*, bool usd,
                                   bool updateHasSpecs);
 
    // The node graph representing the compositional structure of this prim.
    PcpPrimIndex_GraphRefPtr _graph;
 
    // The prim stack.  This is just a derived structure representing
    // a cached strong-to-weak traversal of the graph collecting specs.
    Pcp_CompressedSdSiteVector _primStack;
 
    // List of errors local to this prim, encountered during computation.
    // NULL if no errors were found (the expected common case).
    std::unique_ptr<PcpErrorVector> _localErrors;
};
 
inline void swap(PcpPrimIndex &l, PcpPrimIndex &r) { l.swap(r); }
 
class PcpPrimIndexOutputs 
{
public:
    enum PayloadState { NoPayload,
                        IncludedByIncludeSet, ExcludedByIncludeSet,
                        IncludedByPredicate, ExcludedByPredicate };
 
    PcpPrimIndex primIndex;
 
    PcpErrorVector allErrors;
 
    PayloadState payloadState = NoPayload;
    
    PcpDynamicFileFormatDependencyData dynamicFileFormatDependency;
 
    PcpExpressionVariablesDependencyData expressionVariablesDependency;
 
    std::vector<PcpCulledDependency> culledDependencies;
 
    PcpNodeRef Append(PcpPrimIndexOutputs&& childOutputs,
                      const PcpArc& arcToParent,
                      PcpErrorBasePtr *error);
};
 
class PcpPrimIndexInputs {
public:
    PcpPrimIndexInputs() 
        : cache(nullptr)
        , variantFallbacks(nullptr)
        , includedPayloads(nullptr)
        , includedPayloadsMutex(nullptr)
        , parentIndex(nullptr)
        , cull(true)
        , usd(false) 
    { }
 
    bool IsEquivalentTo(const PcpPrimIndexInputs& params) const;
 
    PcpPrimIndexInputs& Cache(PcpCache* cache_)
    { cache = cache_; return *this; }
 
    PcpPrimIndexInputs& VariantFallbacks(const PcpVariantFallbackMap* map)
    { variantFallbacks = map; return *this; }
 
    using PayloadSet = std::unordered_set<SdfPath, SdfPath::Hash>;
    PcpPrimIndexInputs& IncludedPayloads(const PayloadSet* payloadSet)
    { includedPayloads = payloadSet; return *this; }
 
    PcpPrimIndexInputs &IncludedPayloadsMutex(tbb::spin_rw_mutex *mutex)
    { includedPayloadsMutex = mutex; return *this; }
 
    PcpPrimIndexInputs &IncludePayloadPredicate(
        std::function<bool (const SdfPath &)> predicate)
    { includePayloadPredicate = predicate; return *this; }
    
    PcpPrimIndexInputs& Cull(bool doCulling = true)
    { cull = doCulling; return *this; }
 
    PcpPrimIndexInputs& USD(bool doUSD = true)
    { usd = doUSD; return *this; }
 
    PcpPrimIndexInputs& FileFormatTarget(const std::string& target)
    { fileFormatTarget = target; return *this; }
 
// private:
    PcpCache* cache;
    const PcpVariantFallbackMap* variantFallbacks;
    const PayloadSet* includedPayloads;
    tbb::spin_rw_mutex *includedPayloadsMutex;
    std::function<bool (const SdfPath &)> includePayloadPredicate;
    const PcpPrimIndex *parentIndex;
    std::string fileFormatTarget;
    bool cull;
    bool usd;
};
 
PCP_API
void
PcpComputePrimIndex(
    const SdfPath& primPath,
    const PcpLayerStackPtr& layerStack,
    const PcpPrimIndexInputs& inputs,
    PcpPrimIndexOutputs* outputs,
    ArResolver* pathResolver = NULL);
 
PCP_API
bool
PcpIsNewDefaultStandinBehaviorEnabled();
 
// Sets the prim stack in \p index.
void
Pcp_RescanForSpecs(PcpPrimIndex* index, bool usd);
 
// Returns true if \p index should be recomputed due to changes to
// any computed asset paths that were used to find or open layers
// when originally composing \p index. This may be due to scene
// description changes or external changes to asset resolution that
// may affect the computation of those asset paths.
bool
Pcp_NeedToRecomputeDueToAssetPathChange(const PcpPrimIndex& index);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_PRIM_INDEX_H