batch_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_BATCH_RENDERER_H
#define RVE_RENDER_SERVER_BATCH_RENDERER_H

#include <OGRE/OgreMaterial.h>

#include "points_renderer_desc.h"

#include <ros/message_forward.h>

#include <boost/unordered_map.hpp>
#include <boost/random/linear_congruential.hpp>
#include <boost/shared_ptr.hpp>

#include <OGRE/OgreSceneManager.h>
#include <OGRE/OgreSceneNode.h>

namespace rve_common
{
class UUID;
}

namespace rve_render_server
{

template<typename Child, typename Input, typename Renderable, typename Description>
class BatchRenderer
{
private:
  typedef boost::shared_ptr<Renderable> RenderablePtr;
  typedef std::vector<RenderablePtr> V_Renderable;

  struct InputInfo
  {
    struct RenderableInfo
    {
      RenderablePtr opaque_rend;
      uint32_t opaque_start;
      uint32_t opaque_count;

      RenderablePtr alpha_rend;
      uint32_t alpha_start;
      uint32_t alpha_count;
    };

    std::vector<RenderableInfo> rends;
  };

  typedef boost::unordered_map<uint32_t, InputInfo> M_InputInfo;

public:
  BatchRenderer(Ogre::SceneManager* scene_manager, const Description& desc)
  : desc_(desc)
  , scene_manager_(scene_manager)
  , scene_node_(0)
  {
    std::pair<Ogre::MaterialPtr, Ogre::MaterialPtr> mats = static_cast<Child*>(this)->createMaterials(desc);
    opaque_material_ = mats.first;
    alpha_material_ = mats.second;

    scene_node_ = scene_manager_->getRootSceneNode()->createChildSceneNode();

    id_gen_.seed(time(0));
  }

  ~BatchRenderer()
  {
    scene_manager_->destroySceneNode(scene_node_);
  }

  uint32_t add(const rve_common::UUID& id, const Input& input)
  {
    InputInfo pinfo;

    uint32_t total_count = 0;
    uint32_t total_opaque_count = 0;
    uint32_t total_alpha_count = 0;
    uint32_t input_count = static_cast<Child*>(this)->getInputCount(input);
    while (total_count < input_count)
    {
      // Add opaque points
      RenderablePtr opaque_rend = getOrCreateRenderable(false);

      uint32_t opaque_count = 0;
      uint32_t opaque_start = 0;
      opaque_rend->add(id, input, total_opaque_count, opaque_start, opaque_count);
      total_opaque_count += opaque_count;

      // Add transparent points
      RenderablePtr alpha_rend = getOrCreateRenderable(true);

      uint32_t alpha_count = 0;
      uint32_t alpha_start = 0;
      alpha_rend->add(id, input, total_alpha_count, alpha_start, alpha_count);
      total_alpha_count += alpha_count;

      total_count = total_alpha_count + total_opaque_count;

      typename InputInfo::RenderableInfo rinfo;
      rinfo.opaque_rend = opaque_rend;
      rinfo.opaque_start = opaque_start;
      rinfo.opaque_count = opaque_count;
      rinfo.alpha_rend = alpha_rend;
      rinfo.alpha_start = alpha_start;
      rinfo.alpha_count = alpha_count;
      pinfo.rends.push_back(rinfo);
    }

    uint32_t internal_id = 0;

    while (internal_id == 0 || !points_.insert(std::make_pair(internal_id, pinfo)).second)
    {
      internal_id = id_gen_();
    }

    scene_node_->needUpdate();

    return internal_id;
  }

  void remove(uint32_t id)
  {
    typename M_InputInfo::iterator it = points_.find(id);
    if (it == points_.end())
    {
      return;
    }

    const InputInfo& pinfo = it->second;
    for (size_t i = 0; i < pinfo.rends.size(); ++i)
    {
      const typename InputInfo::RenderableInfo& rinfo = pinfo.rends[i];
      rinfo.opaque_rend->remove(rinfo.opaque_start, rinfo.opaque_count);
      rinfo.alpha_rend->remove(rinfo.alpha_start, rinfo.alpha_count);
    }

    points_.erase(it);

    shrinkRenderables();

    scene_node_->needUpdate();
  }

  void clear()
  {
    points_.clear();
    renderables_.clear();

    scene_node_->needUpdate();
  }

private:
  RenderablePtr getOrCreateRenderable(bool alpha)
  {
    typename V_Renderable::iterator it = renderables_.begin();
    typename V_Renderable::iterator end = renderables_.end();
    for (; it != end; ++it)
    {
      const RenderablePtr& rend = *it;
      if (!rend->isFull() && alpha == rend->isAlpha())
      {
        return rend;
      }
    }

    RenderablePtr rend(new Renderable(desc_, alpha));
    rend->setMaterial(alpha ? alpha_material_->getName() : opaque_material_->getName());
    scene_node_->attachObject(rend.get());
    renderables_.push_back(rend);

    return rend;
  }

  void shrinkRenderables()
  {
    uint32_t empty_count = 0;
    typename V_Renderable::iterator it = renderables_.begin();
    for (; it != renderables_.end();)
    {
      const RenderablePtr& rend = *it;
      if (rend->isEmpty())
      {
        ++empty_count;
      }
      else
      {
        ++it;
        continue;
      }

      // Keep one empty renderable at any given time
      if (empty_count > 0)
      {
        it = renderables_.erase(it);
      }
      else
      {
        ++it;
      }
    }

    scene_node_->needUpdate();
  }

  M_InputInfo points_;
  boost::rand48 id_gen_;

  Description desc_;
  Ogre::SceneManager* scene_manager_;

  V_Renderable renderables_;

  Ogre::MaterialPtr opaque_material_;
  Ogre::MaterialPtr alpha_material_;
  Ogre::SceneNode* scene_node_;
};

} // namespace rve_render_server

#endif // RVE_RENDER_SERVER_BATCH_RENDERER_H