glfBatch.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 __glfBatch_hh__
#define __glfBatch_hh__

#include "glfRenderTarget.hh"
#include "glfViewport.hh"
#include "glfTexture.hh"
#include "glfDepthBufferMode.hh"
#include "glfStencilBufferMode.hh"
#include "glfBlendMode.hh"
#include "glfShaderProgram.hh"
#include "glfVertexBuffer.hh"
#include "glfElementBuffer.hh"
#include "glfMatrix.hh"

namespace BIAS {

  /**
   * \brief A batch represents a single Draw call including all parameters (render states).
   * \attention The pointers to all objects passed to the 'Set...' functions must still
   * be valid when the batch is rendered. The objects are not copied!
   * \ingroup g_openglframework 
   * \author jkollmann
   */
  class BIASOpenGLFramework_EXPORT glfBatch {
  public:
    glfBatch();
    ~glfBatch();

    /**
     * Sets the render target. Must be non-NULL. Default render target is 'glfScreen'.
     */
    void SetRenderTarget(const glfRenderTarget* renderTarget);

    /**
     * Sets the viewport. Must be non-NULL. There is no default viewport, so
     * you _must_ set one.
     */
    void SetViewport(const glfViewport* viewport);

    /**
     * Sets the texture of a texture unit. NULL is allowed. Defaults are NULL.
     * If a texture of a texture unit is NULL, it should not be used.
     */
    void SetTexture(const glfTexture* texture, int textureUnit);
    
    unsigned int GetMaxUsedTextureIndex();
    
    /**
     * Releases texture including the matrix associated with
     * the argument index.
     */
    void ReleaseTextures(unsigned int fromIndex);

    /**
     * Sets the depth buffer mode. 
     * Defaults to GL Default.
     * \Attention If passed NULL, the currently set GL state is used!  
     */
    void SetDepthBufferMode(const glfDepthBufferMode* depthBufferMode);

    /**
     * Sets the stencil buffer mode. 
     * Defaults to GL Default.
     * \Attention If passed NULL, the currently set GL state is used!
     */
    void SetStencilBufferMode(const glfStencilBufferMode* stencilBufferMode);


    /**
    * Sets the blend mode. 
    * Defaults to GL Default.
    * \Attention If passed NULL, the currently set GL state is used!
    */
    void SetBlendMode(const glfBlendMode* blendMode);

    /**
     * Sets the shader program. NULL is allowed. If the shader program is NULL,
     * the fixed-function pipeline is used.
     */
    void SetShaderProgram(const glfShaderProgram* shaderProgram);

    /**
     * Sets the vertex buffer. Must be non-NULL.
     */
    void SetVertexBuffer(const glfVertexBuffer* vertexBuffer);

    /**
     * Sets the element buffer. NULL is allowed. If no element buffer is used,
     * you call Batch::SetPrimitiveType and vertices will be rendered
     * straight from the vertex buffer.
     */
    void SetElementBuffer(const glfElementBuffer* elementBuffer);

    /**
     * Sets the primitive type to rendering.
     * This is used only if no element buffer is provided.
     * Valid primitive types are be GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP,
     * GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES,
     * GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON.
     */
    void SetPrimitiveType(GLenum primitiveType);

    /**
     * Sets the range of vertices to be rendered if no element buffer is
     * set, or the range of vertex indices if an element buffer is set.
     * By default, all geometry will be rendered.
     */
    void SetRange(int first, int count);

    /**
     * Sets the modelview matrix. Must be non-NULL. Default is the identity matrix.
     */
    void SetModelViewMatrix(const glfMatrix* matrix);

    /**
     * Sets the projection matrix. Must be non-NULL. Default is the identity matrix.
     */
    void SetProjectionMatrix(const glfMatrix* matrix);

    /**
     * Sets a texture matrix. NULL is allowed. If a texture matrix is NULL,
     * it will not be set and is undefined. Make sure to not use a texture
     * matrix that is not set.
     */
    void SetTextureMatrix(const glfMatrix* matrix, int index);

    unsigned int GetMaxUsedTextureMatrixIndex() const;
    
    /**
     * Releases texture matrices including the matrix associated with
     * the argument index.
     */
    void ReleaseTextureMatrices(unsigned int fromIndex);

    /**
     * Draws the batch.
     */
    void Draw();

    /**
     * Sets all render states possibly modified by Batch to the OpenGL defaults.
     * Should be called before using an external library that uses OpenGL.
     * \note: The viewport cannot be set to default, because the default is
     * unknown to Batch.
     */
    static void SetDefaultRenderStates();

    static int GetMaxSupportedTextureUnits();
    static int GetMaxSupportedTextureMatrices();

    void Init();

  private:
    void BindRenderStates();

    GLint MAX_TEXTURE_UNITS_;
    GLint MAX_TEXTURE_COORDS_;
    bool initialized_;
    int maxUsedTextureIndex_;
    int maxUsedTextureMatrixIndex_;

    const glfViewport* viewport_;
    std::vector<const glfTexture*> textures_;
    const glfDepthBufferMode* depthBufferMode_;
    const glfStencilBufferMode* stencilBufferMode_;
    const glfBlendMode* blendMode_;
    const glfShaderProgram* shaderProgram_;
    const glfRenderTarget* renderTarget_;
    const glfVertexBuffer* vertexBuffer_;
    const glfElementBuffer* elementBuffer_;
    GLenum primitiveType_;
    int first_, count_;
    const glfMatrix* modelViewMatrix_;
    const glfMatrix* projectionMatrix_;
    std::vector<const glfMatrix*> textureMatrix_;
  };
  
} // namespace BIAS

#endif // __glfBatch_hh__