registry.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_REGISTRY_H
#define PXR_USD_SDR_REGISTRY_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/tf/singleton.h"
#include "pxr/usd/sdr/api.h"
#include "pxr/usd/sdr/declare.h"
#include "pxr/usd/sdr/discoveryPlugin.h"
#include "pxr/usd/sdr/parserPlugin.h"
#include "pxr/usd/sdr/shaderNode.h"
#include "pxr/usd/sdr/shaderNodeQuery.h"
#include "pxr/usd/sdr/shaderNodeDiscoveryResult.h"
#include "pxr/usd/sdf/assetPath.h"
#include <map>
#include <mutex>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdrRegistry : public TfWeakBase
{
public:
    using DiscoveryPluginRefPtrVec = SdrDiscoveryPluginRefPtrVector;
 
    SDR_API
    static SdrRegistry& GetInstance();
 
    SDR_API
    void SetExtraDiscoveryPlugins(DiscoveryPluginRefPtrVec plugins);
 
    SDR_API
    void SetExtraDiscoveryPlugins(const std::vector<TfType>& pluginTypes);
 
 
    SDR_API
    void AddDiscoveryResult(SdrShaderNodeDiscoveryResult&& discoveryResult);
 
    SDR_API
    void AddDiscoveryResult(
        const SdrShaderNodeDiscoveryResult& discoveryResult);
 
    SDR_API
    void SetExtraParserPlugins(const std::vector<TfType>& pluginTypes);
 
    SDR_API
    SdrStringVec GetSearchURIs() const;
 
    SDR_API
    SdrIdentifierVec
    GetShaderNodeIdentifiers(const TfToken& family = TfToken(),
                             SdrVersionFilter filter =
                             SdrVersionFilterDefaultOnly) const;
 
    SDR_API
    SdrStringVec GetShaderNodeNames(const TfToken& family = TfToken()) const;
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeByIdentifier(
        const SdrIdentifier& identifier,
        const SdrTokenVec& typePriority = SdrTokenVec());
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeByIdentifierAndType(
        const SdrIdentifier& identifier,
        const TfToken& nodeType);
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeByName(
        const std::string& name,
        const SdrTokenVec& typePriority = SdrTokenVec(),
        SdrVersionFilter filter = SdrVersionFilterDefaultOnly);
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeByNameAndType(
        const std::string& name,
        const TfToken& nodeType,
        SdrVersionFilter filter = SdrVersionFilterDefaultOnly);
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeFromAsset(
        const SdfAssetPath &shaderAsset,
        const SdrTokenMap &metadata=SdrTokenMap(),
        const TfToken &subIdentifier=TfToken(),
        const TfToken &sourceType=TfToken());
 
    SDR_API
    SdrShaderNodeConstPtr GetShaderNodeFromSourceCode(
        const std::string &sourceCode,
        const TfToken &sourceType,
        const SdrTokenMap &metadata=SdrTokenMap());
 
    SDR_API
    SdrShaderNodePtrVec GetShaderNodesByIdentifier(const SdrIdentifier& identifier);
 
    SDR_API
    SdrShaderNodePtrVec GetShaderNodesByName(
        const std::string& name,
        SdrVersionFilter filter = SdrVersionFilterDefaultOnly);
 
    SDR_API
    SdrShaderNodePtrVec GetShaderNodesByFamily(
        const TfToken& family = TfToken(),
        SdrVersionFilter filter = SdrVersionFilterDefaultOnly);
 
    SDR_API
    SdrShaderNodePtrVec GetAllShaderNodes();
 
    SDR_API
    SdrTokenVec GetAllShaderNodeSourceTypes() const;
 
    SDR_API
    SdrShaderNodeQueryResult RunQuery(const SdrShaderNodeQuery& query);
 
    SDR_API
    void ParseAll();
 
protected:
    // Allow TF to construct the class
    friend class TfSingleton<SdrRegistry>;
    SdrRegistry(const SdrRegistry&) = delete;
    SdrRegistry& operator=(const SdrRegistry&) = delete;
 
    SDR_API
    SdrRegistry();
 
    SDR_API
    ~SdrRegistry();
 
private:
    class _DiscoveryContext;
    friend class _DiscoveryContext;
 
    using _TypeToParserPluginMap = 
        std::unordered_map<TfToken, SdrParserPlugin*, TfToken::HashFunctor>;
 
    // Node cache data structure, stored SdrShaderNodes keyed by
    // identifier and source type.
    using _ShaderNodeMapKey = std::pair<SdrIdentifier, TfToken>;
    using _ShaderNodeMap =
        std::unordered_map<_ShaderNodeMapKey, SdrShaderNodeUniquePtr, TfHash>;
 
    // Discovery results data structure, SdrShaderNodeDiscoveryResults
    // multimap keyed ny identifier
    using _DiscoveryResultsByIdentifier = std::unordered_multimap<
        TfToken, SdrShaderNodeDiscoveryResult, TfHash>;
    using _DiscoveryResultsByIdentifierRange = 
        std::pair<_DiscoveryResultsByIdentifier::const_iterator,
                  _DiscoveryResultsByIdentifier::const_iterator>;
 
    // Discovery results data structure: a multimap of raw pointers to 
    // SdrShaderNodeDiscoveryResults (i.e. pointers to the discovery results
    // stored in a _DiscoveryResultsByIdentifier) keyed by name.
    using _DiscoveryResultPtrsByName = std::unordered_multimap<
        std::string, const SdrShaderNodeDiscoveryResult *, TfHash>;
    using _DiscoveryResultPtrsByNameRange = 
        std::pair<_DiscoveryResultPtrsByName::const_iterator,
                  _DiscoveryResultPtrsByName::const_iterator>;
 
    // The discovery result data structures are not concurrent and must be kept
    // in sync, thus they need some locking infrastructure.
    mutable std::mutex _discoveryResultMutex;
 
    // The node map is not a concurrent data structure, thus it needs some
    // locking infrastructure. Ensure that _discoveryResultMutex is not
    // acquired after _nodeMapMutex is acquired, to avoid deadlock.
    mutable std::mutex _nodeMapMutex;
 
    // Runs each discovery plugin provided and adds the results to the
    // internal discovery result maps
    void _RunDiscoveryPlugins(
        const DiscoveryPluginRefPtrVec& discoveryPlugins);
 
    // Takes the discovery and puts in the maps that hold the discovery
    // results, keeping them in sync.
    void _AddDiscoveryResultNoLock(SdrShaderNodeDiscoveryResult&& dr);
 
    // Finds and instantiates the discovery plugins
    void _FindAndInstantiateDiscoveryPlugins();
 
    // Finds and instantiates the parser plugins
    void _FindAndInstantiateParserPlugins();
 
    // Instantiates the specified parser plugins and adds them to
    // the registry.
    void _InstantiateParserPlugins(const std::set<TfType>& parserPluginTypes);
 
    // Parses the node for the discovery result if adding it to the node map if
    // able and adds the discovery result to the discovery result maps.
    // Intended for the GetShadeNodeFromAsset and GetShaderNodeFromSourceCode
    // APIs which can add nodes that don't already appear in the discovery
    // results.
    SdrShaderNodeConstPtr _ParseNodeFromAssetOrSourceCode(
        SdrParserPlugin &parser, SdrShaderNodeDiscoveryResult &&dr);
 
    // Implementation helper for getting the first node of the given sourceType 
    // in the range of node discovery results for a paricular identifier.
    SdrShaderNodeConstPtr _GetNodeInIdentifierRangeWithSourceType(
        _DiscoveryResultsByIdentifierRange range, const TfToken& sourceType);
 
    // Implementation helper for getting the first node of the given sourceType 
    // and matching the given version filter in the range of node discovery 
    // results for a paricular name.
    SdrShaderNodeConstPtr _GetNodeInNameRangeWithSourceType(
        _DiscoveryResultPtrsByNameRange range, const TfToken& sourceType,
        SdrVersionFilter filter);
 
    // Thread-safe find of a shader node in the cache by key.
    SdrShaderNodeConstPtr _FindNodeInCache(
        const _ShaderNodeMapKey &key) const;
 
    // Thread-safe insertion of a node into the cache with a given key. If a 
    // node with the same key already exists in the cache, the pointer to the
    // existing node will be returned, otherwise the pointer to pointer to the
    // inserted node is returned.
    SdrShaderNodeConstPtr _InsertNodeInCache(
        _ShaderNodeMapKey &&key, SdrShaderNodeUniquePtr &&node);
 
    // Finds an existing node in the node cache for the discovery result if one
    // exists. Otherwise it parses the new node, inserts it into the cache, and
    // returns it. If there was an error parsing or validating the node, 
    // `nullptr` will be returned.
    SdrShaderNodeConstPtr _FindOrParseNodeInCache(
        const SdrShaderNodeDiscoveryResult& dr);
 
    // Return the parser plugin for a discovery type. Returns null if no parser 
    // plugin has that discovery type.
    SdrParserPlugin*
    _GetParserForDiscoveryType(const TfToken& discoveryType) const;
 
    // The discovery plugins that were found through libplug and/or provided by
    // the client
    DiscoveryPluginRefPtrVec _discoveryPlugins;
 
    // The parser plugins that have been discovered via the plugin system. Maps
    // a discovery result's "discovery type" to a specific parser.
    _TypeToParserPluginMap _parserPluginMap;
 
    // The parser plugins.  This has ownership of the plugin objects.
    std::vector<std::unique_ptr<SdrParserPlugin>> _parserPlugins;
 
    // The preliminary discovery results prior to parsing. These are stored 
    // in a multimap by identifier and a multimap by name. If accessing or
    // mutating, _discoveryResultMutex should be used.
    _DiscoveryResultsByIdentifier _discoveryResultsByIdentifier;
    _DiscoveryResultPtrsByName _discoveryResultPtrsByName;
 
    // Set of all possible source types as determined by the existing discovery
    // results. Populated along with the discovery result multimaps. If 
    // accessing or mutating, _discoveryResultMutex should be used.
    TfToken::Set _allSourceTypes;
 
    // Maps a node's identifier and source type to a node instance. If accessing
    // or mutating, _nodeMapMutex should be used.
    _ShaderNodeMap _nodeMap;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDR_REGISTRY_H