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 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 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
//=============================================================================