types.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_TYPES_H
#define PXR_USD_PCP_TYPES_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/site.h"
#include "pxr/usd/sdf/layer.h"
#include "pxr/base/tf/pxrTslRobinMap/robin_set.h"
 
#include <limits>
#include <vector>
 
 
PXR_NAMESPACE_OPEN_SCOPE
 
enum PcpArcType {
    // The root arc is a special value used for the root node of 
    // the prim index. Unlike the following arcs, it has no parent node.
    PcpArcTypeRoot,
    
    // The following arcs are listed in strength order.
    PcpArcTypeInherit,
    PcpArcTypeVariant,
    PcpArcTypeRelocate,
    PcpArcTypeReference,
    PcpArcTypePayload,
    PcpArcTypeSpecialize,
    
    PcpNumArcTypes
};
 
enum PcpRangeType {
    // Range including just the root node.
    PcpRangeTypeRoot,
 
    // Ranges including child arcs, from the root node, of the specified type 
    // as well as all descendants of those arcs.
    PcpRangeTypeInherit,
    PcpRangeTypeVariant,
    PcpRangeTypeReference,
    PcpRangeTypePayload,
    PcpRangeTypeSpecialize,
 
    // Range including all nodes.
    PcpRangeTypeAll,
 
    // Range including all nodes weaker than the root node.
    PcpRangeTypeWeakerThanRoot,
 
    // Range including all nodes stronger than the payload
    // node.
    PcpRangeTypeStrongerThanPayload,
 
    PcpRangeTypeInvalid
};
 
inline bool 
PcpIsInheritArc(PcpArcType arcType)
{
    return (arcType == PcpArcTypeInherit);
}
 
inline bool 
PcpIsSpecializeArc(PcpArcType arcType)
{
    return (arcType == PcpArcTypeSpecialize);
}
 
inline bool
PcpIsClassBasedArc(PcpArcType arcType)
{
    return PcpIsInheritArc(arcType) || PcpIsSpecializeArc(arcType);
}
 
struct PcpSiteTrackerSegment {
    PcpSite site;
    PcpArcType arcType;
};
 
typedef std::vector<PcpSiteTrackerSegment> PcpSiteTracker;
 
// Internal type for Sd sites.
struct Pcp_SdSiteRef {
    Pcp_SdSiteRef(const SdfLayerRefPtr& layer_, const SdfPath& path_) :
        layer(layer_), path(path_)
    {
        // Do nothing
    }
 
    bool operator==(const Pcp_SdSiteRef& other) const
    {
        return layer == other.layer && path == other.path;
    }
 
    bool operator!=(const Pcp_SdSiteRef& other) const
    {
        return !(*this == other);
    }
 
    bool operator<(const Pcp_SdSiteRef& other) const
    {
        return layer < other.layer ||
               (!(other.layer < layer) && path < other.path);
    }
 
    bool operator<=(const Pcp_SdSiteRef& other) const
    {
        return !(other < *this);
    }
 
    bool operator>(const Pcp_SdSiteRef& other) const
    {
        return other < *this;
    }
 
    bool operator>=(const Pcp_SdSiteRef& other) const
    {
        return !(*this < other);
    }
 
    // These are held by reference for performance,
    // to avoid extra ref-counting operations.
    const SdfLayerRefPtr & layer;
    const SdfPath & path;
};
 
// Internal type for Sd sites.
struct Pcp_CompressedSdSite {
    Pcp_CompressedSdSite(size_t nodeIndex_, size_t layerIndex_) :
        nodeIndex(static_cast<uint16_t>(nodeIndex_)),
        layerIndex(static_cast<uint16_t>(layerIndex_))
    {
        TF_VERIFY(nodeIndex_  < (size_t(1) << 16));
        TF_VERIFY(layerIndex_ < (size_t(1) << 16));
    }
 
    // These are small to minimize the size of vectors of these.
    uint16_t nodeIndex;     // The index of the node in its graph.
    uint16_t layerIndex;    // The index of the layer in the node's layer stack.
};
typedef std::vector<Pcp_CompressedSdSite> Pcp_CompressedSdSiteVector;
 
// XXX Even with <map> included properly, doxygen refuses to acknowledge
// the existence of std::map, so if we include the full typedef in the
// \typedef directive, it will warn and fail to produce an entry for 
// PcpVariantFallbackMap.  So we instead put the decl inline.
typedef std::map<std::string, std::vector<std::string>> PcpVariantFallbackMap;
 
using PcpTokenSet = pxr_tsl::robin_set<TfToken, TfToken::HashFunctor>;
 
#if defined(doxygen)
constexpr size_t PCP_INVALID_INDEX = unspecified;
#else
constexpr size_t PCP_INVALID_INDEX = std::numeric_limits<size_t>::max();
#endif
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_TYPES_H