renderSetup.h

Go to the documentation of this file.

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

#ifndef BALL_VIEW_RENDERING_RENDERSETUP_H
#define BALL_VIEW_RENDERING_RENDERSETUP_H

#ifndef BALL_VIEW_RENDERING_GLRENDERER_H
# include <BALL/VIEW/RENDERING/glRenderer.h>
#endif

#ifndef BALL_VIEW_RENDERING_RENDERTARGET_H
# include <BALL/VIEW/RENDERING/renderTarget.h>
#endif

#ifndef BALL_VIEW_RENDERING_GLRENDERWINDOW_H
# include <BALL/VIEW/RENDERING/glRenderWindow.h>
#endif

#ifndef BALL_SYSTEM_MUTEX_H
# include <BALL/SYSTEM/mutex.h>
#endif

#include <QtCore/QThread>

namespace BALL {
  namespace VIEW {

    class Scene;

    class BALL_VIEW_EXPORT RenderSetup
      : public QThread
    {
      public:
        RenderSetup(Renderer* r, RenderTarget* t, Scene* scene, const Stage* stage);

        RenderSetup(const RenderSetup& rs);

        const RenderSetup& operator = (const RenderSetup& rs);

        // TODO: this should be boost smart pointers!
        Renderer*       renderer;
        RenderTarget*   target;

        enum STEREO_SETUP {
          NONE,
          LEFT_EYE,
          RIGHT_EYE
        };

        void init();

        void resize(Size width, Size height);

        void pauseRendering() { rendering_paused_ = true; }

        void startRendering() { rendering_paused_ = false; }

        bool isPaused() const { return rendering_paused_; }

        void setReceiveBufferUpdates(bool do_receive) { receive_updates_ = do_receive; }

        bool receivesBufferUpdates() const { return receive_updates_; };

        void updateCamera(const Camera* camera = 0);

        void setOffset(const Vector3& offset);

        void setStereoMode(STEREO_SETUP stereo) { stereo_setup_ = stereo; };

        void bufferRepresentation(const Representation& rep);

        void removeRepresentation(const Representation& rep);

        void renderToBuffer();

        bool exportPNG(const String& filename);

        void setLights(bool reset_all = false);

        void updateBackgroundColor();
        
        Position prepareGridTextures(const RegularData3D& grid, const ColorMap& map);

        void removeGridTextures(const RegularData3D& grid);

        Vector3 mapViewportTo3D(Position x, Position y);

        Vector2 map3DToViewport(const Vector3& vec);

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

        void showRuler(bool show);

        void projectionModeChanged();

        void useContinuousLoop(bool use_loop);

        bool isContinuous() { return use_continuous_loop_; }

        virtual void makeCurrent();

        virtual void run();

      protected:
        // does the hard work and can be called from a continuous loop as well as from event-based rendering
        void renderToBuffer_();

        bool rendering_paused_;
        bool receive_updates_;
        bool use_offset_;

        Camera  camera_;
        Vector3 camera_offset_;

        STEREO_SETUP stereo_setup_;

        // switches between rendering continously and rendering upon events
        bool use_continuous_loop_;

        Scene* scene_;
        Stage const* stage_;

        // locks the renderer during updates and rendering
        mutable Mutex render_mutex_;

        Size width_;
        Size height_;
        bool do_resize_;

        bool show_ruler_;

        // This pointer is used to avoid uneccessary RTTI calls and casting. If the target is not a
        // GLRenderWindow or one of its derived classes, this pointer will simply be NULL
        GLRenderWindow* gl_target_;
    };
  }
}

#endif