Enable serialization of collision_world

Author: saibalde

src/bvh/collision_world.cpp

@@ -38,6 +38,7 @@
 #include <memory>
 #include <vt/transport.h>
 #include <vt/trace/trace_lite.h>
+#include <checkpoint/checkpoint.h>
 
 namespace bvh
 {
@@ -141,4 +142,32 @@ namespace bvh
   {
     return m_impl->collision_object_narrowphase_logger;
   }
+
+  std::unique_ptr< collision_world >
+  collision_world::deserialize(char *buffer)
+  {
+    auto world = checkpoint::deserialize< collision_world >(buffer);
+    for (auto &obj : world->m_impl->collision_objects) {
+      obj->set_collision_world(world.get());
+    }
+    return world;
+  }
+
+  std::vector< std::unique_ptr< collision_object > > &
+  collision_world::get_collision_objects()
+  {
+    return m_impl->collision_objects;
+  }
+
+  std::size_t &
+  collision_world::get_overdecomposition()
+  {
+    return m_impl->overdecomposition;
+  }
+
+  ::vt::EpochType &
+  collision_world::get_epoch()
+  {
+    return m_impl->epoch;
+  }
 }

src/bvh/collision_world.hpp

@@ -58,7 +58,7 @@ namespace bvh
     template< typename T >
     using narrowphase_functor = std::function< narrowphase_result_pair( const broadphase_collision< T > &, const broadphase_collision< T > & ) >;
 
-    explicit collision_world( std::size_t _overdecomposition_factor, const world_config &_cfg = {} );
+    explicit collision_world( std::size_t _overdecomposition_factor = 0, const world_config &_cfg = {} );
     ~collision_world();
 
     collision_world( const collision_world & ) = delete;
@@ -100,8 +100,22 @@ namespace bvh
     std::shared_ptr< spdlog::logger > collision_object_broadphase_logger() const;
     std::shared_ptr< spdlog::logger > collision_object_narrowphase_logger() const;
 
+    template <typename Serializer>
+    void serialize(Serializer &s)
+    {
+      s | get_collision_objects()
+        | get_overdecomposition()
+        | get_epoch();
+    }
+
+    static std::unique_ptr< collision_world > deserialize(char *buffer);
+
   private:
 
+    std::vector< std::unique_ptr< collision_object > > &get_collision_objects();
+    std::size_t &get_overdecomposition();
+    ::vt::EpochType &get_epoch();
+
     struct impl;
 
     friend impl &get_impl( collision_world &_world );

tests/SerializerTest.cpp

@@ -43,6 +43,7 @@
 #include <bvh/collision_object/narrowphase.hpp>
 #include <bvh/collision_object/types.hpp>
 #include <bvh/collision_object.hpp>
+#include <bvh/collision_world.hpp>
 #include "TestCommon.hpp"
 
 TEMPLATE_TEST_CASE("a single value can be serialized", "[serializer]", int, double, float, std::size_t )
@@ -236,6 +237,15 @@ TEST_CASE( "collision_object serialization", "[serializer][collision_object]" )
   auto recPtr = checkpoint::deserialize< bvh::collision_object >( ser->getBuffer() );
 }
 
+TEST_CASE( "collision_world serialization", "[serializer][collision_world]" )
+{
+  bvh::collision_world world( 2 );
+  auto &obj1 = world.create_collision_object();
+  auto &obj2 = world.create_collision_object();
+  auto ser = checkpoint::serialize< bvh::collision_world >( world );
+  auto recPtr = bvh::collision_world::deserialize( ser->getBuffer() );
+}
+
 #if 0
 TEMPLATE_TEST_CASE("multiple values can be serialized", "[serializer]", int, double, float, std::size_t )
 {