ShaderMaterial.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_RENDER_SHADER_MATERIAL_H
#define MATERIALX_RENDER_SHADER_MATERIAL_H
 
 
#include <MaterialXCore/Generated.h>
#include <MaterialXRender/Image.h>
#include <MaterialXRender/Mesh.h>
#include <MaterialXRender/ImageHandler.h>
#include <MaterialXRender/LightHandler.h>
#include <MaterialXRender/Camera.h>
#include <MaterialXGenShader/UnitSystem.h>
 
#include <memory>
 
MATERIALX_NAMESPACE_BEGIN
 
using MaterialPtr = std::shared_ptr<class ShaderMaterial>;
 
class MX_RENDER_API ShadowState
{
  public:
    ImagePtr shadowMap;
    Matrix44 shadowMatrix;
    ImagePtr ambientOcclusionMap;
    float ambientOcclusionGain = 0.0f;
};
 
class MX_RENDER_API ShaderMaterial
{
  public:
    ShaderMaterial();
    virtual ~ShaderMaterial();
 
    void setDocument(DocumentPtr doc);
 
    DocumentPtr getDocument() const;
 
    void setElement(TypedElementPtr val);
 
    TypedElementPtr getElement() const;
 
    void setMaterialNode(NodePtr node);
 
    NodePtr getMaterialNode() const;
 
    void setUdim(const std::string& val);
 
    const std::string& getUdim();
 
    virtual bool loadSource(const FilePath& vertexShaderFile,
                            const FilePath& pixelShaderFile,
                            bool hasTransparency) = 0;
 
    virtual bool generateShader(GenContext& context) = 0;
 
    virtual void copyShader(MaterialPtr ShaderMaterial) = 0;
 
    virtual bool generateShader(ShaderPtr hwShader) = 0;
 
    virtual bool generateEnvironmentShader(GenContext& context,
                                           const FilePath& filename,
                                           DocumentPtr stdLib,
                                           const FilePath& imagePath);
 
    ShaderPtr getShader() const;
 
    bool hasTransparency() const;
 
    virtual bool bindShader() const = 0;
 
    virtual void bindViewInformation(CameraPtr camera) = 0;
 
    virtual void bindImages(ImageHandlerPtr imageHandler,
                            const FileSearchPath& searchPath,
                            bool enableMipmaps = true) = 0;
 
    virtual void unbindImages(ImageHandlerPtr imageHandler) = 0;
 
    virtual ImagePtr bindImage(const FilePath& filePath,
                               const std::string& uniformName,
                               ImageHandlerPtr imageHandler,
                               const ImageSamplingProperties& samplingProperties) = 0;
 
    virtual void bindLighting(LightHandlerPtr lightHandler,
                              ImageHandlerPtr imageHandler,
                              const ShadowState& shadowState) = 0;
 
    virtual void bindMesh(MeshPtr mesh) = 0;
 
    virtual bool bindPartition(MeshPartitionPtr part) const = 0;
 
    virtual void drawPartition(MeshPartitionPtr part) const = 0;
 
    virtual void unbindGeometry() = 0;
 
    virtual VariableBlock* getPublicUniforms() const = 0;
 
    virtual ShaderPort* findUniform(const std::string& path) const = 0;
 
    virtual void modifyUniform(const std::string& path,
                               ConstValuePtr value,
                               std::string valueString = EMPTY_STRING) = 0;
 
  protected:
    virtual void clearShader() = 0;
 
  protected:
    ShaderPtr _hwShader;
    MeshPtr _boundMesh;
 
    DocumentPtr _doc;
    TypedElementPtr _elem;
    NodePtr _materialNode;
 
    std::string _udim;
    bool _hasTransparency;
 
    ImageVec _boundImages;
};
 
MATERIALX_NAMESPACE_END
 
#endif