glRenderer.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: glRenderer.h,v 1.36.16.1 2007/03/25 21:26:15 oliver Exp $
//

#ifndef BALL_VIEW_RENDERING_GLRENDERER_H
#define BALL_VIEW_RENDERING_GLRENDERER_H

#ifndef BALL_VIEW_RENDERING_RENDERER_H
# include <BALL/VIEW/RENDERING/renderer.h>
#endif

#ifndef BALL_MATHS_QUATERNION_H
# include <BALL/MATHS/quaternion.h>
#endif

#ifndef BALL_VIEW_DATATYPE_COLORRGBA_H
# include <BALL/VIEW/DATATYPE/colorRGBA.h>
#endif

#ifndef BALL_VIEW_KERNEL_GEOMETRICOBJECT_H
# include <BALL/VIEW/KERNEL/geometricObject.h>
#endif

#ifndef BALL_VIEW_KERNEL_STAGE_H
# include <BALL/VIEW/KERNEL/stage.h>
#endif

#ifdef BALL_HAS_GLEW
# include <GL/glew.h>
#endif

#ifndef BALL_VIEW_RENDERING_GLDISPLAYLIST_H
# include <BALL/VIEW/RENDERING/glDisplayList.h>
#endif

#ifndef BALL_DATATYPE_REGULARDATA3D_H
# include <BALL/DATATYPE/regularData3D.h>
#endif

#ifndef APIENTRY
#define APIENTRY
#endif

class QFont;

namespace BALL
{
// defines the maximal number of GL-objects, which can be selected in picking mode
// a number as big as 100.000 is needed for large molecules, just to be sure we use a million
#define BALL_GLRENDERER_PICKING_NUMBER_OF_MAX_OBJECTS 1000000
  namespace VIEW
  {
    class Scene;
    class GLDisplayList;
    class MeshBuffer;
    class ColorMap;
    class RenderTarget;

    class BALL_VIEW_EXPORT GLRenderer
      : public Renderer
    {
      friend class Scene;
      public:

      enum StereoMode
      {
        NO_STEREO = 0,

        ACTIVE_STEREO,

        DUAL_VIEW_STEREO,

        DUAL_VIEW_DIFFERENT_DISPLAY_STEREO
      };

      enum RenderMode
      {
        RENDER_MODE_UNDEFINED = 0,

        RENDER_MODE_SOLID,

        RENDER_MODE_TRANSPARENT,

        RENDER_MODE_ALWAYS_FRONT
      };


      enum BufferMode
      {
        DIRECT_RENDERING = 0,

        DISPLAY_LISTS_RENDERING,

        REBUILD_DISPLAY_LISTS
      };


      class BALL_VIEW_EXPORT WrongModes:  public Exception::GeneralException
      {
        public:

        WrongModes(const char* file, int line, int mode, int precision);
      };

      typedef unsigned int Name;

      GLRenderer();

      virtual ~GLRenderer();

      virtual void clear();

      void dump(std::ostream& s, Size depth) const;

      inline Name getName(const GeometricObject& object);

      GeometricObject* getObject(GLRenderer::Name name) const;

      virtual bool init(Scene& scene);

      virtual bool init(const Stage& stage, float width, float height);

      virtual void setLights(bool reset_all = false);

      virtual void setSmoothLines(bool smooth_lines);
      virtual bool getSmoothLines();

      Vector3 mapViewportTo3D(Position x, Position y);

      Vector2 map3DToViewport(const Vector3& vec);

      void pickObjects1(Position x1, Position y1, Position x2, Position y2);

      void pickObjects2(List<GeometricObject*>& objects);

      void enterPickingMode();

      void exitPickingMode();

      void setSize(float width, float height);

      float getXScale() const;

      float getYScale() const;

      virtual void updateBackgroundColor();

      // Initialise transparent rendering
      void initTransparent();

      // Initialise solid rendering
      void initSolid();

      // Initialise always front rendering
      void initAlwaysFront();

      void setAntialiasing(bool state);

      void removeRepresentation(const Representation& rep);

      void bufferRepresentation(const Representation& rep);

      void drawBuffered(const Representation& rep);

      bool hasDisplayListFor(const Representation& rep) const;

      void setStereoMode(StereoMode state);

      StereoMode getStereoMode() const;

      RenderMode getRenderMode() const;

      void setRenderMode(RenderMode mode) { render_mode_ = mode;}

      virtual void renderToBuffer(RenderTarget* renderTarget, BufferMode);

      virtual bool render(const Representation& representation, bool for_display_list = false);

      virtual void bufferingDependentRender_(const Representation& repr, BufferMode mode);

      bool isExtensionSupported(const String& extension) const;

      void clearVertexBuffersFor(Representation& rep);

      bool vertexBuffersSupported() const;

      String getVendor();

      String getRenderer();

      String getOpenGLVersion();

      vector<String> getExtensions();

      bool enableVertexBuffers(bool state);

      bool vertexBuffersEnabled() const;

      DrawingMode getDrawingMode() const;

      void initPerspective();

      //_
      void setColorRGBA_(const ColorRGBA& color);

      //_
      void vertexVector3_(const Vector3& v);

      //
      void updateCamera(const Camera* camera = 0);

      //
      void setupStereo(float eye_separation, float focal_length);

      Position createTextureFromGrid(const RegularData3D& grid, const ColorMap& map);
      void removeTextureFor_(const RegularData3D& grid);

      void getFrustum(float& near, float& far, float& left, float& right, float& top, float& bottom);

  protected:

      bool mapViewplaneToScreen_();

      void renderRepresentation_(const Representation& representation, bool for_display_list);

      void renderRepresentations_(BufferMode mode);

      virtual void renderLabel_(const Label& /*label*/);

      virtual void renderLine_(const Line& /*line*/);

      virtual void renderMultiLine_(const MultiLine& line);

      virtual void renderMesh_(const Mesh& /*mesh*/);

      virtual void renderQuadMesh_(const QuadMesh& /*mesh*/);

      void initDrawingMeshes_();

      void initDrawingOthers_();

      virtual void renderRuler();

      virtual void renderPoint_(const Point& /*point*/);

      virtual void renderSimpleBox_(const SimpleBox& /*box*/);

      virtual void renderBox_(const Box& /*box*/);

      virtual void renderSphere_(const Sphere& /*sphere*/);

      virtual void renderDisc_(const Disc& /*disc*/);

      virtual void renderTube_(const Tube& /*tube*/);

      virtual void renderTwoColoredLine_(const TwoColoredLine& /*two_colored_line*/);

      virtual void renderTwoColoredTube_(const TwoColoredTube& /*two_colored_tube*/);

      virtual void renderClippingPlane_(const ClippingPlane& plane);

      virtual void renderGridVisualisation_(const GridVisualisation& vol);

      //_
      void setColor4ub_(const GeometricObject& object);

      //_
      void createSpheres_();

      //_
      void createTubes_();

      //_
      void createBoxes_();

      //_
      void createDottedSphere_(int precision);

      //_
      void subdivideTriangle_(Vector3& v1, Vector3& v2, Vector3& v3, int precision);

      //_
      void createLineBox_();

      //_
      void createDotBox_();

      //_
      void createSolidBox_();

      //_
      void clearNames_();

      //_
      void normalVector3_(const Vector3& v);


      //_
      void translateVector3_(const Vector3& v);

      //_
      void texCoordVector3_(const Vector3& v)
        { glTexCoord3f(v.x, v.y, v.z); }

      //_
      void scaleVector3_(const Vector3& v);

      //_
      void rotateVector3Angle_(const Vector3& v, Real angle);

      //_
      void scale_(float f);


      void initGLU_(DrawingMode mode);

      //_
      void generateIlluminationTexture_(float ka, float kd, float kr, float shininess);

      inline Position getTextureIndex_(Position x, Position y, Position z, Size width, Size height);
      void setupGridClipPlanes_(const GridVisualisation& slice);

      DrawingMode           drawing_mode_;

      Index                 drawing_precision_;

      //_
      float                 near_;
      //_
      float                 far_;
      //_
      float                 left_;
      //_
      float                 right_;
      //_
      float                 top_;
      //_
      float                 bottom_;
      
      //_
      float                 x_scale_;

      //_
      float                 y_scale_;

      GLDisplayList*        GL_spheres_list_;
      GLDisplayList*        GL_tubes_list_;
      GLDisplayList*        GL_boxes_list_;
      GLDisplayList*        sphere_list_;
      GLDisplayList         line_list_;
      GLuint                line_texture_bind_;
      GLubyte               line_tex_[128][128][4];

      // naming of geometric objects
      typedef HashMap<const GeometricObject*, Name> NameHashMap;
      typedef HashMap<Name, const GeometricObject*> GeometricObjectHashMap;
      typedef HashMap<const Representation*, GLDisplayList*> DisplayListHashMap;
      typedef HashMap<const Representation*, vector<MeshBuffer*> > MeshBufferHashMap;

      GeometricObjectHashMap  name_to_object_;
      NameHashMap             object_to_name_;
      DisplayListHashMap      display_lists_;
      MeshBufferHashMap       rep_to_buffers_;
      Name                    all_names_;
      GLuint                  object_buffer_[BALL_GLRENDERER_PICKING_NUMBER_OF_MAX_OBJECTS];
      Vector3                 normal_vector_;

      StereoMode              stereo_;
      RenderMode              render_mode_;

      bool                    use_vertex_buffer_;
      bool smooth_lines_;
      bool                    picking_mode_;
      ModelType               model_type_;
      Position                display_lists_index_;
      bool                    single_pick_;
      bool                    drawed_other_object_;
      bool                    drawed_mesh_;
      GLUquadricObj*  GLU_quadric_obj_;
      HashMap<const RegularData3D*, Position> grid_to_texture_;
      GLuint                  cel_texture_;
    };

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/VIEW/RENDERING/glRenderer.iC>
# endif

  } // namespace VIEW
} // namespace BALL

#endif // BALL_VIEW_RENDERING_GLRENDERER_H