primCompositionQuery.h

Go to the documentation of this file.

//
// Copyright 2019 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_USD_PRIM_COMPOSITION_QUERY_H
#define PXR_USD_USD_PRIM_COMPOSITION_QUERY_H


#include "pxr/pxr.h"
#include "pxr/usd/usd/api.h"
#include "pxr/usd/usd/prim.h"

#include "pxr/usd/pcp/node.h"
#include "pxr/usd/pcp/primIndex.h"

#include <memory>

PXR_NAMESPACE_OPEN_SCOPE

class UsdPrimCompositionQueryArc
{
public:
    ~UsdPrimCompositionQueryArc() = default;

    
    USD_API
    PcpNodeRef GetTargetNode() const;

    USD_API
    PcpNodeRef GetIntroducingNode() const;



    USD_API
    SdfLayerHandle GetTargetLayer() const;

    USD_API
    SdfPath GetTargetPrimPath() const;

    USD_API
    UsdResolveTarget MakeResolveTargetUpTo(
        const SdfLayerHandle &subLayer = nullptr) const;

    USD_API
    UsdResolveTarget MakeResolveTargetStrongerThan(
        const SdfLayerHandle &subLayer = nullptr) const;



    USD_API
    SdfLayerHandle GetIntroducingLayer() const;

    USD_API
    SdfPath GetIntroducingPrimPath() const;

    USD_API
    bool GetIntroducingListEditor(SdfReferenceEditorProxy *editor, 
                                  SdfReference *ref) const;

    USD_API
    bool GetIntroducingListEditor(SdfPayloadEditorProxy *editor, 
                                  SdfPayload *payload) const;

    USD_API
    bool GetIntroducingListEditor(SdfPathEditorProxy *editor, 
                                  SdfPath *path) const;

    USD_API
    bool GetIntroducingListEditor(SdfNameEditorProxy *editor, 
                                  std::string *name) const;



    USD_API
    PcpArcType GetArcType() const;

    USD_API
    bool IsImplicit() const;

    USD_API
    bool IsAncestral() const; 
    
    USD_API
    bool HasSpecs() const; 
        
    USD_API
    bool IsIntroducedInRootLayerStack() const;

    USD_API
    bool IsIntroducedInRootLayerPrimSpec() const;


private:
    // These will only be created by a UsdPrimCompositionQuery itself.
    friend class UsdPrimCompositionQuery;
    UsdPrimCompositionQueryArc(const PcpNodeRef &node);

    PcpNodeRef _node;
    PcpNodeRef _originalIntroducedNode;
    PcpNodeRef _introducingNode;

    std::shared_ptr<PcpPrimIndex> _primIndex;
};

class UsdPrimCompositionQuery
{
public:
    enum class ArcTypeFilter
    {
        All = 0,

        // Single arc types
        Reference,
        Payload,
        Inherit,
        Specialize,
        Variant,

        // Related arc types
        ReferenceOrPayload,
        InheritOrSpecialize,

        // Inverse of related arc types
        NotReferenceOrPayload,
        NotInheritOrSpecialize,
        NotVariant
    };

    enum class DependencyTypeFilter
    {
        All = 0,

        Direct,
        Ancestral
    };

    enum class ArcIntroducedFilter
    {
        All = 0,

        // Indicates that we only want arcs that are authored somewhere in the
        // root layer stack.
        IntroducedInRootLayerStack,

        // Indicates that we only want arcs that are authored directly in the
        // in the prim's prim spec in the root layer stack.
        IntroducedInRootLayerPrimSpec
    };

    enum class HasSpecsFilter
    {
        All = 0,

        HasSpecs,
        HasNoSpecs
    };

    struct Filter 
    {
        ArcTypeFilter arcTypeFilter {ArcTypeFilter::All};

        DependencyTypeFilter dependencyTypeFilter {DependencyTypeFilter::All};

        ArcIntroducedFilter arcIntroducedFilter {ArcIntroducedFilter::All};

        HasSpecsFilter hasSpecsFilter {HasSpecsFilter::All};

        Filter() {};

        bool operator==(const Filter &rhs) {
            return arcIntroducedFilter == rhs.arcIntroducedFilter &&
                arcTypeFilter == rhs.arcTypeFilter &&
                dependencyTypeFilter == rhs.dependencyTypeFilter &&
                hasSpecsFilter == rhs.hasSpecsFilter;
        };

        bool operator!=(const Filter &rhs) {
            return !(*this == rhs);
        };
    };

    USD_API
    static UsdPrimCompositionQuery GetDirectReferences(const UsdPrim & prim);

    USD_API
    static UsdPrimCompositionQuery GetDirectInherits(const UsdPrim & prim);

    USD_API
    static UsdPrimCompositionQuery GetDirectRootLayerArcs(const UsdPrim & prim);

    USD_API
    UsdPrimCompositionQuery(const UsdPrim & prim, 
                            const Filter &filter = Filter());

    ~UsdPrimCompositionQuery() = default;

    USD_API
    void SetFilter(const Filter &filter);

    USD_API
    Filter GetFilter() const;

    USD_API
    std::vector<UsdPrimCompositionQueryArc> GetCompositionArcs();

private:
    UsdPrim _prim;
    Filter _filter;
    std::shared_ptr<PcpPrimIndex> _expandedPrimIndex;
    std::vector<UsdPrimCompositionQueryArc> _unfilteredArcs;
};


PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_USD_PRIM_COMPOSITION_QUERY_H