ShaderGenerator.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
 
 
#pragma once
 
#include <QStringList>
#include <QString>
#include <string>
#include <list>
#include <map>
#include <vector>
 
#include <ACG/GL/gl.hh>
#include <ACG/Config/ACGDefines.hh>
 
 
namespace ACG
{
 
 
// #define MAX_SHADER_INPUT_UNITS 32
// #define MAX_SHADER_CONSTANTS 0x200
// #define MAX_SHADER_GEN_DEFINES 0x100
#define SG_MAX_SHADER_LIGHTS 8
 
enum ShaderGenLightType
{
  SG_LIGHT_DIRECTIONAL = 0,
  SG_LIGHT_POINT,
  SG_LIGHT_SPOT,
  SG_LIGHT_FORCE_DWORD = 0xFFFFFFFF
};
 
enum ShaderGenShadeMode
{
  SG_SHADE_UNLIT = 0,
  SG_SHADE_FLAT,
  SG_SHADE_GOURAUD,
  SG_SHADE_PHONG,
  SG_SHADE_FORCE_DWORD = 0xFFFFFFFF
};
 
class ShaderGenDesc
{
 
public:
  ShaderGenDesc() :
    version(150),
    numLights(0),
    twoSidedLighting(false),
    shadeMode(SG_SHADE_UNLIT),
    vertexColors(false),
    vertexTemplateFile(""),
    tessControlTemplateFile(""),
    tessEvaluationTemplateFile(""),
    geometryTemplateFile(""),
    fragmentTemplateFile(""),
    normalizeTexColors(true),
    colorMaterialMode(GL_AMBIENT_AND_DIFFUSE),
    clipDistanceMask(0),
    textureTypes_(),
    texGenDim(0),
    texGenMode(GL_EYE_LINEAR),
    texGenPerFragment(false)
  {
    for ( unsigned int i = 0 ; i < SG_MAX_SHADER_LIGHTS ; ++i)
      lightTypes[i] = SG_LIGHT_DIRECTIONAL;
    if(!ACG::openGLVersionTest(3,2))   // version 140 or less
    {
      if(!ACG::openGLVersionTest(3,1)) // assume version 130
      {                            // less is not supported
        version = 130;
        if(ACG::checkExtensionSupported("EXT_texture_buffer"))
          macros.append(QString("#extension GL_EXT_texture_buffer:  enable"));
      }
      else        // version 140 texture buffer is part of spec
      {
        version = 140;
      }
    }
  }
 
  //In case, something crashes with the light types, try this hammer ;-)
//  const ShaderGenDesc& operator= (const ShaderGenDesc& _rhs) {
// 
//    version = _rhs.version;
// 
//    numLights                         = _rhs.numLights;
//    twoSidedLighting                  = _rhs.twoSidedLighting;
// 
//    std::copy(_rhs.lightTypes,_rhs.lightTypes+SG_MAX_SHADER_LIGHTS,lightTypes);
//    textureTypes_ = _rhs.textureTypes_;
// 
//    shadeMode                         = _rhs.shadeMode;
//    vertexColors                      = _rhs.vertexColors;
//    vertexTemplateFile                = _rhs.vertexTemplateFile;
//    tessControlTemplateFile           = _rhs.tessControlTemplateFile;
//    tessEvaluationTemplateFile        = _rhs.tessEvaluationTemplateFile;
//    geometryTemplateFile              = _rhs.geometryTemplateFile;
//    fragmentTemplateFile              = _rhs.fragmentTemplateFile;
// 
//    textureTypes_ = _rhs.textureTypes_;
// 
//    return *this;
//  }
 
  // glsl version, i.e. 130, 150, 330 etc.
  // Versions before 130 are not supported (deprecated "varying", "ftransform".. stuff)
  // Specification of each version available on http://www.opengl.org/registry/
  // default: 150 (OpenGL 3.2, supports geometry shaders, msaa samplers, gl_PrimitiveID )
  int version;
 
  int numLights;
  ShaderGenLightType lightTypes[SG_MAX_SHADER_LIGHTS];
 
  bool twoSidedLighting;
 
  ShaderGenShadeMode shadeMode;
 
  bool vertexColors;
 
  // optionally specify shader template file names
  QString vertexTemplateFile;
  QString tessControlTemplateFile;
  QString tessEvaluationTemplateFile;
  QString geometryTemplateFile;
  QString fragmentTemplateFile;
 
  // optionally specify shader mod ids
  std::vector<unsigned int> shaderMods;
 
  // preprocessor macros for the shaders
  // these are added to all shaders directly after the #version directive
  QStringList macros;
 
  QString toString() const;
 
  bool normalizeTexColors;
 
  QString vertexColorsInterpolator;
 
  QString vertexNormalInterpolator;
 
  // color material for input vertex colors: GL_EMISSION, GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_AMBIENT_AND_DIFFUSE
  // Usage of vertex colors in lighting function, as diffuse, emission, ambient color ..  see glColorMaterial()
  // default: GL_AMBIENT_AND_DIFFUSE
  GLenum colorMaterialMode;
 
  // Bitmask of enabled hardware clip planes.
  // Bit i represents the i'th clip plane starting at the least significant bit.
  // This is needed to pass the gl_ClipDistance[] array through the geometry shader stage.
  uint clipDistanceMask;
 
  struct TextureType
  {
    GLenum type;
    bool shadow;
  };
private:
  // TODO: remove this, multitexturing always requires some customization! should be done via custom shader templates or mods. only allow one diffuse texture, as this is something commonly used and intentions are clear
  std::map<size_t,TextureType> textureTypes_;
 
public:
  const std::map<size_t,TextureType>& textureTypes() const {return textureTypes_;}
 
  void addTextureType(GLenum _type, bool _shadow, size_t _stage)
  {
    TextureType t;
    t.type = _type;
    t.shadow = _shadow;
    textureTypes_[_stage] = t;
  }
 
  void clearTextures(){textureTypes_.clear();}
 
  bool textured()const {return !textureTypes_.empty();}
 
 
 
  // automatic texture coordinate generation, emulation of glTexGen
  // this takes priority over any texcoords provided via addTextureType 
 
  // dimension of generated texture coordinate: 0,1,2,3,4  (default: 0 - disabled)
  int texGenDim;
 
  // texture generation mode: GL_OBJECT_LINEAR, GL_EYE_LINEAR, GL_SPHERE_MAP, GL_NORMAL_MAP, GL_REFLECTION_MAP
  GLenum texGenMode; 
 
  // generate texture coordinates per vertex or fragment
  // default: false -> per vertex
  bool texGenPerFragment;
 
  void enableTexGenObjectLinear(int _dim = 2)
  {
    texGenDim = std::max(std::min(_dim, 4), 0);
    texGenMode = GL_OBJECT_LINEAR;
  }
 
  void enableTexGenEyeLinear(int _dim = 2)
  {
    texGenDim = std::max(std::min(_dim, 4), 0);
    texGenMode = GL_EYE_LINEAR;
  }
 
  void enableTexGenSphericalMap(int _dim = 2)
  {
    texGenDim = std::max(std::min(_dim, 2), 0);
    texGenMode = GL_SPHERE_MAP;
  }
 
  void enableTexGenNormalMap(int _dim = 3)
  {
    texGenDim = std::max(std::min(_dim, 3), 0);
    texGenMode = GL_NORMAL_MAP;
  }
 
  void enableTexGenReflectionMap(int _dim = 3)
  {
    texGenDim = std::max(std::min(_dim, 3), 0);
    texGenMode = GL_REFLECTION_MAP;
  }
 
  void disableTexGen() { texGenDim = 0; }
 
 
  // comparison operator
  bool operator == (const ShaderGenDesc& _rhs) const
  {
    if (numLights != _rhs.numLights)
      return false;
 
    if ( twoSidedLighting != _rhs.twoSidedLighting )
      return false;
 
    if (shadeMode != _rhs.shadeMode)
      return false;
 
    if (vertexColors != _rhs.vertexColors)
      return false;
 
    if (textured() != _rhs.textured())
      return false;
 
    if (vertexColors)
    {
      if (vertexColorsInterpolator != _rhs.vertexColorsInterpolator)
        return false;
 
      if (colorMaterialMode != _rhs.colorMaterialMode)
        return false;
    }
 
    if (!geometryTemplateFile.isEmpty())
    {
      // clip distance mask only affects the geometry shader
      if (clipDistanceMask != _rhs.clipDistanceMask)
        return false;
    }
 
    if (fragmentTemplateFile != _rhs.fragmentTemplateFile)
      return false;
 
    if (geometryTemplateFile != _rhs.geometryTemplateFile)
      return false;
 
    if (vertexTemplateFile != _rhs.vertexTemplateFile)
      return false;
 
    if (tessControlTemplateFile != _rhs.tessControlTemplateFile)
      return false;
 
    if (tessEvaluationTemplateFile != _rhs.tessEvaluationTemplateFile)
      return false;
 
    if (macros != _rhs.macros)
      return false;
 
    if (texGenDim != _rhs.texGenDim)
      return false;
 
    if (texGenDim)
    {
      if (texGenMode != _rhs.texGenMode)
        return false;
 
      if (texGenPerFragment != _rhs.texGenPerFragment)
        return false;
    }
 
    if (shaderMods != _rhs.shaderMods)
      return false;
 
    if (vertexNormalInterpolator != _rhs.vertexNormalInterpolator)
      return false;
 
    if (numLights)
      return memcmp(lightTypes, _rhs.lightTypes, numLights * sizeof(ShaderGenLightType)) == 0;
 
    return true;
  }
};
 
 
class ACGDLLEXPORT ShaderGenerator
{
public:
 
  ShaderGenerator();
  virtual ~ShaderGenerator();
 
 
  struct DefaultIODesc
  {
    DefaultIODesc();
 
    bool inputTexCoord_, // texcoords
      inputColor_,    // vertex colors 
      inputNormal_;   // view space normals
 
    bool passPosVS_, // view space position
      passPosOS_, // object space position
      passTexCoord_, // texcoords
      passColor_,    // vertex colors 
      passNormalVS_, // view space normals
      passNormalOS_; // object space normals
  };
  
 
  void setGLSLVersion(int _version);
 
  void addIncludeFile(QString _fileName);
 
  void initVertexShaderIO(const ShaderGenDesc* _desc, const DefaultIODesc* _iodesc);
 
  void initTessControlShaderIO(const ShaderGenDesc* _desc, ShaderGenerator* _prevStage, const DefaultIODesc* _iodesc);
 
  void initTessEvalShaderIO(const ShaderGenDesc* _desc, ShaderGenerator* _prevStage, const DefaultIODesc* _iodesc);
 
  void initGeometryShaderIO(const ShaderGenDesc* _desc, ShaderGenerator* _prevStage, const DefaultIODesc* _iodesc);
 
  void initFragmentShaderIO(const ShaderGenDesc* _desc, ShaderGenerator* _prevStage, const DefaultIODesc* _iodesc);
 
  void initDefaultUniforms();
 
  void addInput(const QString& _input);
 
  void addInput(const QString& _type, const QString& _varname) { addInput(_type + QString(" ") + _varname); }
 
  void addOutput(const QString& _output);
 
  void addOutput(const QString& _type, const QString& _varname) { addOutput(_type + QString(" ") + _varname); }
 
 
  void addUniform(QString _uniform, QString _comment = "");
 
  void addDefine(const QString& _define);
 
  void addIODefine(const QString& _macroName, const QString& _resolvedName);
 
  void addMacros(const QStringList& _macros);
 
  bool hasDefine(QString _define) const;
 
  void addLayout(QString _layout);
 
 
  void addRawIOBlock(QStringList _codeBlock) {rawIO_.append(_codeBlock);}
 
  void addLight(int lightIndex_, ShaderGenLightType _light);
 
  void buildShaderCode(QStringList* _pMainCode, const QStringList& _defaultLightingFunctions);
 
  const QStringList& getShaderCode();
 
  void saveToFile(const char* _fileName);
 
 
  void matchInputs(const ShaderGenerator* _previousShaderStage, bool _passToNextStage, QString _inputPrefix = "outVertex", QString _outputPrefix = "outGeometry");
 
  void defineIOAbstraction(const DefaultIODesc* _iodesc, bool _vs, bool _fs);
 
  int getNumOutputs() const;
 
  QString getOutputName(int _id) const;
 
  int getNumInputs() const;
 
  QString getInputName(int _id) const;
 
  QString getIOMapName(int _inId) const;
 
 
public:
 
  struct Keywords 
  {
    Keywords();
 
    // preprocessor macros that can be defined
 
    // request vertex attributes that should be available in all shader stages:
    QString macro_requestPosVS, // view space position
      macro_requestPosOS,       // object space position
      macro_requestTexcoord,    // mesh texture coordinate
      macro_requestVertexColor, // vertex color
      macro_requestNormalVS,    // view space normal
      macro_requestNormalOS;    // object space normal
 
    // input / output abstraction macros
    QString macro_inputPosVS,
      macro_inputPosOS,
      macro_inputPosCS,
      macro_inputNormalVS,
      macro_inputNormalOS,
      macro_inputTexcoord,
      macro_inputVertexColor,
 
      macro_outputPosVS,
      macro_outputPosOS,
      macro_outputPosCS,
      macro_outputNormalVS,
      macro_outputNormalOS,
      macro_outputTexcoord,
      macro_outputVertexColor;
 
    // default input/output variable names without prefixes
    QString ioPosCS,
      ioPosOS,
      ioPosVS,
      ioNormalVS,
      ioNormalOS,
      ioTexcoord,
      ioColor;
 
    // input/output prefix at each shader stage
    QString vs_inputPrefix,
      vs_outputPrefix,
      tcs_outputPrefix,
      tes_outputPrefix,
      gs_outputPrefix,
      fs_outputPrefix;
 
    // actual input/output of vertex shader
    QString vs_inputPosition,
      vs_inputNormal,
      vs_inputTexCoord,
      vs_inputColor,
      vs_outputPosCS,
      vs_outputPosVS,
      vs_outputPosOS,
      vs_outputTexCoord,
      vs_outputNormalVS,
      vs_outputNormalOS,
      vs_outputVertexColor,
      fs_outputFragmentColor;
  };
 
  static const Keywords keywords;
 
private:
 
  void addStringToList(QString _str, QStringList* _list, QString _prefix = "", QString _postfix = "");
 
  void addIOToCode(const QStringList& _cmds);
 
  QStringList code_;
 
 
  QStringList imports_;
 
  int version_;
 
  QStringList inputs_;
  QStringList outputs_;
  QStringList uniforms_;
  QStringList genDefines_;
  QStringList layouts_;
 
  QStringList rawIO_;
 
  bool inputArrays_;
 
  bool outputArrays_;
 
  QString inputPrefix_;
 
  QString outputPrefix_;
};
 
 
 
class ACGDLLEXPORT ShaderModifier
{
  friend class ShaderProgGenerator;
 
public:
  ShaderModifier(void);
  virtual ~ShaderModifier(void);
 
  virtual void modifyVertexIO(ShaderGenerator* _shader) {}
 
  virtual void modifyVertexBeginCode(QStringList* _code) {}
 
  virtual void modifyVertexEndCode(QStringList* _code) {}
 
  virtual void modifyGeometryIO(ShaderGenerator* _shader) {}
 
  virtual void modifyTessControlIO(ShaderGenerator* _shader) {}
 
  virtual void modifyTessEvalIO(ShaderGenerator* _shader) {}
 
  virtual void modifyFragmentIO(ShaderGenerator* _shader) {}
 
  virtual void modifyFragmentBeginCode(QStringList* _code) {}
 
  virtual void modifyFragmentEndCode(QStringList* _code) {}
 
  virtual void modifyLightingCode(QStringList* _code, int _lightId, ShaderGenLightType _lightType) {}
 
  virtual bool replaceDefaultLightingCode() {return false;}
 
  unsigned int getID() {return modifierID_;}
 
 
  static ShaderModifier* loadFromFile(QString _filename);
 
 
//  operator unsigned int() const {return modifierID_;}
  operator std::vector<unsigned int>() const {return std::vector<unsigned int>(1,modifierID_);}
 
  std::vector<unsigned int> operator | (const std::vector<unsigned int>& _v) const
  {
    std::vector<unsigned int> r(1 + _v.size(), modifierID_);
    for (size_t i = 0; i < _v.size(); ++i)
      r[i + 1] = _v[i];
    return r;
  }
 
private:
  unsigned int modifierID_;
};
 
 
class ACGDLLEXPORT ShaderProgGenerator
{
public:
 
  static void setShaderDir(QString _dir);
 
  static QString getShaderDir();
 
  explicit ShaderProgGenerator(const ShaderGenDesc* _desc);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, const std::vector<unsigned int>& _modifierIDs);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, const std::vector<unsigned int>* _modifierIDs);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, const unsigned int* _modifierIDs, unsigned int _numModifiers);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, ShaderModifier* const* _modifiers, unsigned int _numModifiers);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, const std::vector<ShaderModifier*>& _modifiers);
 
  ShaderProgGenerator(const ShaderGenDesc* _desc, const std::vector<ShaderModifier*>* _modifiers);
 
  virtual ~ShaderProgGenerator(void);
 
 
  void saveVertexShToFile(const char* _fileName);
  void saveGeometryShToFile(const char* _fileName);
  void saveFragmentShToFile(const char* _fileName);
 
  const QStringList& getVertexShaderCode();
 
  const QStringList& getTessControlShaderCode();
 
  const QStringList& getTessEvaluationShaderCode();
 
  const QStringList& getGeometryShaderCode();
 
  const QStringList& getFragmentShaderCode();
 
  
  int getNumActiveModifiers() const;
 
  ShaderModifier* getActiveModifier(int _i);
 
 
  static unsigned int registerModifier(ShaderModifier* _modifier);
 
  bool hasGeometryShader() const;
 
  bool hasTessControlShader() const;
 
  bool hasTessEvaluationShader() const;
 
  void generateShaders();
 
  static bool loadStringListFromFile(QString _fileName, QStringList* _out);
 
  static QString getAbsFilePath(QString _fileName);
 
private:
 
  void loadShaderTemplateFromFile();
 
  void scanShaderTemplate(QStringList& _templateSrc, QString _templateFilename, QStringList* _outLayoutDirectives = 0);
 
  void init(const ShaderGenDesc* _desc, ShaderModifier* const* _modifiers, unsigned int _numActiveMods);
  void init(const ShaderGenDesc* _desc, const unsigned int* _modifiers, unsigned int _numActiveMods);
 
  void buildVertexShader();
  void buildTessControlShader();
  void buildTessEvalShader();
  void buildGeometryShader();
  void buildFragmentShader();
 
  void addVertexBeginCode(QStringList* _code);
  void addVertexEndCode(QStringList* _code);
 
  void addFragmentBeginCode(QStringList* _code);
  void addFragmentEndCode(QStringList* _code);
 
  void addLightingFunctions(QStringList* _code);
 
  void addLightingCode(QStringList* _code);
 
  void modifyLightingCode(QStringList* _code, ShaderModifier* _modifier);
 
  void addTexGenCode(QStringList* _code, bool _fragmentShader);
 
  static QString getPathName(QString _strFileName);
 
  int checkForIncludes(QString _str, ShaderGenerator* _gen, QString _includePath);
 
  int checkForIncludes(QString _str, QStringList* _outImport, QString _includePath);
 
 
  void initGenDefines(ShaderGenerator* _gen);
 
  static void loadLightingFunctions();
 
  ShaderGenerator* vertex_;
  ShaderGenerator* tessControl_;
  ShaderGenerator* tessEval_;
  ShaderGenerator* geometry_;
  ShaderGenerator* fragment_;
 
  QStringList vertexTemplate_;
  QStringList tessControlTemplate_;
  QStringList tessEvalTemplate_;
  QStringList geometryTemplate_;
  QStringList fragmentTemplate_;
 
  ShaderGenDesc   desc_;
  std::vector<ShaderModifier*> activeMods_;
 
 
  static int numRegisteredModifiers_;
  static std::vector<ShaderModifier*> registeredModifiers_;
 
  QString vertexShaderFile_;
  QString tessControlShaderFile_;
  QString tessEvalShaderFile_;
  QString geometryShaderFile_;
  QString fragmentShaderFile_;
 
  QStringList tessControlLayout_;
  QStringList tessEvalLayout_;
 
 
  ShaderGenerator::DefaultIODesc ioDesc_;
 
 
  static QString shaderDir_;
  static QStringList lightingCode_;
 
  
};
 
 
//=============================================================================
} // namespace ACG
//=============================================================================