renderer.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "rve_render_server/renderer.h"
// TODO server should really hook into the renderer, rather than the renderer knowing about the server
#include "rve_render_server/server.h"
#include "rve_render_server/init.h"
#include "rve_render_server/render_window.h"
#include "rve_render_server/render_texture.h"
#include "rve_render_server/scene.h"
#include "rve_render_server/camera.h"
#include "rve_render_server/disable_rendering_scheme_listener.h"
#include "rve_render_server/mesh_loader.h"
#include "rve_render_server/pickable.h"

#include <OGRE/OgreRoot.h>
#include <OGRE/OgreRenderSystem.h>
#include <OGRE/OgreRenderWindow.h>
#include <OGRE/OgreEntity.h>
#include <OGRE/OgreCamera.h>
#include <OGRE/OgreSceneManager.h>

#include <ros/console.h>
#include <ros/assert.h>
#include <ros/package.h>
#include <ros/callback_queue.h>
#include <ros/node_handle.h>

#include <rve_msgs/FrameStats.h>
#include <std_msgs/Empty.h>

#if USE_NVPERFSDK

#include "NVPerfSDK.h"

// On some versions of Linux NVPMInit() crashes in __strstr_sse42
// This forces it to use our version instead
// strstr implementation found at: http://en.wikibooks.org/wiki/C_Programming/Strings#The_strstr_function
// nvidia developer forums post about the crash: http://developer.nvidia.com/forums/index.php?showtopic=4926
const char *(strstr)(const char *haystack, const char *needle)
{
   size_t needlelen;
   /* Check for the null needle case.  */
   if (*needle == '\0')
       return (char *) haystack;
   needlelen = strlen(needle);
   for (; (haystack = strchr(haystack, *needle)) != NULL; haystack++)
       if (strncmp(haystack, needle, needlelen) == 0)
           return (char *) haystack;
   return NULL;
}

#endif

using namespace rve_common;

namespace rve_render_server
{

Renderer::Renderer(bool enable_ogre_log)
: running_(false)
, first_window_created_(false)
, enable_ogre_log_(enable_ogre_log)
, callback_queue_(new ros::CallbackQueue)
#if USE_NVPERFSDK
, nvperfsdk_initialized_(false)
, do_experiment_(false)
, start_experiment_(false)
#endif
{
  pickable_id_gen_.seed(time(0));
}

Renderer::~Renderer()
{
  stop();
}

void Renderer::start()
{
  if (running_)
  {
    return;
  }

  init();

  running_ = true;
  render_thread_ = boost::thread(&Renderer::renderThread, this);
}

void Renderer::stop()
{
  if (!running_)
  {
    return;
  }

  running_ = false;
  render_thread_.join();

  scenes_.clear();
  materials_.clear();
  meshes_.clear();
  render_targets_.clear();
  Ogre::Root::getSingleton().getRenderSystem()->destroyRenderWindow(primary_render_window_->getName());
  delete Ogre::Root::getSingletonPtr();
}

void Renderer::init()
{
  Ogre::LogManager* log_manager = new Ogre::LogManager();
  log_manager->createLog( "Ogre.log", false, false, !enable_ogre_log_ );

  Ogre::Root* root = new Ogre::Root("");
  root->loadPlugin( "RenderSystem_GL" );
  root->loadPlugin( "Plugin_OctreeSceneManager" );
  root->loadPlugin( "Plugin_CgProgramManager" );

  // Taken from gazebo
  Ogre::RenderSystem* render_system = NULL;
#if OGRE_VERSION_MAJOR >=1 && OGRE_VERSION_MINOR >= 7
  const Ogre::RenderSystemList& rsList = root->getAvailableRenderers();
  Ogre::RenderSystemList::const_iterator renderIt = rsList.begin();
  Ogre::RenderSystemList::const_iterator renderEnd = rsList.end();
#else
  Ogre::RenderSystemList* rsList = root->getAvailableRenderers();
  Ogre::RenderSystemList::iterator renderIt = rsList->begin();
  Ogre::RenderSystemList::iterator renderEnd = rsList->end();
#endif
  for ( ; renderIt != renderEnd; ++renderIt )
  {
    render_system = *renderIt;

    if ( render_system->getName() == "OpenGL Rendering Subsystem" )
    {
      break;
    }
  }

  if ( render_system == NULL )
  {
    throw std::runtime_error( "Could not find the opengl rendering subsystem!\n" );
  }

  //render_system->setConfigOption("FSAA","4");
  render_system->setConfigOption("RTT Preferred Mode", "FBO");

  root->setRenderSystem( render_system );
  root->initialise( false );

  scheme_listener_.reset(new DisableRenderingSchemeListener);
  Ogre::MaterialManager::getSingleton().addListener(scheme_listener_.get(), "GBuffer");
  Ogre::MaterialManager::getSingleton().addListener(scheme_listener_.get(), "GBufferStippleAlpha");
  Ogre::MaterialManager::getSingleton().addListener(scheme_listener_.get(), "AlphaBlend");
  Ogre::MaterialManager::getSingleton().addListener(scheme_listener_.get(), "WeightedAverageAlpha");
  Ogre::MaterialManager::getSingleton().addListener(scheme_listener_.get(), "Pick");

  Ogre::LogManager::getSingleton().getDefaultLog()->setDebugOutputEnabled(true);
  Ogre::LogManager::getSingleton().getDefaultLog()->setLogDetail(Ogre::LL_BOREME);

  frame_stats_pub_ = getServer()->getNodeHandle().advertise<rve_msgs::FrameStats>("frame_stats", 10);
}

template<typename F>
void callAFunction(F f)
{
  f();
}

void Renderer::threadInit()
{
  Ogre::Root* root = Ogre::Root::getSingletonPtr();
  // Create the primary hidden render window.  Ogre uses the first-created render window to bind all its
  // gpu resources to, so you aren't allowed to destroy it, which is problematic if we use the first render window
  // that is created by a client.
  Ogre::NameValuePairList params;
  params["hidden"] = "true";
  primary_render_window_ = root->createRenderWindow("Primary", 1, 1, false, &params);
  Ogre::ResourceGroupManager::getSingleton().createResourceGroup(ROS_PACKAGE_NAME);

  std::string pkg_path = ros::package::getPath(ROS_PACKAGE_NAME);
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/textures", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/fonts", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/models", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/materials/programs", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/materials/scripts", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/compositors", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/shaderlib", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/shaderlib/points", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().addResourceLocation( pkg_path + "/media/shaderlib/lines", "FileSystem", ROS_PACKAGE_NAME );
  Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

  std::for_each(init_functions_.begin(), init_functions_.end(), callAFunction<InitFunction>);
  init_functions_.clear();
}

RenderWindow* Renderer::createRenderWindow(const rve_common::UUID& id, const std::string& parent_window, uint32_t width, uint32_t height)
{
  if (render_targets_.count(id) > 0)
  {
    std::stringstream ss;
    ss << "Render target with id [" << id << "] already exists";
    throw std::runtime_error(ss.str());
  }

  RenderWindow* rw = new RenderWindow(id, this, parent_window, width, height);
  RenderTargetPtr ptr(rw);
  render_targets_[id] = ptr;

  return rw;
}

RenderWindow* Renderer::getRenderWindow(const rve_common::UUID& id)
{
  RenderTarget* target = getRenderTarget(id);
  RenderWindow* win = dynamic_cast<RenderWindow*>(target);
  if (!win)
  {
    std::stringstream ss;
    ss << "Render target [" << id << "] is not a window";
    throw std::runtime_error(ss.str());
  }

  return win;
}

RenderTexture* Renderer::createRenderTexture(const rve_common::UUID& id, uint32_t width, uint32_t height)
{
  if (render_targets_.count(id) > 0)
  {
    std::stringstream ss;
    ss << "Render target with id [" << id << "] already exists";
    throw std::runtime_error(ss.str());
  }

  RenderTexture* rt = new RenderTexture(id, this, width, height);
  RenderTargetPtr ptr(rt);
  render_targets_[id] = ptr;

  return rt;
}

void Renderer::destroyRenderTarget(const rve_common::UUID& id)
{
  M_RenderTarget::iterator it = render_targets_.find(id);
  if (it == render_targets_.end())
  {
    std::stringstream ss;
    ss << "Render target [" << id << "] does not exist";
    throw std::runtime_error(ss.str());
  }

  render_targets_.erase(it);
}

RenderTarget* Renderer::getRenderTarget(const rve_common::UUID& id)
{
  M_RenderTarget::iterator it = render_targets_.find(id);
  if (it == render_targets_.end())
  {
    std::stringstream ss;
    ss << "Render target [" << id << "] does not exist";
    throw std::runtime_error(ss.str());
  }

  return it->second.get();
}

Scene* Renderer::createScene(const UUID& id)
{
  if (scenes_.count(id) > 0)
  {
    ROS_WARN_STREAM("UUID " << id << " collided when creating a scene!");
    return 0;
  }

  Ogre::Root* root = Ogre::Root::getSingletonPtr();
  Ogre::SceneManager* scene_manager = root->createSceneManager(Ogre::ST_GENERIC);
  ScenePtr scene(new Scene(id, scene_manager));
  scenes_[id] = scene;

  return scene.get();
}

void Renderer::destroyScene(const UUID& id)
{
  M_Scene::iterator it = scenes_.find(id);
  if (it == scenes_.end())
  {
    std::stringstream ss;
    ss << "Scene " << id << " does not exist!";
    throw std::runtime_error(ss.str());
  }

  scenes_.erase(it);
}

Scene* Renderer::getScene(const UUID& id)
{
  M_Scene::iterator it = scenes_.find(id);
  if (it == scenes_.end())
  {
    std::stringstream ss;
    ss << "Scene " << id << " does not exist!";
    throw std::runtime_error(ss.str());
  }

  return it->second.get();
}

Camera* Renderer::getCamera(const UUID& id)
{
  M_Scene::iterator it = scenes_.begin();
  M_Scene::iterator end = scenes_.end();
  for (; it != end; ++it)
  {
    const ScenePtr& scene = it->second;
    Camera* cam = scene->getCamera(id);
    if (cam)
    {
      return cam;
    }
  }

  return 0;
}

void Renderer::addMaterial(const rve_common::UUID& id, const MaterialPtr& mat)
{
  materials_[id] = mat;
}

void Renderer::removeMaterial(const rve_common::UUID& id)
{
  materials_.erase(id);
}

MaterialPtr Renderer::getMaterial(const rve_common::UUID& id)
{
  M_Material::iterator it = materials_.find(id);
  if (it == materials_.end())
  {
    std::stringstream ss;
    ss << "Material [" << id << "] does not exist";
    throw std::runtime_error(ss.str());
  }

  return it->second;
}

void Renderer::addMesh(const rve_common::UUID& id, const MeshPtr& mesh)
{
  meshes_[id] = mesh;
}

void Renderer::removeMesh(const rve_common::UUID& id)
{
  meshes_.erase(id);
}

MeshPtr Renderer::getMesh(const rve_common::UUID& id)
{
  M_Mesh::iterator it = meshes_.find(id);
  if (it == meshes_.end())
  {
    std::stringstream ss;
    ss << "Mesh [" << id << "] does not exist";
    throw std::runtime_error(ss.str());
  }

  return it->second;
}

bool Renderer::meshExists(const rve_common::UUID& id)
{
  return meshes_.find(id) != meshes_.end();
}

void Renderer::addTexture(const rve_common::UUID& id, const TexturePtr& tex)
{
  textures_[id] = tex;
}

void Renderer::removeTexture(const rve_common::UUID& id)
{
  textures_.erase(id);
}

TexturePtr Renderer::getTexture(const rve_common::UUID& id)
{
  M_Texture::iterator it = textures_.find(id);
  if (it == textures_.end())
  {
    throw std::runtime_error("Texture [" + id.toString() + "] does not exist");
  }

  return it->second;
}

bool Renderer::textureExists(const rve_common::UUID& id)
{
  return textures_.find(id) != textures_.end();
}

uint32_t Renderer::allocatePickID(Pickable* p)
{
  ROS_ASSERT(p);

  uint32_t id = 0;
  while (id == 0 || (!pickables_.insert(std::make_pair(id, p)).second))
  {
    id = pickable_id_gen_();
  }

  return id;
}

void Renderer::deallocatePickID(uint32_t pick_id)
{
  pickables_.erase(pick_id);
}

void Renderer::translatePickIDs(const V_PickRenderValues& ids, V_Picked& out_picked)
{
  // TODO: if we assume ids is sorted we can cache the pickable
  // which should help performance if this turns out to be a bottleneck
  V_PickRenderValues::const_iterator it = ids.begin();
  V_PickRenderValues::const_iterator end = ids.end();
  for (; it != end; ++it)
  {
    const PickRenderValues& prv = *it;
    if (prv.isNull())
    {
      continue;
    }

    M_Pickable::iterator pickable_it = pickables_.find(prv.id);
    if (pickable_it != pickables_.end())
    {
      Pickable* p = pickable_it->second;
      Picked picked = p->translatePick(prv);
      if (picked.isNull())
      {
        continue;
      }

      out_picked.push_back(picked);
    }
  }
}

bool Renderer::useGeometryShaders()
{
  //return false;
  return Ogre::Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_GEOMETRY_PROGRAM);
}

#if USE_NVPERFSDK
std::vector<std::pair<std::string, UINT> > g_perf_counters;

int enumerateNVPerfCounters(UINT index, char* name)
{
  ROS_INFO_STREAM(index << " " << name);
  g_perf_counters.push_back(std::make_pair(name, index));
  return NVPM_OK;
}

void Renderer::doExperimentCallback(const std_msgs::EmptyConstPtr&)
{
  start_experiment_ = true;
}

#endif

void Renderer::renderThread()
{
  threadInit();

#if USE_NVPERFSDK
  {
    uint32_t ret = NVPMInit();
    if (ret == NVPM_OK)
    {
      nvperfsdk_initialized_ = true;
      NVPMEnumCounters(enumerateNVPerfCounters);
      for (uint32_t i = 0; i < g_perf_counters.size(); ++i)
      {
        //const std::string& name = g_perf_counters[i].first;
        UINT index = g_perf_counters[i].second;
        int ret = NVPMAddCounter(index);
        ROS_ASSERT_MSG(ret == NVPM_OK, "ret = %d", ret);
      }

      experiment_stats_pub_ = getServer()->getNodeHandle().advertise<rve_msgs::FrameStats>("experiment_stats", 10);
      do_experiment_sub_ = getServer()->getNodeHandle().subscribe("do_experiment", 1, &Renderer::doExperimentCallback, this);
    }
    else
    {
      ROS_ERROR("Failed to initialize NVPerfSDK: %d", ret);
    }
  }
#endif

  while (running_)
  {
    if (render_targets_.empty())
    {
      callback_queue_->callAvailable(ros::WallDuration(0.1));
      continue;
    }

#if USE_NVPERFSDK
    if (start_experiment_)
    {
      do_experiment_ = true;
      start_experiment_ = false;
    }
#endif

    ros::WallTime start = ros::WallTime::now();

    rve_msgs::FrameStats frame_stats;

#if 0
    Ogre::Root::getSingleton().renderOneFrame();
#else
    if (Ogre::Root::getSingleton()._fireFrameStarted())
    {
#if USE_NVPERFSDK
      int pass_count = 1;

      if (do_experiment_)
      {
        NVPMBeginExperiment(&pass_count);
        ROS_INFO("pass_count %d", pass_count);
      }

      for (int pass = 0; pass < pass_count; ++pass)
      {
        if (do_experiment_)
        {
          NVPMBeginPass(pass);
        }
#endif

      M_RenderTarget::iterator it = render_targets_.begin();
      M_RenderTarget::iterator end = render_targets_.end();
      for (; it != end; ++it)
      {
        const RenderTargetPtr& wnd = it->second;
        wnd->beginRender();
      }

#if USE_NVPERFSDK
      if (!do_experiment_)
#endif
      {
        callback_queue_->callAvailable(ros::WallDuration(0.1));
      }

      it = render_targets_.begin();
      end = render_targets_.end();
      for (; it != end; ++it)
      {
        const RenderTargetPtr& wnd = it->second;
        wnd->finishRender();

        frame_stats.render_window_stats.push_back(wnd->getLastFrameStats());
      }

#if USE_NVPERFSDK
        if (do_experiment_)
        {
          NVPMEndPass(pass);
        }
      }

      if (do_experiment_)
      {
        NVPMEndExperiment();
        callback_queue_->callAvailable();

        UINT64 value, cycles;
        NVPMGetCounterValueByName("GPU Bottleneck", 0, &value, &cycles);
        char bottleneck_name[1024];
        NVPMGetGPUBottleneckName(value, bottleneck_name);
        frame_stats.nv_perf_counters.gpu_bottleneck = bottleneck_name;
      }
#endif

      Ogre::Root::getSingleton()._fireFrameEnded();
    }
    else
#endif
    {
      callback_queue_->callAvailable();
    }

    ros::WallTime end = ros::WallTime::now();
    //ROS_INFO("Frame took %f", (end - start).toSec());
    frame_stats.total_frame_time = (end - start).toSec();

#if USE_NVPERFSDK
    if (nvperfsdk_initialized_)
    {
      UINT count = 0;
      NVPMSample(0, &count);
      //ROS_INFO_STREAM("Samples: " << count);

      for (uint32_t i = 0; i < g_perf_counters.size(); ++i)
      {
        const std::string& name = g_perf_counters[i].first;
        UINT index = g_perf_counters[i].second;
        UINT64 value = 0;
        UINT64 cycles = 0;
        int ret = NVPMGetCounterValue(index, 0, &value, &cycles);
        if (ret == NVPM_OK)
        {
          rve_msgs::NVPerfCounter counter;
          counter.name = name;
          counter.value = value;
          counter.cycles = cycles;
          counter.value_as_pct = ((double)value / (double)cycles) * 100.0f;
          frame_stats.nv_perf_counters.counters.push_back(counter);
          //std::cout << name << ": " << "value: " << value << " cycles: " << cycles << std::endl;
        }
        else
        {
          ROS_ERROR("Failed to retrieve %s: %d", name.c_str(), ret);
        }
      }
    }

    if (do_experiment_)
    {
      experiment_stats_pub_.publish(frame_stats);
      do_experiment_ = false;
    }
    else
#endif
    {
      frame_stats_pub_.publish(frame_stats);
    }

  }

#if USE_NVPERFSDK
  if (nvperfsdk_initialized_)
  {
    NVPMShutdown();
  }
#endif
}

void Renderer::registerInitFunction(const InitFunction& func)
{
  init_functions_.push_back(func);
}

} // namespace rve_render_server