scene.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_client/scene.h"
#include "rve_render_client/single_scene_object.h"
#include "rve_render_client/scene_object_collection.h"
#include <rve_render_client/client_context.h>
#include <rve_common/uuid.h>

#include <rve_interfaces/Scene.h>

#include <ros/assert.h>

#include <boost/unordered_set.hpp>
#include <boost/bind.hpp>

#include <algorithm>

using namespace rve_common;

namespace rve_render_client
{

struct Scene::Impl
{
  Impl(Scene* parent);

  void addObject(SceneObject* obj);
  void removeObject(SceneObject* obj);

  void create(ClientContext* context);
  void destroy(ClientContext* context);

  const rve_common::UUID& getID() { return id_; }
  void getDependencies(V_UUID& deps);

  rve_interfaces::SceneProxy* getProxy(ClientContext* context);

  Scene* parent_;
  rve_common::UUID id_;

  typedef boost::unordered_set<SceneObject*> S_SceneObject;
  S_SceneObject objects_;

  typedef boost::unordered_set<ClientContext*> S_ClientContext;
  S_ClientContext contexts_;
};

Scene::Impl::Impl(Scene* parent)
: parent_(parent)
, id_(rve_common::UUID::generate())
{}

void Scene::Impl::addObject(SceneObject* obj)
{
  bool inserted = objects_.insert(obj).second;
  ROS_ASSERT(inserted);

  // for each context, call obj->create(this, context);
  std::for_each(contexts_.begin(), contexts_.end(), boost::bind(&SceneObject::create, obj, parent_, _1));
}

void Scene::Impl::removeObject(SceneObject* obj)
{
  // for each context, call obj->destroy(this, context);
  std::for_each(contexts_.begin(), contexts_.end(), boost::bind(&SceneObject::destroy, obj, parent_, _1));

  objects_.erase(obj);
}

void Scene::Impl::create(ClientContext* context)
{
  bool inserted = contexts_.insert(context).second;
  ROS_ASSERT(inserted);

  rve_interfaces::SceneProxy* proxy = getProxy(context);
  proxy->create(getID());

  // for each object, call obj->create(this, context);
  std::for_each(objects_.begin(), objects_.end(), boost::bind(&SceneObject::create, _1, parent_, context));
}

void Scene::Impl::destroy(ClientContext* context)
{
  contexts_.erase(context);

  // for each object, call obj->destroy(this, context);
  std::for_each(objects_.begin(), objects_.end(), boost::bind(&SceneObject::destroy, _1, parent_, context));

  rve_interfaces::SceneProxy* proxy = getProxy(context);
  proxy->destroy(getID());
}

rve_interfaces::SceneProxy* Scene::Impl::getProxy(ClientContext* context)
{
  // We don't need the scene proxy very often, so caching it is likely not a win and is (very) slightly more complex
  InterfaceHandle handle = context->lookupInterface("scene");
  return context->getInterface<rve_interfaces::SceneProxy>(handle);
}

void Scene::Impl::getDependencies(V_UUID& deps)
{
  std::for_each(objects_.begin(), objects_.end(), boost::bind(&SceneObject::getContextDependencies, _1, deps));
}


Scene::Scene()
: impl_(new Impl(this))
{
}

Scene::~Scene()
{
}

void Scene::addObject(SceneObject* obj)
{
  impl_->addObject(obj);
}

void Scene::removeObject(SceneObject* obj)
{
  impl_->removeObject(obj);
}

void Scene::create(ClientContext* context)
{
  impl_->create(context);
}

void Scene::destroy(ClientContext* context)
{
  impl_->destroy(context);
}

const rve_common::UUID& Scene::getID()
{
  return impl_->getID();
}

void Scene::getDependencies(V_UUID& deps)
{
  impl_->getDependencies(deps);
}


void destroyScene(Scene* scene)
{
  while (!scene->impl_->contexts_.empty())
  {
    ClientContext* context = *scene->impl_->contexts_.begin();
    context->removeObject(scene);
  }

  delete scene;
}

ScenePtr createScene(const ClientContextPtr& context)
{
  ScenePtr scene(new Scene, destroyScene);
  context->addObject(scene.get());
  return scene;
}

} // namespace rve_render_client