TemplateSpecializedBatch.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 __TemplateSpecializedBatch_hh__
#define __TemplateSpecializedBatch_hh__

#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Base/glfRenderTarget.hh>
#include <OpenGLFramework/Base/glfDepthBufferMode.hh>
#include <OpenGLFramework/Base/glfViewport.hh>
#include <OpenGLFramework/Base/glfMatrix.hh>
#include <OpenGLFramework/Base/glfTexture2D.hh>
#include <bias_config.h> 


namespace BIAS {

  /** This file contains the header for a class template.
  * This template shall aid in the usage of the OpenGLFramework,
  * by proposing an implementation scheme to encapsulate OpenGL processings.
  * The whole proposal is based on the Batch concept proposed in the OpenGLFramework.
  * As such the implementation can be emphesised as mantic gathering and 
  * maintenance of the necessary stateinformation to execute one or multiple 
  * rendering passes.
  *
  * \author bartczak 04/2008
  **/
  class BIASOpenGLFramework_EXPORT TemplateSpecializedBatch {
  public:
    enum ProcessingScheme {myProcessingScheme=0, myOtherProcessingScheme};
  protected:
    /** This enum is used to tell the class how it shall behave and setup
    * GL states, it is specified using Init().
    **/
     ProcessingScheme processingScheme_;
  public:    

    TemplateSpecializedBatch();

    /** \name Pre Init Calls.
    * In this section methods are found that must be issued to the obejcts BEFORE
    * Init() is called.
    */
    /** @{ */
    //void SomeUsefullStateSetter();
    /** @} */

    /** \name Calls when appropriate Context is available.
    */
    /** @{ */
    /** This method initializes all necessary GL structures. 
    * \attention must not be called before appropriate GLContext is available!
    **/
    void Init(TemplateSpecializedBatch::ProcessingScheme ps);

    /** \name Communication with other GPU work steps*/
    /** @{ */

    /** Method determines where the results are delivered. 
    * The default is the Screen, which is the same to passing NULL.
    * 
    **/
    void SetRenderTarget(BIAS::glfRenderTarget* rt);

    /** Method determines the viewport size, which is used in
    * the render target.
    **/
    void SetViewport(unsigned int viewportWidth, 
      unsigned int viewportHeight, unsigned int viewportOx = 0, 
      unsigned int viewportOy = 0      );

    /** Textures are a pretty way to exchange information between GPU worksteps. 
    * Although some kind of polymorphism is 
    * available not all texture object implement the same amount of functionality.
    * I therefore propose to implement the appropriate, specialized interface.
    **/
    // void SetTexture(some texture pointer);
    // void GetTexture(some texture pointer reference);
    /** @} */

    /** \name General I/O */
    /** @{ */
    /** Some textures will certainly be created internally.
    * The UploadTextureContent routines, take care to fill them with content.
    * Currently not all texture targets are fully implemented, therefore
    * I also propose to implement the appropriate interface.
    **/
    void UploadTextureImage(BIAS::ImageBase& img);

    /** It will certainly be necessary to pass non GL specific data 
    * to influence the processing. 
    * If changes are made that make a reinitilaization necessary 
    * you should work with flags that are evaluated before drawing 
    * and are processed when all state changes have been gathered.
    * Use the Update() and the PreExecute_() methods for that.
    **/
    //void SetParameter<MoreInfo>(some object/primitive type);

    /** Method evaluates set parameters and adapts the GL state. **/
    void Update();

    /** @} */

    /** 
    *  Configures GL and issues a "rendering" on the GPU.
    **/
    void Execute();
    /** @} */

  protected:
    /** Guard for multiple calls to Init().
    * This way one can prohibit conflicts with already setup 
    * shader programms, which would start throwing exceptions.
    **/
    bool initialized_;

    /** This flag deteremines whether the PreExecute method has to be called or not. **/
    bool callPreExecuteFlag_;

    /** Is the first call performed by the Execute method called.
    * This method can be used to update shader parameters etc.
    **/
    void PreExecute_();


    //*************************
    //      Batch Assembly 
    //*************************
    /** \name Batch Assembly */
    /** @{ */
    /** This is the core implementation that determines how
    * updates to the GL state are handled. In this all GL state updates are 
    * gathered and the update stratgy is implemented here.
    **/
    BIAS::glfBatch batch_;
    /** Connects all data used in GL processing to the batch.
    **/
    void InitBatch_();
    /** @} */


    //*************************
    //  Geometry Specification 
    //*************************
    /** \name Geometry Specification */
    /** @{ */
    /** If you want to process something, you will need vertex data! 
    * Of course its possible to have it defined and managed outside this
    * class, but here is the general idea.
    **/
    BIAS::glfVertexBuffer vertices_;

    /** Element buffers can be suitable are however not mandatory. **/
    BIAS::glfElementBuffer elements_;

    /** Creates the associated GL objects and the content of vertices_ and elements_.
    * Connection to batch_ is performed in InitBatch_().
    **/
    void InitPrimitiveData_();
    /** @} */


    //*************************
    //        Textures
    //*************************
    /** \name Textures. 
    * Various textures exist in opengl however we did not implement them all yet.
    * Whats pretty heavily used is the Texture2D class, which therefore is well implemented...
    * Number of texture matrices and textures, which be handled in a single pass might differ!
    **/
    /** @{ */
    BIAS::glfTexture2D textureInTextureUnit0;
    //Texture2D textureInTextureUnit1;
    //Texture2D textureInTextureUnit...;
    //Texture2D textureInTextureUnitM;


    /** Creates and initializes the necessary textures.
    * Connection to batch_ is performed in InitBatch_().
    **/
    void InitTextureData_();

    //RenderMatrix textureMatrixInTextureUnit0;
    //RenderMatrix textureMatrixInTextureUnit1;
    //RenderMatrix textureMatrixInTextureUnit...;  
    //RenderMatrix textureMatrixInTextureUnitN;  

    /** Creates and initializes the necessary texture matrices.
    * Connection to batch_ is performed in InitBatch_().
    **/
    void InitTextureMatrixData_();
    /** @} */

    
    //*************************
    //  Vertex Transformation
    //*************************
    /** \name Vertex Transformation. 
    * GL contains a default vertex processing chain, which requires the specification
    * of an affine transformation matrix, the ModelView matrix, and a Projection Matrix.
    * In the end projected vertices are mapped to a viewport.
    **/
    /** @{ */
    BIAS::glfMatrix ModelViewMatrix_;
    BIAS::glfMatrix ProjectionMatrix_;   

    /** Create and setup the render matrices and the viewport. 
    * Connection to batch_ is performed in InitBatch_().
    * The viewport is not changed here! It is changed by 
    * SetViewport method.
    **/
    void InitVertexTransformation_();

    BIAS::glfViewport viewport_;
    /** @} */


    //*************************
    //         Shaders
    //*************************
    /** \name Shaders.
    * The GL processing pipeline is made more flexible by the useage of Shaders. 
    * You do not have to use shaders. Yet I guess the shaders are the reason for using
    * the OpenGLFramework in the first place... 
    * (remove these lines and their usage should you not need them?!)
    **/
    /** @{ */
    BIAS::glfShaderProgram shaderProgram_;
    /* Vertex shaders do not have to be used!*/
    //Shader vertexShader_;
    BIAS::glfShader fragmentShader_;

    /** Creates and issues initialization of shader execution.
    * Connection to batch_ is performed in InitBatch_().
    **/
    void InitShaders_();
    /** @} */


    //*************************
    // Per Fragment Operations
    //*************************
    /** \name Per Fragment Operations.
    * In the Gl process ing pipeline after shader application per pixel
    * operations are performed. This are depth test, stencil test, blending ... .
    * Still not all tests are wraped in the OpenGLFramework, but when needed they will.
    **/
    /** @{ */
    BIAS::glfDepthBufferMode depthTest_;

    //BlendMode blending_;

    /** Create and setup the per fragment operations.
    * Connection to batch_ is performed in InitBatch_().
    **/
    void InitPerFragmentOperations_();
    /** @} */

  };

}//end of namespace

#endif