ShaderRenderer.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_SHADERRENDERER_H
#define MATERIALX_SHADERRENDERER_H
 
 
#include <MaterialXRender/Camera.h>
#include <MaterialXRender/GeometryHandler.h>
#include <MaterialXRender/ImageHandler.h>
#include <MaterialXRender/LightHandler.h>
 
#include <MaterialXGenShader/Shader.h>
 
MATERIALX_NAMESPACE_BEGIN
 
using RenderContextHandle = void*;
 
using ShaderRendererPtr = std::shared_ptr<class ShaderRenderer>;
 
class MX_RENDER_API ShaderRenderer
{
  public:
    enum class MatrixConvention
    {
        OpenGL = 0,
        Metal = 1
    };
    using StageMap = StringMap;
 
  public:
    virtual ~ShaderRenderer() { }
 
 
    virtual void initialize(RenderContextHandle = nullptr) { }
 
    void setCamera(CameraPtr camera)
    {
        _camera = camera;
    }
 
    CameraPtr getCamera() const
    {
        return _camera;
    }
 
    void setImageHandler(ImageHandlerPtr imageHandler)
    {
        _imageHandler = imageHandler;
    }
 
    ImageHandlerPtr getImageHandler() const
    {
        return _imageHandler;
    }
 
    void setLightHandler(LightHandlerPtr lightHandler)
    {
        _lightHandler = lightHandler;
    }
 
    LightHandlerPtr getLightHandler() const
    {
        return _lightHandler;
    }
 
    void setGeometryHandler(GeometryHandlerPtr geometryHandler)
    {
        _geometryHandler = geometryHandler;
    }
 
    GeometryHandlerPtr getGeometryHandler() const
    {
        return _geometryHandler;
    }
 
 
    virtual void createProgram(ShaderPtr shader);
 
    virtual void createProgram(const StageMap& stages);
 
    virtual void validateInputs() { }
 
    virtual void updateUniform(const string& name, ConstValuePtr value);
 
    virtual void setSize(unsigned int width, unsigned int height);
 
    virtual void render() { }
 
 
    virtual ImagePtr captureImage(ImagePtr image = nullptr)
    {
        return nullptr;
    }
 
 
  protected:
    ShaderRenderer(unsigned int width, unsigned int height, Image::BaseType baseType,
                   MatrixConvention matrixConvention = MatrixConvention::OpenGL);
 
  protected:
    unsigned int _width;
    unsigned int _height;
    Image::BaseType _baseType;
 
    MatrixConvention _matrixConvention;
 
    CameraPtr _camera;
    ImageHandlerPtr _imageHandler;
    GeometryHandlerPtr _geometryHandler;
    LightHandlerPtr _lightHandler;
};
 
class MX_RENDER_API ExceptionRenderError : public Exception
{
  public:
    ExceptionRenderError(const string& msg, const StringVec& errorLog = StringVec()) :
        Exception(msg),
        _errorLog(errorLog)
    {
    }
 
    ExceptionRenderError(const ExceptionRenderError& e) :
        Exception(e),
        _errorLog(e._errorLog)
    {
    }
 
    ExceptionRenderError& operator=(const ExceptionRenderError& e)
    {
        Exception::operator=(e);
        _errorLog = e._errorLog;
        return *this;
    }
 
    const StringVec& errorLog() const
    {
        return _errorLog;
    }
 
  private:
    StringVec _errorLog;
};
 
MATERIALX_NAMESPACE_END
 
#endif