renderDelegate.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HD_RENDER_DELEGATE_H
#define PXR_IMAGING_HD_RENDER_DELEGATE_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hd/api.h"
#include "pxr/imaging/hd/aov.h"
#include "pxr/imaging/hd/changeTracker.h"
#include "pxr/imaging/hd/command.h"
#include "pxr/imaging/hd/dataSource.h"
#include "pxr/imaging/hd/rendererCreateArgs.h"
#include "pxr/base/vt/dictionary.h"
#include "pxr/base/tf/token.h"
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdfPath;
class HdRprim;
class HdSprim;
class HdBprim;
class HdSceneDelegate;
class HdRenderIndex;
class HdRenderPass;
class HdInstancer;
class HdDriver;
class Hgi;
 
TF_DECLARE_REF_PTRS(HdSceneIndexBase);
 
using HdRenderPassSharedPtr = std::shared_ptr<class HdRenderPass>;
using HdRenderPassStateSharedPtr = std::shared_ptr<class HdRenderPassState>;
using HdResourceRegistrySharedPtr = std::shared_ptr<class HdResourceRegistry>;
using HdDriverVector = std::vector<HdDriver*>;
 
class HdRenderParam 
{
public:
    HdRenderParam() {}
    HD_API
    virtual ~HdRenderParam();
 
    HD_API
    virtual bool SetArbitraryValue(const TfToken& key, const VtValue& value);
 
    HD_API
    virtual VtValue GetArbitraryValue(const TfToken& key) const;
 
    HD_API
    virtual bool HasArbitraryValue(const TfToken& key) const;
 
    HD_API
    virtual bool IsValid() const;
 
private:
    // Hydra will not attempt to copy the class.
    HdRenderParam(const HdRenderParam &) = delete;
    HdRenderParam &operator =(const HdRenderParam &) = delete;
};
 
typedef TfHashMap<TfToken, VtValue, TfToken::HashFunctor> HdRenderSettingsMap;
 
struct HdRenderSettingDescriptor 
{
    // A human readable name.
    std::string name;
    // The key for HdRenderDelegate::SetRenderSetting/GetRenderSetting.
    TfToken key;
    // The default value.
    VtValue defaultValue;
};
 
typedef std::vector<HdRenderSettingDescriptor> HdRenderSettingDescriptorList;
 
class HdRenderDelegate
{
public:
    HD_API
    virtual ~HdRenderDelegate();
 
    HD_API
    virtual void SetDrivers(HdDriverVector const& drivers);
 
    virtual const TfTokenVector &GetSupportedRprimTypes() const = 0;
 
    virtual const TfTokenVector &GetSupportedSprimTypes() const = 0;
 
 
    virtual const TfTokenVector &GetSupportedBprimTypes() const = 0;
 
    HD_API
    virtual HdRenderParam *GetRenderParam() const;
 
    virtual HdResourceRegistrySharedPtr GetResourceRegistry() const = 0;
 
    HD_API
    virtual void SetRenderSetting(TfToken const& key, VtValue const& value);
 
    HD_API
    virtual VtValue GetRenderSetting(TfToken const& key) const;
 
    template<typename T>
    T GetRenderSetting(TfToken const& key, T const& defValue) const {
        return GetRenderSetting(key).Cast<T>().GetWithDefault(defValue);
    }
 
    HD_API
    virtual HdRenderSettingDescriptorList GetRenderSettingDescriptors() const;
 
    HD_API
    virtual unsigned int GetRenderSettingsVersion() const;
 
    HD_API
    virtual VtDictionary GetRenderStats() const;
 
    HD_API
    virtual HdContainerDataSourceHandle GetCapabilities() const;
 
 
    HD_API
    virtual bool IsPauseSupported() const;
 
    HD_API
    virtual bool IsPaused() const;
 
    HD_API
    virtual bool Pause();
 
    HD_API
    virtual bool Resume();
 
    HD_API
    virtual bool IsStopSupported() const;
 
    HD_API
    virtual bool IsStopped() const;
 
    HD_API
    virtual bool Stop(bool blocking = true);
 
    HD_API
    virtual bool Restart();
 
 
    virtual HdRenderPassSharedPtr CreateRenderPass(HdRenderIndex *index,
                                      HdRprimCollection const& collection) = 0;
 
    HD_API
    virtual HdRenderPassStateSharedPtr CreateRenderPassState() const;
 
 
    virtual HdInstancer *CreateInstancer(HdSceneDelegate *delegate,
                                         SdfPath const& id) = 0;
 
    virtual void DestroyInstancer(HdInstancer *instancer) = 0;
 
 
 
    virtual HdRprim *CreateRprim(TfToken const& typeId,
                                 SdfPath const& rprimId) = 0;
 
    virtual void DestroyRprim(HdRprim *rPrim) = 0;
 
    virtual HdSprim *CreateSprim(TfToken const& typeId,
                                 SdfPath const& sprimId) = 0;
 
    virtual HdSprim *CreateFallbackSprim(TfToken const& typeId) = 0;
 
    virtual void DestroySprim(HdSprim *sprim) = 0;
 
    virtual HdBprim *CreateBprim(TfToken const& typeId,
                                 SdfPath const& bprimId) = 0;
 
 
    virtual HdBprim *CreateFallbackBprim(TfToken const& typeId) = 0;
 
    virtual void DestroyBprim(HdBprim *bprim) = 0;
 
 
    virtual void CommitResources(HdChangeTracker *tracker) = 0;
 
    
    HD_API
    virtual TfToken GetMaterialBindingPurpose() const;
 
 
    HD_API
    virtual TfToken GetMaterialNetworkSelector() const;
 
    HD_API
    virtual TfTokenVector GetMaterialRenderContexts() const;
 
    HD_API
    virtual TfTokenVector GetRenderSettingsNamespaces() const;
 
    HD_API
    virtual bool IsPrimvarFilteringNeeded() const;
 
    HD_API
    virtual TfTokenVector GetShaderSourceTypes() const;
 
 
    HD_API
    virtual HdAovDescriptor GetDefaultAovDescriptor(TfToken const& name) const;
 
    
    HD_API
    virtual HdCommandDescriptors GetCommandDescriptors() const;
 
    HD_API
    virtual bool InvokeCommand(
        const TfToken &command,
        const HdCommandArgs &args = HdCommandArgs());
 
    HD_API
    const std::string &GetRendererDisplayName() {
        return _displayName;
    }
 
    
    HD_API
    virtual void SetTerminalSceneIndex(
        const HdSceneIndexBaseRefPtr &terminalSceneIndex);
 
    HD_API
    virtual void Update();
 
    HD_API
    virtual bool IsParallelSyncEnabled(const TfToken &primType) const;
 
protected:
    HD_API
    HdRenderDelegate();
    HD_API
    HdRenderDelegate(HdRenderSettingsMap const& settingsMap);
 
    HdRenderDelegate(const HdRenderDelegate &) = delete;
    HdRenderDelegate &operator=(const HdRenderDelegate &) = delete;
 
    HD_API
    void _PopulateDefaultSettings(
        HdRenderSettingDescriptorList const& defaultSettings);
 
    HdRenderSettingsMap _settingsMap;
    unsigned int _settingsVersion;
 
private:
 
    friend class HdRendererPlugin;
    void _SetRendererDisplayName(const std::string &displayName) {
        _displayName = displayName;
    }
    std::string _displayName;
 
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif //PXR_IMAGING_HD_RENDER_DELEGATE_H