RenderContextBase.hh

#ifndef __RENDER_CONTEXT_BASE_HH__
#define __RENDER_CONTEXT_BASE_HH__

#include <bias_config.h>

#ifndef BIAS_HAVE_OPENGL
#  error You need BIAS with USE_OpenGL Please recompile BIAS.
#endif // BUILD_GLviewer

#include <vector>

#include <Base/Common/W32Compat.hh>
#include <Base/Image/Image.hh>

#include <GLviewer/Scenes/SceneBase.hh>
#include <GLviewer/GLProjectionParametersInterface.hh>
#include <GLviewer/Controller/ControlInterface.hh>
#include <GLviewer/View.hh>

#ifdef BIAS_HAVE_PTHREADS
#include <Utils/MutexSingleton.hh>
#endif

namespace BIAS {
  class BIASGLviewer_EXPORT SceneBGImage;

  /** \class RenderContextBase
      \brief Base for all classes creating interface
      between GL and  "window manager".
      new version without glprojection
      \ingroup g_glviewer
  */
  class BIASGLviewer_EXPORT RenderContextBase {
  public:
    RenderContextBase();
    virtual ~RenderContextBase() {}

    /** \brief prints to current status of the OpenGL context*/
    void PrintGLStatus();

    /** \brief Simple rendering routine.
     * Assumes that all viewport settings are good and renders scene.
     * \return 0 all good. */
    virtual int Render();
    /**\brief Demands a rendering from the Context; */
    virtual void Redisplay() = 0;

    /** \brief try to make this OpenGl context current */
    virtual void MakeGLContextCurrent() = 0;

#ifdef BIAS_HAVE_PTHREADS
    int LockContextSwitch();
    int ReleaseContextSwitch();
#endif

    /** brief Get the currently displayed image as unsigned char color image.
     *  Set lock to false if no context lock should be used (i.e. if called from
        within an already context locked environment*/
    virtual int GetImage(BIAS::Image<unsigned char>& Image, bool lock = true);
    /** brief Get the currently displayed image as unsigned char grey image
     *  Set lock to false if no context lock should be used (i.e. if called from
        within an already context locked environment*/
    virtual int GetGreyImage(BIAS::Image<unsigned char>& Image, bool lock = true);
    /** brief Get the currently displayed depth image
     *  Set lock to false if no context lock should be used (i.e. if called from
        within an already context locked environment*
     *  \param invalid[in]: depth value which is set as invalid (default = 0.0) */

    virtual int GetDepthMap(BIAS::Image<float>& Image, const float invalid = 0.0, bool lock = true);
    /** brief Get the currently displayed zbuffer image (values 0-1) *
     *  Set lock to false if no context lock should be used (i.e. if called from
        within an already context locked environment*/
    virtual int GetZBuffer(BIAS::Image<float>& Image, bool lock = true);
    /** brief Get the currently displayed zbuffer image in metric (real) values
     *  Set lock to false if no context lock should be used (i.e. if called from
        within an already context locked environment.
    * \param invalid[in]: z value which is set as invalid (default = 0.0)*
    */
    virtual int GetMetricZMap(BIAS::Image<float>& Image, const float invalid = 0.0, bool lock = true);

    /** \brief attach scenes to render here
     * \attention Do not append scene of type SceneBGImage here, for correct
     * background image rendering rather use SetBackgroundImageScene(). */
    void AppendScene(SceneBase* scene, bool push_front = false);
    /** \brief removes scene with the given pointer from the vector of scenes */
    void RemoveScene(SceneBase* scene, bool noWarning = false);
    /**\brief Inserts or deletes a scene at the specified position
     * in std::vector<SceneBase*> scenes_. */
    void InsertSceneAt(SceneBase* scene, unsigned int index);
    /** \brief removes scene with the given index in the vector of scenes */
    void DeleteSceneAt(unsigned int index);
    /** \brief returns scene with the given index in the vector of scenes */
    SceneBase* GetSceneAt(unsigned int index);

    /** \brief Deactivate background image rendering pass by passing NULL here,
     * or deactivating scene itself.
     * First choice will speed up rendering more (if noticeable anyway). */
    void SetBackgroundImageScene(SceneBGImage* backgroundImageScene);
    /** \brief Delete the background image scene.
     * \attention The scene is deleted by call to delete, do not delete again outside.*/
    void DeleteBackgroundImageScene();

    /** \brief Delete the attached scenes.
     * \attention The scenes are destroyed, do not delete outside again.*/
    void DeleteScenes();
    /** \brief Delete the attached scenes.
    * \attention The scenes are NOT destroyed, delete outside if intended
    * or use DeleteScenes() instead.*/
    void ClearScenes();
    void DeleteControler() {delete control_; control_ = NULL;}
    void DeleteController() {delete control_; control_ = NULL;}

    /**\brief return a vector with pointers to all attached scenes
     * \return vector with pointers to scenes of Type SceneBase */
    const std::vector<SceneBase*>& GetScenes() const {
      return scenes_;
    };
    /**\brief Get the number of attached scenes.
     * \return Number of attached scenes*/
    int  GetSceneCount();

    /** \brief additional control listeners can be attached, or removed here
    * @{ */
    void AppendAdditionalListener(ControlInterface* listener)
    {if(listener!=NULL) additionalListeners_.push_back(listener); }
    void ClearAdditionalListeners() {additionalListeners_.clear(); }
    void RemoveAdditionalListener(ControlInterface& listener);
    /** @} */

    //control implementation:
    /** .
     * Control is implemented the following way:       cout<<"F1"<<endl;
     * All input is passed to control_ first, if this is not handling
     * the input, the information is passed to all scenes_. One can think of
     * extending this to different behaviour models, like
     * not passing anything to scenes or always passing input to scenes.
     * Distingushing between the scenes (exluding scene of information)
     * must be handled on scene side.
     *
     * @{ */

    /**\brief Set the controller.
     * \param newControl[in]: Pointer to a ControlInterface
     * such as TrackballControl, FlyControl, etc.*/
    void SetControl(BIAS::ControlInterface* newControl);
    /** \brief delete the current controller
     * \attention the controller is deleted, do not delete outside again*/
    void DeleteControl() {delete control_; control_ = NULL;}

    bool LeftMouseDoubleClicked(int x, int y,int m);
    bool LeftMouseSingleClicked(int x, int y);
    bool LeftMouseDown(int x, int y);
    bool LeftMouseUp(int x, int y);
    bool LeftMouseMoved(int x1, int x2, int y1, int y2);
    bool RightMouseSingleClicked(int x, int y);
    bool RightMouseDoubleClicked(int x, int y);
    bool RightMouseMoved(int x1, int x2, int y1, int y2);
    bool RightMouseDown(int x, int y);
    bool RightMouseUp(int x, int y);
    bool MiddleMouseMoved(int x1, int x2, int y1, int y2);
    bool MiddleMouseDown(int x, int y);
    bool MiddleMouseUp(int x, int y);
    bool LeftAndRightMouseMoved(int x1, int x2, int y1, int y2);
    bool MouseLeftWindow();
    bool SpecialKeyPressed(int key);
    bool SpecialKeyUp(int key);
    bool StandardKeyPressed(unsigned char ,int ,int );
    bool StandardKeyUp(unsigned char ,int ,int );
    /** Always informs both camera and scenes! */
    bool TimerExpired();
    bool WindowReshape(int width, int height);
    bool MouseWheelUsed(double stepsize);
    bool MouseMoved(int x, int y);
    /** @} */

    /**\brief activate timer with intervall in ms */
    virtual void SetTimer(unsigned int interval) =0;
    /**\brief deactivate timer*/
    virtual void DeactivateTimer() =0;

    /**\brief get the camera
     * \return current camera projection parameters, can be of type
     * GLProjection of any from GLProjectionParametersBase derived class.
     * \deprecated Use GetGLProjectionParametersInterface() instead*/
    const GLProjectionParametersInterface* GetCamera() {
        BIASWARN("Deprecated Use GetGLProjectionParametersInterface() instead");
        return camera_;}

    /**\brief Delete the camera
     * \attention The camera pointer is deleted, do not delete outside again!
    * \deprecated Use DeleteGLProjectionParametersInterface() instead*/
    void DeleteCamera() {
        BIASWARN("Deprecated Use DeleteGLProjectionParametersInterface() instead");
        delete camera_; camera_ = NULL;}

    /**\brief get the camera parameters
    * \return current camera projection parameters, can be of type
    * GLProjection of any from GLProjectionParametersBase derived class.*/
    const GLProjectionParametersInterface* GetGLProjectionParametersInterface()
            {return camera_;}
    /**\brief set the camera parameters
    * \param newCamera[in]: the new camera projection parameters, can be of type
    * GLProjection of any from GLProjectionParametersBase derived class.*/
    void SetGLProjectionParametersInterface(GLProjectionParametersInterface* newCamera);

    /**\brief Turn AutoClipping on, now the near and far clipping plane is automatically
    * derived and set.  */
    void SetAutoClipping(bool on) { AutoClipping_ = on;}

    /** @brief sets minimum znear for autoclipping
    if autoclpiing is enabled the z-near and z-far plane are computed using
    the boudingspheres of the scenes. SetAutoClipMinZNear defines the minimal
    used znear value. */
    void SetAutoClipMinZNear(double znear)
    {  AutoMinZNear_ = znear; };

    /**
    * Returns the center of all bounding boxes of appended scenes
    * and the radius which include all scenes. Return true iff
    * at least one scene with a bounding box was found, else false
    */
    bool GetSceneCenter(BIAS::Vector3<double>& center,
            BIAS::Vector3<double>& radius);

    /**\brief set the opengl clear color for color buffer
     * \param cc[in]: clear color, clamped to range [0..1] */
    inline void SetClearColor(const BIAS::Vector4<float>& cc)
    {
      ClearColor_ = cc;
      if (camera_) camera_->SetClearColor(ClearColor_);

    };

    /**\brief En-/Disable blending */
    bool SetBlending(bool blend=true);
    /**\brief En-/Disable backface culling */
    bool SetBackfaceCulling(bool cull=true);
    /**\brief center the viewport */
    void CenterViewport(bool center = true);
    /**\brief Append a view to the context.
     * \param view [in]: the view to append */
    void AppendView(View* view);

    /**\brief switches rendering of bounding boxes for all scenes*/
    inline void GlobalBoundingBoxSwitch(bool theswitch) {
      for (unsigned int i=0; i<scenes_.size(); i++) {
        scenes_[i]->SetRenderBoundingBox(theswitch);
      }
    };

    /**\brief Enable the useage of stencil buffer*/
    void EnableStencilUsage(bool enable);

    /** \brief Enable or disable selection mode. In selection mode
    * the interception point with a scene is calculated and SelectObjectAt() is
    * called on the scene when double clicked. */
    virtual void SetSelectionMode(bool selectionmode)
    {   bSelectionMode_ = selectionmode; };
    /**\brief Get the selectinmode */
    virtual bool GetSelectionMode(){return bSelectionMode_;};

  protected:
    /** called once when rendering starts */
    void Init_();

  protected:
    std::vector<SceneBase*> scenes_;
    SceneBGImage* backgroundImageScene_;
    ControlInterface* control_;
    GLProjectionParametersInterface* camera_;
    BIAS::Vector4<float> ClearColor_;

    /** Listening for special keys only */
    std::vector<ControlInterface*> additionalListeners_;

    unsigned int TimerInterval_; //0 = disabled
    bool initialized_;
    bool blendingAllowed_;
    bool culling_;
    bool centerViewport_;
    bool UseStencil_;
    bool AutoClipping_;
    bool bSelectionMode_;
    double AutoMinZNear_;

#ifdef BIAS_HAVE_PTHREADS
  private:
    static BIAS::MutexSingleton *contextLock_;
#endif //BIAS_HAVE_PTHREADS

    std::vector<View*> views_;
  };

}//end namespace
#endif