GlslProgram.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_GLSLPROGRAM_H
#define MATERIALX_GLSLPROGRAM_H
 
 
#include <MaterialXRenderGlsl/Export.h>
 
#include <MaterialXRender/Camera.h>
#include <MaterialXRender/GeometryHandler.h>
#include <MaterialXRender/ImageHandler.h>
#include <MaterialXRender/LightHandler.h>
 
#include <MaterialXGenShader/Shader.h>
 
MATERIALX_NAMESPACE_BEGIN
 
// Shared pointer to a GlslProgram
using GlslProgramPtr = std::shared_ptr<class GlslProgram>;
 
class MX_RENDERGLSL_API GlslProgram
{
  public:
    static GlslProgramPtr create()
    {
        return GlslProgramPtr(new GlslProgram());
    }
 
    virtual ~GlslProgram();
 
 
    void setStages(ShaderPtr shader);
 
    void addStage(const string& stage, const string& sourceCode);
 
    const string& getStageSourceCode(const string& stage) const;
 
    ShaderPtr getShader() const
    {
        return _shader;
    }
 
 
    void build();
 
    bool hasBuiltData();
 
    // Clear built shader program data, if any.
    void clearBuiltData();
 
 
    struct MX_RENDERGLSL_API Input
    {
        static int INVALID_OPENGL_TYPE;
 
        int location;
        int gltype;
        int size;
        string typeString;
        MaterialX::ValuePtr value;
        bool isConstant;
        string path;
        string unit;
        string colorspace;
 
        Input(int inputLocation, int inputType, int inputSize, const string& inputPath) :
            location(inputLocation),
            gltype(inputType),
            size(inputSize),
            isConstant(false),
            path(inputPath)
        { }
    };
    using InputPtr = std::shared_ptr<Input>;
    using InputMap = std::unordered_map<string, InputPtr>;
 
    const InputMap& getUniformsList();
 
    const InputMap& getAttributesList();
 
    void findInputs(const string& variable,
                    const InputMap& variableList,
                    InputMap& foundList,
                    bool exactMatch);
 
 
    bool bind();
 
    bool hasActiveAttributes() const;
 
    bool hasUniform(const string& name);
 
    void bindUniform(const string& name, ConstValuePtr value, bool errorIfMissing = true);
 
    void bindAttribute(const GlslProgram::InputMap& inputs, MeshPtr mesh);
 
    void bindPartition(MeshPartitionPtr partition);
 
    void bindMesh(MeshPtr mesh);
 
    void unbindGeometry();
 
    void bindTextures(ImageHandlerPtr imageHandler);
 
    void bindLighting(LightHandlerPtr lightHandler, ImageHandlerPtr imageHandler);
 
    void bindViewInformation(CameraPtr camera);
 
    void bindTimeAndFrame(float time = 1.0f, float frame = 1.0f);
 
    void unbind() const;
 
 
    void printUniforms(std::ostream& outputStream);
 
    void printAttributes(std::ostream& outputStream);
 
 
  public:
    static unsigned int UNDEFINED_OPENGL_RESOURCE_ID;
    static int UNDEFINED_OPENGL_PROGRAM_LOCATION;
 
  protected:
    GlslProgram();
 
    // Update a list of program input uniforms
    const InputMap& updateUniformsList();
 
    // Update a list of program input attributes
    const InputMap& updateAttributesList();
 
    // Utility to find a uniform value in an uniform list.
    // If uniform cannot be found a null pointer will be return.
    ValuePtr findUniformValue(const string& uniformName, const InputMap& uniformList);
 
    // Bind an individual texture to a program uniform location
    ImagePtr bindTexture(unsigned int uniformType, int uniformLocation, const FilePath& filePath,
                         ImageHandlerPtr imageHandler, const ImageSamplingProperties& imageProperties);
 
    // Utility to map a MaterialX type to an OpenGL type
    static int mapTypeToOpenGLType(TypeDesc type);
 
    // Bind a value to the uniform at the given location.
    void bindUniformLocation(int location, ConstValuePtr value);
 
  private:
    // Stages used to create program
    // Map of stage name and its source code
    StringMap _stages;
 
    // Generated program. A non-zero number indicates a valid shader program.
    unsigned int _programId;
 
    // List of program input uniforms
    InputMap _uniformList;
    // List of program input attributes
    InputMap _attributeList;
 
    // Hardware shader (if any) used for program creation
    ShaderPtr _shader;
 
    // Attribute buffer resource handles
    // for each attribute identifier in the program
    std::unordered_map<string, unsigned int> _attributeBufferIds;
 
    // Attribute indexing buffer handle
    std::map<MeshPartitionPtr, unsigned int> _indexBufferIds;
 
    // Attribute vertex array handle
    unsigned int _vertexArray;
 
    // Currently bound mesh
    MeshPtr _boundMesh;
 
    // Program texture map
    std::unordered_map<string, unsigned int> _programTextures;
 
    // Enabled vertex stream program locations
    std::set<int> _enabledStreamLocations;
};
 
MATERIALX_NAMESPACE_END
 
#endif