renderer.h

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.
 */

#ifndef RVE_RENDER_SERVER_RENDERER_H
#define RVE_RENDER_SERVER_RENDERER_H

#include <string>
#include <vector>
#include <map>

#include <boost/unordered_map.hpp>
#include <boost/random/linear_congruential.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>

#include <rve_common/uuid.h>

#include <ros/publisher.h>
#include <ros/subscriber.h>
#include <ros/message_forward.h>

namespace ros
{
class CallbackQueue;
}

namespace std_msgs
{
ROS_DECLARE_MESSAGE(Empty);
}

namespace Ogre
{
class RenderWindow;
}

namespace rve_render_server
{

class RenderWindow;
class RenderTexture;
class RenderTarget;
class Scene;
class Camera;
class Material;
typedef boost::shared_ptr<Material> MaterialPtr;
class Texture;
typedef boost::shared_ptr<Texture> TexturePtr;
class Mesh;
typedef boost::shared_ptr<Mesh> MeshPtr;
class DisableRenderingSchemeListener;
typedef boost::shared_ptr<DisableRenderingSchemeListener> DisableRenderingSchemeListenerPtr;
class Pickable;
struct PickRenderValues;
typedef std::vector<PickRenderValues> V_PickRenderValues;
struct Picked;
typedef std::vector<Picked> V_Picked;

class Renderer;
Renderer* getRenderer();

class Renderer
{
public:
  Renderer(bool enable_ogre_log);
  ~Renderer();

  void start();
  void stop();

   void destroyRenderTarget(const rve_common::UUID& id);
   RenderTarget* getRenderTarget(const rve_common::UUID& id);

   RenderTexture* createRenderTexture(const rve_common::UUID& id, uint32_t width, uint32_t height);
   RenderWindow* createRenderWindow(const rve_common::UUID& id, const std::string& parent_window, uint32_t width, uint32_t height);
   RenderWindow* getRenderWindow(const rve_common::UUID& id);

   Scene* createScene(const rve_common::UUID& id);
   void destroyScene(const rve_common::UUID& id);
   Scene* getScene(const rve_common::UUID& id);

   Camera* getCamera(const rve_common::UUID& id);

   ros::CallbackQueue* getServerThreadCallbackQueue() { return callback_queue_.get(); }

   void addMaterial(const rve_common::UUID& id, const MaterialPtr& mat);
   void removeMaterial(const rve_common::UUID& id);
   MaterialPtr getMaterial(const rve_common::UUID& id);

   void addMesh(const rve_common::UUID& id, const MeshPtr& mesh);
   void removeMesh(const rve_common::UUID& id);
   MeshPtr getMesh(const rve_common::UUID& id);
   bool meshExists(const rve_common::UUID& id);

   void addTexture(const rve_common::UUID& id, const TexturePtr& tex);
   void removeTexture(const rve_common::UUID& id);
   TexturePtr getTexture(const rve_common::UUID& id);
   bool textureExists(const rve_common::UUID& id);

   bool useGeometryShaders();

   uint32_t allocatePickID(Pickable* p);
   void deallocatePickID(uint32_t pick_id);
   void translatePickIDs(const V_PickRenderValues& ids, V_Picked& out_picked);

   typedef boost::function<void(void)> InitFunction;
   void registerInitFunction(const InitFunction& func);

private:
  void init();
  void renderThread();

  void threadInit();

#if USE_NVPERFSDK
  void doExperimentCallback(const std_msgs::EmptyConstPtr&);
#endif

  boost::thread render_thread_;
  bool running_;
  bool first_window_created_;
  bool enable_ogre_log_;
  Ogre::RenderWindow* primary_render_window_;

  typedef boost::shared_ptr<RenderTarget> RenderTargetPtr;
  typedef std::map<rve_common::UUID, RenderTargetPtr> M_RenderTarget;
  M_RenderTarget render_targets_;

  typedef boost::shared_ptr<Scene> ScenePtr;
  typedef std::map<rve_common::UUID, ScenePtr> M_Scene;
  M_Scene scenes_;

  typedef boost::shared_ptr<ros::CallbackQueue> CallbackQueuePtr;
  CallbackQueuePtr callback_queue_;

  typedef std::map<rve_common::UUID, MaterialPtr> M_Material;
  M_Material materials_;

  typedef std::map<rve_common::UUID, TexturePtr> M_Texture;
  M_Texture textures_;

  typedef std::map<rve_common::UUID, MeshPtr> M_Mesh;
  M_Mesh meshes_;

  typedef boost::unordered_map<uint32_t, Pickable*> M_Pickable;
  M_Pickable pickables_;
  boost::rand48 pickable_id_gen_;

  DisableRenderingSchemeListenerPtr scheme_listener_;

  ros::Publisher frame_stats_pub_;

  std::vector<InitFunction> init_functions_;

#if USE_NVPERFSDK
  bool nvperfsdk_initialized_;
  bool do_experiment_;
  bool start_experiment_;

  ros::Subscriber do_experiment_sub_;
  ros::Publisher experiment_stats_pub_;
#endif
};

} // namespace rve_render_server

#endif // RVE_RENDER_SERVER_RENDERER_H