scene.h

Go to the documentation of this file.

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

#ifndef BALL_VIEW_WIDGETS_SCENE_H
#define BALL_VIEW_WIDGETS_SCENE_H

#ifndef BALL_VIEW_KERNEL_MODULARWIDGET_H
# include <BALL/VIEW/KERNEL/modularWidget.h>
#endif

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

#ifndef BALL_VIEW_KERNEL_COMMON_H
# include <BALL/VIEW/KERNEL/common.h>
#endif 

#ifndef BALL_VIEW_RENDERING_RENDERWINDOW_H
# include <BALL/VIEW/RENDERING/renderWindow.h>
#endif

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

#ifndef BALL_VIEW_RENDERING_RENDERSETUP_H
# include <BALL/VIEW/RENDERING/renderSetup.h>
#endif

#include <QtCore/qthread.h>
#include <QtCore/qtimer.h>
#include <QtGui/QDragEnterEvent>
#include <QtGui/QWheelEvent>
#include <QtGui/QKeyEvent>
#include <QtGui/QDropEvent>
#include <QtGui/QToolBar>
#include <QtGui/QActionGroup>

// This allows us to switch raytracing on and off. Later, we might add this flag
// to config.h or remove it completely and always raytracing always.
#undef ENABLE_RAYTRACING
//#define ENABLE_RAYTRACING
       
#ifdef ENABLE_RAYTRACING 

#ifndef BALL_VIEW_RENDERING_RAYTRACINGRENDERER_H
# include <BALL/VIEW/RENDERING/raytracingRenderer.h>
#endif

# include <boost/shared_ptr.hpp>
#endif // ENABLE_RAYTRACING 

class QMouseEvent;
class QRubberBand;
class QMenu;

namespace BALL
{
  namespace VIEW
  {
    class Preferences;
    class LightSettings;
    class StageSettings;
    class MaterialSettings;
    class AnimationThread;
    class ClippingPlane;

    class TransformationEvent6D;
    class MotionTrackingEvent;
    class ButtonEvent;

    class BALL_VIEW_EXPORT Scene
      : public QWidget,
        public ModularWidget
    {
      friend class AnimationThread;
      friend class RenderSetup;

#ifdef ENABLE_RAYTRACING
      typedef boost::shared_ptr<RaytracingRenderer> RaytracingRendererPtr;
      typedef boost::shared_ptr<t_RenderWindow> RaytracingWindowPtr;
#endif

      Q_OBJECT

      public:

      BALL_EMBEDDABLE(Scene, ModularWidget)

      


      
      enum ModeType
      {
        ROTATE__MODE         = 0,

        MOVE__MODE,

        // add new modi here!!!
        
        PICKING__MODE
      };

      enum ModeAction
      {
        TRANSLATE_ACTION,

        ZOOM_ACTION,

        ROTATE_ACTION,

        ROTATE_CLOCKWISE_ACTION
      };


      
      enum WindowType
      {
        CONTROL_WINDOW = 0,
        
        LEFT_EYE_WINDOW,

        RIGHT_EYE_WINDOW
      };
        


      Scene();

      Scene(QWidget* parent_widget, const char* name = NULL, Qt::WFlags w_flags = 0);

      Scene (const Scene& scene, QWidget* parent_widget = NULL, const char* name = NULL, Qt::WFlags wflags = 0);

      virtual ~Scene();

      virtual void clear();



      void set(const Scene& scene);

      const Scene& operator = (const Scene& scene);



      virtual void onNotify(Message *message);

      virtual bool exportScene(Renderer &er) const;


      
      virtual void initializeWidget(MainControl& main_control);
    
      virtual void fetchPreferences(INIFile& inifile);
      
      virtual void writePreferences(INIFile& inifile);

      virtual void checkMenu(MainControl& main_control);
      


      virtual bool isValid() const;

      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;
      
      Stage* getStage()
        { return stage_;}

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

      void setCamera(const Camera& camera);

      List<Camera>& getAnimationPoints()
        { return animation_points_;}

      static void setAnimationSmoothness(float value)
        { animation_smoothness_ = value;}

      static float getAnimationSmoothness()
        { return animation_smoothness_;}

      void setDefaultLighting(bool update_GL = true);

      void initializePreferencesTab(Preferences &preferences);
      
      void finalizePreferencesTab(Preferences &preferences);

      virtual void applyPreferences();
        
      static void setMouseSensitivity(float sensitivity)
        { mouse_sensitivity_ = sensitivity; }

      static float getMouseSensitivity()
        { return mouse_sensitivity_;}
      
      static void setMouseWheelSensitivity(float sensitivity)
        { mouse_wheel_sensitivity_ = sensitivity; }

      static float getMouseWheelSensitivity()
        { return mouse_wheel_sensitivity_;}

      static void setShowLightSources(bool state)
        { show_light_sources_ = state;}
      
      static bool showLightSourcesEnabled() 
        { return show_light_sources_;}

      GLRenderer& getGLRenderer()
        { return *gl_renderer_;}

#ifdef ENABLE_RAYTRACING
      RaytracingRenderer& getRaytracingRenderer()
        { return *rt_renderer_;}
#endif

      void setGLRenderer(GLRenderer& renderer);

      static bool stereoBufferSupportTest();
      
      float getMousePositionX() { return x_window_pos_new_;}

      float getMousePositionY() { return y_window_pos_new_;}

      bool exportPNG(const String& filename);

      virtual void setWidgetVisible(bool state);

      void setOffScreenRendering(bool enabled, Size factor);

      virtual void paintEvent(QPaintEvent* e);

      virtual void keyPressEvent(QKeyEvent* e);

      virtual void mouseDoubleClickEvent(QMouseEvent* e);

      virtual bool eventFilter(QObject* object, QEvent* event);

      ModeType getMode() const
        { return current_mode_;}

      virtual void setMode(ModeType mode);

      static void setScreenShotNumber(Position pos) { screenshot_nr_ = pos;}

      static void setPOVNumber(Position pos) { pov_nr_ = pos;}

      static void setVRMLNumber(Position pos) {vrml_nr_ = pos;}

      void rotate(float degree_right, float degree_up);

      void rotateClockwise(float degree);

      void move(Vector3 v);

      void moveComposites(const List<Composite*>& composites, Vector3 v);

      void rotateComposites(const List<Composite*>& composites, float degree_right, float degree_up, float degree_clockwise = 0);

      bool isAnimationRunning() const;

      void setTurnPoint(const Vector3& v) { system_origin_ = v;}

      const Vector3& getTurnPoint() const { return system_origin_;}

      void setFullScreen(bool state);

      void setFPSEnabled(bool state) { show_fps_ = state; }

      void showText(const String& text, Size font_size = 20);

      virtual void addToolBarEntries(QToolBar* tb);

      bool isUpdateRunning() const { return update_running_;}

      void resetTracking() {tracking_initialized_ = false;}
      
      bool inMoveMode() const { return (mouse_button_is_pressed_ && (getMode() == MOVE__MODE)); }

// TODO: this pretty hacky!
#ifdef ENABLE_RAYTRACING
      void updateAllRTMaterials();

      void updateRTMaterialForRepresentation(Representation const* rep, const Stage::RaytracingMaterial& new_material);
#endif

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

      void updateGL();

    public slots:

      void createCoordinateSystem();

      void createCoordinateSystemAtOrigin();

      String exportPNG();
      
      void exportPOVRay();

      void exportNextPOVRay();

      void printScene();

      void showExportPNGDialog();

      void showExportVRMLDialog();

      void setPreview(bool state) { use_preview_ = state; }

      bool usePreview() const { return use_preview_; }
      
      virtual void switchShowWidget();

      void addGlWindow();

      void exitStereo();

      void enterActiveStereo();

      void enterDualStereo();

      void enterDualStereoDifferentDisplays();

      void clearRecordedAnimation();
      
      void startAnimation();

      void stopAnimation();

      void switchToLastMode();

      void switchShowGrid();

      void showInfos();

      void setupViewVolume();

      void storeViewPoint();

      void restoreViewPoint();

#ifdef ENABLE_RAYTRACING
      RaytracingWindowPtr getWindow(WindowType aWindowType);
#endif
  
      protected slots:



      virtual void rotateMode_();

      virtual void pickingMode_();

      virtual void moveMode_();
      
      virtual void showViewPoint_();

      virtual void setViewPoint_();

      virtual void resetCamera_();

      virtual void resetRepresentationsForRenderer_(RenderSetup& rs);

      virtual void dropEvent(QDropEvent* e);

      virtual void dragEnterEvent(QDragEnterEvent* e);

      // dummy slot for menu entries without immediate action (saves many lines code this way)
      void dummySlot(){}

      protected:



      virtual void init();

      virtual void paintGL();

      virtual void resizeEvent(QResizeEvent* event);

      virtual void customEvent(QEvent* evt);

      virtual void transformationEvent6D(TransformationEvent6D* evt);

      virtual void motionTrackingEvent(MotionTrackingEvent* evt);

      virtual void buttonPressEvent(ButtonEvent* evt);

      virtual void buttonReleaseEvent(ButtonEvent* evt);

      virtual void mouseMoveEvent(QMouseEvent* qmouse_event);

      virtual void mousePressEvent(QMouseEvent* qmouse_event);

      virtual void mouseReleaseEvent(QMouseEvent* qmouse_event);

      virtual void wheelEvent(QWheelEvent* qmouse_event);

      //_
      void animate_();

      void processRotateModeMouseEvents_(QMouseEvent* e);
      void processMoveModeMouseEvents_(QMouseEvent* e);

      void rotateSystem_();
      void rotateSystemClockwise_();
      void translateSystem_();
      void zoomSystem_();
      Index getMoveModeAction_(const QMouseEvent& e);

      void selectionPressed_();
      void selectionPressedMoved_();

      void selectObjects_();
      void pickParent_(QPoint p);

      void writeLights_(INIFile& inifile) const;
      
      void readLights_(const INIFile& inifile);

      inline float getXDiff_();
      inline float getYDiff_();
      inline Vector3 getTranslationVector_(const Vector3& v);
      
      void createCoordinateSystem_(bool at_origin);
  
      String createFPSInfo_();

      //_ state of the scene: picking or rotate mode?
      ModeType current_mode_;

      //_ last state of the scene: picking or rotate mode?
      ModeType last_mode_;
  
      // Menu entry IDs
      QAction *rotate_action_, *picking_action_, *move_action_;
      QAction *no_stereo_action_, *active_stereo_action_, *dual_stereo_action_, *dual_stereo_different_display_action_, *fullscreen_action_;
      QAction *record_animation_action_, *start_animation_action_, *clear_animation_action_, *cancel_animation_action_;
      QAction *animation_export_POV_action_, *animation_export_VRML_action_,  *animation_export_PNG_action_, *animation_repeat_action_;
      QAction *switch_grid_;
      QMenu* create_coordinate_system_;
      
      Vector3 system_origin_;
      Vector3 old_trackorigin_;
      bool tracking_initialized_;
      Quaternion old_trackrotation_;

      bool need_update_;
      bool update_running_;

      Index x_window_pos_old_;
      Index y_window_pos_old_;
      Index x_window_pos_new_;
      Index y_window_pos_new_;

      Index x_window_pick_pos_first_;
      Index y_window_pick_pos_first_;
      Index x_window_pick_pos_second_;
      Index y_window_pick_pos_second_;
      bool pick_select_;
      QRubberBand* rb_;

      Stage* stage_;
      Camera stereo_camera_;
      Camera stored_camera_;

      std::vector<RenderSetup> renderers_;
      GLRenderer* gl_renderer_;

#ifdef ENABLE_RAYTRACING
      RaytracingRendererPtr rt_renderer_;
      RaytracingWindowPtr rt_window_;
#endif

      static float mouse_sensitivity_;
      static float mouse_wheel_sensitivity_;
      static bool show_light_sources_;
      static float animation_smoothness_;

      LightSettings* light_settings_;
      StageSettings* stage_settings_;
      MaterialSettings* material_settings_;

      // nr of last png file export
      static Position screenshot_nr_;
      // nr of last pov file export
      static Position pov_nr_;
      //nr of last vrml or stl export
      static Position vrml_nr_;

      List<Camera> animation_points_;
      AnimationThread* animation_thread_;
      bool stop_animation_;
      bool want_to_use_vertex_buffer_;
      bool mouse_button_is_pressed_;
      bool preview_;
      bool use_preview_;

      PreciseTime time_;
      float zoom_factor_;
      QPoint info_point_;
      QByteArray last_state_;
      list<float> fps_;
      bool show_fps_;
      static bool offscreen_rendering_;
      Size offscreen_factor_;
      String text_;
      Size   font_size_;
      QToolBar* toolbar_view_controls_;
      QList<QAction*> toolbar_actions_view_controls_;
      bool ignore_pick_;
      QActionGroup* mode_group_;

      String info_string_;

      GLRenderWindow* main_display_;

      Index stereo_left_eye_;
      Index stereo_right_eye_;
    };


    class BALL_VIEW_EXPORT AnimationThread
      : public QThread
    {
      public:
        
        AnimationThread(){};

        virtual void run() {scene_->animate_();}

        void mySleep(Size msec);

        void setScene(Scene* scene) { scene_ = scene;}

        Scene* getScene() { return scene_;}

      protected:

        Scene* scene_;
    };


} } // namespaces

#endif // BALL_VIEW_WIDGETS_SCENE_H