renderer.h

Go to the documentation of this file.

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

#ifndef BALL_VIEW_RENDERING_RENDERER_H
#define BALL_VIEW_RENDERING_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

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 Object
    {
      public:

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

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

      virtual Vector3 mapViewportTo3D(Position x, Position y);

      virtual Vector2 map3DToViewport(const Vector3& vec);


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


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

      //_
      float           width_;

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

  } // namespace VIEW
} // namespace BALL

#endif // BALL_VIEW_RENDERING_RENDERER_H