SimpleMultiPassFragmentShader.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef SIMPLE_MULTIPASS_FRAGMENT_SHADER_HH_
#define SIMPLE_MULTIPASS_FRAGMENT_SHADER_HH_

#include <OpenGLFramework/RenderingContext/glfPBuffer.hh>
#include <OpenGLFramework/Utils/ShaderProgramPool.hh>
#include <OpenGLFramework/Utils/Texture2DPool.hh>
#include <OpenGLFramework/Utils/FramebufferSetupPool.hh>
#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Utils/Primitives.hh>
#include <map>
#include <bias_config.h>

namespace BIAS
{

  /** Class allows to add actions different then rendering to the multipass shader execution. 
   * \ingroup g_openglframework 
  * \author bartczak 03/2009
  **/
  class BIASOpenGLFramework_EXPORT SMPFSActionInterface {
  public:
    /** Executes the post action.
     * \param currentIter is the current iteration of the Execute call.
     * \param numIter is the overall number of iterations of the Execute call.
     **/
    virtual ~SMPFSActionInterface(){}
    virtual void Execute(const unsigned int& currentIter, const unsigned int& numIter) = 0;
    virtual SMPFSActionInterface* Clone() const = 0;
    /** Allows to bring the object to some initial position. **/
    virtual void Reset() {};

  };

  /**
   * this class collects a number of shaders and textures uniquely identified by their names
   * shader uniforms can be set by addressing the shaders by their names
   * textures a shader reads from and writes to can be spezified by setting input and output textures addressing the textures through their names
   * calling Execute with a vector of shader names as parameter executes all shaders on the gpu in the order given by the shader names vector
   *
   * Usage Example:
   *   SimpleMultiPassFragmentShader smpfs;
   *   smpfs.Init(); // init pBuffer context. Init(false) requires glContext to be created manually
   *
   *   smpfs.AddFragmentShader(shader_source, "ShaderName"); // shader_source is a string
   *
   *   smpfs.LoadTexture(...) or smpfs.CreateTexture(...)
   *
   *   smpfs.SetShaderVariable(...) // set uniform variables if required; textures not allowed
   *
   *   smpfs.SetInputTextures("ShaderName", ...) and smpfs.SetOutputTextures("ShaderName", ...)
   *
   *   for (...) {
   *   smpfs.Execute(...);
   *   smpfs.SetShaderVariable(...); //change uniform variables
   *   }
   *
   *   smpfs.CopyToImage(string("VariableName"), image); //get result from texture
   *
   * \ingroup g_openglframework 
   * \author frick
   **/
  class BIASOpenGLFramework_EXPORT SimpleMultiPassFragmentShader
  {
  public:

    /**
     * standard constructor
     */
    SimpleMultiPassFragmentShader();

    /**
     * initializes openGL context (if createGLContext = true) and some internal variables, must be called first
     */
    void
    Init(bool createGLContext = true);

    /**
     * resets this object
     */
    void
    Destroy();

    /**
     * adds an fragment shader with name shader_name and shader source code shader_source
     */
    void
    AddFragmentShader(const std::string& shader_source,
        const std::string& shader_name);

    /**
     * adds an fragment shader with name shader_name from file shader_path to the shader_source
     */
    void
    AddFragmentShaderFromFile(const std::string& shader_path,
        const std::string& shader_name);

    /**
     * loads an image as texture with name texture_name
     */
    void
    LoadTexture(const ImageBase& image, const std::string& texture_name,
        GLenum minFilter = GL_NEAREST, GLenum magFilter = GL_NEAREST,
        GLenum wrapS = GL_CLAMP, GLenum wrapT = GL_CLAMP,
        GLenum internalFormat = 0, int mipmap = 0);

    /**
     * creates new texture with name texture_name
     * (for example storageType ImageBase::ST_float, colorModel ImageBase::CM_Grey creates a 1 channel float texture)
     *
     */
    void
    CreateTexture(int width, int height, ImageBase::EStorageType storageType,
        ImageBase::EColorModel colorModel, const std::string& texture_name,
        GLenum minFilter = GL_NEAREST, GLenum magFilter = GL_NEAREST,
        GLenum wrapS = GL_CLAMP, GLenum wrapT = GL_CLAMP, int mipmap = 0);
     void
    CreateTexture(int width, int height, GLenum internalFormat, const std::string& texture_name,
        GLenum minFilter = GL_NEAREST, GLenum magFilter = GL_NEAREST,
        GLenum wrapS = GL_CLAMP, GLenum wrapT = GL_CLAMP, int mipmap = 0);

    /**
     * sets all textures from vector texture_names as input textures
     * the vector sampler2D holds the names of the textures in shader source code
     * each texture_names[i] will be bind to the shader uniform sampler2D variable with name sampler2D[i]
     */
    void
        SetInputTextures(const std::string& shader_name, const std::vector<
            std::string>& samplers2D,
            const std::vector<std::string>& texture_names);

    /**
    * Asociated the texture from texture pool with name <texturePoolName>, with the
    * uniform sampler named <uniformName> in shader source of shader <sahderName>.
    */
     void
        SetInputTextures(const std::string& shaderName, const std::string& uniformVarName,
            const std::string& texturePoolName);

    /**
     * sets all textures from vector texture_names as output textures for the shader shader_name
     */
    void
    SetOutputTextures(const std::string& shader_name, 
    const std::vector<std::string>& texture_names, const std::string& depthTextureName = "");

    /**
     * sets a texture with name texture_name as output texture for the shader shader_name
     */
    void
    SetOutputTexture(const std::string& shader_name,
    const std::string& texture_name, const std::string& depthTextureName = "");

    /**
     * executes all shaders with names in shader_names vector in the given order (iter_number)-times
     */
    void
    Execute(const std::vector<std::string>& shader_names,
        unsigned int iter_number = 1);

    /**
     * copies texture with the texture_name to image
     */
    void
    CopyToImage(const std::string& texture_name, ImageBase& image);

    /**
     * copies texture with the texture_name to image
     */
    void
    CopyChannelsToImage(const std::string& texture_name, GLenum format, ImageBase& image);


    /**
     * sets the value of uniform shader variable var_name for shader shader_name
     * if the variable type is sampler2D then an glfException is thrown
     * use SetOutput/InputTextures to set this variablews
     */
    template<class StorageType>
      void
      SetShaderVariable(const std::string& shader_name,
          const std::string& var_name, StorageType value);


      /** Sets the depth test for the particular shader execution. 
      * It is not required that the shader already exists, if not used the shaders
      * use the default behaviour implemented in glfDepthBufferMode.
      * \author bartczak 03/2009
      **/
      void SetDepthTest(const std::string& shaderName, 
        const bool enabled, GLenum depthFunc);

      /** Enables the clearence of the output, each time when rendered into.
      * Is per default enabled with the given default parameters.
      * \author bartczak 03/2009 
      **/
      void EnableColorClearance(const std::string& shaderName, 
        float red = 0.0f, float green = 0.0f, float blue = 0.0f, float alpha = 0.0f);

      /** Enables the clearence of the output, each time when rendered into.
      * Is per default enabled with the given default parameters.
      * \author bartczak 03/2009 
      **/
      void EnableDepthClearance(const std::string& shaderName, float depth = 1.0f);

      /** Disables the clearence of the output when rendered into.
      * Per default the clearance is enabled.
      * \author bartczak 03/2009 
      **/
      void DisableColorClearance(const std::string& shaderName);

      /** Disables the clearence of the output when rendered into.
      * Per default the clearance is enabled.
      * \author bartczak 03/2009 
      **/
      void DisableDepthClearance(const std::string& shaderName);

      Texture2DPool& GetTexture2DPool() {return texture_pool_;}
      FramebufferSetupPool& GetFramebufferSetupPool() {return framebuffer_setup_pool_;}
      glfFramebufferObject* GetFBO() {return framebuffer_setup_pool_.GetFBO();}
      

      /** Sets an action that is performed after the respective shader has run.
      * Shader does not have to exist.
      **/
      void SetPostAction(const std::string& shaderName, const SMPFSActionInterface& postAction);
      void ResetPostAction(const std::string& shaderName);
      void ClearPostAction(const std::string& shaderName);

      /** Instead ogf processing a whole image, the fragment shaders are run only on a set of
       * symmetric patches. 
       * \param referenceWidth the patches are calculated relative to this target resolution width.
       * \param referenceHeight the patches are calculated relative to this target resolution height.
       * \param posX the patche's center x position relative to width.
       * \param posX the patche's center y position relative to height.
       * \param hw the patche's half window size.
       * \attention This has to be changed for every target resolution.
       * \attention Call after init.
       * \author bartczak 01/2010
       **/
      void EvaluateOnlyPatches(const unsigned int referenceWidth, 
                               const unsigned int referenceHeight,
                               const std::vector<unsigned int>& posX,
                               const std::vector<unsigned int>& posY,
                               const unsigned int hw);

      /** Instead of processing a whole image, the fragment shaders are run only on a region around an image line.
       * \param referenceWidth the lines are calculated relative to this target resolution width.
       * \param referenceHeight the lines are calculated relative to this target resolution height.
       * \param posy the line's y position.
       * \param hw the half window size around the lines y position.
       * \attention This has to be changed for every target resolution.
       * \attention Call after init.
       * \author bartczak 08/2010
       **/
      void EvaluateOnlyLine(const unsigned int referenceWidth,
                            const unsigned int referenceHeight,
                            const unsigned int posY,
                            const unsigned int hw);

  private:

    std::vector<std::pair<glfTexture*, std::pair<std::string, std::string> > >*
    GetInputTextures_(const std::string& shader_name);
    void
    SetInputTextures_(const std::string& shader_name, std::vector<std::pair<
        glfTexture*, std::pair<std::string, std::string> > >& textures);
    void
        ActivateInputTextures_(const std::string& shader_name,
            std::vector<std::pair<glfTexture*, std::pair<std::string,
                std::string> > >& textures);

    bool IsInputTexture_(const std::string& texture_name);
    bool IsOutputTexture_(const std::string& texture_name);

    std::vector<std::string>*
    GetOutputTextureNames_(const std::string& shader_name);

    bool initialized_, createdGLContext_;

    glfPBuffer pbuffer_;
    Texture2DPool texture_pool_;
    FramebufferSetupPool framebuffer_setup_pool_;
    ShaderProgramPool shader_pool_;
    // key: shader program name - value: vector of pairs: texture pointer -- pair: texture sampler2D name, texture user name (pool name)
    std::map<std::string, std::vector<std::pair<glfTexture*, std::pair<
        std::string, std::string> > > > input_textures_;

    //##################
    glfBatch batch_;
    void
    InitBatch_()
    {
      //      batch_.SetDepthBufferMode(&depthTest_);
      batch_.SetElementBuffer(&elements_);
      batch_.SetVertexBuffer(&vertices_);
      batch_.SetViewport(&viewport_);
      batch_.SetModelViewMatrix(&ModelViewMatrix_);
      batch_.SetProjectionMatrix(&ProjectionMatrix_);
    }

    glfVertexBuffer vertices_;
    glfElementBuffer elements_;
    void
    InitPrimitiveData_()
    {
      Primitives::PlainQuad2DWithTexture2D(vertices_, elements_, false);
    }

    glfMatrix ModelViewMatrix_;
    glfMatrix ProjectionMatrix_;
    glfViewport viewport_;
    void
    InitVertexTransformation_()
    {
      ModelViewMatrix_.MakeIdentity();
      ProjectionMatrix_.MakeIdentity();
    }


    std::map<std::string, glfDepthBufferMode> depthTest_;    
    void ActivateDepthTest_(const std::string& shaderName);

    class ActionGuard{
    public:
      ActionGuard();
      ~ActionGuard();
      ActionGuard(const SMPFSActionInterface* action);
      //void operator=(const SMPFSActionInterface& action);
       void operator=(const SMPFSActionInterface* action);
      void Execute(const unsigned int& currentIter, const unsigned int& numIter);  
      ActionGuard(const ActionGuard& a);
      ActionGuard& operator=(const ActionGuard& a);
      void Reset();
    private:                  
      SMPFSActionInterface* action_;
    };
    std::map<std::string, ActionGuard> postActions_;

  };

  /** Pingpongs  **/
  /*class BIASOpenGLFramework_EXPORT SwapTextureObjectsAction : public SMPFSActionInterface {
  public:
    SwapTextureObjectsAction(glfTexture* texA, glfTexture* texB);
    void SkipLastIteration();
    void MaxNumExecutions(unsigned int maxExecutions);
    void Reset();
    

  private:
    bool skipLastIteration_;
    unsigned int maxExecutions_;
    unsigned int execCounter_;
    glfTexture* texA_;
    glfTexture* texB_;

  }*/

}

#endif /* SIMPLE_MULTIPASS_FRAGMENT_SHADER_HH_ */