vpAROgre.cpp

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2025 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.
 */

 
#include <visp3/core/vpConfig.h>
 
#ifdef VISP_HAVE_OGRE
 
#include <visp3/ar/vpAROgre.h>
#include <visp3/core/vpIoTools.h>
 
#include <OgreRectangle2D.h>
 
#if (VISP_HAVE_OGRE_VERSION >= (1<<16 | 11<<8 | 0))
#include <OgreMatrix4.h>
#include <Bites/OgreWindowEventUtilities.h>
typedef OgreBites::WindowEventUtilities OgreWindowEventUtilities;
#else
typedef Ogre::WindowEventUtilities OgreWindowEventUtilities;
#endif
 
BEGIN_VISP_NAMESPACE
unsigned int vpAROgre::sID = 0;
unsigned int vpAROgre::sRTSSUsers = 0;

vpAROgre::vpAROgre(const vpCameraParameters &cam, unsigned int width, unsigned int height, const char *resourcePath,
                   const char *pluginsPath)
  : name("ViSP - Augmented Reality"), mInitialized(false), mRoot(0), mCamera(0), mSceneMgr(0), mWindow(0), mResourcePath(resourcePath),
  mPluginsPath(pluginsPath),
#ifdef VISP_HAVE_OIS
  mInputManager(0), mKeyboard(0),
#endif
  keepOn(true), // When created no reason to stop displaying
  mImageRGBA(), mImage(), mPixelBuffer(), mBackground(nullptr), mBackgroundHeight(0), mBackgroundWidth(0),
  mWindowHeight(height), mWindowWidth(width), windowHidden(false), mNearClipping(0.001), mFarClipping(200), mcam(cam),
  mshowConfigDialog(true), mOptionalResourceLocation()
{
  std::stringstream nameSceneManager;
  nameSceneManager << "SceneManagerInstance" << sID;
  mSceneManagerName = nameSceneManager.str();
  ++sID;
#if defined(OGRE_BUILD_COMPONENT_RTSHADERSYSTEM) & (VISP_HAVE_OGRE_VERSION >= (1<<16 | 10 <<8 | 0))
  mMaterialMgrListener = NULL;
  mShaderGenerator = NULL;
#endif
}

bool vpAROgre::initialiseRTShaderSystem()
{
#if defined(OGRE_BUILD_COMPONENT_RTSHADERSYSTEM) & (VISP_HAVE_OGRE_VERSION >= (1<<16 | 10 <<8 | 0))
  if (Ogre::RTShader::ShaderGenerator::initialize() || (sRTSSUsers > 0)) {
    ++sRTSSUsers;
    mShaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
 
// Create and register the material manager listener if it doesn't exist yet.
    if (!mMaterialMgrListener) {
      mMaterialMgrListener = new OgreBites::SGTechniqueResolverListener(mShaderGenerator);
      Ogre::MaterialManager::getSingleton().addListener(mMaterialMgrListener);
    }
    return true;
  }
#endif
  return false;
}

void vpAROgre::destroyRTShaderSystem()
{
#if defined(OGRE_BUILD_COMPONENT_RTSHADERSYSTEM) & (VISP_HAVE_OGRE_VERSION >= (1<<16 | 10 <<8 | 0))
  // Restore default scheme.
  Ogre::MaterialManager::getSingleton().setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
 
  // Unregister the material manager listener.
  if (mMaterialMgrListener != NULL) {
    Ogre::MaterialManager::getSingleton().removeListener(mMaterialMgrListener);
    delete mMaterialMgrListener;
    mMaterialMgrListener = NULL;
  }
 
  // Destroy RTShader system.
  if (mShaderGenerator != NULL) {
    if (sRTSSUsers > 0) {
      --sRTSSUsers;
    }
    if (sRTSSUsers == 0) {
      Ogre::RTShader::ShaderGenerator::destroy();
    }
    mShaderGenerator = NULL;
  }
#endif
}

void vpAROgre::init(vpImage<unsigned char> &I,
                    bool
#ifdef VISP_HAVE_OIS
                        bufferedKeys
#endif
                    ,
                    bool hidden)
{
  mBackgroundWidth = I.getWidth();
  mBackgroundHeight = I.getHeight();
 
  init(
#ifdef VISP_HAVE_OIS
      bufferedKeys,
#else
      false,
#endif
      hidden);
 
#if (VISP_HAVE_OGRE_VERSION >= (13 <<16 | 0 <<8 | 0))
// Register the scene manager.
  Ogre::RTShader::ShaderGenerator::getSingleton().addSceneManager(Ogre::Root::getSingletonPtr()->getSceneManager(mSceneManagerName));
#endif
 
  // Create the background image which will come from the grabber
  createBackground(I);
}

void vpAROgre::init(vpImage<vpRGBa> &I,
                    bool
#ifdef VISP_HAVE_OIS
                        bufferedKeys
#endif
                    ,
                    bool hidden)
{
  mBackgroundWidth = I.getWidth();
  mBackgroundHeight = I.getHeight();
 
  init(
#ifdef VISP_HAVE_OIS
      bufferedKeys,
#else
      false,
#endif
      hidden);
 
#if (VISP_HAVE_OGRE_VERSION >= (13 <<16 | 0 <<8 | 0))
// Register the scene manager.
  Ogre::RTShader::ShaderGenerator::getSingleton().addSceneManager(Ogre::Root::getSingletonPtr()->getSceneManager(mSceneManagerName));
#endif
 
  // Create the background image which will come from the grabber
  createBackground(I);
}

void vpAROgre::init(bool
#ifdef VISP_HAVE_OIS
                        bufferedKeys
#endif
                    ,
                    bool hidden)
{
  // Create the root
  // mPluginsPath may contain more than one folder location separated by ";"
  bool pluginsFileExists = false;
  std::string pluginFile;
  std::vector<std::string> plugingsPaths = vpIoTools::splitChain(std::string(mPluginsPath), std::string(";"));
  for (size_t i = 0; i < plugingsPaths.size(); i++) {
#if defined(NDEBUG) || !defined(_WIN32)
    pluginFile = plugingsPaths[i] + "/plugins.cfg";
#else
    pluginFile = plugingsPaths[i] + "/plugins_d.cfg";
#endif
 
    if (vpIoTools::checkFilename(pluginFile)) {
      pluginsFileExists = true;
      break;
    }
  }
  if (!pluginsFileExists) {
    std::string errorMsg = std::string("Error: the requested plugins file \"")
#if defined(NDEBUG) || !defined(_WIN32)
      +std::string("plugins.cfg")
#else
      + std::string("plugins_d.cfg")
#endif
      + std::string("\" doesn't exist in ") + std::string(mPluginsPath);
    std::cout << errorMsg << std::endl;
 
    throw(vpException(vpException::ioError, errorMsg));
  }
  std::cout << "######################### Load plugin file: " << pluginFile << std::endl;
 
  if (Ogre::Root::getSingletonPtr() == nullptr) {
    mRoot = new Ogre::Root(pluginFile, "ogre.cfg", "Ogre.log");
  }
  else {
    mRoot = Ogre::Root::getSingletonPtr();
  }
 
  // Create the window
  bool canInit = true;
  if (mshowConfigDialog) {
    mRoot->restoreConfig();
#if (VISP_HAVE_OGRE_VERSION < (1<<16 | 10<<8 | 0))
    bool isOK = mRoot->showConfigDialog();
#else
    bool isOK = mRoot->showConfigDialog(OgreBites::getNativeConfigDialog());
#endif
    if (!isOK) {
      canInit = false;
    }
  }
  else {
    if (!mRoot->restoreConfig()) {
      canInit = false;
    }
  }
 
  if (!mRoot->isInitialised()) {
    if (!canInit) { // We set the default renderer system
      const Ogre::RenderSystemList &lRenderSystemList = mRoot->getAvailableRenderers();
      if (lRenderSystemList.size() == 0) {
        throw "ConfigDialog aborted"; // Exit the application on cancel
      }
 
      Ogre::RenderSystem *lRenderSystem = lRenderSystemList.at(0);
      std::cout << "Using " << lRenderSystem->getName() << " as renderer." << std::endl;
      mRoot->setRenderSystem(lRenderSystem);
    }
 
    mRoot->initialise(false);
  }
 
#if (VISP_HAVE_OGRE_VERSION < (1<<16 | 10<<8 | 0))
  mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);
#elif (VISP_HAVE_OGRE_VERSION < (14<<16 | 0<<8 | 0))
  mSceneMgr = mRoot->createSceneManager(Ogre::DefaultSceneManagerFactory::FACTORY_TYPE_NAME, mSceneManagerName);
#else
  mSceneMgr = mRoot->createSceneManager(Ogre::SMT_DEFAULT, mSceneManagerName);
#endif
 
  bool fullscreen = false;
  Ogre::NameValuePairList misc;
  Ogre::ConfigOptionMap config = mRoot->getRenderSystem()->getConfigOptions();
  Ogre::ConfigOptionMap::const_iterator it = config.begin();
 
  while (it != config.end()) {
    Ogre::String leftconf = (*it).first;
    Ogre::String rightconf = (*it).second.currentValue;
 
    if (leftconf == "Video Mode") {
      if (canInit) {
        std::stringstream ss(rightconf.c_str());
        std::string dummy;
        ss >> mWindowWidth >> dummy >> mWindowHeight;
        if (ss.fail()) {
          std::cout << "Cannot read Ogre video mode" << std::endl;
        }
      }
      else if (mWindowWidth == 0 && mWindowHeight == 0) {
        mWindowWidth = mBackgroundWidth;
        mWindowHeight = mBackgroundHeight;
      }
    }
    else if (leftconf == "Full Screen") {
      if (canInit && (rightconf == "Yes")) {
        fullscreen = true;
      }
    }
    else {
      misc[leftconf] = rightconf;
    }
 
    ++it;
  }
 
  // With Ogre version >= 1.8.1 we hide the window
  if (hidden) {
#if (OGRE_VERSION >= (1 << 16 | 8 << 8 | 1))
    misc["hidden"] = "true";
    windowHidden = true;
#endif
  }
  mWindow = mRoot->createRenderWindow(name, mWindowWidth, mWindowHeight, fullscreen, &misc);
 
  // Load resource paths from config file
 
  // File format is:
  //  [ResourceGroupName]
  //  ArchiveType=Path
  //  .. repeat
  // For example:
  //  [General]
  //  FileSystem=media/
  //  Zip=packages/level1.zip
 
  // mResourcePath may contain more than one folder location separated by ";"
  bool resourcesFileExists = false;
  std::string resourceFile;
  std::vector<std::string> resourcesPaths = vpIoTools::splitChain(std::string(mResourcePath), std::string(";"));
  for (size_t i = 0; i < resourcesPaths.size(); i++) {
    resourceFile = resourcesPaths[i] + "/resources.cfg";
    if (!vpIoTools::checkFilename(resourceFile)) {
      continue;
    }
    resourcesFileExists = true;
    std::cout << "######################### Load resource file: " << resourceFile << std::endl;
    Ogre::ConfigFile cf;
    cf.load(resourceFile);
    // Go through all sections & settings in the file
#if (VISP_HAVE_OGRE_VERSION < (1<<16 | 11<<8 | 0))
    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
 
    Ogre::String secName, typeName, archName;
    while (seci.hasMoreElements()) {
      secName = seci.peekNextKey();
      Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
      Ogre::ConfigFile::SettingsMultiMap::iterator i;
      for (i = settings->begin(); i != settings->end(); ++i) {
        typeName = i->first;
        archName = i->second;
        bool doesResourceExist = vpIoTools::checkDirectory(archName) || vpIoTools::checkFilename(archName);
        if (doesResourceExist) {
          if (!Ogre::ResourceGroupManager::getSingleton().resourceLocationExists(archName, secName)) {
            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
          }
          else {
            std::cout << "INFO: Resource location \"" << archName << "\" of type \"" << typeName << "\" has already been added to the list of known resource locations." << std::endl;
          }
        }
        else if (!doesResourceExist) {
          std::cout << "INFO: Resource \"" << archName << "\" of type \"" << typeName << "\" does not exist." << std::endl;
        }
      }
    }
#else
    const  Ogre::ConfigFile::SettingsBySection_ &sectionsNamesAndSettigns = cf.getSettingsBySection();
    Ogre::String secName, typeName, archName;
    for (std::pair<Ogre::String, Ogre::ConfigFile::SettingsMultiMap> name_settings : sectionsNamesAndSettigns) {
      secName = name_settings.first;
      Ogre::ConfigFile::SettingsMultiMap settings = name_settings.second;
      Ogre::ConfigFile::SettingsMultiMap::iterator i;
      for (i = settings.begin(); i != settings.end(); ++i) {
        typeName = i->first;
        archName = i->second;
        bool doesResourceExist = vpIoTools::checkDirectory(archName) || vpIoTools::checkFilename(archName);
        if (doesResourceExist) {
          if (!Ogre::ResourceGroupManager::getSingleton().resourceLocationExists(archName, secName)) {
            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
          }
          else {
            std::cout << "INFO: Resource location \"" << archName << "\" of type \"" << typeName << "\" has already been added to the list of known resource locations." << std::endl;
          }
        }
        else if (!doesResourceExist) {
          std::cout << "INFO: Resource \"" << archName << "\" of type \"" << typeName << "\" does not exist." << std::endl;
        }
      }
    }
#endif
  }
  if (!resourcesFileExists) {
    std::string errorMsg = std::string("Error: the requested resource file \"resources.cfg\"") +
      std::string("doesn't exist in ") + std::string(mResourcePath);
 
    std::cout << errorMsg << std::endl << std::flush;
 
    throw(vpException(vpException::ioError, errorMsg));
  }
 
  // Add Optional resources (given by the user).
  std::cout << "##################### add optional resource locations given by the user" << std::endl;
  for (std::list<std::string>::const_iterator iter = mOptionalResourceLocation.begin();
       iter != mOptionalResourceLocation.end(); ++iter) {
    const Ogre::String typeName("FileSystem");
    bool doesResourceExist = vpIoTools::checkDirectory(*iter) || vpIoTools::checkFilename(*iter);
    if (doesResourceExist) {
      if (!Ogre::ResourceGroupManager::getSingleton().resourceLocationExists(*iter, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)) {
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(*iter, typeName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
      }
      else {
        std::cout << "INFO: Resource location \"" << *iter << "\" of type \"" << typeName << "\" has already been added to the list of known resource locations." << std::endl;
      }
    }
    else if (!doesResourceExist) {
      std::cout << "INFO: Resource \"" << *iter << "\" of type \"" << typeName << "\" does not exist." << std::endl;
    }
  }
 
 
#if (VISP_HAVE_OGRE_VERSION >= (1<<16 | 10 <<8 | 0))
  // Initialize the RTShaderSystem, if available
  bool hasInitializedTheRTSS = initialiseRTShaderSystem();
  if (!hasInitializedTheRTSS) {
    std::cout << "[vpAROgre::init] RTSS is not available." << std::endl;
  }
#endif
 
  // Initialise resources
  std::cout << "##################### add resources" << std::endl;
  Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
  //-----------------------------------------------------
  // 4 Create the SceneManager
  //
  //    ST_GENERIC = octree
  //    ST_EXTERIOR_CLOSE = simple terrain
  //    ST_EXTERIOR_FAR = nature terrain (depreciated)
  //    ST_EXTERIOR_REAL_FAR = paging landscape
  //    ST_INTERIOR = Quake3 BSP
  //-----------------------------------------------------
 
// Create the camera
  createCamera();
 
  // Create a viewport
  Ogre::Viewport *viewPort = mWindow->addViewport(mCamera);
  //   Ogre::Viewport* viewPort = mCamera->getViewport();
  viewPort->setClearEveryFrame(true);
  // Set the projection parameters to match the camera intrinsic parameters
  updateCameraProjection();
 
  // Create the 3D scene
  createScene();
 
  // Initialise and register event handlers
  mRoot->addFrameListener(this);
 
  // Register as a Window listener
  OgreWindowEventUtilities::addWindowEventListener(mWindow, this);
  OgreWindowEventUtilities::_addRenderWindow(mWindow);
 
#ifdef VISP_HAVE_OIS
  // Initialise OIS
  Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
  OIS::ParamList pl;
 
  size_t windowHnd = 0;
  std::ostringstream windowHndStr;
  // Initialise window
  mWindow->getCustomAttribute("WINDOW", &windowHnd);
  windowHndStr << windowHnd;
  pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
// Let the user use the keyboard elsewhere
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
  pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
#endif
 
  mInputManager = OIS::InputManager::createInputSystem(pl);
 
  // Create all devices
  // Here we only consider the keyboard input
  mKeyboard = static_cast<OIS::Keyboard *>(mInputManager->createInputObject(OIS::OISKeyboard, bufferedKeys));
  if (!bufferedKeys) {
    mKeyboard->setEventCallback(this);
  }
#endif
 
  // Initialise a render to texture to be able to retrieve a screenshot
  try {
    Ogre::TexturePtr Texture = Ogre::TextureManager::getSingleton().createManual(
        "rtf", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWindow->getWidth(),
        mWindow->getHeight(), 0, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET);
 
    Ogre::RenderTexture *RTarget = Texture->getBuffer()->getRenderTarget();
    RTarget->addViewport(mCamera);
    RTarget->getViewport(0)->setClearEveryFrame(true);
    RTarget->getViewport(0)->setOverlaysEnabled(false);
  }
  catch (const Ogre::Exception &) {
    std::cout << "Info: Texture rtf is already known by the resource manager." << std::endl;
  }
 
  mInitialized = true;
}

vpAROgre::~vpAROgre(void)
{
  if (!mInitialized) {
    return;
  }
#if (VISP_HAVE_OGRE_VERSION >= (1<<16 | 11<<8 | 0))
  mPixelBuffer.reset();
#else
  mPixelBuffer.setNull();
#endif
// Destroy 3D scene
  destroyScene();
  // Close OIS
  closeOIS();
 
  // Destroy the RTSS, if available
  destroyRTShaderSystem();
 
  if (mWindow) {
    OgreWindowEventUtilities::removeWindowEventListener(mWindow, this);
    OgreWindowEventUtilities::_removeRenderWindow(mWindow);
    windowClosed(mWindow);
  }
 
// Delete root
  bool hasNoMoreElements = false;
#if (VISP_HAVE_OGRE_VERSION < (1<<16 | 11<<8 | 0))
  if (Ogre::Root::getSingletonPtr()) {
    hasNoMoreElements = !Ogre::Root::getSingletonPtr()->getSceneManagerIterator().hasMoreElements();
  }
#else
  if (Ogre::Root::getSingletonPtr()) {
    hasNoMoreElements = Ogre::Root::getSingletonPtr()->getSceneManagers().empty();
  }
#endif
 
  if (hasNoMoreElements && mRoot) {
    delete mRoot;
  }
  mRoot = 0;
}

bool vpAROgre::stopTest(const Ogre::FrameEvent &evt)
{
  // Always keep this part
  if (keepOn) {
    return updateScene(evt);
  }
  else {
    return keepOn;
  }
}

bool vpAROgre::frameStarted(const Ogre::FrameEvent &evt)
{
  // custom method telling what to do at the beginning of each frame
  bool result = customframeStarted(evt);
 
  // Listen to the window
  OgreWindowEventUtilities::messagePump();
  processInputEvent(evt);
 
  // See if we have to stop rendering
  if (result)
    return stopTest(evt);
  else
    return result;
}

bool vpAROgre::frameEnded(const Ogre::FrameEvent &evt)
{
  // custom method telling what to do at the end of each frame
  bool result = customframeEnded(evt);
 
  // See if we have to stop rendering
  if (result)
    return stopTest(evt);
  else
    return result;
}

bool vpAROgre::customframeStarted(const Ogre::FrameEvent & /*evt*/)
{
  // See if window was closed
  if (mWindow->isClosed())
    return false;
 
#ifdef VISP_HAVE_OIS
  // Get keyboard input
  mKeyboard->capture();
  if (mKeyboard->isKeyDown(OIS::KC_ESCAPE))
    return false;
#endif
  return true;
}

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

bool vpAROgre::windowClosing(Ogre::RenderWindow *rw)
{
  if (rw == mWindow) {
    keepOn = false;
  }
  return !keepOn;
}

void vpAROgre::windowClosed(Ogre::RenderWindow *rw)
{
  // Only close for window that created OIS (the main window in these demos)
  if (rw == mWindow)
    closeOIS();
}

bool vpAROgre::renderOneFrame(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMw)
{
  // Update the background to match the situation
  updateBackgroundTexture(I);
 
  // Update the camera parameters to match the grabbed image
  updateCameraParameters(cMw);
 
  // Display on Ogre Window
  return mRoot->renderOneFrame();
}

bool vpAROgre::renderOneFrame(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMw)
{
  // Update the background to match the situation
  updateBackgroundTexture(I);
 
  // Update the camera parameters to match the grabbed image
  updateCameraParameters(cMw);
 
  // Display on Ogre Window
  return mRoot->renderOneFrame();
}

void vpAROgre::display(const vpImage<unsigned char> &I, const vpHomogeneousMatrix &cMw)
{
  // Display on Ogre Window
  if (renderOneFrame(I, cMw)) {
    mWindow->update();
    keepOn = true;
  }
  else {
    keepOn = false;
  }
}

void vpAROgre::display(const vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMw)
{
  // Display on Ogre Window
  if (renderOneFrame(I, cMw)) {
    mWindow->update();
    keepOn = true;
  }
  else {
    keepOn = false;
  }
}

bool vpAROgre::continueRendering(void) { return keepOn; }

void vpAROgre::setCameraParameters(const vpCameraParameters &cameraP) { mcam = cameraP; }

void vpAROgre::load(const std::string &entityName, const std::string &model)
{
  Ogre::Entity *newEntity = mSceneMgr->createEntity(entityName, model);
  Ogre::SceneNode *newNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(entityName);
  newNode->attachObject(newEntity);
}

void vpAROgre::setMaterial(const std::string &entityName, const std::string &materialName)
{
  // Reset the position
  Ogre::Entity *entity = mSceneMgr->getEntity(entityName);
  entity->setMaterialName(materialName);
}

void vpAROgre::setPosition(const std::string &sceneName, const vpTranslationVector &wTo)
{
  // Reset the position
  Ogre::SceneNode *node = mSceneMgr->getSceneNode(sceneName);
  node->setPosition((Ogre::Real)wTo[0], (Ogre::Real)wTo[1], (Ogre::Real)wTo[2]);
}

vpTranslationVector vpAROgre::getPosition(const std::string &sceneName) const
{
  Ogre::Vector3 translation = mSceneMgr->getSceneNode(sceneName)->getPosition();
  return vpTranslationVector((Ogre::Real)translation[0], (Ogre::Real)translation[1], (Ogre::Real)translation[2]);
}

void vpAROgre::setRotation(const std::string &sceneName, const vpRotationMatrix &wRo)
{
  // Get the node in its original position
  mSceneMgr->getSceneNode(sceneName)->resetOrientation();
  // Apply the new rotation
  Ogre::Matrix3 rotationOgre = Ogre::Matrix3((Ogre::Real)wRo[0][0], (Ogre::Real)wRo[0][1], (Ogre::Real)wRo[0][2],
                                             (Ogre::Real)wRo[1][0], (Ogre::Real)wRo[1][1], (Ogre::Real)wRo[1][2],
                                             (Ogre::Real)wRo[2][0], (Ogre::Real)wRo[2][1], (Ogre::Real)wRo[2][2]);
  Ogre::Quaternion q(rotationOgre);
  mSceneMgr->getSceneNode(sceneName)->rotate(q);
}

void vpAROgre::addRotation(const std::string &sceneName, const vpRotationMatrix &wRo)
{
  // Apply the new rotation
  Ogre::Matrix3 rotationOgre = Ogre::Matrix3((Ogre::Real)wRo[0][0], (Ogre::Real)wRo[0][1], (Ogre::Real)wRo[0][2],
                                             (Ogre::Real)wRo[1][0], (Ogre::Real)wRo[1][1], (Ogre::Real)wRo[1][2],
                                             (Ogre::Real)wRo[2][0], (Ogre::Real)wRo[2][1], (Ogre::Real)wRo[2][2]);
  Ogre::Quaternion q(rotationOgre);
  mSceneMgr->getSceneNode(sceneName)->rotate(q);
}

void vpAROgre::setPosition(const std::string &sceneName, const vpHomogeneousMatrix &wMo)
{
  // Extract the position and orientation data
  vpRotationMatrix rotations;
  vpTranslationVector translation;
  wMo.extract(rotations);
  wMo.extract(translation);
  // Apply them to the node
  setPosition(sceneName, translation);
  setRotation(sceneName, rotations);
}

void vpAROgre::setVisibility(const std::string &sceneName, bool isVisible)
{
  mSceneMgr->getSceneNode(sceneName)->setVisible(isVisible);
}

void vpAROgre::setScale(const std::string &sceneName, float factorx, float factory, float factorz)
{
  // Reset the scale to its original value
  mSceneMgr->getSceneNode(sceneName)->scale(Ogre::Vector3(1, 1, 1) / mSceneMgr->getSceneNode(sceneName)->getScale());
  // Apply the new scale
  mSceneMgr->getSceneNode(sceneName)->scale(Ogre::Vector3(factorx, factory, factorz));
}

void vpAROgre::createCamera(void) { mCamera = mSceneMgr->createCamera("Camera"); }

void vpAROgre::createBackground(vpImage<unsigned char> & /* I */)
{
  // Create a rectangle to show the incoming images from the camera
  mBackground = new Ogre::Rectangle2D(true);     // true = textured
  mBackground->setCorners(-1.0, 1.0, 1.0, -1.0); // Spread all over the window
  mBackground->setBoundingBox(Ogre::AxisAlignedBox(-100000.0 * Ogre::Vector3::UNIT_SCALE,
                                                   100000.0 * Ogre::Vector3::UNIT_SCALE)); // To be shown everywhere
 
  // Texture options
  Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_NONE);
  Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(1);
 
  // Dynamic texture
  // If we are using opengl we can boost a little bit performances with a
  // dynamic texture
  if (mRoot->getRenderSystem()->getName() == "OpenGL Rendering Subsystem") {
    try {
      Ogre::TextureManager::getSingleton().createManual(
        "BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
        mBackgroundWidth,  // width
        mBackgroundHeight, // height
        0,                 // num of mip maps
        Ogre::PF_BYTE_L, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
    }
    catch (const Ogre::Exception &) {
      std::cout << "Info: Texture BackgroundTexture is already known by the resource manager." << std::endl;
    }
  }
  else {
    try {
      Ogre::TextureManager::getSingleton().createManual(
        "BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
        mBackgroundWidth,  // width
        mBackgroundHeight, // height
        0,                 // num of mip maps
        Ogre::PF_BYTE_L, Ogre::TU_DEFAULT);
    }
    catch (const Ogre::Exception &) {
      std::cout << "Info: Texture BackgroundTexture is already known by the resource manager." << std::endl;
    }
  }
 
  // Pointer to the dynamic texture
  Ogre::TexturePtr dynTexPtr = Ogre::TextureManager::getSingleton().getByName("BackgroundTexture");
  //#if ( OGRE_VERSION >= (1 << 16 | 9 << 8 | 0) )
  //    .dynamicCast<Ogre::Texture>();// Get the pixel buffer
  //#else
  //      ;
  //#endif
  mPixelBuffer = dynTexPtr->getBuffer();
 
  // Material to apply the texture to the background
  try {
    Ogre::MaterialPtr Backgroundmaterial = Ogre::MaterialManager::getSingleton().create(
      "BackgroundMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    Ogre::Technique *Backgroundtechnique = Backgroundmaterial->createTechnique();
    Backgroundtechnique->createPass();
    Backgroundmaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false);
    Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false); // Background
    Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); // Background
    Backgroundmaterial->getTechnique(0)->getPass(0)->createTextureUnitState("BackgroundTexture");
#if (VISP_HAVE_OGRE_VERSION >= (1<<16 | 11<<8 | 0))
    mBackground->setMaterial(Backgroundmaterial);                  // Attach the material to the rectangle
#else
    mBackground->setMaterial("BackgroundMaterial");                  // Attach the material to the rectangle
#endif
  }
  catch (const Ogre::Exception &) {
    std::cout << "Info: Material BackgroundMaterial is already known by the resource manager." << std::endl;
  }
 
  // Add the background to the Scene Graph so it will be rendered
  Ogre::SceneNode *BackgroundNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("BackgoundNode");
  BackgroundNode->attachObject(mBackground);
}

void vpAROgre::createBackground(vpImage<vpRGBa> & /* I */)
{
  // Create a rectangle to show the incoming images from the camera
  mBackground = new Ogre::Rectangle2D(true);     // true = textured
  mBackground->setCorners(-1.0, 1.0, 1.0, -1.0); // Spread all over the window
  mBackground->setBoundingBox(Ogre::AxisAlignedBox(-100000.0 * Ogre::Vector3::UNIT_SCALE,
                                                   100000.0 * Ogre::Vector3::UNIT_SCALE)); // To be shown everywhere
 
  // Texture options
  Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_NONE);
  Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(1);
 
  // Dynamic texture
  // If we are using opengl we can boost a little bit performances with a
  // dynamic texture
  if (mRoot->getRenderSystem()->getName() == "OpenGL Rendering Subsystem") {
    try {
      Ogre::TextureManager::getSingleton().createManual(
        "BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
        mBackgroundWidth,  // width
        mBackgroundHeight, // height
        0,                 // num of mip maps
        Ogre::PF_BYTE_BGRA, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
    }
    catch (const Ogre::Exception &) {
      std::cout << "Info: Texture BackgroundTexture is already known by the resource manager." << std::endl;
    }
  }
  else { // As that texture does not seem to work properly with direct3D we
        // use a default texture
    try {
      Ogre::TextureManager::getSingleton().createManual(
         "BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
         mBackgroundWidth,  // width
         mBackgroundHeight, // height
         0,                 // num of mip maps
         Ogre::PF_BYTE_BGRA, Ogre::TU_DEFAULT);
    }
    catch (const Ogre::Exception &) {
      std::cout << "Info: Texture BackgroundTexture is already known by the resource manager." << std::endl;
    }
  }
 
  // Pointer to the dynamic texture
  Ogre::TexturePtr dynTexPtr = Ogre::TextureManager::getSingleton().getByName("BackgroundTexture");
  //#if ( OGRE_VERSION >= (1 << 16 | 9 << 8 | 0) )
  //      .dynamicCast<Ogre::Texture>();// Get the pixel buffer
  //#else
  //      ;
  //#endif
 
  // Get the pixel buffer
  mPixelBuffer = dynTexPtr->getBuffer();
 
  // Material to apply the texture to the background
  try {
    Ogre::MaterialPtr Backgroundmaterial = Ogre::MaterialManager::getSingleton().create(
      "BackgroundMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    Ogre::Technique *Backgroundtechnique = Backgroundmaterial->createTechnique();
    Backgroundtechnique->createPass();
    Backgroundmaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false);
    Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false); // Background
    Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); // Background
    Backgroundmaterial->getTechnique(0)->getPass(0)->createTextureUnitState("BackgroundTexture");
 
#if (VISP_HAVE_OGRE_VERSION >= (1<<16 | 11<<8 | 0))
    mBackground->setMaterial(Backgroundmaterial);                  // Attach the material to the rectangle
#else
    mBackground->setMaterial("BackgroundMaterial");                  // Attach the material to the rectangle
#endif
  }
  catch (const Ogre::Exception &) {
    std::cout << "Info: Material BackgroundMaterial is already known by the resource manager." << std::endl;
  }
  mBackground->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND); // To be rendered in Background
 
  // Add the background to the Scene Graph so it will be rendered
  Ogre::SceneNode *BackgroundNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("BackgoundNode");
  BackgroundNode->attachObject(mBackground);
}

void vpAROgre::closeOIS(void)
{
#ifdef VISP_HAVE_OIS
  if (mInputManager) {
    mInputManager->destroyInputObject(mKeyboard);
 
    OIS::InputManager::destroyInputSystem(mInputManager);
    mInputManager = 0;
  }
#endif
}

// Note: equation taken from:
// http://strawlab.org/2011/11/05/augmented-reality-with-OpenGL/
void vpAROgre::updateCameraProjection(void)
{
  if (mCamera != 0) {
    Ogre::Real f, n, f_m_n, f_p_n, px, py, u0, v0;
    f = (Ogre::Real)(mFarClipping);  // Far clip distance
    n = (Ogre::Real)(mNearClipping); // Near clip distance
    f_m_n = (Ogre::Real)(f - n);
    f_p_n = (Ogre::Real)(f + n);
    px = (Ogre::Real)mcam.get_px();
    py = (Ogre::Real)mcam.get_py();
    u0 = (Ogre::Real)mcam.get_u0();
    v0 = (Ogre::Real)mcam.get_v0();
    Ogre::Matrix4 Projection = Ogre::Matrix4(
        (Ogre::Real)(2.0 * px / mBackgroundWidth), 0, (Ogre::Real)(1.0 - 2.0 * (u0 / mBackgroundWidth)), 0, 0,
        (Ogre::Real)(2.0 * py / mBackgroundHeight), (Ogre::Real)(-1.0 + 2.0 * (v0 / mBackgroundHeight)), 0, 0, 0,
        (Ogre::Real)(-1.0 * f_p_n / f_m_n), (Ogre::Real)(-2.0 * f * n / f_m_n), 0, 0, -1.0, 0);
    mCamera->setCustomProjectionMatrix(true, Projection);
  }
}

void vpAROgre::updateBackgroundTexture(const vpImage<unsigned char> &I)
{
  // Inspired from Ogre wiki :
  // http://www.ogre3d.org/tikiwiki/Creating+dynamic+textures Lock the pixel
  // buffer and get a pixel box. HBL_DISCARD is to use for best performance
  // than HBL_NORMAL
  mPixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD); // Lock the buffer
  const Ogre::PixelBox &pixelBox = mPixelBuffer->getCurrentLock();
  // Buffer data
  Ogre::uint8 *pDest = static_cast<Ogre::uint8 *>(pixelBox.data);
  // Fill in the data in the grey level texture
  memcpy(pDest, I.bitmap, mBackgroundHeight * mBackgroundWidth);
 
  // Unlock the pixel buffer
  mPixelBuffer->unlock();
}

void vpAROgre::updateBackgroundTexture(const vpImage<vpRGBa> &I)
{
  // Inspired from Ogre wiki :
  // http://www.ogre3d.org/tikiwiki/Creating+dynamic+textures Lock the pixel
  // buffer and get a pixel box. HBL_DISCARD is to use for best performance
  // than HBL_NORMAL
  mPixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD); // Lock the buffer
  const Ogre::PixelBox &pixelBox = mPixelBuffer->getCurrentLock();
  // Buffer data
  Ogre::uint8 *pDest = static_cast<Ogre::uint8 *>(pixelBox.data);
// Fill in the data in the grey level texture
#if 1 // if texture in BGRa format
  for (unsigned int i = 0; i < mBackgroundHeight; i++) {
    for (unsigned int j = 0; j < mBackgroundWidth; j++) {
      // Color Image
      //      *pDest++=I[i][mBackgroundWidth-j].B; // Blue component
      //      *pDest++=I[i][mBackgroundWidth-j].G; // Green component
      //      *pDest++=I[i][mBackgroundWidth-j].R; // Red component
 
      *pDest++ = I[i][j].B; // Blue component
      *pDest++ = I[i][j].G; // Green component
      *pDest++ = I[i][j].R; // Red component
 
      *pDest++ = 255; // Alpha component
    }
  }
#else // if texture in RGBa format which is the format of the input image
  memcpy(pDest, I.bitmap, mBackgroundHeight * mBackgroundWidth * sizeof(vpRGBa));
#endif
 
  // Unlock the pixel buffer
  mPixelBuffer->unlock();
}

void vpAROgre::updateCameraParameters(const vpHomogeneousMatrix &cMw)
{
  // The matrix is given to Ogre with some changes to fit with the world
  // projection
  Ogre::Matrix4 ModelView
      //    = Ogre::Matrix4( (Ogre::Real)-cMo[0][0],  (Ogre::Real)-cMo[0][1],
      //    (Ogre::Real)-cMo[0][2],  (Ogre::Real)-cMo[0][3],
    = Ogre::Matrix4((Ogre::Real)cMw[0][0], (Ogre::Real)cMw[0][1], (Ogre::Real)cMw[0][2], (Ogre::Real)cMw[0][3],
                    (Ogre::Real)-cMw[1][0], (Ogre::Real)-cMw[1][1], (Ogre::Real)-cMw[1][2], (Ogre::Real)-cMw[1][3],
                    (Ogre::Real)-cMw[2][0], (Ogre::Real)-cMw[2][1], (Ogre::Real)-cMw[2][2], (Ogre::Real)-cMw[2][3],
                    (Ogre::Real)0, (Ogre::Real)0, (Ogre::Real)0, (Ogre::Real)1);
#if (VISP_HAVE_OGRE_VERSION >= (1 << 16 | 11 << 8 | 0))
  Ogre::Affine3 ModelViewAsAffine(ModelView);
  mCamera->setCustomViewMatrix(true, ModelViewAsAffine);
#else
  mCamera->setCustomViewMatrix(true, ModelView);
#endif
}

void vpAROgre::getRenderingOutput(vpImage<vpRGBa> &I, const vpHomogeneousMatrix &cMo)
{
  updateCameraParameters(cMo);
  Ogre::TexturePtr dynTexPtr = Ogre::TextureManager::getSingleton().getByName("rtf");
  //#if ( OGRE_VERSION >= (1 << 16 | 9 << 8 | 0) )
  //        .dynamicCast<Ogre::Texture>();
  //#else
  //        ;
  //#endif
  Ogre::RenderTexture *RTarget = dynTexPtr->getBuffer()->getRenderTarget();
  mWindow->update();
  RTarget->update();
  if (I.getHeight() != mWindow->getHeight() || I.getWidth() != mWindow->getWidth()) {
    I.resize(mWindow->getHeight(), mWindow->getWidth());
  }
  mPixelBuffer = dynTexPtr->getBuffer();
  mPixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
  const Ogre::PixelBox &pixelBox = mPixelBuffer->getCurrentLock();
  dynTexPtr->getBuffer()->blitToMemory(pixelBox);
  Ogre::uint8 *pDest = static_cast<Ogre::uint8 *>(pixelBox.data);
#if 1 // if texture in BGRa format
  for (unsigned int i = 0; i < I.getHeight(); i++) {
    for (unsigned int j = 0; j < I.getWidth(); j++) {
      // Color Image
      I[i][j].B = *pDest++; // Blue component
      I[i][j].G = *pDest++; // Green component
      I[i][j].R = *pDest++; // Red component
      I[i][j].A = *pDest++; // Alpha component
    }
  }
#else // if texture in RGBa format which is the format of the input image
  memcpy(I.bitmap, pDest, I.getHeight() * I.getWidth() * sizeof(vpRGBa));
#endif
 
  // Unlock the pixel buffer
  mPixelBuffer->unlock();
}
END_VISP_NAMESPACE
#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work around to avoid warning: libvisp_ar.a(vpAROgre.cpp.o) has no symbols
void dummy_vpAROgre() { }
#endif