glRenderer.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
 
#ifndef BALL_VIEW_RENDERING_RENDERERS_GLRENDERER_H
#define BALL_VIEW_RENDERING_RENDERERS_GLRENDERER_H
 
#ifndef BALL_VIEW_RENDERING_RENDERERS_RENDERER_H
# include <BALL/VIEW/RENDERING/RENDERERS/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_COMPILER_MSVC
# define WINDOWS_LEAN_AND_MEAN
# include <windows.h>
#endif
 
#ifdef BALL_HAS_GLEW
# include <GL/glew.h>
#elif defined(BALL_OS_DARWIN)
# include <OpenGL/gl.h>
# include <OpenGL/glu.h>
#else
# include <GL/gl.h>
# include <GL/glu.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 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;
 
      using Renderer::init;
 
      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();
 
      virtual void pickObjects(Position x1, Position y1, Position x2, Position y2, 
                               std::list<GeometricObject*>& objects);
 
      void pickObjects1(Position x1, Position y1, Position x2, Position y2);
 
      void pickObjects2(std::list<GeometricObject*>& objects);
 
      void setFogIntensity(float intensity);
 
      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;
 
      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 runningOnVirtualBox();
 
      bool enableVertexBuffers(bool state);
 
      bool vertexBuffersEnabled() const;
 
      DrawingMode getDrawingMode() const;
 
      void initPerspective();
 
      void setProjection();
 
      //_
      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);
 
      virtual void getFrustum(float& near_f, float& far_f, float& left_f, float& right_f, float& top_f, float& bottom_f);
 
      void updateMaterialForRepresentation(Representation const* rep) { bufferRepresentation(*rep); }
 
  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 setOrthographicZoom(float orthographic_zoom);
 
      //_
      float getOrthographicZoom(void);
 
      //_
      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);
 
      // Sets the current OpenGL material
      void setMaterial_(const Stage::Material& mat);
      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_;
 
      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_;
 
      float                   orthographic_zoom_;
    };
 
# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/VIEW/RENDERING/RENDERERS/glRenderer.iC>
# endif
 
  } // namespace VIEW
} // namespace BALL
 
#endif // BALL_VIEW_RENDERING_GLRENDERER_H