Support Rendering Replica models in the simulator (under CONSTRUCTION)

src/esp/assets/Asset.cpp

@@ -20,6 +20,11 @@ AssetInfo AssetInfo::fromPath(const std::string& path) {
     info.type = AssetType::INSTANCE_MESH;
   } else if (endsWith(path, "ptex_quad_mesh.ply")) {
     info.type = AssetType::FRL_PTEX_MESH;
+  } else if (endsWith(path, "mesh.ply")) {
+    // Warning:
+    // The order of if clause matters. cannot move "mesh.ply" before
+    // "ptex_quad_mesh.ply" or "semantic_quad_mesh.ply"
+    info.type = AssetType::FRL_PTEX_MESH;
   } else if (endsWith(path, "house.json")) {
     info.type = AssetType::SUNCG_SCENE;
   } else if (endsWith(path, ".glb")) {

src/esp/assets/PTexMeshData.cpp

@@ -4,12 +4,16 @@
 
 #include "PTexMeshData.h"
 
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
 #include <fstream>
 #include <sstream>
 #include <unordered_map>
 #include <vector>
 
 #include <Corrade/Containers/Array.h>
+#include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Utility/Directory.h>
 #include <Magnum/GL/BufferTextureFormat.h>
 #include <Magnum/ImageView.h>
@@ -34,7 +38,10 @@ void PTexMeshData::load(const std::string& meshFile,
   ASSERT(io::exists(atlasFolder));
 
   // Parse parameters
-  const auto& paramsFile = atlasFolder + "/parameters.json";
+  // careful: when using "join", no leading forward slash in the file name.
+  // otherwise the corrade would think it is absolute path
+  const auto& paramsFile =
+      Corrade::Utility::Directory::join(atlasFolder, "parameters.json");
   ASSERT(io::exists(paramsFile));
   const io::JsonDocument json = io::parseJsonFile(paramsFile);
   splitSize_ = json["splitSize"].GetDouble();
@@ -203,20 +210,23 @@ void PTexMeshData::calculateAdjacency(const PTexMeshData::MeshData& mesh,
 
   std::unordered_map<uint64_t, std::vector<EdgeData>> edgeMap;
 
-  size_t numFaces = mesh.ibo.size() / 4;
+  // only works on quad meshes
+  const int polygonStride = 4;
+  size_t numFaces = mesh.ibo.size() / polygonStride;
 
   typedef std::unordered_map<uint64_t, std::vector<EdgeData>>::iterator
       EdgeIter;
-  std::vector<EdgeIter> edgeIterators(numFaces * 4);
+  std::vector<EdgeIter> edgeIterators(numFaces * polygonStride);
 
   // for each face
   for (int f = 0; f < numFaces; f++) {
     // for each edge
-    for (int e = 0; e < 4; e++) {
+    for (int e = 0; e < polygonStride; e++) {
       // add to edge to face map
-      const int e_index = f * 4 + e;
+      const int e_index = f * polygonStride + e;
       const uint32_t i0 = mesh.ibo[e_index];
-      const uint32_t i1 = mesh.ibo[f * 4 + ((e + 1) % 4)];
+      const uint32_t i1 =
+          mesh.ibo[f * polygonStride + ((e + 1) % polygonStride)];
       const uint64_t key =
           (uint64_t)std::min(i0, i1) << 32 | (uint32_t)std::max(i0, i1);
 
@@ -236,11 +246,11 @@ void PTexMeshData::calculateAdjacency(const PTexMeshData::MeshData& mesh,
     }
   }
 
-  adjFaces.resize(numFaces * 4);
+  adjFaces.resize(numFaces * polygonStride);
 
   for (int f = 0; f < numFaces; f++) {
-    for (int e = 0; e < 4; e++) {
-      const int e_index = f * 4 + e;
+    for (int e = 0; e < polygonStride; e++) {
+      const int e_index = f * polygonStride + e;
       auto it = edgeIterators[e_index];
       const std::vector<EdgeData>& adj = it->second;
 
@@ -267,13 +277,16 @@ void PTexMeshData::calculateAdjacency(const PTexMeshData::MeshData& mesh,
       }
 
       // pack adjacent face and rotation into 32-bit int
-      adjFaces[f * 4 + e] = (rot << ROTATION_SHIFT) | (adjFace & FACE_MASK);
+      adjFaces[f * polygonStride + e] =
+          (rot << ROTATION_SHIFT) | (adjFace & FACE_MASK);
     }
   }
 }
 
 void PTexMeshData::loadMeshData(const std::string& meshFile) {
   PTexMeshData::MeshData originalMesh;
+
+  std::cout << "start parsing PLY... " << std::endl;
   parsePLY(meshFile, originalMesh);
 
   submeshes_.clear();
@@ -583,7 +596,7 @@ void PTexMeshData::uploadBuffersToGPU(bool forceReload) {
     currentMesh->ibo.setData(submeshes_[iMesh].ibo,
                              Magnum::GL::BufferUsage::StaticDraw);
   }
-  std::cout << "... done" << std::endl;
+  std::cout << "done" << std::endl;
 
   std::cout << "Calculating mesh adjacency... ";
   std::cout.flush();
@@ -594,6 +607,7 @@ void PTexMeshData::uploadBuffersToGPU(bool forceReload) {
   for (int iMesh = 0; iMesh < submeshes_.size(); ++iMesh) {
     calculateAdjacency(submeshes_[iMesh], adjFaces[iMesh]);
   }
+  std::cout << "... done" << std::endl;
 
   for (int iMesh = 0; iMesh < submeshes_.size(); ++iMesh) {
     auto& currentMesh = renderingBuffers_[iMesh];
@@ -602,35 +616,56 @@ void PTexMeshData::uploadBuffersToGPU(bool forceReload) {
                                   currentMesh->abo);
     currentMesh->abo.setData(adjFaces[iMesh],
                              Magnum::GL::BufferUsage::StaticDraw);
+
+    // experiment code (may not work):
     currentMesh->mesh.setPrimitive(Magnum::GL::MeshPrimitive::LinesAdjacency)
         .setCount(currentMesh->ibo.size() / 2)
         .addVertexBuffer(currentMesh->vbo, 0, gfx::PTexMeshShader::Position{})
         .setIndexBuffer(currentMesh->ibo, 0,
                         Magnum::GL::MeshIndexType::UnsignedInt);
   }
 
+  // load atlas data and upload them to GPU
+
+  std::cout << "loading atlas textures: " << std::endl;
   for (size_t iMesh = 0; iMesh < renderingBuffers_.size(); ++iMesh) {
-    const std::string rgbFile =
-        atlasFolder_ + "/" + std::to_string(iMesh) + "-color-ptex.rgb";
-    if (!io::exists(rgbFile)) {
-      ASSERT(false, "Can't find " + rgbFile);
-    }
+    const std::string rgbFile = Corrade::Utility::Directory::join(
+        atlasFolder_, std::to_string(iMesh) + "-color-ptex.rgb");
+
+    ASSERT(io::exists(rgbFile), Error : Cannot find the rgb file);
+
     std::cout << "\rLoading atlas " << iMesh + 1 << "/"
-              << renderingBuffers_.size() << "... ";
+              << renderingBuffers_.size() << " from " << rgbFile << "... ";
     std::cout.flush();
 
-    Cr::Containers::Array<const char, Cr::Utility::Directory::MapDeleter> data =
-        Cr::Utility::Directory::mapRead(rgbFile);
-    const int dim = static_cast<int>(std::sqrt(data.size() / 3));  // square
+    const size_t numBytes = io::fileSize(rgbFile);
+    const int dim = static_cast<int>(std::sqrt(numBytes / 3));  // square
+
+    // Open file
+    int fd = open(std::string(rgbFile).c_str(), O_RDONLY, 0);
+    // MAP_POPULATE does not work on mac. It is to reduce the penalty of page
+    // faults. Code should be OK without it. void* mmappedData = mmap(NULL,
+    // numBytes, PROT_READ, MAP_PRIVATE | MAP_POPULATE, fd, 0);
+    void* mmappedData = mmap(NULL, numBytes, PROT_READ, MAP_PRIVATE, fd, 0);
+
+    Corrade::Containers::ArrayView<unsigned char> data(
+        (unsigned char*)(mmappedData), numBytes);
+
+    // atlas
+    // the size of each image is dim x dim x 3 (RGB), which equals to numBytes
     Magnum::ImageView2D image(Magnum::PixelFormat::RGB8UI, {dim, dim}, data);
     renderingBuffers_[iMesh]
         ->tex.setWrapping(Magnum::GL::SamplerWrapping::ClampToEdge)
         .setMagnificationFilter(Magnum::GL::SamplerFilter::Linear)
         .setMinificationFilter(Magnum::GL::SamplerFilter::Linear)
-        // .setStorage(1, GL::TextureFormat::RGB8UI, image.size())
+        // .setStorage(1, Magnum::GL::TextureFormat::RGB8UI, image.size())
         .setSubImage(0, {}, image);
+
+    munmap(mmappedData, numBytes);
+    close(fd);
+
+    std::cout << "done" << std::endl;
   }
-  std::cout << "... done" << std::endl;
 
   buffersOnGPU_ = true;
 }

src/esp/assets/PTexMeshData.h

@@ -42,8 +42,7 @@ class PTexMeshData : public BaseMesh {
 
   // ==== geometry ====
   void load(const std::string& meshFile, const std::string& atlasFolder);
-  float exposure() const;
-  void setExposure(const float& val);
+
   uint32_t tileSize() const { return tileSize_; }
 
   const std::vector<MeshData>& meshes() const;
@@ -61,13 +60,29 @@ class PTexMeshData : public BaseMesh {
   virtual void uploadBuffersToGPU(bool forceReload = false) override;
   virtual Magnum::GL::Mesh* getMagnumGLMesh(int submeshID) override;
 
+  float exposure() const;
+  void setExposure(const float& val);
+
+  // TODO:
+  float gamma() const;
+  void setGamma(const float& val);
+
+  float saturation() const;
+  void setSaturation(const float& val);
+
  protected:
   void loadMeshData(const std::string& meshFile);
 
   float splitSize_ = 0.0f;
   uint32_t tileSize_ = 0;
+
   float exposure_ = 1.0f;
+  float gamma_ = 1.0f;
+  float saturation_ = 1.0f;
+  bool isHdr_ = false;
+
   std::string atlasFolder_;
+
   std::vector<MeshData> submeshes_;
 
   // ==== rendering ====

src/esp/assets/ResourceManager.cpp

@@ -105,14 +105,21 @@ bool ResourceManager::loadPTexMeshData(const AssetInfo& info,
   // if this is a new file, load it and add it to the dictionary
   const std::string& filename = info.filepath;
   if (resourceDict_.count(filename) == 0) {
-    const std::string atlasDir =
-        Corrade::Utility::String::stripSuffix(filename, "ptex_quad_mesh.ply") +
-        "ptex_textures";
+    const auto atlasDir = [=]()->std::string{
+      // backwards compatibility
+      if (Corrade::Utility::String::endsWith(filename, "ptex_quad_mesh.ply")) {
+        return (Corrade::Utility::String::stripSuffix(filename, "ptex_quad_mesh.ply") +
+        "ptex_textures");
+      }
+        // officially released Replica dataset
+        return (Corrade::Utility::String::stripSuffix(filename, "mesh.ply") +
+        "textures");
+    };
 
     meshes_.emplace_back(std::make_unique<PTexMeshData>());
     int index = meshes_.size() - 1;
     auto* pTexMeshData = dynamic_cast<PTexMeshData*>(meshes_[index].get());
-    pTexMeshData->load(filename, atlasDir);
+    pTexMeshData->load(filename, atlasDir());
 
     // update the dictionary
     resourceDict_.emplace(filename, MeshMetaData(index, index));

src/esp/core/logging.h

@@ -15,6 +15,7 @@
     if (!(x)) {                                                                \
       std::cout << "Assert failed: " #x << ", " << __FILE__ << ":" << __LINE__ \
                 << std::endl;                                                  \
+      std::cout << #__VA_ARGS__ << std::endl;                                  \
       exit(-1);                                                                \
     }                                                                          \
   } while (false)