layerStack.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_PCP_LAYER_STACK_H
#define PXR_USD_PCP_LAYER_STACK_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/errors.h"
#include "pxr/usd/pcp/layerStackIdentifier.h"
#include "pxr/usd/pcp/mapExpression.h"
#include "pxr/usd/sdf/layerTree.h"
#include "pxr/base/tf/declarePtrs.h"
 
#include <tbb/spin_mutex.h>
#include <iosfwd>
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
TF_DECLARE_REF_PTRS(SdfLayer);
TF_DECLARE_WEAK_AND_REF_PTRS(PcpLayerStack);
TF_DECLARE_WEAK_AND_REF_PTRS(Pcp_LayerStackRegistry);
 
class ArResolverContext;
class Pcp_LayerStackRegistry;
class Pcp_MutedLayers;
class PcpExpressionVariables;
class PcpLayerStackChanges;
class PcpLifeboat;
class SdfSchemaBase;
 
class PcpLayerStack : public TfRefBase, public TfWeakBase {
    PcpLayerStack(const PcpLayerStack&) = delete;
    PcpLayerStack& operator=(const PcpLayerStack&) = delete;
 
public:
    // See Pcp_LayerStackRegistry for creating layer stacks.
    PCP_API
    virtual ~PcpLayerStack();
 
    PCP_API
    const PcpLayerStackIdentifier& GetIdentifier() const;
 
    bool IsUsd() const {
        return _isUsd;
    };
 
    PCP_API
    const SdfLayerRefPtrVector& GetLayers() const;
 
    PCP_API
    SdfLayerHandleVector GetSessionLayers() const;
 
    PCP_API
    const SdfLayerTreeHandle& GetLayerTree() const;
 
    PCP_API
    const SdfLayerTreeHandle& GetSessionLayerTree() const;
 
    PCP_API
    const SdfLayerOffset* GetLayerOffsetForLayer(const SdfLayerHandle&) const;
 
    PCP_API
    const SdfLayerOffset* GetLayerOffsetForLayer(const SdfLayerRefPtr&) const;
    
    PCP_API
    const SdfLayerOffset* GetLayerOffsetForLayer(size_t layerIdx) const;
 
    PCP_API
    const SdfSchemaBase* GetSchemaForAllLayers() const;
 
    PCP_API
    const std::set<std::string>& GetMutedLayers() const;
 
    PcpErrorVector GetLocalErrors() const {
        return _localErrors ? *_localErrors.get() : PcpErrorVector();
    }
 
    PCP_API
    bool HasLayer(const SdfLayerHandle& layer) const;
    PCP_API
    bool HasLayer(const SdfLayerRefPtr& layer) const;
 
    const PcpExpressionVariables& GetExpressionVariables() const
    { return *_expressionVariables; }
 
    const std::unordered_set<std::string>&
    GetExpressionVariableDependencies() const 
    { return _expressionVariableDependencies; }
 
    double GetTimeCodesPerSecond() const { return _timeCodesPerSecond; }
 
    PCP_API
    const SdfRelocatesMap& GetRelocatesSourceToTarget() const;
 
    PCP_API
    const SdfRelocatesMap& GetRelocatesTargetToSource() const;
 
    PCP_API
    const SdfRelocatesMap& GetIncrementalRelocatesSourceToTarget() const;
 
    PCP_API
    const SdfRelocatesMap& GetIncrementalRelocatesTargetToSource() const;
 
    PCP_API
    const SdfPathVector& GetPathsToPrimsWithRelocates() const;
 
    PCP_API
    void Apply(const PcpLayerStackChanges& changes, PcpLifeboat* lifeboat);
 
    PCP_API
    PcpMapExpression GetExpressionForRelocatesAtPath(const SdfPath &path);
 
    PCP_API
    bool HasRelocates() const;
 
private:
    // Only a registry can create a layer stack.
    friend class Pcp_LayerStackRegistry;
    // PcpCache needs access to check the _registry.
    friend class PcpCache;
    // Needs access to _sublayerSourceInfo
    friend bool Pcp_NeedToRecomputeDueToAssetPathChange(const PcpLayerStackPtr&);
 
    // Construct a layer stack for the given \p identifier that will be
    // installed into \p registry. This installation is managed by
    // \p registry and does not occur within the c'tor. See comments on
    // _registry for more details.
    PcpLayerStack(const PcpLayerStackIdentifier &identifier,
                  const Pcp_LayerStackRegistry &registry);
 
    void _BlowLayers();
    void _BlowRelocations();
    void _Compute(const std::string &fileFormatTarget,
                  const Pcp_MutedLayers &mutedLayers);
 
    SdfLayerTreeHandle _BuildLayerStack(
        const SdfLayerHandle & layer,
        const SdfLayerOffset & offset,
        double layerTcps,
        const ArResolverContext & pathResolverContext,
        const SdfLayer::FileFormatArguments & layerArgs,
        const std::string & sessionOwner,
        const Pcp_MutedLayers & mutedLayers,
        SdfLayerHandleSet *seenLayers,
        PcpErrorVector *errors);
 
private:
    const PcpLayerStackIdentifier _identifier;
 
    Pcp_LayerStackRegistryPtr _registry;
 
 
    SdfLayerRefPtrVector _layers;
 
    std::vector<PcpMapFunction> _mapFunctions;
 
    double _timeCodesPerSecond;
 
    SdfLayerTreeHandle _layerTree;
 
    SdfLayerTreeHandle _sessionLayerTree;
 
    struct _SublayerSourceInfo {
        _SublayerSourceInfo() = default;
        _SublayerSourceInfo(
            const SdfLayerHandle& layer_,
            const std::string& authoredSublayerPath_,
            const std::string& computedSublayerPath_)
        : layer(layer_)
        , authoredSublayerPath(authoredSublayerPath_)
        , computedSublayerPath(computedSublayerPath_) { }
 
        SdfLayerHandle layer;
        std::string authoredSublayerPath;
        std::string computedSublayerPath;
    };
 
    std::vector<_SublayerSourceInfo> _sublayerSourceInfo;
 
    std::set<std::string> _mutedAssetPaths;
 
    std::unique_ptr<PcpErrorVector> _localErrors;
 
    SdfRelocatesMap _relocatesSourceToTarget;
    SdfRelocatesMap _relocatesTargetToSource;
    SdfRelocatesMap _incrementalRelocatesSourceToTarget;
    SdfRelocatesMap _incrementalRelocatesTargetToSource;
 
    typedef std::map<SdfPath, PcpMapExpression::VariableUniquePtr,
            SdfPath::FastLessThan> _RelocatesVarMap;
    _RelocatesVarMap _relocatesVariables;
    tbb::spin_mutex _relocatesVariablesMutex;
 
    SdfPathVector _relocatesPrimPaths;
 
    std::shared_ptr<PcpExpressionVariables> _expressionVariables;
 
    std::unordered_set<std::string> _expressionVariableDependencies;
 
    const SdfSchemaBase* _schemaForAllLayers;
 
    bool _isUsd;
};
 
PCP_API
std::ostream& operator<<(std::ostream&, const PcpLayerStackPtr&);
PCP_API
std::ostream& operator<<(std::ostream&, const PcpLayerStackRefPtr&);
 
bool
Pcp_IsValidRelocatesEntry(
    const SdfPath &source, const SdfPath &target, std::string *errorMessage);
 
void
Pcp_BuildRelocateMap(
    const std::vector<std::pair<SdfLayerHandle, SdfRelocates>> &layerRelocates,
    SdfRelocatesMap *relocatesMap,
    PcpErrorVector *errors);
 
void
Pcp_ComputeRelocationsForLayerStack(
    const PcpLayerStack &layerStack,
    SdfRelocatesMap *relocatesSourceToTarget,
    SdfRelocatesMap *relocatesTargetToSource,
    SdfRelocatesMap *incrementalRelocatesSourceToTarget,
    SdfRelocatesMap *incrementalRelocatesTargetToSource,
    SdfPathVector *relocatesPrimPaths,
    PcpErrorVector *errors);
 
// Returns true if \p layerStack should be recomputed due to changes to
// any computed asset paths that were used to find or open layers
// when originally composing \p layerStack. 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 PcpLayerStackPtr& layerStack);
 
// Returns true if the \p layerStack should be recomputed because 
// \p changedLayer has had changes that would cause the layer stack to have
// a different computed overall time codes per second value.
bool
Pcp_NeedToRecomputeLayerStackTimeCodesPerSecond(
    const PcpLayerStackPtr& layerStack, const SdfLayerHandle &changedLayer);
 
bool PcpIsSessionOwnerSublayerReorderingEnabled();
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_LAYER_STACK_H