Bullet Physics Integration #1

.circleci/config.yml

@@ -16,7 +16,7 @@ jobs:
       - run:
           name: setup
           command: |
-              sudo pip install -U black "isort[pyproject]" numpy pytest sphinx
+              sudo pip install -U black "isort[pyproject]" numpy pytest sphinx pillow tqdm
               sudo pip install -r requirements.txt --progress-bar off
       - run:
           name: run black
@@ -166,7 +166,7 @@ jobs:
           name: Download test data
           command: |
 
-              if [ ! -d ./habitat-sim/data ]
+              if [ ! -d ./habitat-sim/data/scene_datasets/habitat-test-scenes/van-gogh-room.glb ]
               then
                 cd habitat-sim
                 wget http://dl.fbaipublicfiles.com/habitat/habitat-test-scenes.zip

README.md

@@ -160,6 +160,13 @@ To run the above benchmarks on your machine, see instructions in the [examples](
    Use W/A/S/D keys to move forward/left/backward/right and arrow keys to control gaze direction (look up/down/left/right).
    Try to find the picture of a woman surrounded by a wreath.
    Have fun!
+1. **Physical interactions**: If you would like to try out habitat with dynamical objects (under development), first install [Bullet Physics](https://github.com/bulletphysics/bullet3/). Then download pre-processed object set from this [link](http://dl.fbaipublicfiles.com/habitat/objects_v0.1.zip) and extract as `habitat-sim/data/objects/`. Next use
+   ```bash
+   python setup.py install --bullet    # build habitat with bullet physics
+   build/viewer --enable-physics /path/to/data/scene_datasets/habitat-test-scenes/van-gogh-room.glb
+   ```
+   Move around, and press O key to add object, press P/F to interact with the last added object, press V to remove, and press V key to invert gravity.
+
 1. **Non-interactive testing**: Run the example script:
    ```bash
    python examples/example.py --scene /path/to/data/scene_datasets/habitat-test-scenes/skokloster-castle.glb

data/default.phys_scene_config.json

@@ -0,0 +1,12 @@
+{
+    "physics simulator": "bullet",
+    "timestep": 0.01,
+    "gravity": [0,-9.8,0],
+    "friction coefficient": 0.4,
+    "restitution coefficient": 0.1,
+    "rigid object paths":[
+        "objects/cheezit",
+        "objects/chefcan",
+        "objects/banana"
+    ]
+}

setup.py

@@ -37,6 +37,12 @@ def build_parser():
         help="""Build in headless mode.
 Use "HEADLESS=True pip install ." to build in headless mode with pip""",
     )
+    parser.add_argument(
+        "--bullet",
+        dest="use_bullet",
+        action="store_true",
+        help="""Build with Bullet simulation engine.""",
+    )
     parser.add_argument(
         "--force-cmake",
         "--cmake",
@@ -87,7 +93,6 @@ def build_parser():
         "This is nice for incrementally building for development but "
         "can cause install magnum bindings to fall out-of-sync",
     )
-
     return parser
 
 
@@ -230,6 +235,7 @@ def build_extension(self, ext):
         # NOTE: BUILD_TEST is intentional as opposed to BUILD_TESTS which collides
         # with definition used by some of our dependencies
         cmake_args += ["-DBUILD_TEST={}".format("ON" if args.build_tests else "OFF")]
+        cmake_args += ["-DWITH_BULLET={}".format("ON" if args.use_bullet else "OFF")]
         cmake_args += [
             "-DBUILD_DATATOOL={}".format("ON" if args.build_datatool else "OFF")
         ]

src/CMakeLists.txt

@@ -46,6 +46,8 @@ include(cmake/dependencies.cmake)
 # include source dirs
 include_directories(${PROJECT_SOURCE_DIR})
 
+# Physics
+add_definitions(-DBT_ENABLE_PROFILE)
 # compiler define for enabling ptex support
 if(BUILD_PTEX_SUPPORT)
   message("Building with ptex support")
@@ -59,6 +61,7 @@ add_subdirectory(esp/gfx/)
 add_subdirectory(esp/assets)
 add_subdirectory(esp/io)
 add_subdirectory(esp/scene)
+add_subdirectory(esp/physics)
 add_subdirectory(esp/nav)
 add_subdirectory(esp/agent)
 add_subdirectory(esp/sensor)

src/cmake/dependencies.cmake

@@ -112,6 +112,8 @@ if(NOT USE_SYSTEM_MAGNUM)
 
   # These are enabled by default but we don't need them right now -- disabling
   # for slightly faster builds. If you need any of these, simply delete a line.
+  set(WITH_INTERCONNECT OFF CACHE BOOL "" FORCE)
+  set(WITH_TESTSUITE OFF CACHE BOOL "" FORCE)
   set(WITH_DEBUGTOOLS OFF CACHE BOOL "" FORCE)
   set(WITH_PRIMITIVES OFF CACHE BOOL "" FORCE)
   set(WITH_TEXT OFF CACHE BOOL "" FORCE)
@@ -125,8 +127,11 @@ if(NOT USE_SYSTEM_MAGNUM)
   set(WITH_STBIMAGEIMPORTER ON CACHE BOOL "WITH_STBIMAGEIMPORTER" FORCE)
   set(WITH_STBIMAGECONVERTER ON CACHE BOOL "WITH_STBIMAGECONVERTER" FORCE)
   set(WITH_SDL2APPLICATION OFF CACHE BOOL "WITH_SDL2APPLICATION" FORCE)
+  set(WITH_EIGEN ON CACHE BOOL "WITH_EIGEN" FORCE)
+  # Debug tool to visualize physics interaction
+  set(WITH_PRIMITIVES ON CACHE BOOL "WITH_PRIMITIVES" FORCE)
+  set(WITH_DEBUGTOOLS ON CACHE BOOL "WITH_DEBUGTOOLS" FORCE)
   set(WITH_GLFWAPPLICATION OFF CACHE BOOL "WITH_GLFWAPPLICATION" FORCE)
-  set(WITH_EIGEN ON CACHE BOOL "WITH_EIGEN" FORCE) # Eigen integration
   if(BUILD_PYTHON_BINDINGS)
     set(WITH_PYTHON ON CACHE BOOL "" FORCE) # Python bindings
   endif()

src/esp/assets/Attributes.cpp

@@ -0,0 +1,259 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+#include "Attributes.h"
+#include <algorithm>
+
+namespace esp {
+namespace assets {
+
+Attributes::Attributes() {
+  doubleMap_ = std::map<std::string, double>();
+  intMap_ = std::map<std::string, int>();
+  stringMap_ = std::map<std::string, std::string>();
+  magnumVec3Map_ = std::map<std::string, Magnum::Vector3>();
+  vecStringsMap_ = std::map<std::string, std::vector<std::string> >();
+}
+
+// return true if any container has the key
+bool Attributes::exists(std::string key) {
+  if (doubleMap_.count(key) > 0)
+    return true;
+  if (intMap_.count(key) > 0)
+    return true;
+  if (stringMap_.count(key) > 0)
+    return true;
+  if (magnumVec3Map_.count(key) > 0)
+    return true;
+  if (vecStringsMap_.count(key) > 0)
+    return true;
+
+  return false;
+}
+
+// check if an attribute of a specific type exists
+bool Attributes::existsAs(DataType t, std::string key) {
+  if (t == DOUBLE)
+    if (doubleMap_.count(key) > 0)
+      return true;
+  if (t == INT)
+    if (intMap_.count(key) > 0)
+      return true;
+  if (t == STRING)
+    if (stringMap_.count(key) > 0)
+      return true;
+  if (t == MAGNUMVEC3)
+    if (magnumVec3Map_.count(key) > 0)
+      return true;
+  if (t == VEC_STRINGS)
+    if (vecStringsMap_.count(key) > 0)
+      return true;
+  return false;
+}
+
+// count the number of containers with the key
+int Attributes::count(std::string key) {
+  int numAttributes = 0;
+  if (doubleMap_.count(key) > 0)
+    numAttributes++;
+  if (intMap_.count(key) > 0)
+    numAttributes++;
+  if (stringMap_.count(key) > 0)
+    numAttributes++;
+  if (magnumVec3Map_.count(key) > 0)
+    numAttributes++;
+  if (vecStringsMap_.count(key) > 0)
+    numAttributes++;
+  return numAttributes;
+}
+
+// erase the key from all maps
+void Attributes::eraseAll(std::string key) {
+  if (doubleMap_.count(key) > 0)
+    doubleMap_.erase(key);
+  if (intMap_.count(key) > 0)
+    intMap_.erase(key);
+  if (stringMap_.count(key) > 0)
+    stringMap_.erase(key);
+  if (magnumVec3Map_.count(key) > 0)
+    magnumVec3Map_.erase(key);
+  if (vecStringsMap_.count(key) > 0)
+    vecStringsMap_.erase(key);
+}
+
+// erase the key from a particular map
+void Attributes::eraseAs(DataType t, std::string key) {
+  if (t == DOUBLE) {
+    if (doubleMap_.count(key) > 0)
+      doubleMap_.erase(key);
+  } else if (t == INT) {
+    if (intMap_.count(key) > 0)
+      intMap_.erase(key);
+  } else if (t == STRING) {
+    if (stringMap_.count(key) > 0)
+      stringMap_.erase(key);
+  } else if (t == MAGNUMVEC3) {
+    if (magnumVec3Map_.count(key) > 0)
+      magnumVec3Map_.erase(key);
+  } else if (t == VEC_STRINGS) {
+    if (vecStringsMap_.count(key) > 0)
+      vecStringsMap_.erase(key);
+  }
+}
+
+// clear all maps
+void Attributes::clear() {
+  doubleMap_.clear();
+  intMap_.clear();
+  stringMap_.clear();
+  magnumVec3Map_.clear();
+  vecStringsMap_.clear();
+}
+
+// clear only a particular map
+void Attributes::clearAs(DataType t) {
+  if (t == DOUBLE) {
+    doubleMap_.clear();
+  } else if (t == INT) {
+    intMap_.clear();
+  } else if (t == STRING) {
+    stringMap_.clear();
+  } else if (t == MAGNUMVEC3) {
+    magnumVec3Map_.clear();
+  } else if (t == VEC_STRINGS) {
+    vecStringsMap_.clear();
+  }
+}
+
+//----------------------------------------//
+//  Type specific getters/setters
+//----------------------------------------//
+// return the queried entry in the double map
+// will throw an exception if the key does not exist in the double map
+double Attributes::getDouble(std::string key) {
+  return doubleMap_.at(key);
+}
+
+// set a double attribute key->val
+void Attributes::setDouble(std::string key, double val) {
+  doubleMap_[key] = val;
+}
+
+int Attributes::getInt(std::string key) {
+  return intMap_.at(key);
+}
+
+void Attributes::setInt(std::string key, int val) {
+  intMap_[key] = val;
+}
+
+std::string Attributes::getString(std::string key) {
+  return stringMap_.at(key);
+}
+
+void Attributes::setString(std::string key, std::string val) {
+  stringMap_[key] = val;
+}
+
+Magnum::Vector3 Attributes::getMagnumVec3(std::string key) {
+  return magnumVec3Map_.at(key);
+}
+
+void Attributes::setMagnumVec3(std::string key, Magnum::Vector3 val) {
+  magnumVec3Map_[key] = val;
+}
+std::vector<std::string> Attributes::getVecStrings(std::string key) {
+  return vecStringsMap_.at(key);
+}
+
+void Attributes::setVecStrings(std::string key, std::vector<std::string> val) {
+  vecStringsMap_[key] = val;
+}
+
+// add a string to a string vector (to avoid get/set copying)
+void Attributes::appendVecStrings(std::string key, std::string val) {
+  vecStringsMap_[key].push_back(val);
+}
+
+void Attributes::removeFromVecString(std::string key, std::string val) {
+  std::vector<std::string>& stringVec = vecStringsMap_[key];
+  std::vector<std::string>::iterator position =
+      std::find(stringVec.begin(), stringVec.end(), val);
+  if (position != stringVec.end())  // == .end() means the element was not found
+    stringVec.erase(position);
+}
+
+// return a formated string exposing the current contents of the attributes maps
+std::string Attributes::listAttributes() {
+  std::string attributes =
+      "List of attributes: \n----------------------------------------\n";
+
+  attributes += "\nDoubles: \n";
+  for (auto it = doubleMap_.begin(); it != doubleMap_.end(); ++it) {
+    attributes += it->first + " : " + std::to_string(it->second) + "\n";
+  }
+
+  attributes += "\nInts: \n";
+  for (auto it = intMap_.begin(); it != intMap_.end(); ++it) {
+    attributes += it->first + " : " + std::to_string(it->second) + "\n";
+  }
+
+  attributes += "\nStrings: \n";
+  for (auto it = stringMap_.begin(); it != stringMap_.end(); ++it) {
+    attributes += it->first + " : " + it->second + "\n";
+  }
+
+  attributes += "\nMagnum Vector3s: \n";
+  for (auto it = magnumVec3Map_.begin(); it != magnumVec3Map_.end(); ++it) {
+    attributes += it->first + " : [" + std::to_string(it->second[0]) + ", " +
+                  std::to_string(it->second[1]) + ", " +
+                  std::to_string(it->second[2]) + "]\n";
+  }
+
+  attributes += "\nVectors of Strings: \n";
+  for (auto it = vecStringsMap_.begin(); it != vecStringsMap_.end(); ++it) {
+    attributes += it->first + " : [";
+    for (auto vs_it = it->second.begin(); vs_it != it->second.end(); ++vs_it) {
+      if (vs_it != it->second.begin())
+        attributes += ", ";
+      attributes += *vs_it;
+    }
+    attributes += "]\n";
+  }
+
+  attributes += "\n----------------------------------------\n\n";
+  return attributes;
+}
+
+PhysicsObjectAttributes::PhysicsObjectAttributes() {
+  // fill necessary attribute defaults
+  setDouble("mass", 1.0);
+  setDouble("margin", 0.01);
+  setDouble("scale", 1.0);
+  setMagnumVec3("COM", Magnum::Vector3(0));
+  setMagnumVec3("inertia", Magnum::Vector3(0., 0., 0.));
+  setDouble("frictionCoefficient", 0.5);
+  setDouble("restitutionCoefficient", 0.6);
+  setDouble("linDamping", 0.2);
+  setDouble("angDamping", 0.2);
+  setString("originHandle", "");
+  setString("renderMeshHandle", "");
+  setString("collisionMeshHandle", "");
+}
+
+PhysicsSceneAttributes::PhysicsSceneAttributes() {
+  setMagnumVec3("gravity", Magnum::Vector3(0, -9.8, 0));
+  setDouble("frictionCoefficient", 0.4);
+  setDouble("restitutionCoefficient", 0.05);
+  setString("renderMeshHandle", "");
+  setString("collisionMeshHandle", "");
+}
+
+PhysicsManagerAttributes::PhysicsManagerAttributes() {
+  setString("simulator", "none");
+  setDouble("timestep", 0.01);
+  setInt("maxSubsteps", 10);
+}
+}  // namespace assets
+}  // namespace esp