shaderNode.h

Go to the documentation of this file.

//
// Copyright 2018 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_SDR_SHADER_NODE_H
#define PXR_USD_SDR_SHADER_NODE_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/sdr/api.h"
#include "pxr/base/tf/staticTokens.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/vt/value.h"
#include "pxr/usd/sdr/declare.h"
#include "pxr/usd/sdr/shaderNodeMetadata.h"
#include "pxr/usd/sdr/shaderNodeDiscoveryResult.h"
 
#include <unordered_map>
 
PXR_NAMESPACE_OPEN_SCOPE
 
#define SDR_NODE_FIELD_KEY_TOKENS                  \
    ((Identifier, "_identifier"))                  \
    ((Name, "_name"))                              \
    ((Family, "_family")) /* deprecated */         \
    ((Function, "_function"))                      \
    ((SourceType, "_sourceType")) /* deprecated */ \
    ((ShadingSystem, "_shadingSystem"))
 
TF_DECLARE_PUBLIC_TOKENS(SdrNodeFieldKey, SDR_API, SDR_NODE_FIELD_KEY_TOKENS);
 
class SdrShaderNode
{
public:
 
 
    SDR_API
    SdrShaderNode(
        const SdrIdentifier& identifier,
        const SdrVersion& version,
        const std::string& name,
        const TfToken& function,
        const TfToken& shadingSystem,
        const std::string& definitionURI,
        const std::string& implementationURI,
        SdrShaderPropertyUniquePtrVec&& properties,
        const SdrShaderNodeMetadata& metadata = SdrShaderNodeMetadata(),
        const std::string &sourceCode = std::string()
    ): SdrShaderNode(
        identifier,
        version,
        name,
        function,
        metadata.GetContext(),
        shadingSystem,
        definitionURI,
        implementationURI,
        std::move(properties),
        metadata,
        sourceCode
    ) {}
 
    SDR_API
    SdrShaderNode(
        const SdrIdentifier& identifier,
        const SdrVersion& version,
        const std::string& name,
        const TfToken& function,
        const TfToken& context, // deprecated
        const TfToken& shadingSystem,
        const std::string& definitionURI,
        const std::string& implementationURI,
        SdrShaderPropertyUniquePtrVec&& properties,
        const SdrShaderNodeMetadata& metadata = SdrShaderNodeMetadata(),
        const std::string &sourceCode = std::string());
 
    SDR_API
    virtual ~SdrShaderNode();
 
 
    const SdrIdentifier& GetIdentifier() const { return _identifier; }
 
    SdrVersion GetShaderVersion() const { return _version; }
 
    const std::string& GetName() const { return _name; }
 
    const TfToken& GetFamily() const { return _function; }
 
    const TfToken& GetFunction() const { return _function; }
 
    const TfToken& GetShadingSystem() const { return _shadingSystem; }
 
    const TfToken& GetSourceType() const { return _shadingSystem; }
 
    const std::string& GetResolvedDefinitionURI() const { return _definitionURI; }
 
    const std::string& GetResolvedImplementationURI() const {
        return _implementationURI;
    }
 
    const std::string &GetSourceCode() const { return _sourceCode; }
 
    SDR_API
    bool IsValid() const { return _isValid; }
 
    SDR_API
    std::string GetInfoString() const;
 
 
 
    SDR_API
    const SdrTokenVec& GetShaderInputNames() const;
 
    SDR_API
    const SdrTokenVec& GetShaderOutputNames() const;
 
    SDR_API
    SdrShaderPropertyConstPtr GetShaderInput(const TfToken& inputName) const;
 
    SDR_API
    SdrShaderPropertyConstPtr GetShaderOutput(const TfToken& outputName) const;
 
    SDR_API
    SdrTokenVec GetAssetIdentifierInputNames() const;
 
    SDR_API
    SdrShaderPropertyConstPtr GetDefaultInput() const;
 
 
 
 
    SDR_API
    const SdrTokenMap& GetMetadata() const;
 
    SDR_API
    const SdrShaderNodeMetadata& GetMetadataObject() const;
 
    const TfToken& GetDomain() const { return _domain; }
 
    const TfToken& GetSubdomain() const { return _subdomain; }
 
    const TfToken& GetContext() const { return _context; }
 
    SDR_API
    TfToken GetRole() const;
 
    SDR_API
    const TfToken& GetLabel() const { return _label; }
 
    SDR_API
    const TfToken& GetCategory() const { return _category; }
 
    SDR_API
    std::string GetHelp() const;
 
    SDR_API
    const SdrTokenVec& GetDepartments() const { return _departments; }
 
    SDR_API
    const SdrTokenVec& GetOpenPages() const { return _openPages; }
 
    SDR_API
    const SdrTokenMap& GetPagesShownIf() const { return _pagesShownIf; }
 
    SDR_API
    const SdrTokenVec& GetPrimvars() const { return _primvars; }
 
    SDR_API
    const SdrTokenVec& GetAdditionalPrimvarProperties() const {
        return _primvarNamingProperties;
    }
 
    SDR_API
    std::string GetImplementationName() const;
 
 
 
 
    SDR_API
    const SdrTokenVec& GetPages() const { return _pages; }
 
    SDR_API
    SdrTokenVec GetPropertyNamesForPage(const std::string& pageName) const;
 
    SDR_API
    SdrTokenVec GetAllVstructNames() const;
 
 
    // Stores the result of the compliance check of property names to
    // sdrShaderNodeIdentifiers
    using ComplianceResults = std::unordered_map<TfToken,
                              std::vector<SdrIdentifier>, 
                              TfToken::HashFunctor>;
 
    SDR_API
    static
    ComplianceResults CheckPropertyCompliance(
        const std::vector<SdrShaderNodeConstPtr> &shaderNodes);
 
 
    // Performs a post-process on properties to determine information that can
    // only be determined after parsing or in aggregate. Clients SHOULD NOT
    // need to call this.
    void _PostProcessProperties();
 
 
    
    SDR_API
    VtValue GetDataForKey(const TfToken& key) const;
 
protected:
    SdrShaderNode& operator=(const SdrShaderNode&) = delete;
 
    bool _isValid;
    SdrIdentifier _identifier;
    SdrVersion _version;
    std::string _name;
    TfToken _function;
    TfToken _context;
    TfToken _shadingSystem;
    std::string _definitionURI;
    std::string _implementationURI;
    SdrShaderPropertyUniquePtrVec _properties;
    SdrTokenMap _legacyMetadata;
    SdrShaderNodeMetadata _metadata;
    std::string _sourceCode;
 
    SdrShaderPropertyMap _inputs;
    SdrTokenVec _inputNames;
    SdrShaderPropertyMap _outputs;
    SdrTokenVec _outputNames;
 
    // Stored metadata to support getter API on SdrShaderNode that
    // returns const ref.
    TfToken _domain;
    TfToken _subdomain;
    TfToken _label;
    TfToken _category;
    SdrTokenVec _departments;
    SdrTokenVec _openPages;
    SdrTokenMap _pagesShownIf;
 
    // Processed primvar metadata. `_primvars` contains the names of primvars
    // consumed by this node, whereas `_primvarNamingProperties` contains the
    // names of string input properties whose values provide the names of
    // additional primvars consumed by this node.
    SdrTokenVec _primvars;
    SdrTokenVec _primvarNamingProperties;
 
    // Aggregated pages data, from examining SdrShaderProperty's page metadata
    SdrTokenVec _pages;
 
private:
    // Initializes `_primvars` and `_primvarNamingProperties`
    void _InitializePrimvars();
 
    // Determines which pages are present on the node's properties
    SdrTokenVec _ComputePages() const;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDR_SHADER_NODE_H