ShaderDataGenerator.h

Go to the documentation of this file.

#ifndef B_SHADER_DATA_GENERATOR_H
#define B_SHADER_DATA_GENERATOR_H

#include "IShaderData.h"
#include "MaterialData.h"
#include "Texture.h"

struct ShaderGeneratorSettings
{
    GLuint maxLights;               // The maximum number of light sources to be used 
    bool ambientLighting;           // Set true if the shader should support ambient lighting
    bool diffuseLighting;           // Set true if the shader should support diffuse lighting
    bool specularLighting;          // Set true if the shader should support specular lighting
    bool ambientColor;              // Set true if the material specifies an ambient color (usually Ka)
    bool diffuseColor;              // Set true if the material specifies a diffuse color (usually Kd)
    bool specularColor;             // Set true if the material specifies a specular color (usually Ks)
    bool diffuseMap;                // Set true if a texture should be used for diffuse coloring
    bool normalMap;                 // Set true if a texture should be used to define the normal vectors
    bool specularMap;               // Set true if a texture should be used to define specularity
    bool transparencyValue;         // Set true if a transparency value should be passed
    bool variableNumberOfLights;    // Set true if the number of lights may vary, otherwise the number of lights has to be the same as specified as maximum number of lights
    bool isText;                    // Set true if the shader should be used for displaying text
};

class ShaderDataGenerator : public IShaderData
{
public:

    /* Typedefs */
    typedef std::unordered_map<std::string, std::string>        TextureMap;
    typedef std::unordered_map<std::string, std::string>        CubeRelflectionMap;
    typedef std::unordered_map<std::string, vmml::Vector3f>     Vector3Map;
    typedef std::unordered_map<std::string, GLfloat>            ScalarMap;

    /* Functions */

    ShaderDataGenerator();

    ShaderDataGenerator(GLuint maxLights, bool ambientLighting, const MaterialData &materialData, bool variableNumberOfLights, bool isText);

    ShaderDataGenerator(const ShaderGeneratorSettings &shaderGeneratorSettings);

    virtual ~ShaderDataGenerator() {}

    ShaderDataGenerator &create(const ShaderGeneratorSettings &shaderGeneratorSettings);

    std::string getVertShaderSrc()  const   { return _vertShaderSrc; }

    std::string getFragShaderSrc()  const   { return _fragShaderSrc; }

    GLuint getMaxLights() const { return _maxLights; }

    bool supportsVariableNumberOfLights() const { return _variableNumberOfLights; }

    bool supportsAmbientLighting() const    { return _ambientLighting; }

    bool supportsDiffuseLighting() const    { return _diffuseLighting; }

    bool supportsSpecularLighting() const   { return _specularLighting; }

    bool supportsCubicReflectionMap() const { return _cubicReflectionMap; }

    bool        isValid()           const   { return _valid; }

private:

    /* Functions */

    void buildShader();
    void initializeSourceCommonVariables();
    void createVertShader();
    void createFragShader();
    void readMaterialAttributes(GLuint maxLights, bool variableNumberOfLights, bool ambientLighting, bool isText, const TextureMap &t, const Vector3Map &v, const ScalarMap &s);
    
    /* Variables */

    std::string _vertShaderSrc;
    std::string _fragShaderSrc;
    bool        _valid;

    GLuint      _maxLights;
    bool        _variableNumberOfLights;
    bool        _ambientLighting;
    bool        _diffuseLighting;
    bool        _specularLighting;
    bool        _ambientColor;
    bool        _diffuseColor;
    bool        _specularColor;
    bool        _diffuseMap;
    bool        _normalMap;
    bool        _specularMap;
    bool        _cubicReflectionMap;
    bool        _transparencyValue;
    bool        _isText;

};

#endif /* defined(B_SHADER_DATA_GENERATOR_H) */