vpAROgre.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2023 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 https://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)
  {
    mOptionalResourceLocation.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> mOptionalResourceLocation; 
};
 
#endif // VISP_HAVE_OGRE
 
#endif