renderer.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_VIEW_RENDERING_RENDERERS_RENDERER_H
#define BALL_VIEW_RENDERING_RENDERERS_RENDERER_H

#ifndef BALL_VIEW_KERNEL_REPRESENTATION_H
# include <BALL/VIEW/KERNEL/representation.h>
#endif

#ifndef BALL_CONCEPT_OBJECT_H
# include <BALL/CONCEPT/object.h>
#endif

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

#ifndef BALL_MATHS_VECTOR2_H
# include <BALL/MATHS/vector2.h>
#endif

class QImage;

namespace BALL
{
  namespace VIEW
  {
    class Scene;
    class Line;
    class MultiLine;
    class Tube;
    class Mesh;
    class Label;
    class Point;
    class Sphere;
    class Disc;
    class Box;
    class SimpleBox;
    class TwoColoredLine;
    class TwoColoredTube;
    class ClippingPlane;
    class GridVisualisation;
    class QuadMesh;

    class BALL_VIEW_EXPORT Renderer
    {
      public:

      enum StereoMode
      {
        NO_STEREO = 0,

        ACTIVE_STEREO,

        DUAL_VIEW_STEREO,

        DUAL_VIEW_DIFFERENT_DISPLAY_STEREO,

        TOP_BOTTOM_STEREO,

        INTERLACED_STEREO
      };

      BALL_CREATE(Renderer)

      

      Renderer();

      Renderer(const Renderer& renderer);

      virtual ~Renderer() {}

      virtual void clear(){}

      virtual bool init(Scene& scene);

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

      virtual void setLights(bool reset_all = false);

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

      virtual void updateMaterialForRepresentation(Representation const*) {};

      virtual void updateBackgroundColor();

      virtual void setupEnvironmentMap(const QImage& image);

      virtual void setupStereo(float eye_separation, float focal_length);

      virtual void useContinuousLoop(bool use_loop)
      {
        // TODO: mutex for use_continuous_loop_ just to be on the safe side
        use_continuous_loop_ = use_loop;
      };

      bool isContinuous() { return use_continuous_loop_; }

      virtual bool hasFPScounter() { return false; }

      virtual double getFPS() { return 0; }

      virtual bool finish();

      virtual Vector3 mapViewportTo3D(Position x, Position y);

      virtual Vector2 map3DToViewport(const Vector3& vec);

      virtual void pickObjects(Position x1, Position y1, Position x2, Position y2,
                               std::list<GeometricObject*>& objects);

      virtual void getFrustum(float& near_f, float& far_f, float& left_f, float& right_f,
                              float& top_f,  float& bottom_f);



      virtual bool renderOneRepresentation(const Representation& representation);


      virtual void bufferRepresentation(const Representation& /*rep*/) {};

      virtual void removeRepresentation(const Representation& /*rep*/) {};

      virtual const Stage& getStage() const
        { return *stage_;}

      virtual void setStage(const Stage& stage)
        { stage_ = &stage;}

      bool hasStage() const;

      virtual void setSize(float width, float height) {width_ = width; height_ = height;}

      virtual float getWidth() const { return width_;}

      virtual float getHeight() const { return height_;}

      virtual void setPreviewMode(bool show_preview) { show_preview_ = show_preview; }

      virtual void showLightSources(bool show_light_sources) { show_light_sources_ = show_light_sources; }

      virtual void renderRuler();

      virtual void setStereoMode(StereoMode state);

      virtual StereoMode getStereoMode() const;

      virtual void setStereoFrustumConversion(int width_factor, int height_factor);



      bool operator == (const Renderer& /*renderer*/) const
        { return true; }

      virtual void render_(const GeometricObject* object);

      protected:

      virtual void renderClippingPlane_(const ClippingPlane&)
        {Log.error() << "renderClippingPlane_ not implemented in derived Renderer class" << std::endl;}

      // Render a text label
      virtual void renderLabel_(const Label& /*label*/)
        {Log.error() << "renderLabel_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderLine_(const Line& /*line*/)
        {Log.error() << "renderLine_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderMultiLine_(const MultiLine& /*line*/)
        {Log.error() << "renderMultiLine_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderMesh_(const Mesh& /*mesh*/)
        {Log.error() << "renderMesh_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderPoint_(const Point& /*point*/)
        {Log.error() << "renderPoint_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderBox_(const Box& /*box*/)
        {Log.error() << "renderBox_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderSimpleBox_(const SimpleBox& /*box*/)
        {Log.error() << "renderSimpleBox_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderSphere_(const Sphere& /*sphere*/)
        {Log.error() << "renderSphere_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderDisc_(const Disc& /*disc*/)
        {Log.error() << "renderDisc_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderTube_(const Tube& /*tube*/)
        {Log.error() << "renderTube_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderTwoColoredLine_(const TwoColoredLine& /*two_colored_line*/)
        {Log.error() << "renderTwoColoredLine_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderTwoColoredTube_(const TwoColoredTube& /*two_colored_tube*/)
        {Log.error() << "renderTwoColoredTube_ not implemented in derived Renderer class" << std::endl;}

      virtual void renderGridVisualisation_(const GridVisualisation&)
        {Log.error() << "renderGridVisualisation_ not implemented in derived Renderer class" << std::endl;}
      virtual void renderQuadMesh_(const QuadMesh&)
        {Log.error() << "renderQuadMesh_ not implemented in derived Renderer class" << std::endl;}

      //_
      Scene* scene_;

      //_
      const Stage*    stage_;

      //_The width of the render area
      float           width_;

      //_The height of the render area
      float           height_;

      //_
      bool            show_preview_;

      //_
      float           volume_width_;

      //_
      bool            show_light_sources_;

      //_
      Camera          camera_;

      // An offset added to camera position and look at
      Vector3         camera_offset_;

      bool            use_continuous_loop_;

      Size            stereo_frustum_conversion_width_;
      Size            stereo_frustum_conversion_height_;

      StereoMode      stereo_;
    };

  } // namespace VIEW
} // namespace BALL

#endif // BALL_VIEW_RENDERING_RENDERER_H