layerStack.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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 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 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;
 
    bool _isUsd;
};
 
PCP_API
std::ostream& operator<<(std::ostream&, const PcpLayerStackPtr&);
PCP_API
std::ostream& operator<<(std::ostream&, const PcpLayerStackRefPtr&);
 
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);
 
PCP_API
bool
PcpIsTimeScalingForLayerTimeCodesPerSecondDisabled();
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_LAYER_STACK_H