vpAROgre.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2015 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Augmented Reality viewer using Ogre3D.
 *
 * Authors:
 * Bertrand Delabarre
 *
 *****************************************************************************/

#ifndef __VP_AROGRE__
#define __VP_AROGRE__

#include <visp3/core/vpConfig.h>

#ifdef VISP_HAVE_OGRE
#include <list>

#include <visp3/core/vpImage.h>
#include <visp3/core/vpImageConvert.h>
#include <visp3/core/vpRGBa.h>

#include <visp3/core/vpImageTools.h>
#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpRotationMatrix.h>
#include <visp3/core/vpRxyzVector.h>

#include <Ogre.h>
#include <OgreFrameListener.h>

#ifdef VISP_HAVE_OIS
#  include <OIS.h>
#endif

class VISP_EXPORT vpAROgre : public Ogre::FrameListener, public Ogre::WindowEventListener
#ifdef VISP_HAVE_OIS
               , public OIS::KeyListener
#endif
{ 
 public:       
  vpAROgre(const vpCameraParameters &cam = vpCameraParameters(), 
       unsigned int width = 0, unsigned int height = 0,
       const char* resourcePath = 
#ifdef VISP_HAVE_OGRE_RESOURCES_PATH
       VISP_HAVE_OGRE_RESOURCES_PATH,
#else
       ".",
#endif
       const char* pluginsPath = 
#ifdef VISP_HAVE_OGRE_PLUGINS_PATH
       VISP_HAVE_OGRE_PLUGINS_PATH
#else
       "."
#endif
       );
    
  virtual ~vpAROgre(void);
  
  inline void addResource(const std::string& resourceLocation){
    mOptionnalResourceLocation.push_back(resourceLocation);
  }
  
  void addRotation(const std::string &sceneName, const vpRotationMatrix &wRo);
  
  bool continueRendering(void);
  
  virtual bool customframeStarted(const Ogre::FrameEvent& evt);

  virtual bool customframeEnded(const Ogre::FrameEvent& evt);
  
  virtual void display(const vpImage<unsigned char> &I, 
           const vpHomogeneousMatrix &cMw);

  virtual void display(const vpImage<vpRGBa> &I, 
           const vpHomogeneousMatrix &cMw);
  
  inline Ogre::Camera* getCamera(){ return mCamera; }

  inline double getFarClippingDistance() const { return mFarClipping; }

  inline double getNearClippingDistance() const { return mNearClipping; }
  
  vpTranslationVector getPosition(const std::string &sceneName)const;
  
  void getRenderingOutput(vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo);
  
  inline Ogre::SceneManager* getSceneManager(){ return mSceneMgr; }
  
  virtual void init(vpImage<unsigned char> &I, bool bufferedKeys=false, bool hidden=false);
  virtual void init(vpImage<vpRGBa> &I, bool bufferedKeys=false, bool hidden=false);
  
  bool isWindowHidden(){ return windowHidden; }
  
#ifdef VISP_HAVE_OIS

  virtual bool keyPressed( const OIS::KeyEvent & /*e*/) { return true; }
  virtual bool keyReleased( const OIS::KeyEvent & /*e*/) {  return true; }
#endif

  void load(const std::string &entityName, const std::string &model);

  bool renderOneFrame(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMw);
  
  bool renderOneFrame(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMw);
  
  void setCameraParameters(const vpCameraParameters &cameraP);

  void setFarClippingDistance(const double &dist){
    mFarClipping = dist;
    updateCameraProjection();
  }

  void setNearClippingDistance(const double &dist){
    mNearClipping = dist;
    updateCameraProjection();
  }
  
  inline void setPluginsPath(const char* pluginsPath){
    mPluginsPath = pluginsPath;
  }
  
  void setPosition(const std::string &sceneName, const vpTranslationVector &wTo);
  void setPosition(const std::string &sceneName, const vpHomogeneousMatrix &wMo);
  
  inline void setResourcePath(const char* resourcePath){
    mResourcePath = resourcePath;
  }
  
  void setRotation(const std::string &sceneName, const vpRotationMatrix &wRo);
  
  void setScale(const std::string &sceneName, const float factorx, const float factory, const float factorz);
  
  inline void setShowConfigDialog(const bool showConfigDialog){
    mshowConfigDialog = showConfigDialog;
  }
  
  void setVisibility(const std::string &sceneName, bool isVisible);
  
  inline void setWindowName(const Ogre::String &n){
    name = n;
  }

  inline void setWindowPosition(const unsigned int win_x, const unsigned int win_y){
    if(mWindow == NULL){
      throw vpException(vpException::notInitialized, "Window not initialised, cannot set its position");
    }
    mWindow->reposition(static_cast<int>(win_x), static_cast<int>(win_y));
  }
  
  virtual void windowClosed(Ogre::RenderWindow* rw);
  
 protected:

  virtual void init(bool bufferedKeys=false, bool hidden=false);
  virtual void createCamera(void);

  virtual void createScene(void){};

  virtual void closeOIS(void);

  virtual bool updateScene(const Ogre::FrameEvent & /*evt*/) {return true;};

  virtual bool processInputEvent(const Ogre::FrameEvent & /*evt*/) {return true;};

  virtual bool destroyScene(void) {
      if(!mSceneMgr)
           return false;

      mSceneMgr->destroyAllCameras ();
      mSceneMgr->clearScene();
      mRoot->destroySceneManager(mSceneMgr);
      return true;
  }
  
  virtual void updateCameraParameters (const vpHomogeneousMatrix &cMo);

  virtual void updateCameraProjection(void);

  virtual void updateBackgroundTexture(const vpImage<unsigned char> &I);

  virtual void updateBackgroundTexture(const vpImage<vpRGBa> &I);


 private:

  void createBackground(vpImage<unsigned char> &I);
  void createBackground(vpImage<vpRGBa> &I);

  bool frameStarted(const Ogre::FrameEvent& evt);

  bool frameEnded( const Ogre::FrameEvent& evt);

  bool stopTest(const Ogre::FrameEvent& evt);

 protected:
  // Attributes
  Ogre::String name;                            
  // OGRE 3D System
  Ogre::Root*       mRoot;                         
  Ogre::Camera*     mCamera;                   
  Ogre::SceneManager* mSceneMgr;                 
  Ogre::RenderWindow* mWindow;                   
  Ogre::String      mResourcePath;             
  Ogre::String      mPluginsPath;             
#ifdef VISP_HAVE_OIS
  // OIS Input manager and devices
  OIS::InputManager* mInputManager;
  OIS::Keyboard*       mKeyboard;
#endif

  // ViSP AR System
  bool keepOn;                                            
  vpImage<vpRGBa> mImageRGBA;                             
  vpImage<unsigned char> mImage;                          
  Ogre::HardwarePixelBufferSharedPtr mPixelBuffer;        
  Ogre::Rectangle2D* mBackground;                         
  unsigned int mBackgroundHeight;                         
  unsigned int mBackgroundWidth;                          
  unsigned int mWindowHeight;                             
  unsigned int mWindowWidth;                              
  bool windowHidden;                                     
  // Camera calculations
  double mNearClipping;                          
  double mFarClipping;                           
  vpCameraParameters mcam;                       
  bool mshowConfigDialog;                         
  std::list<std::string> mOptionnalResourceLocation;  
};

#endif // VISP_HAVE_OGRE

#endif