SceneBase.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __SCENEBASE_HH__
#define __SCENEBASE_HH__

#include <bias_config.h>

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

#include <list>
#include <Base/Geometry/HomgPoint3D.hh>
#include <Base/Geometry/HomgPlane3D.hh>

#include <Gui/biasgl.h>
#include <Base/Math/Vector3.hh>
#include <Base/Debug/Debug.hh>


namespace BIAS {    

  enum POINT_DRAW_STYLE{
    POINT_SIMPLE =0,
    POINT_SPLATTING,
    POINT_LIGHTFIELD,
    POINT_QUADTREE,
    POINT_ZBUFFER,
    POINT_PROPABILITY,
    POINT_MESHED
  };

  enum TRIANGLEMESH_DRAW_STYLE{
    TRIANGLE_SIMPLE =0,
    TRIANGLE_SPLATTING
  };
  
  //forward declarations
  class BIASGLviewer_EXPORT GLProjectionParametersInterface;

  /** \class SceneBase
      \brief Base class for all scenes.
      \ingroup g_glviewer
      \author bartczak
   */
  class BIASGLviewer_EXPORT SceneBase : public BIAS::Debug
  {
  public:
    enum EChannel { C_BothMono, C_LeftOnly, C_RightOnly, C_BothStereo };

    /**\brief  constructor*/
    SceneBase();
    /**\brief  destructor*/
    virtual ~SceneBase(){};

    /**\brief  Set the camera as projectionparametersinterface, can be of type
     * GLProjection of of any from GLProjectionParametersBase derived class*/
    virtual void SetGLProjectionParametersInterface(GLProjectionParametersInterface* nc)
    { camera_ = nc; IsActive_=true; };
    
    /**\brief  Get the camera as projectionparametersinterface, can be of type
    * GLProjection of of any from GLProjectionParametersBase derived class*/
    virtual GLProjectionParametersInterface* GetGLProjectionParametersInterface()
    { return camera_; };

    /**\brief Select a scene element/primitive at position p.
     * Overwrite in derived class to react to selections
     * \param p [in]: position to select object at.
     * \return false if nothing could be done, true on success */
    virtual bool SelectObjectAt(BIAS::Vector3<double>& p){return false;};
    /** \brief Reset the selection, overwrite to react on calls to
     * this function in derived classes.*/
    virtual void ResetSelection(){};

    /**\brief Set the drawing style for points*/
    void  SetPointDrawStyle(POINT_DRAW_STYLE style){dPointDrawStyle_ = style;};
    /**\brief Get the drawing style for points*/
    POINT_DRAW_STYLE GetPointDrawStyle(){return dPointDrawStyle_;};

    /**\brief Set the drawing style for triangles*/
    void  SetTriangleMeshDrawStyle(TRIANGLEMESH_DRAW_STYLE style)
    { dTriangleMeshDrawStyle_ = style;};
    /**\brief Get the drawing style for triangles*/
    TRIANGLEMESH_DRAW_STYLE GetTriangleMeshDrawStyle(){return dTriangleMeshDrawStyle_;};

    /**\brief Set whether to render the boundign box or not*/
    virtual void SetRenderBoundingBox(bool render)
    { renderBoundingBox_ = render;  }

    /**\brief  Method is called by GLProjection if its params have changed.
        The method should then take necassary steps for adapting
        the rendering state. Needed information should then be fetched
        through the camera_ pointer.
        This method is only called if the
        abstract set of parameters has changed, say the parameters
        that are also contained in BIAS::Projection */
    virtual void UpdateCameraRelatedState() {}

    /** \brief this is the entry point seen from GLProjectionParametersBase.
        It is called whenever redrawing is required. It checks the
        IsActive flag and eventually call Draw(). */
    virtual void Render() ;

    /**\brief Returns whether the scene is active or not*/
    bool IsActive() const {return IsActive_;};
    /**\brief Set whether the scene is active or not*/
    void SetActive(bool b) {IsActive_ = b;};

    /**\brief Returns the active color channel*/
    enum EChannel GetActiveChannel() const
    { return ActiveChannel_; }
    /**\brief Set a color channel active*/
    void SetActiveChannel(const enum EChannel channel)
    { ActiveChannel_ = channel; }

    /** \brief sets a color mask for the scene rendering */
    void SetColorMask(bool red=true, bool green=true, bool blue=true,bool alpha=true)
    {
      colorMask_[0] = (red) ? GL_TRUE : GL_FALSE;
      colorMask_[1] = (green) ? GL_TRUE : GL_FALSE;
      colorMask_[2] = (blue) ? GL_TRUE : GL_FALSE;
      colorMask_[3] = (alpha) ? GL_TRUE : GL_FALSE;
    }

    /** \brief Determine and return the bouning box of all elements of the scene*/
    virtual void GetBoundingBox(BIAS::Vector3<double> & themin, BIAS::Vector3<double> & themax)
    {
      themin = BIAS::Vector3<double>(0.0, 0.0, 0.0);
      themax = BIAS::Vector3<double>(0.0, 0.0, 0.0);
    }

    /** @brief check if bounding boxes of two scenes overlap */
    virtual bool HasBoundingBoxCollision(SceneBase* otherScene);

    /** @brief compute time to contact of bounding boxes */
    virtual double TimeToContact(SceneBase* otherScene,
                                 BIAS::Vector3<double>& collisionpoint);

    /** @brief get mass and velocity in m/s */
    void GetMomentum(double& mass, BIAS::Vector3<double>& velocity) const {
      mass = mass_;
      velocity = velocity_;
    }

    /** @brief set mass and velocity in m/s */
    void SetMomentum(const double& mass,
                     const BIAS::Vector3<double>& velocity) {
      mass_ = mass;
      velocity_ = velocity;
    }


    /** @brief set collision behaviour:
     *   1.0=elastic, no energy is lost,
     *   >1 superelastic (requires energy from outside)
     *   <1 plastic, converts kinetic into other energy */
    void SetElasticity(const double& elas) {
      elasticity_ = elas;
    }

    /**\brief returns the elasticity value*/
    double GetElasticity(){
      return elasticity_;
    }

    /** @brief set behaviour with respect to gravity */
    void SetGravityImmunity(bool i) {
      gravityImmunity_ = i;
    }

    /** @brief is this scene accelerated by gravity ? */
    bool GetGravityImmunity() const {
      return gravityImmunity_;
    }

    /** @brief compute momentum of each scene after collision
     *
     *  see http://de.wikipedia.org/wiki/Sto%C3%9F_(Physik)
     *  @param contactnormal the normal of the plane between the two objects
     *         at the moment they collide (imagine a piece of paper in between)
     */
    virtual void PerformCollision(SceneBase* otherscene,
                                  const BIAS::Vector3<double>& contactnormal=
                                  BIAS::Vector3<double>(-1e10,-1e10,-1e10));

    /** @brief change position using a small time step of delta seconds
     *         and change velocity using gravity vector in m/s^2
     *
     *  No collision detection and handling here, since other scenes are
     *  unknown at this level.
     */
    void ApplyTimeStep(const double& delta = 1.0,
                       const BIAS::Vector3<double>& gravity =
                       BIAS::Vector3<double>(0,-9.81,0),
                       const double& frictioncoefficient = 0.999);

    /** @brief call this method for a vector of scenes to solve the collision
        problem. STATIC and THUS CONST !!! */
    static void AnimationAndCollision(std::vector<SceneBase*> scenes,
                                      const BIAS::Vector3<double>& gravity =
                                      BIAS::Vector3<double>(0,10,0),
                                      const double& friction = 0.999);

    /**\brief dump info about the scene */
    void DumpInfo() const;

    /** @brief this moves the scene (no rotation yet) */
    virtual void MoveScene(const double& delta = 1.0);


    std::list<BIAS::HomgPoint3D > CornersFromBoundingBox(const BIAS::Vector3<double>& b1,
                                                         const BIAS::Vector3<double>& b2);
    std::list<BIAS::HomgPlane3D > FacesFromBoundingBox(const BIAS::Vector3<double>& b1,
                                                       const BIAS::Vector3<double>& b2);

    /** @brief render the bounding box of the scene using gl-lines */
    virtual void RenderBoundingBox();

    /** @brief set time quantization for animations */
    static void SetAnimationSpeed(double s) {
      animationSpeed_ = s;
    }

    /** @brief get time quantization for animations */
    static double GetAnimationSpeed() {
      return animationSpeed_;
    }

  protected:

    /// how long does a single step in time take for animations ?
    static double animationSpeed_;
    /** \brief To do anything usefull, overload this method, assume context is
            * ready and draw. Draw() is called from Render() only if the
            * scene object is active (IsActive == true). */
    virtual void Draw() = 0;

    POINT_DRAW_STYLE         dPointDrawStyle_;
    TRIANGLEMESH_DRAW_STYLE  dTriangleMeshDrawStyle_;

    bool IsActive_;

    enum EChannel ActiveChannel_;    
    BIAS::GLProjectionParametersInterface* camera_;
    GLboolean colorMask_[4];

    /// for collision:
    double mass_;
    /// scene velocity in m/s
    BIAS::Vector3<double> velocity_;
    /// if true, scene is not accelerated by gravity
    bool gravityImmunity_;
    /// the more elastic the less enegry is lost in collisions
    double elasticity_;
    /// show the bounding box ?
    bool renderBoundingBox_;
  };
}//end namespace

#endif // __SCENEBASE_HH__