vpAROgre.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 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 _vpAROgre_h_
#define _vpAROgre_h_

#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/vpHomogeneousMatrix.h>
#include <visp3/core/vpImageTools.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, float factorx, float factory, float factorz);

  inline void setShowConfigDialog(bool showConfigDialog) { mshowConfigDialog = showConfigDialog; }

  void setVisibility(const std::string &sceneName, bool isVisible);

  inline void setWindowName(const Ogre::String &n) { name = n; }

  inline void setWindowPosition(unsigned int win_x, 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