shaderNodeDiscoveryResult.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_SDR_NODE_DISCOVERY_RESULT_H
#define PXR_USD_SDR_NODE_DISCOVERY_RESULT_H
 
 
#include "pxr/usd/sdr/declare.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct SdrShaderNodeDiscoveryResult {
    SdrShaderNodeDiscoveryResult(
        const SdrIdentifier& identifier,
        const SdrVersion& version,
        const std::string& name,
        const TfToken& function,
        const TfToken& discoveryType,
        const TfToken& shadingSystem,
        const std::string& uri,
        const std::string& resolvedUri,
        const std::string &sourceCode=std::string(),
        const SdrTokenMap &metadata=SdrTokenMap(),
        const std::string& blindData=std::string(),
        const TfToken& subIdentifier=TfToken()
    ) : identifier(identifier),
        version(version),
        name(name),
        function(function),
        family(this->function),
        discoveryType(discoveryType),
        shadingSystem(shadingSystem),
        sourceType(this->shadingSystem),
        uri(uri),
        resolvedUri(resolvedUri),
        sourceCode(sourceCode),
        metadata(metadata),
        blindData(blindData),
        subIdentifier(subIdentifier)
    { }
 
    SdrShaderNodeDiscoveryResult(SdrShaderNodeDiscoveryResult&& other)
      : identifier(std::move(other.identifier)),
        version(std::move(other.version)),
        name(std::move(other.name)),
        function(std::move(other.function)),
        family(this->function),
        discoveryType(std::move(other.discoveryType)),
        shadingSystem(std::move(other.shadingSystem)),
        sourceType(this->shadingSystem),
        uri(std::move(other.uri)),
        resolvedUri(std::move(other.resolvedUri)),
        sourceCode(std::move(other.sourceCode)),
        metadata(std::move(other.metadata)),
        blindData(std::move(other.blindData)),
        subIdentifier(std::move(other.subIdentifier))
    { }
 
    SdrShaderNodeDiscoveryResult(const SdrShaderNodeDiscoveryResult& other)
      : identifier(other.identifier),
        version(other.version),
        name(other.name),
        function(other.function),
        family(this->function),
        discoveryType(other.discoveryType),
        shadingSystem(other.shadingSystem),
        sourceType(this->shadingSystem),
        uri(other.uri),
        resolvedUri(other.resolvedUri),
        sourceCode(other.sourceCode),
        metadata(other.metadata),
        blindData(other.blindData),
        subIdentifier(other.subIdentifier)
    { }
 
    SdrShaderNodeDiscoveryResult& operator=(
        SdrShaderNodeDiscoveryResult&& other)
    {
        this->identifier = std::move(other.identifier);
        this->version = std::move(other.version);
        this->name = std::move(other.name);
        this->function = std::move(other.function);
        this->family = this->function;
        this->discoveryType = std::move(other.discoveryType);
        this->shadingSystem = std::move(other.shadingSystem);
        this->sourceType = this->shadingSystem;
        this->uri = std::move(other.uri);
        this->resolvedUri = std::move(other.resolvedUri);
        this->sourceCode = std::move(other.sourceCode);
        this->metadata = std::move(other.metadata);
        this->blindData = std::move(other.blindData);
        this->subIdentifier = std::move(other.subIdentifier);
        return *this;
    }
 
    SdrShaderNodeDiscoveryResult& operator=(
        const SdrShaderNodeDiscoveryResult& other)
    {
        SdrShaderNodeDiscoveryResult copy(other);
        *this = std::move(copy);
        return *this;
    }
 
    SdrIdentifier identifier;
 
    SdrVersion version;
 
    std::string name;
 
    TfToken function;
 
    TfToken& family;
 
    TfToken discoveryType;
 
    TfToken shadingSystem;
 
    TfToken& sourceType;
 
    std::string uri;
 
    std::string resolvedUri;
 
    std::string sourceCode;
 
    SdrTokenMap metadata;
 
    std::string blindData;
 
    TfToken subIdentifier;
};
 
typedef std::vector<SdrShaderNodeDiscoveryResult> SdrShaderNodeDiscoveryResultVec;
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDR_NODE_DISCOVERY_RESULT_H