GLState.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.              *
 *                                                                           *
\*===========================================================================*/
 
//=============================================================================
//
//  CLASS GLState
//
//=============================================================================
 
 
#ifndef ACG_GLSTATE_HH
#define ACG_GLSTATE_HH
 
 
//== INCLUDES =================================================================
 
 
#include "gl.hh"
#include "../Math/GLMatrixT.hh"
#include "../Math/VectorT.hh"
#include "../Config/ACGDefines.hh"
#include "ColorStack.hh"
#include <stack>
#include <vector>
#include <bitset>
#include <deque>
 
#ifdef _MSC_VER
        #pragma warning(push)
        #pragma warning(disable:4251)
#endif
 
//== NAMESPACES ===============================================================
 
 
namespace ACG {
 
 
//== CLASS DEFINITION =========================================================
 
 
struct GLStateContext
{
  // this struct is needed for push/popAttrib operations
  // it contains a copy of the OpenGL state machine
 
public:
  GLStateContext();
 
 
  // glEnable / glDisable states
  // iff a bit is set for a state, it is enabled in OpenGL
  std::bitset<0xFFFF+1> glStateEnabled_;
 
  // element 0: sfactor, 1: dfactor, 2 : alpha_sfactor, 3 : alpha_dfactor
  GLenum blendFuncState_[4];
 
  GLenum blendEquationState_;
 
  GLclampf blendColorState_[4];
 
  GLenum alphaFuncState_;
  GLclampf alphaRefState_;
 
  // depth function
  GLenum depthFunc_;
 
  // buffer targets available in opengl:
  // GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, GL_UNIFORM_BUFFER, GL_SHADER_STORAGE_BUFFER ...
  // current state of a buffer target
  GLuint glBufferTargetState_[14];
 
 
  // active texture unit: GL_TEXTUREi
  GLenum activeTexture_;
 
  // texture generation mode we only support one mode for all coordinates
  GLint texGenMode_;
 
  struct TextureStage
  {
    TextureStage() : target_(0), buf_(0) {}
    // current stage target
    GLenum target_;
    // current stage buffer
    GLuint buf_;
  };
  // 16 texture stages
  TextureStage glTextureStage_[16];
 
  // current shade model: GL_FLAT, GL_SMOOTH, set by glShadeModel
  GLenum shadeModel_;
 
  // current cull face mode: GL_FRONT, GL_FRONT_AND_BACK
  GLenum cullFace_;
 
 
  // current depth range:  zNear and zFar
  GLclampd depthRange_[2];
 
  // vertex pointers, used in glVertexPointer, glTexcoordPointer..
  struct GLVertexPointer
  {
    GLVertexPointer() : size(0), type(0), stride(0), pointer(0) {}
    
    GLint size;
    GLenum type;
    GLsizei stride;
    const GLvoid* pointer;
 
    bool equals(GLint _size, GLenum _type, GLsizei _stride, const GLvoid* _ptr)
    {
      return (size == _size && _type == type && _stride == stride && pointer == _ptr);
    }
 
    void set(GLint _size, GLenum _type, GLsizei _stride, const GLvoid* _ptr)
    {
      size = _size; type = _type; stride = _stride; pointer = _ptr;
    }
  };
 
  GLVertexPointer vertexPointer_;
  GLVertexPointer normalPointer_;
  GLVertexPointer texcoordPointer_;
  GLVertexPointer colorPointer_;
 
 
  // draw buffers
  GLenum drawBufferSingle_;
  GLenum drawBufferState_[16];
  int activeDrawBuffer_; // = 0 -> drawBufferSignle_; != 0 -> drawBufferState
 
  // framebuffer
  //  framebuffer id for each target: 0 - GL_DRAW_FRAMEBUFFER, 1-> GL_READ_FRAMEBUFFER
  GLuint framebuffers_[2];
 
  // current gl shader program
  GLuint program_;
};
 
 
class ACGDLLEXPORT GLState
{
public:
 
  GLState(bool _updateGL = true, bool _compatibilityProfile = true );
 
  ~GLState() {}
 
  void makeCurrent() {  }
 
  static void syncFromGL();
 
  void initialize();
 
  bool updateGL() const { return updateGL_; }
  void set_updateGL(bool _b) { updateGL_ = _b; }
 
  unsigned int msSinceLastRedraw () const { return msSinceLastRedraw_; }
 
  void set_msSinceLastRedraw (unsigned int _ms) { msSinceLastRedraw_ = _ms; }
 
  void setState ();
 
  void clearBuffers ();
 
  //===========================================================================
  //===========================================================================
 
  void setCompatibilityProfile( bool _compatibility );
 
  bool compatibilityProfile() const;
 
private:
 
  bool compatibilityProfile_;
 
  //===========================================================================
  //===========================================================================
 
public:
 
  static void enable(GLenum _cap, bool _warnRemoved = true);
 
  static void disable(GLenum _cap, bool _warnRemoved = true);
 
  static void lockState(GLenum _cap);
 
  static void unlockState(GLenum _cap);
 
  static bool isStateLocked(GLenum _cap);
 
  static bool isStateEnabled(GLenum _cap);
 
 
  static void enableClientState(GLenum _cap);
  static void disableClientState(GLenum _cap);
 
  static void lockClientState(GLenum _cap);
  static void unlockClientState(GLenum _cap);
 
  static bool isClientStateEnabled(GLenum _cap);
  static bool isClientStateLocked(GLenum _cap);
 
 
  static void blendFunc(GLenum _sfactor, GLenum _dfactor) { blendFuncSeparate(_sfactor, _dfactor, _sfactor, _dfactor); }
 
  static void getBlendFunc(GLenum* _sfactor, GLenum* _dfactor) { getBlendFuncSeparate(_sfactor, _dfactor, 0, 0); }
 
  static void lockBlendFunc() { lockBlendFuncSeparate(); }
  static void unlockBlendFunc() { unlockBlendFuncSeparate(); }
  static bool isBlendFuncLocked() {return isBlendFuncSeparateLocked();}
 
 
 
  static void blendFuncSeparate(GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha, GLenum _dstAlpha);
 
  static void getBlendFuncSeparate(GLenum* _srcRGB, GLenum* _dstRGB, GLenum* _srcAlpha, GLenum* _dstAlpha);
 
  static void lockBlendFuncSeparate(bool _rgb = true, bool _alpha = true) { blendFuncSeparateLock_[0] = _rgb; blendFuncSeparateLock_[1] = _alpha; }
  static void unlockBlendFuncSeparate() { lockBlendFuncSeparate(false, false); }
  static bool isBlendFuncSeparateLocked() { return blendFuncSeparateLock_[0] || blendFuncSeparateLock_[1]; }
  static bool isBlendFuncSeparateColorLocked() { return blendFuncSeparateLock_[0]; }
  static bool isBlendFuncSeparateAlphaLocked() { return blendFuncSeparateLock_[1]; }
 
 
  static void blendEquation(GLenum _mode);
 
  static GLenum getBlendEquation() {return stateStack_.back().blendEquationState_;}
 
  static void lockBlendEquation() {blendEquationLock_ = true;}
  static void unlockBlendEquation() {blendEquationLock_ = false;}
  static bool isBlendEquationLocked() {return blendEquationLock_;}
 
  static void blendColor(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha);
 
  static void getBlendColor(GLclampf* _col);
 
  static void lockBlendColor() {blendColorLock_ = true;}
  static void unlockBlendColor() {blendColorLock_ = false;}
  static bool isBlendColorLocked() {return blendColorLock_;}
 
 
  static void alphaFunc(GLenum _func, GLclampf _ref);
 
  static void getAlphaFunc(GLenum* _func, GLclampf* _ref);
 
  static void lockAlphaFunc() {alphaFuncLock_ = true;}
  static void unlockAlphaFunc() {alphaFuncLock_ = false;}
  static bool isAlphaFuncLocked() {return alphaFuncLock_;}
 
 
  static void shadeModel(GLenum _mode);
  static GLenum getShadeModel() {return stateStack_.back().shadeModel_;}
  static void lockShadeModel() {shadeModelLock_ = true;}
  static void unlockShadeModel() {shadeModelLock_ = false;}
  static bool isShadeModelLocked() {return shadeModelLock_;}
 
 
  static void cullFace(GLenum _mode);
  static GLenum getCullFace() {return stateStack_.back().cullFace_;}
  static void lockCullFace() {cullFaceLock_ = true;}
  static void unlockCullFace() {cullFaceLock_ = false;}
  static bool isCullFaceLocked() {return cullFaceLock_;}
 
  static void depthRange(GLclampd _zNear, GLclampd _zFar);
  static void getDepthRange(GLclampd* _zNearOut, GLclampd* _zFarOut);
  static void lockDepthRange() {depthRangeLock_ = true;}
  static void unlockDepthRange() {depthRangeLock_ = false;}
  static bool isDepthRangeLocked() {return depthRangeLock_;}
  
  //===========================================================================
  //===========================================================================
 
  static void vertexPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid* _pointer);
  static void getVertexPointer(GLint* _size, GLenum* _type, GLsizei* _stride, const GLvoid** _pointer);
 
  static void vertexPointer(const Vec2f* _p) {vertexPointer(2, GL_FLOAT, 0, _p);}
  static void vertexPointer(const Vec2d* _p) {vertexPointer(2, GL_DOUBLE, 0, _p);}
  static void vertexPointer(const Vec3f* _p) {vertexPointer(3, GL_FLOAT, 0, _p);}
  static void vertexPointer(const Vec3d* _p) {vertexPointer(3, GL_DOUBLE, 0, _p);}
  static void vertexPointer(const Vec4f* _p) {vertexPointer(4, GL_FLOAT, 0, _p);}
  static void vertexPointer(const Vec4d* _p) {vertexPointer(4, GL_DOUBLE, 0, _p);}
 
  static void lockVertexPointer() {vertexPointerLock_ = true;}
  static void unlockVertexPointer() {vertexPointerLock_ = false;}
  static bool isVertexPointerLocked() {return vertexPointerLock_;}
 
  static void normalPointer(GLenum _type, GLsizei _stride, const GLvoid* _pointer);
  static void getNormalPointer(GLenum* _type, GLsizei* _stride, const GLvoid** _pointer);
 
  static void normalPointer(const Vec3f* _p) { glNormalPointer(GL_FLOAT, 0, _p); }
  static void normalPointer(const Vec3d* _p) { glNormalPointer(GL_DOUBLE, 0, _p); }
 
  static void lockNormalPointer() {normalPointerLock_ = true;}
  static void unlockNormalPointer() {normalPointerLock_ = false;}
  static bool isNormalPointerLocked() {return normalPointerLock_;}
 
 
  static void colorPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid* _pointer);
  static void getColorPointer(GLint* _size, GLenum* _type, GLsizei* _stride, const GLvoid** _pointer);
 
  static void colorPointer(const Vec3uc* _p) {colorPointer(3, GL_UNSIGNED_BYTE, 0, _p);}
  static void colorPointer(const Vec3f* _p) {colorPointer(3, GL_FLOAT, 0, _p);}
  static void colorPointer(const Vec4uc* _p) {colorPointer(4, GL_UNSIGNED_BYTE, 0, _p);}
  static void colorPointer(const Vec4f* _p) {colorPointer(4, GL_FLOAT, 0, _p);}
 
  static void lockColorPointer() {colorPointerLock_ = true;}
  static void unlockColorPointer() {colorPointerLock_ = false;}
  static bool isColorPointerLocked() {return colorPointerLock_;}
 
 
  static void texcoordPointer(GLint _size, GLenum _type, GLsizei _stride, const GLvoid* _pointer);
  static void getTexcoordPointer(GLint* _size, GLenum* _type, GLsizei* _stride, const GLvoid** _pointer);
 
  static void texcoordPointer(const float* _p) {texcoordPointer(1, GL_FLOAT, 0, _p); }
  static void texcoordPointer(const double* _p) {texcoordPointer(1, GL_DOUBLE, 0, _p); }
  static void texcoordPointer(const Vec2f* _p) {texcoordPointer(2, GL_FLOAT, 0, _p); }
  static void texcoordPointer(const Vec2d* _p) {texcoordPointer(2, GL_DOUBLE, 0, _p); }
  static void texcoordPointer(const Vec3f* _p) {texcoordPointer(3, GL_FLOAT, 0, _p); }
  static void texcoordPointer(const Vec3d* _p) {texcoordPointer(3, GL_DOUBLE, 0, _p); }
  static void texcoordPointer(const Vec4f* _p) {texcoordPointer(4, GL_FLOAT, 0, _p); }
  static void texcoordPointer(const Vec4d* _p) {texcoordPointer(4, GL_DOUBLE, 0, _p); }
 
 
  static void setTexGenMode(GLenum _coord, GLenum _name, GLint _param);
 
  static void getTexGenMode(GLenum _coord, GLenum _name, GLint* _param);
 
  static void lockTexcoordPointer() {colorPointerLock_ = true;}
  static void unlockTexcoordPointer() {colorPointerLock_ = false;}
  static bool isTexcoordPointerLocked() {return colorPointerLock_;}
 
 
  //===========================================================================
  //===========================================================================
 
  static void genBuffersARB(GLsizei n, GLuint* buffers);
 
  static void genBuffers(GLsizei n, GLuint* buffers);
 
  static void bufferDataARB(
          GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
 
  static void bufferData(
          GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
 
  static GLvoid* mapBuffer (GLenum target, GLenum access);
 
  static GLboolean unmapBuffer (GLenum target);
 
  static size_t getBufferSize(GLenum _target);
  
  static void deleteBuffers(GLsizei n, const GLuint* buffers);
 
  static void bindBuffer(GLenum _target, GLuint _buffer);  
  static void bindBufferARB(GLenum _target, GLuint _buffer) {bindBuffer(_target, _buffer);}
 
  static void lockBufferTarget(GLenum _target);
  
  static void unlockBufferTarget(GLenum _target);
 
  static bool isBufferTargetLocked(GLenum _target);
 
  static GLuint getBoundBuf(GLenum _target);
 
  static GLenum getShaderType(GLuint _shader);
  
  static size_t getShaderSourceLength(GLuint _shader);
  
  static size_t getShaderSource(GLuint _shader, char* _buffer, size_t _bufferSize);
  
  
  static GLuint getAttachedShader(GLuint _program, GLenum _type);
  
  static void drawBuffer(GLenum _mode);
  static void drawBuffers(GLsizei _n, const GLenum* _bufs);
 
  static void lockDrawBuffer() {drawBufferLock_ = true;}
  static void unlockDrawBuffer() {drawBufferLock_ = false;}
  static bool isDrawBufferLocked() {return drawBufferLock_;}
 
 
  static void bindFramebuffer(GLenum _target, GLuint _framebuffer);
  static GLuint getFramebufferDraw();
  static GLuint getFramebufferRead();
 
  static void lockFramebuffer(GLenum _target);
  static void unlockFramebuffer(GLenum _target);
  static bool isFramebufferLocked(GLenum _target);
 
 
  //===========================================================================
  //===========================================================================
 
  static void useProgram(GLuint _program);
  static GLuint getProgram() {return stateStack_.back().program_;}
 
  static void lockProgram() {programLock_ = true;}
  static void unlockProgram() {programLock_ = false;}
  static bool isProgramLocked() {return programLock_;}
 
 
private:
 
  static int getBufferTargetIndex(GLenum _target);
 
public:
 
  //===========================================================================
  //===========================================================================
 
  static void activeTexture(GLenum _texunit);
  static void activeTextureARB(GLenum _texunit) {activeTexture(_texunit);}
 
 
  inline static GLenum getActiveTexture() {return stateStack_.back().activeTexture_;}
  inline static int getActiveTextureIndex() {return getActiveTexture() - GL_TEXTURE0;}
 
  static void bindTexture(GLenum _target, GLuint _buffer);
 
  static void lockTextureStage();
 
  static void unlockTextureStage();
 
  static bool isTextureTargetLocked();
 
  static GLuint getBoundTextureBuffer(); 
  static GLenum getBoundTextureTarget();
 
public:
 
  //===========================================================================
  //===========================================================================
 
  void reset_projection();
 
  void set_projection(const GLMatrixd& _m) {
    GLMatrixd inv_m(_m);  inv_m.invert();  set_projection(_m, inv_m);
  }
  void set_projection(const GLMatrixd& _m, const GLMatrixd& _inv_m);
 
  void ortho( double _left, double _right,
              double _bottom, double _top,
              double _near_plane, double _far_plane );
 
  void frustum( double _left, double _right,
                double _bottom, double _top,
                double _near_plane, double _far_plane );
 
  void perspective( double _fovY, double _aspect,
                    double _near_plane, double _far_plane );
 
  void viewport( int _left, int _bottom, int _width, int _height,
                 int _glwidth = 0, int _glheight = 0);
 
 
  //===========================================================================
  //===========================================================================
 
 
  void reset_modelview();
 
  void set_modelview(const GLMatrixd& _m) {
    GLMatrixd inv_m(_m);  inv_m.invert();  set_modelview(_m, inv_m);
  }
  void set_modelview(const GLMatrixd& _m, const GLMatrixd& _inv_m);
 
  void lookAt( const Vec3d& _eye, const Vec3d& _center, const Vec3d& _up );
 
  void translate( double _x, double _y, double _z,
                  MultiplyFrom _mult_from = MULT_FROM_RIGHT );
                  
  void translate( Vec3d _vector,
                  MultiplyFrom _mult_from = MULT_FROM_RIGHT );
 
  void rotate( double _angle, double _x, double _y, double _z,
               MultiplyFrom _mult_from = MULT_FROM_RIGHT );
 
  void scale( double _s )
  { scale(_s, _s, _s); }
 
  void scale( double _s,
              MultiplyFrom /* _mult_from = MULT_FROM_RIGHT  */ )
  { scale(_s, _s, _s); }
 
  void scale( double _sx, double _sy, double _sz,
              MultiplyFrom _mult_from = MULT_FROM_RIGHT );
 
  void mult_matrix( const GLMatrixd& _m, const GLMatrixd& _inv_m,
                    MultiplyFrom _mult_from = MULT_FROM_RIGHT );
 
 
  void push_projection_matrix();
  void pop_projection_matrix();
 
  void push_modelview_matrix();
  void pop_modelview_matrix();
 
  //===========================================================================
  //===========================================================================
 
 
  const GLMatrixd& projection() const {
    return projection_;
  }
 
  const GLMatrixd& modelview() const {
    return modelview_;
  }
 
  const GLMatrixd& viewport() const {
    return window2viewport_;
  }
 
  GLMatrixd forward_projection() const {
    return window2viewport_ * projection_ * modelview_;
  }
 
  const GLMatrixd& inverse_projection() const {
    return inverse_projection_;
  }
 
  const GLMatrixd& inverse_modelview() const {
    return inverse_modelview_;
  }
 
  void get_viewport( int& _left, int& _bottom,
                     int& _width, int& _height ) const {
    _left = left_; _bottom = bottom_; _width = width_; _height = height_;
  }
 
  int viewport_width() const { return width_; }
  int viewport_height() const { return height_; }
 
  int context_width() const { return glwidth_; }
 
  int context_height() const { return glheight_; }
 
  double near_plane() const { return near_plane_; }
 
  double far_plane() const { return far_plane_; }
 
  double fovy() const;
 
  double aspect() const;
 
  Vec3d eye() const;
 
  Vec3d viewing_direction() const {
    return viewing_direction(width_>>1, height_>>1);
  }
 
  Vec3d viewing_direction(int _x, int _y) const;
 
  Vec3d up() const;
 
  Vec3d right() const;
 
  void viewing_ray(int _x, int _y, Vec3d& _origin, Vec3d& _direction) const;
  
  const GLenum& depthFunc() const;
  void set_depthFunc(const GLenum& _depth_func);
 
 
  static void depthFunc(GLenum _depthFunc);
 
  inline static void lockDepthFunc() {depthFuncLock_ = true;}
  inline static void unlockDepthFunc() {depthFuncLock_ = false;}
  inline static bool isDepthFuncLocked() {return depthFuncLock_;}
 
 
  //--- project and unproject points ------------------------------------------
 
  Vec3d project(const Vec3d& _point) const;
 
  Vec3d unproject(const Vec3d& _winPoint) const;
 
 
 
 
  //--- color & material ------------------------------------------------------
 
  static const Vec4f default_clear_color;
  static const Vec4f default_base_color;
  static const Vec4f default_ambient_color;
  static const Vec4f default_diffuse_color;
  static const Vec4f default_specular_color;
  static const Vec4f default_overlay_color;
  static const float default_shininess;
 
 
  void set_color(const Vec4f& _col);
 
  const Vec4f& color() { return color_; };
 
  void set_clear_color(const Vec4f& _col);
  const Vec4f& clear_color() const { return clear_color_; }
 
  void set_base_color(const Vec4f& _col);
  const Vec4f& base_color() const { return base_color_; }
 
  void set_ambient_color(const Vec4f& _col);
  const Vec4f& ambient_color() const { return ambient_color_; }
 
  void set_diffuse_color(const Vec4f& _col);
  const Vec4f& diffuse_color() const { return diffuse_color_; }
 
  void set_specular_color(const Vec4f& _col);
  const Vec4f& specular_color() const { return specular_color_; }
 
  void set_overlay_color(const Vec4f& _col);
 
  const Vec4f& overlay_color() const { return overlay_color_; }
 
  void set_shininess(float _shininess);
  float shininess() const { return shininess_; }
 
 
 
 
  //--- thickness -------------------------------------------------------------
 
  void set_point_size(float _f);
  float point_size() const { return point_size_; }
 
  void set_line_width(float _f);
  float line_width() const { return line_width_; }
 
  //===========================================================================
  //===========================================================================
 
public:
  unsigned int render_pass() const { return render_pass_; }
 
  void reset_render_pass() { render_pass_ = 1; }
 
  void next_render_pass() { ++render_pass_; }
 
  unsigned int max_render_passes() const { return max_render_passes_; }
 
  void set_max_render_passes(const unsigned int _max) { max_render_passes_ = _max; }
 
private:
  unsigned int render_pass_;
 
  unsigned int max_render_passes_;
 
  //===========================================================================
  //===========================================================================  
 
  public:
    void set_bounding_box(ACG::Vec3d _min, ACG::Vec3d _max );
    
    void get_bounding_box(ACG::Vec3d& _min, ACG::Vec3d& _max );
    
    
  private:
    ACG::Vec3d bb_min_,bb_max_;
    
 
  //--- misc ------------------------------------------------------------------
 
public:
  void set_blending(bool _b) { blending_ = _b; }
  bool blending() { return blending_; }
 
  void set_twosided_lighting(bool _b);
  bool twosided_lighting() { return twosided_lighting_; }
 
  //--- Multi Sampling --------------------------------------------------------
 
  void set_multisampling( bool _b );
 
  bool multisampling() { return multisampling_; };
 
  void allow_multisampling( bool _b ) { allow_multisampling_ = _b; };
 
  bool multisampling_allowed(){ return allow_multisampling_; };
  
  int max_texture_units() const { return num_texture_units_; }
  
  //--- Mipmapping ------------------------------------------------------------
  
  void allow_mipmapping(bool _b) { mipmapping_ = _b; }
  
  bool mipmapping_allowed() const { return mipmapping_; }
 
  //--- picking ---------------------------------------------------------------
 
  void pick_init (bool _color);
 
  bool pick_set_maximum (size_t _idx);
 
  void pick_set_name (size_t _idx);
 
  Vec4uc pick_get_name_color (size_t _idx);
 
  Vec4f pick_get_name_color_norm (unsigned int _idx);
 
  void pick_push_name (size_t _idx);
 
  void pick_pop_name ();
 
  std::vector<size_t> pick_color_to_stack (Vec4uc _rgba) const;
 
  size_t pick_free_indicies () const;
 
  bool pick_error () const;
 
  size_t pick_current_index () const;
 
  bool color_picking () const;
 
 
private: //--------------------------------------------------------------------
 
  // matrix stacks
  std::stack<GLMatrixd>  stack_projection_,
                         stack_modelview_,
                         stack_inverse_projection_,
                         stack_inverse_modelview_;
 
  // current matrices
  GLMatrixd  projection_,
             inverse_projection_,
             modelview_,
             inverse_modelview_,
             window2viewport_,
             inverse_window2viewport_;
 
  // viewport
  int left_, bottom_, width_, height_;
 
  // gl context
  int glwidth_, glheight_;
 
  // projection
  double near_plane_, far_plane_;
 
  // colors & materials
  Vec4f   clear_color_;    //< The scenes clear color
  Vec4f   color_;
  Vec4f   base_color_;     //< The emitted color of an Object
  Vec4f   ambient_color_;  //< The ambient color of an Object
  Vec4f   diffuse_color_;  //< The diffuse color of an Object
  Vec4f   specular_color_; //< The specular color of an Object
  Vec4f   overlay_color_;  //< An additional color that can be used to color e.g. a wireframe overlay
 
 
  float shininess_;
 
  // thickness
  float  point_size_, line_width_;
 
  // lighting
  bool twosided_lighting_;
 
  // Multisampling settings
  bool multisampling_;
  bool allow_multisampling_;
  
  static int num_texture_units_;
  
  // Mipmapping settings
  bool mipmapping_;
  
  // helper: should GL matrices be updated
  bool updateGL_;
 
  // true -> draw tranparent Objects
  bool blending_;
 
  // time since last redraw
  unsigned int msSinceLastRedraw_;
 
  // stack for color picking
  ColorStack colorStack_;
 
  // are we using color picking
  bool colorPicking_;
 
 
  // depth comparison function (GL_LESS by default)
  static bool depthFuncLock_;
 
 
  // state locking members
 
  // stack needed for glPush/PopAttrib
  static std::deque <GLStateContext> stateStack_;
 
  // all possible params for glEnable
  static GLenum glStateCaps[95];
 
  // glEnable / glDisable states locker
  // iff a bit is set for a state, it is locked
  static std::bitset<0xFFFF+1> glStateLock_;
 
  static bool blendFuncSeparateLock_[2];
  static bool blendEquationLock_;
  static bool blendColorLock_;
  static bool alphaFuncLock_;
 
  static bool depthRangeLock_;
 
 
  // 4 buffer targets:
  // GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER
  static int glBufferTargetLock_[4];
 
  // 16 texture stages
  static int glTextureStageLock_[16];
 
  // current shade model: GL_FLAT, GL_SMOOTH, set by glShadeModel
  static bool   shadeModelLock_;
 
  // current cull face mode: GL_FRONT, GL_FRONT_AND_BACK
  static bool   cullFaceLock_;  
 
  static bool vertexPointerLock_;
  static bool normalPointerLock_;
  static bool texcoordPointerLock_;
  static bool colorPointerLock_;
 
 
  // draw buffers
  static bool drawBufferLock_;
 
  // framebuffer
  //  framebuffer id for each target: 0 - GL_DRAW_FRAMEBUFFER, 1-> GL_READ_FRAMEBUFFER
  static bool framebufferLock_[2];
 
  // current gl shader program
  static bool programLock_;
 
 
  // graphics card caps, retrieved via glGet
  static int maxTextureCoords_;
  static int maxCombinedTextureImageUnits_;
  static int maxDrawBuffers_;
};
 
#ifdef _MSC_VER
        #pragma warning(push)
#endif
 
//=============================================================================
} // namespace ACG
//=============================================================================
#endif // ACG_GLSTATE_HH defined
//=============================================================================