PlainPerPixelProcessing.hh

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

 Copyright (C) 2003-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 __PlainPerPixelProcessing_hh__
#define __PlainPerPixelProcessing_hh__

#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Base/glfTexture2D.hh>

#include <vector>
#include <list>

#include <bias_config.h> // for MIPOpenGLFramework_EXPORT

namespace BIAS {
  /** Class rendering quad and executing a fragment shader.
   * \ingroup g_openglframework 
  * \attention Do not use any class function without valid context!
  * \author bartczak
  **/
  class BIASOpenGLFramework_EXPORT PlainPerPixelProcessing {
  public:
    PlainPerPixelProcessing(bool flip = false);

    /** Adds textures in their respective index order and assigns them the 
     *  default names img<index> in the shader programm.
     *  \attention Will relink the programm so all uniforms set 
     *  directly on the program  (GetProgram()) will have to be set again!
     **/
    void SetTextures(const std::vector<BIAS::glfTexture2D*>& inputTextures);
    void SetTextures(std::list<BIAS::glfTexture2D*>& inputTextures);
    void SetTexture(BIAS::glfTexture2D* inputTexture);
    void ReleaseTextures();

    void SetSamplerNames(const std::vector<std::string>& samplerNames);

    // /** \deprecated use SwapGLObjects instead**/
    // enum PingPongID {ping=0, pong=1};
    // /** \deprecated use SwapGLObjects instead**/
    // void SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
    //                          const std::vector<BIAS::glfTexture2D*>& pong,
    //                          const PlainPerPixelProcessing::PingPongID& activeID);
    // /** \deprecated use SwapGLObjects instead**/
    // void SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
    //                          const std::vector<BIAS::glfTexture2D*>& pong,
    //                          const std::vector<BIAS::glfTexture2D*>& unSwapped,
    //                          const PlainPerPixelProcessing::PingPongID& activeID);
    // /** \deprecated use SwapGLObjects instead**/
    // void SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
    //                          const std::vector<BIAS::glfTexture2D*>& pong,
    //                          BIAS::glfTexture2D* unSwapped,
    //                          const PlainPerPixelProcessing::PingPongID& activeID);


    // /** Returns the currently set texture set; 
    // * \deprecated use SwapGLObjects instead
    // **/
    // PingPongID SwapPingPongTextures();
    // /** \deprecated use SwapGLObjects instead**/
    // PingPongID GetCurrentPingPongID() const;
    // /** \deprecated use SwapGLObjects instead**/
    // static inline PingPongID GetPingPongIDComplement(const PingPongID ppid) {
    //   if(ppid==ping) return pong;
    //   else return ping;
    // }
    
    void SetOutputSize(unsigned int width, unsigned int height);
    void SetRenderTarget(BIAS::glfRenderTarget* rt);

    void SetFragmentShaderFromFile(const std::string& fileName);
    void SetFragmentShaderFromString(const std::string& source);

 /*   void Link();
    glfShaderProgram* GetProgram();*/
    void SetUniform(const std::string& name, float val);
    void SetUniform(const std::string& name, int val);

    glfDepthBufferMode& GetDepthBufferMode();
    
    void Execute();

    void SetFlip(bool flip=true);
  protected:
    bool basicInit_;
    bool initialized_;
    unsigned int numInputTextures_;
    bool flipTexCoord_;
    void Init_();

    BIAS::glfBatch batch_;
    void InitBatch_();

    BIAS::glfVertexBuffer vertices_;
    BIAS::glfElementBuffer elements_;
    void InitPrimitiveData_();

    BIAS::glfMatrix ModelViewMatrix_;
    BIAS::glfMatrix ProjectionMatrix_;
    BIAS::glfViewport viewport_;
    void InitVertexTransformation_();

    BIAS::glfShaderProgram shaderProgram_;
    BIAS::glfShader fragmentShader_;
    void InitShaders_();

    BIAS::glfDepthBufferMode depthTest_;
    //    void InitPerFragmentOperations_();

    PlainPerPixelProcessing(const PlainPerPixelProcessing&) {}
    PlainPerPixelProcessing& operator=(const PlainPerPixelProcessing&) {return (*this); }

    std::vector<std::string> samplerNames_;

    // bool usePingPongTextures_;
    // bool isPing_;
    // std::vector<BIAS::glfTexture2D*> PingPongTex_[2];

    bool externalUniformsChanged_;
    std::map<std::string, float> uniformsFloat_;
    std::map<std::string, int> uniformsInt_;


  };
} //end of namespace


#endif