connectableAPI.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 USDSHADE_GENERATED_CONNECTABLEAPI_H
#define USDSHADE_GENERATED_CONNECTABLEAPI_H


#include "pxr/pxr.h"
#include "pxr/usd/usdShade/api.h"
#include "pxr/usd/usd/apiSchemaBase.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/stage.h"

#include "pxr/usd/usd/typed.h"
#include "pxr/usd/usdShade/input.h"
#include "pxr/usd/usdShade/output.h"
#include "pxr/usd/usdShade/tokens.h"
#include "pxr/usd/usdShade/types.h"

#include "pxr/base/vt/value.h"

#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/matrix4d.h"

#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"

PXR_NAMESPACE_OPEN_SCOPE

class SdfAssetPath;

// -------------------------------------------------------------------------- //
// CONNECTABLEAPI                                                             //
// -------------------------------------------------------------------------- //

class UsdShadeConnectableAPI : public UsdAPISchemaBase
{
public:
    static const UsdSchemaKind schemaKind = UsdSchemaKind::NonAppliedAPI;

    explicit UsdShadeConnectableAPI(const UsdPrim& prim=UsdPrim())
        : UsdAPISchemaBase(prim)
    {
    }

    explicit UsdShadeConnectableAPI(const UsdSchemaBase& schemaObj)
        : UsdAPISchemaBase(schemaObj)
    {
    }

    USDSHADE_API
    virtual ~UsdShadeConnectableAPI();

    USDSHADE_API
    static const TfTokenVector &
    GetSchemaAttributeNames(bool includeInherited=true);

    USDSHADE_API
    static UsdShadeConnectableAPI
    Get(const UsdStagePtr &stage, const SdfPath &path);


protected:
    USDSHADE_API
    UsdSchemaKind _GetSchemaKind() const override;

private:
    // needs to invoke _GetStaticTfType.
    friend class UsdSchemaRegistry;
    USDSHADE_API
    static const TfType &_GetStaticTfType();

    static bool _IsTypedSchema();

    // override SchemaBase virtuals.
    USDSHADE_API
    const TfType &_GetTfType() const override;

public:
    // ===================================================================== //
    // Feel free to add custom code below this line, it will be preserved by 
    // the code generator. 
    //
    // Just remember to: 
    //  - Close the class declaration with }; 
    //  - Close the namespace with PXR_NAMESPACE_CLOSE_SCOPE
    //  - Close the include guard with #endif
    // ===================================================================== //
    // --(BEGIN CUSTOM CODE)--
    
protected:
    USDSHADE_API
    bool _IsCompatible() const override;
    
public:
    USDSHADE_API
    bool IsContainer() const;

    USDSHADE_API
    bool RequiresEncapsulation() const;


    USDSHADE_API
    static bool CanConnect(const UsdShadeInput &input, 
                           const UsdAttribute &source);

    USDSHADE_API
    static bool CanConnect(const UsdShadeInput &input, 
                           const UsdShadeInput &sourceInput) {
        return CanConnect(input, sourceInput.GetAttr());
    }

    USDSHADE_API
    static bool CanConnect(const UsdShadeInput &input, 
                           const UsdShadeOutput &sourceOutput) {
        return CanConnect(input, sourceOutput.GetAttr());
    }

    USDSHADE_API
    static bool CanConnect(const UsdShadeOutput &output, 
                           const UsdAttribute &source=UsdAttribute());

    USDSHADE_API
    static bool CanConnect(const UsdShadeOutput &output, 
                           const UsdShadeInput &sourceInput) {
        return CanConnect(output, sourceInput.GetAttr());
    }

    USDSHADE_API
    static bool CanConnect(const UsdShadeOutput &output, 
                           const UsdShadeOutput &sourceOutput) {
        return CanConnect(output, sourceOutput.GetAttr());
    }

    using ConnectionModification = UsdShadeConnectionModification;

    USDSHADE_API
    static bool ConnectToSource(
        UsdAttribute const &shadingAttr,
        UsdShadeConnectionSourceInfo const &source,
        ConnectionModification const mod = ConnectionModification::Replace);

    USDSHADE_API
    static bool ConnectToSource(
        UsdShadeInput const &input,
        UsdShadeConnectionSourceInfo const &source,
        ConnectionModification const mod = ConnectionModification::Replace)
    {
        return ConnectToSource(input.GetAttr(), source, mod);
    }

    USDSHADE_API
    static bool ConnectToSource(
        UsdShadeOutput const &output,
        UsdShadeConnectionSourceInfo const &source,
        ConnectionModification const mod = ConnectionModification::Replace)
    {
        return ConnectToSource(output.GetAttr(), source, mod);
    }

    USDSHADE_API
    static bool ConnectToSource(
        UsdAttribute const &shadingAttr,
        UsdShadeConnectableAPI const &source,
        TfToken const &sourceName,
        UsdShadeAttributeType const sourceType=UsdShadeAttributeType::Output,
        SdfValueTypeName typeName=SdfValueTypeName());

    USDSHADE_API
    static bool ConnectToSource(
        UsdShadeInput const &input,
        UsdShadeConnectableAPI const &source,
        TfToken const &sourceName,
        UsdShadeAttributeType const sourceType=UsdShadeAttributeType::Output,
        SdfValueTypeName typeName=SdfValueTypeName())
    {
        return ConnectToSource(input.GetAttr(), source, sourceName, sourceType,
            typeName);
    }

    USDSHADE_API
    static bool ConnectToSource(
        UsdShadeOutput const &output,
        UsdShadeConnectableAPI const &source,
        TfToken const &sourceName,
        UsdShadeAttributeType const sourceType=UsdShadeAttributeType::Output,
        SdfValueTypeName typeName=SdfValueTypeName())
    {
        return ConnectToSource(output.GetAttr(), source, sourceName, sourceType,
            typeName);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdAttribute const &shadingAttr,
                                SdfPath const &sourcePath);

    USDSHADE_API
    static bool ConnectToSource(UsdShadeInput const &input,
                                SdfPath const &sourcePath) {
        return ConnectToSource(input.GetAttr(), sourcePath);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdShadeOutput const &output,
                                SdfPath const &sourcePath) {
        return ConnectToSource(output.GetAttr(), sourcePath);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdAttribute const &shadingAttr,
                                UsdShadeInput const &sourceInput);

    USDSHADE_API
    static bool ConnectToSource(UsdShadeInput const &input,
                                UsdShadeInput const &sourceInput) {
        return ConnectToSource(input.GetAttr(), sourceInput);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdShadeOutput const &output,
                                UsdShadeInput const &sourceInput) {
        return ConnectToSource(output.GetAttr(), sourceInput);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdAttribute const &shadingAttr,
                                UsdShadeOutput const &sourceOutput);

    USDSHADE_API
    static bool ConnectToSource(UsdShadeInput const &input,
                                UsdShadeOutput const &sourceOutput) {
        return ConnectToSource(input.GetAttr(), sourceOutput);
    }

    USDSHADE_API
    static bool ConnectToSource(UsdShadeOutput const &output,
                                UsdShadeOutput const &sourceOutput) {
        return ConnectToSource(output.GetAttr(), sourceOutput);
    }

    USDSHADE_API
    static bool SetConnectedSources(
        UsdAttribute const &shadingAttr,
        std::vector<UsdShadeConnectionSourceInfo> const &sourceInfos);


    USDSHADE_API
    static bool GetConnectedSource(UsdAttribute const &shadingAttr,
                                   UsdShadeConnectableAPI *source,
                                   TfToken *sourceName,
                                   UsdShadeAttributeType *sourceType);

    USDSHADE_API
    static bool GetConnectedSource(UsdShadeInput const &input,
                                   UsdShadeConnectableAPI *source,
                                   TfToken *sourceName,
                                   UsdShadeAttributeType *sourceType) {
        return GetConnectedSource(input.GetAttr(), source, sourceName,
                                  sourceType);
    }

    USDSHADE_API
    static bool GetConnectedSource(UsdShadeOutput const &output,
                                   UsdShadeConnectableAPI *source,
                                   TfToken *sourceName,
                                   UsdShadeAttributeType *sourceType) {
        return GetConnectedSource(output.GetAttr(), source, sourceName,
                                  sourceType);
    }

    USDSHADE_API
    static UsdShadeSourceInfoVector GetConnectedSources(
        UsdAttribute const &shadingAttr,
        SdfPathVector *invalidSourcePaths = nullptr);

    USDSHADE_API
    static UsdShadeSourceInfoVector GetConnectedSources(
        UsdShadeInput const &input,
        SdfPathVector *invalidSourcePaths = nullptr);

    USDSHADE_API
    static UsdShadeSourceInfoVector GetConnectedSources(
        UsdShadeOutput const &output,
        SdfPathVector *invalidSourcePaths = nullptr);

    USDSHADE_API
    static bool GetRawConnectedSourcePaths(UsdAttribute const &shadingAttr, 
                                           SdfPathVector *sourcePaths);

    USDSHADE_API
    static bool GetRawConnectedSourcePaths(UsdShadeInput const &input, 
                                           SdfPathVector *sourcePaths) {
        return GetRawConnectedSourcePaths(input.GetAttr(), sourcePaths);
    }

    USDSHADE_API
    static bool GetRawConnectedSourcePaths(UsdShadeOutput const &output, 
                                           SdfPathVector *sourcePaths) {
        return GetRawConnectedSourcePaths(output.GetAttr(), sourcePaths);
    }

    USDSHADE_API
    static bool HasConnectedSource(const UsdAttribute &shadingAttr);

    USDSHADE_API
    static bool HasConnectedSource(const UsdShadeInput &input) {
        return HasConnectedSource(input.GetAttr());
    }

    USDSHADE_API
    static bool HasConnectedSource(const UsdShadeOutput &output) {
        return HasConnectedSource(output.GetAttr());
    }

    USDSHADE_API
    static bool IsSourceConnectionFromBaseMaterial(
        const UsdAttribute &shadingAttr);

    USDSHADE_API
    static bool IsSourceConnectionFromBaseMaterial(const UsdShadeInput &input) {
        return IsSourceConnectionFromBaseMaterial(input.GetAttr());
    }

    USDSHADE_API
    static bool IsSourceConnectionFromBaseMaterial(const UsdShadeOutput &output)
    {
        return IsSourceConnectionFromBaseMaterial(output.GetAttr());
    }

    USDSHADE_API
    static bool DisconnectSource(
        UsdAttribute const &shadingAttr,
        UsdAttribute const &sourceAttr = UsdAttribute());

    USDSHADE_API
    static bool DisconnectSource(
        UsdShadeInput const &input,
        UsdAttribute const &sourceAttr = UsdAttribute()) {
        return DisconnectSource(input.GetAttr(), sourceAttr);
    }

    USDSHADE_API
    static bool DisconnectSource(
        UsdShadeOutput const &output,
        UsdAttribute const &sourceAttr = UsdAttribute()) {
        return DisconnectSource(output.GetAttr(), sourceAttr);
    }

    USDSHADE_API
    static bool ClearSources(UsdAttribute const &shadingAttr);

    USDSHADE_API
    static bool ClearSources(UsdShadeInput const &input) {
        return ClearSources(input.GetAttr());
    }

    USDSHADE_API
    static bool ClearSources(UsdShadeOutput const &output) {
        return ClearSources(output.GetAttr());
    }

    USDSHADE_API
    static bool ClearSource(UsdAttribute const &shadingAttr) {
        return ClearSources(shadingAttr);
    }

    USDSHADE_API
    static bool ClearSource(UsdShadeInput const &input) {
        return ClearSources(input.GetAttr());
    }

    USDSHADE_API
    static bool ClearSource(UsdShadeOutput const &output) {
        return ClearSources(output.GetAttr());
    }

    USDSHADE_API
    static bool HasConnectableAPI(const TfType& schemaType);

    template <typename T>
    static bool HasConnectableAPI()
    {
        static_assert(std::is_base_of<UsdTyped, T>::value, 
                "Provided type must derive UsdTyped.");
        return HasConnectableAPI(TfType::Find<T>());
    };




    USDSHADE_API
    UsdShadeOutput CreateOutput(const TfToken& name,
                                const SdfValueTypeName& typeName) const;

    USDSHADE_API
    UsdShadeOutput GetOutput(const TfToken &name) const;

    USDSHADE_API
    std::vector<UsdShadeOutput> GetOutputs(
          bool onlyAuthored=true) const;


        
    USDSHADE_API
    UsdShadeInput CreateInput(const TfToken& name,
                               const SdfValueTypeName& typeName) const;

    USDSHADE_API
    UsdShadeInput GetInput(const TfToken &name) const;

    USDSHADE_API
    std::vector<UsdShadeInput> GetInputs(
          bool onlyAuthored=true) const;


};

struct UsdShadeConnectionSourceInfo {
    UsdShadeConnectableAPI source;
    TfToken sourceName;
    UsdShadeAttributeType sourceType = UsdShadeAttributeType::Invalid;
    SdfValueTypeName typeName;

    UsdShadeConnectionSourceInfo() = default;
    explicit UsdShadeConnectionSourceInfo(
        UsdShadeConnectableAPI const &source_,
        TfToken const &sourceName_,
        UsdShadeAttributeType sourceType_,
        SdfValueTypeName typeName_ = SdfValueTypeName())
    : source(source_)
    , sourceName(sourceName_)
    , sourceType(sourceType_)
    , typeName(typeName_)
    {}
    explicit UsdShadeConnectionSourceInfo(UsdShadeInput const &input)
        : source(input.GetPrim())
        , sourceName(input.GetBaseName())
        , sourceType(UsdShadeAttributeType::Input)
        , typeName(input.GetAttr().GetTypeName())
    {}
    explicit UsdShadeConnectionSourceInfo(UsdShadeOutput const &output)
        : source(output.GetPrim())
        , sourceName(output.GetBaseName())
        , sourceType(UsdShadeAttributeType::Output)
        , typeName(output.GetAttr().GetTypeName())
    {}
    USDSHADE_API
    explicit UsdShadeConnectionSourceInfo(
        UsdStagePtr const& stage,
        SdfPath const& sourcePath);

    bool IsValid() const {
        // typeName can be invalid, so we don't check it. Order of checks is in
        // order of cost (cheap to expensive).
        // Note, for the source we only check that the prim is valid. We do not
        // verify that the prim is compatibel with UsdShadeConnectableAPI. This
        // makes it possible to target pure overs
        return (sourceType != UsdShadeAttributeType::Invalid) &&
               !sourceName.IsEmpty() &&
               (bool)source.GetPrim();
    }
    explicit operator bool() const {
        return IsValid();
    }
    bool operator==(UsdShadeConnectionSourceInfo const& other) const {
        // We don't compare the typeName, since it is optional
        return sourceName == other.sourceName &&
               sourceType == other.sourceType &&
               source.GetPrim() == other.source.GetPrim();
    }
    bool operator!=(const UsdShadeConnectionSourceInfo &other) const {
        return !(*this == other);
    }
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif