usdrt/scenegraph/usd/usdShade/shader.h

File members: usdrt/scenegraph/usd/usdShade/shader.h

// Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
// TODO USD COPYRIGHT AS WELL?
#pragma once

// GENERATED FILE DO NOT EDIT

#include "usdrt/scenegraph/usd/usd/schemaBase.h"

// clang-format off
/* Extra Includes
// USDRT NOTE: Use custom includes below instead to allow for
// implementation differences in the custom code. This section comes
// from the pxr schema.usda files which we may not have in usdrt.
//#include "usdrt/scenegraph/usd/usdShade/input.h"
#include "usdrt/scenegraph/usd/usdShade/output.h"
#include "usdrt/scenegraph/usd/usdShade/tokens.h"
#include "usdrt/scenegraph/usd/ndr/declare.h"
#include "usdrt/scenegraph/usd/sdr/shaderNode.h"*/
// clang-format on

// ===================================================================== //
// Feel free to add custom includes between BEGIN and END CUSTOM INCLUDES
// below this line. It will be preserved by the code generator.
// We are using this instead of the `extraIncludes` in the pxr schema.usda
// files to allow for implementation differences in the custom code.
// ===================================================================== //
// --(BEGIN CUSTOM INCLUDES)--
#include <usdrt/scenegraph/usd/usdShade/connectableAPI.h>
#include <usdrt/scenegraph/usd/usdShade/input.h>
#include <usdrt/scenegraph/usd/usdShade/output.h>
// --(END CUSTOM INCLUDES)--

#include <omni/core/IObject.h>
#include <usdrt/scenegraph/base/tf/token.h>
#include <usdrt/scenegraph/base/vt/array.h>
#include <usdrt/scenegraph/interface/IRtAttribute.h>
#include <usdrt/scenegraph/interface/IRtPrim.h>
#include <usdrt/scenegraph/interface/IRtPrimRange.h>
#include <usdrt/scenegraph/interface/IRtRelationship.h>
#include <usdrt/scenegraph/interface/IRtStage.h>
#include <usdrt/scenegraph/usd/sdf/path.h>
#include <usdrt/scenegraph/usd/sdf/types.h>
#include <usdrt/scenegraph/usd/sdf/valueTypeName.h>
#include <usdrt/scenegraph/usd/usd/attribute.h>
#include <usdrt/scenegraph/usd/usd/common.h>
#include <usdrt/scenegraph/usd/usd/prim.h>
#include <usdrt/scenegraph/usd/usd/timeCode.h>

namespace usdrt
{

// -------------------------------------------------------------------------- //
// SHADER                                                                      //
// -------------------------------------------------------------------------- //

class UsdShadeShader : public UsdTyped
{

public:
    static const UsdSchemaType schemaType = UsdSchemaType::ConcreteTyped;

    explicit UsdShadeShader(const UsdPrim& prim = UsdPrim()) : UsdTyped(prim)
    {
    }

    explicit UsdShadeShader(const UsdSchemaBase& schemaObj) : UsdTyped(schemaObj)
    {
    }

    virtual ~UsdShadeShader()
    {
    }

    static UsdShadeShader Define(const UsdStageRefPtr& stage, const SdfPath& path);

    static const TfToken _GetStaticTfType();

private:
    /* virtual */
    const TfToken _GetTfTypeToken() const override;

    // ===================================================================== //
    // Feel free to add custom code for the class definition between BEGIN
    // and END CUSTOM DECLARATION CODE below this line. It will be preserved by
    // the code generator.
    // ===================================================================== //
    // --(BEGIN CUSTOM DECLARATION CODE)--

public:
    // -------------------------------------------------------------------------

    UsdShadeShader(const UsdShadeConnectableAPI& connectable);

    UsdShadeConnectableAPI ConnectableAPI() const;

    // -------------------------------------------------------------------------

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

    UsdShadeOutput GetOutput(const TfToken& name) const;

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

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

    UsdShadeInput GetInput(const TfToken& name) const;

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

    // -------------------------------------------------------------------------

    UsdAttribute GetImplementationSourceAttr() const;

    UsdAttribute CreateImplementationSourceAttr() const;

    UsdAttribute GetIdAttr() const;

    UsdAttribute CreateIdAttr() const;

    TfToken GetImplementationSource() const;

    bool SetShaderId(const TfToken& id) const;

    bool GetShaderId(TfToken* id) const;

    bool SetSourceAsset(const SdfAssetPath& sourceAsset,
                        const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    bool GetSourceAsset(SdfAssetPath* sourceAsset, const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    bool SetSourceAssetSubIdentifier(const TfToken& subIdentifier,
                                     const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    bool GetSourceAssetSubIdentifier(TfToken* subIdentifier,
                                     const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    bool SetSourceCode(const std::string& sourceCode,
                       const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    bool GetSourceCode(std::string* sourceCode, const TfToken& sourceType = UsdShadeTokens->universalSourceType) const;

    // --(END CUSTOM DECLARATION CODE)--
};

inline const TfToken UsdShadeShader::_GetStaticTfType()
{
    const static TfToken token("UsdShadeShader");
    return token;
}

/* virtual */
inline const TfToken UsdShadeShader::_GetTfTypeToken() const
{
    const static TfToken token("UsdShadeShader");
    return token;
}

/* static */
inline UsdShadeShader UsdShadeShader::Define(const UsdStageRefPtr& stage, const SdfPath& path)
{
    if (!stage)
    {
        // TODO error
        return UsdShadeShader();
    }
    return UsdShadeShader(stage->DefinePrim(path, _GetStaticTfType()));
}

} // namespace usdrt
// ===================================================================== //
// Feel free to add custom code below this line. It will be preserved by
// the code generator.
//
// Just remember to wrap code in the appropriate delimiters:
// 'namespace usdrt {', '}'.
// ===================================================================== //
// --(BEGIN CUSTOM CODE)--

#include <usdrt/scenegraph/usd/usdShade/connectableAPI.h>
#include <usdrt/scenegraph/usd/usdShade/nodeDefAPI.h>

namespace usdrt
{

inline UsdShadeShader::UsdShadeShader(const UsdShadeConnectableAPI& connectable) : UsdShadeShader(connectable.GetPrim())
{
}

inline UsdShadeConnectableAPI UsdShadeShader::ConnectableAPI() const
{
    return UsdShadeConnectableAPI(GetPrim());
}

inline UsdShadeOutput UsdShadeShader::CreateOutput(const TfToken& name, const SdfValueTypeName& typeName)
{
    return UsdShadeConnectableAPI(GetPrim()).CreateOutput(name, typeName);
}

inline UsdShadeOutput UsdShadeShader::GetOutput(const TfToken& name) const
{
    return UsdShadeConnectableAPI(GetPrim()).GetOutput(name);
}

inline std::vector<UsdShadeOutput> UsdShadeShader::GetOutputs(bool onlyAuthored) const
{
    return UsdShadeConnectableAPI(GetPrim()).GetOutputs(onlyAuthored);
}

inline UsdShadeInput UsdShadeShader::CreateInput(const TfToken& name, const SdfValueTypeName& typeName)
{
    return UsdShadeConnectableAPI(GetPrim()).CreateInput(name, typeName);
}

inline UsdShadeInput UsdShadeShader::GetInput(const TfToken& name) const
{
    return UsdShadeConnectableAPI(GetPrim()).GetInput(name);
}

inline std::vector<UsdShadeInput> UsdShadeShader::GetInputs(bool onlyAuthored) const
{
    return UsdShadeConnectableAPI(GetPrim()).GetInputs(onlyAuthored);
}

inline UsdAttribute UsdShadeShader::GetImplementationSourceAttr() const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetImplementationSourceAttr();
}

inline UsdAttribute UsdShadeShader::CreateImplementationSourceAttr() const
{
    return UsdShadeNodeDefAPI(GetPrim()).CreateImplementationSourceAttr();
}

inline UsdAttribute UsdShadeShader::GetIdAttr() const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetIdAttr();
}

inline UsdAttribute UsdShadeShader::CreateIdAttr() const
{
    return UsdShadeNodeDefAPI(GetPrim()).CreateIdAttr();
}

inline TfToken UsdShadeShader::GetImplementationSource() const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetImplementationSource();
}

inline bool UsdShadeShader::SetShaderId(const TfToken& id) const
{
    return UsdShadeNodeDefAPI(GetPrim()).SetShaderId(id);
}

inline bool UsdShadeShader::GetShaderId(TfToken* id) const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetShaderId(id);
}

inline bool UsdShadeShader::SetSourceAsset(const SdfAssetPath& sourceAsset, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).SetSourceAsset(sourceAsset, sourceType);
}

inline bool UsdShadeShader::GetSourceAsset(SdfAssetPath* sourceAsset, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetSourceAsset(sourceAsset, sourceType);
}

inline bool UsdShadeShader::SetSourceAssetSubIdentifier(const TfToken& subIdentifier, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).SetSourceAssetSubIdentifier(subIdentifier, sourceType);
}

inline bool UsdShadeShader::GetSourceAssetSubIdentifier(TfToken* subIdentifier, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetSourceAssetSubIdentifier(subIdentifier, sourceType);
}

inline bool UsdShadeShader::SetSourceCode(const std::string& sourceCode, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).SetSourceCode(sourceCode, sourceType);
}

inline bool UsdShadeShader::GetSourceCode(std::string* sourceCode, const TfToken& sourceType) const
{
    return UsdShadeNodeDefAPI(GetPrim()).GetSourceCode(sourceCode, sourceType);
}

} // namespace usdrt