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/RENDERERS/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>
#include <QtCore/QWaitCondition>

#include <boost/enable_shared_from_this.hpp>

#include <deque>

class QImage;

namespace BALL {
  namespace VIEW {

    class ColorMap;
    class Scene;

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

        RenderSetup(const RenderSetup& rs);

        virtual ~RenderSetup();

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

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

        enum RendererType
        {
          UNKNOWN_RENDERER = 0,

          OPENGL_RENDERER,

          POV_RENDERER,

          VRML_RENDERER,

          STL_RENDERER,

          TILING_RENDERER,

          RTFACT_RENDERER
        };

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

        RendererType getRendererType() { return renderer_type_; }

        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();
        
        void setupEnvironmentMap(const QImage& image);

        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 updateMaterialForRepresentation(const Representation* rep);

        void projectionModeChanged();

        void useContinuousLoop(bool use_loop);

        void stop() { MutexLocker ml(&render_mutex_); about_to_quit_ = true; }

        bool isAboutToQuit() { return about_to_quit_; }

        bool isContinuous() { return use_continuous_loop_; }

        void setTimeToLive(int ttl) { ttl_ = ttl; }

        int getTimeToLive() const { return ttl_; }

        void exportPNGAfterTTL(String filename) { export_after_ttl_ = true; export_after_ttl_filename_ = filename; }

        virtual void makeCurrent();

        virtual void run();

        void lock() { render_mutex_.lock(); }
        void unlock() { render_mutex_.unlock(); }

        mutable QWaitCondition wait_for_render;
        // locks the renderer before the next render call
        mutable Mutex loop_mutex;

        bool bufferIsReady() { return buffer_is_ready_; }

        bool isReadyToSwap();

        void setBufferReady(bool is_ready) { buffer_is_ready_ = is_ready; }

        std::deque<boost::shared_ptr<RenderSetup> >& getDependentRenderers() { return keep_in_sync_; }

        void makeDependentOn(boost::shared_ptr<RenderSetup>& partner) { keep_in_sync_.push_back(partner); }

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

        void initType_();

        bool rendering_paused_;
        bool receive_updates_;
        bool use_offset_;

        bool about_to_quit_;

        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_;
        
        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_;
        
        // This pointer is used to avoid uneccessary RTTI calls and casting. If the renderer is not a
        // GLRenderer or one of its derived classes, this pointer will simply be NULL
        GLRenderer* gl_renderer_;

        // The number of render operations to perform before destruction
        int ttl_;

        bool export_after_ttl_;
        String export_after_ttl_filename_;

        // a list of render setups that should be synchronized with this one so that buffer
        // swaps only happen simulatneously
        std::deque<boost::shared_ptr<RenderSetup> > keep_in_sync_;

        bool buffer_is_ready_;

        // the type of the encapsulated renderer
        RendererType renderer_type_;
    };

    class BALL_VIEW_EXPORT RenderToBufferFinishedEvent
      : public QEvent
    {
      public:
        RenderToBufferFinishedEvent(boost::shared_ptr<RenderSetup> renderer)
          : QEvent(static_cast<QEvent::Type>(RENDER_TO_BUFFER_FINISHED_EVENT)),
            renderer_(renderer)
        {};

        boost::shared_ptr<RenderSetup> getRenderer() { return renderer_; }

      protected:
        boost::shared_ptr<RenderSetup> renderer_;
    };

  }
}

#endif