GLState.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openflipper.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenFlipper.                                        *
 *                                                                           *
 *  OpenFlipper 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 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenFlipper 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 LesserGeneral Public          *
 *  License along with OpenFlipper. If not,                                  *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision: 8521 $                                                       *
 *   $Author: moebius $                                                      *
 *   $Date: 2010-02-10 15:57:35 +0100 (Mi, 10. Feb 2010) $                   *
 *                                                                           *
\*===========================================================================*/


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

#ifdef WIN32
        #pragma warning(push)
        #pragma warning(disable:4251)
#endif

//== NAMESPACES ===============================================================


namespace ACG {


//== CLASS DEFINITION =========================================================


class ACGDLLEXPORT GLState
{
public:

  GLState(bool _updateGL = true);

  ~GLState() {}


  void makeCurrent() {  }

  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 ();

  //---  set GL projection matrix ---------------------------------------------


  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);





  //---  set GL modelview matrix ----------------------------------------------


  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 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();


  //---  get GL states and matrices -------------------------------------------


  const GLMatrixd& projection() const {
    return projection_;
  }

  const GLMatrixd& modelview() const {
    return modelview_;
  }

  const GLMatrixd& viewport() const {
    return window2viewport_;
  }

  const GLMatrixd& forward_projection() const {
    return forward_projection_;
  }

  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;


  //--- 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 float default_shininess;


  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_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_;

  //--- 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_; }

  //--- picking ---------------------------------------------------------------


  void pick_init (bool _color);

  bool pick_set_maximum (unsigned int _idx);

  void pick_set_name (unsigned int _idx);

  Vec4uc pick_get_name_color (unsigned int _idx);

  void pick_push_name (unsigned int _idx);

  void pick_pop_name ();

  std::vector<unsigned int> pick_color_to_stack (Vec4uc _rgba) const;

  unsigned int pick_free_indicies () const;

  bool pick_error () const;

  unsigned int pick_current_index () const;

  bool color_picking () const;


private: //--------------------------------------------------------------------

  // update forward projection and backward projection matrices
  void update_matrices();


  // 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_,
             forward_projection_,
             backward_projection_;

  // viewport
  int left_, bottom_, width_, height_;

  // gl context
  int glwidth_, glheight_;

  // projection
  double near_plane_, far_plane_;

  // colors & materials
  Vec4f   clear_color_,
          base_color_,
          ambient_color_,
          diffuse_color_,
          specular_color_;

  float shininess_;

  // thickness
  float  point_size_, line_width_;

  // lighting
  bool twosided_lighting_;

  // Multisampling settings
  bool multisampling_;
  bool allow_multisampling_;
  
  int num_texture_units_;
  
  // 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_;

};

#ifdef WIN32
        #pragma warning(push)
#endif

//=============================================================================
} // namespace ACG
//=============================================================================
#endif // ACG_GLSTATE_HH defined
//=============================================================================