material.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_ST_MATERIAL_H
#define PXR_IMAGING_HD_ST_MATERIAL_H
 
#include "pxr/pxr.h"
#include "pxr/imaging/hdSt/api.h"
#include "pxr/imaging/hdSt/materialNetwork.h"
#include "pxr/imaging/hdSt/shaderCode.h"
#include "pxr/imaging/hd/material.h"
#include "pxr/imaging/hf/perfLog.h"
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
using HdSt_MaterialNetworkShaderSharedPtr =
        std::shared_ptr<class HdSt_MaterialNetworkShader>;
 
class HioGlslfx;
 
class HdStMaterial final: public HdMaterial
{
public:
    HF_MALLOC_TAG_NEW("new HdStMaterial");
 
    struct VolumeMaterialData final
    {
        std::string source;
        HdSt_MaterialParamVector params;
    };
 
    HDST_API
    HdStMaterial(SdfPath const& id);
    HDST_API
    ~HdStMaterial() override;
 
    HDST_API
    void Sync(HdSceneDelegate *sceneDelegate,
              HdRenderParam   *renderParam,
              HdDirtyBits     *dirtyBits) override;
 
    HDST_API
    void Finalize(HdRenderParam *renderParam) override;
 
    HDST_API
    HdDirtyBits GetInitialDirtyBitsMask() const override;
 
    HDST_API
    HdSt_MaterialNetworkShaderSharedPtr GetMaterialNetworkShader() const;
 
    inline const VolumeMaterialData &GetVolumeMaterialData() const;
 
    inline bool HasPtex() const;
 
    inline bool HasLimitSurfaceEvaluation() const;
 
    // Returns true if the material has a displacement terminal.
    inline bool HasDisplacement() const;
 
    inline bool IsUsingFallbackShader() const;
 
    // Returns the material's render pass tag.
    inline const TfToken& GetMaterialTag() const;
 
    HDST_API
    void SetMaterialNetworkShader(
        HdSt_MaterialNetworkShaderSharedPtr &shaderCode);
 
private:
    // Processes the texture descriptors from a material network to
    // create textures using the Storm texture system.
    //
    // Adds buffer specs/sources necessary for textures, e.g., bindless
    // handles or sampling transform for field textures.
    void _ProcessTextureDescriptors(
        HdSceneDelegate * sceneDelegate,
        HdStResourceRegistrySharedPtr const& resourceRegistry,
        std::weak_ptr<HdStShaderCode> const &shaderCode,
        HdStMaterialNetwork::TextureDescriptorVector const &descs,
        HdStShaderCode::NamedTextureHandleVector * texturesFromStorm,
        HdBufferSpecVector * specs,
        HdBufferSourceSharedPtrVector * sources);
    
    bool
    _GetHasLimitSurfaceEvaluation(VtDictionary const & metadata) const;
 
    void _InitFallbackShader();
 
    static HioGlslfx *_fallbackGlslfx;
 
    HdSt_MaterialNetworkShaderSharedPtr _materialNetworkShader;
    VolumeMaterialData _volumeMaterialData;
 
    bool _isInitialized : 1;
    bool _hasPtex : 1;
    bool _hasLimitSurfaceEvaluation : 1;
    bool _hasDisplacement : 1;
    bool _isUsingFallbackShader : 1;
 
    TfToken _materialTag;
    size_t _textureHash;
 
    HdStMaterialNetwork _networkProcessor;
};
 
inline bool HdStMaterial::HasPtex() const
{
    return _hasPtex;
}
 
inline bool HdStMaterial::HasLimitSurfaceEvaluation() const
{
    return _hasLimitSurfaceEvaluation;
}
 
inline bool HdStMaterial::HasDisplacement() const
{
    return _hasDisplacement;
}
 
inline const TfToken& HdStMaterial::GetMaterialTag() const
{
    return _materialTag;
}
 
inline bool HdStMaterial::IsUsingFallbackShader() const
{
    return _isUsingFallbackShader;
}
 
inline const HdStMaterial::VolumeMaterialData &
HdStMaterial::GetVolumeMaterialData() const {
    return _volumeMaterialData;
}
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HD_ST_MATERIAL_H