Updated snapshot to 1.3.3

* Added ExpertEncoder to the Javascript API
  * Allows developers to set quantization options per attribute id
* Bug fixes

CMakeLists.txt

@@ -606,9 +606,6 @@ include_directories("${draco_root}/src" "${draco_build_dir}")
 if (EMSCRIPTEN AND ENABLE_JS_GLUE)
   # Draco js decoder.
   require_compiler_flag("-s ALLOW_MEMORY_GROWTH=1" YES)
-  if (IE_COMPATIBLE)
-    require_compiler_flag("-s LEGACY_VM_SUPPORT=1" YES)
-  endif ()
   require_compiler_flag("-Wno-almost-asm" YES)
   require_compiler_flag("--memory-init-file 0" YES)
   require_compiler_flag("-fno-omit-frame-pointer" YES)
@@ -627,11 +624,7 @@ if (EMSCRIPTEN AND ENABLE_JS_GLUE)
 
   if (CMAKE_BUILD_TYPE STREQUAL "")
     # Force -O3 when no build type is specified.
-    if (IE_COMPATIBLE)
-      add_compiler_flag_if_supported("-g")
-    else ()
-      add_compiler_flag_if_supported("-O3")
-    endif ()
+    add_compiler_flag_if_supported("-O3")
   endif ()
 
   set(draco_js_dec_idl
@@ -798,10 +791,16 @@ else ()
   add_library(draco_points_enc OBJECT
               ${draco_points_common_sources}
               ${draco_points_enc_sources})
-  add_library(draco_unity_plugin OBJECT
-              ${draco_unity_plug_sources})
-  add_library(draco_maya_plugin OBJECT
-              ${draco_maya_plug_sources})
+
+  if (BUILD_UNITY_PLUGIN)
+    add_library(draco_unity_plugin OBJECT
+                ${draco_unity_plug_sources})
+  endif ()
+
+  if (BUILD_MAYA_PLUGIN)
+    add_library(draco_maya_plugin OBJECT
+                ${draco_maya_plug_sources})
+  endif ()
 
   # Library targets that consume the object collections.
   add_library(dracodec

README.md

@@ -5,6 +5,11 @@
 
 News
 =======
+### Version 1.3.3 release
+* Added ExpertEncoder to the Javascript API
+  * Allows developers to set quantization options per attribute id
+* Bug fixes
+
 ### Version 1.3.2 release
 * Bug fixes
 
@@ -212,12 +217,6 @@ $ cmake path/to/draco -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake
 $ make
 ~~~~~
 
-To build a decoder module that is compatible with IE11 (at the cost of a slightly larger resulting module), set the `IE_COMPATIBLE` variable to `true` when generating the cmake file.
-
-~~~~~ bash
-$ cmake path/to/draco -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DIE_COMPATIBLE=true
-~~~~~
-
 WebAssembly Decoder
 -------------------
 

javascript/npm/draco3d/README.md

@@ -5,6 +5,11 @@
 
 News
 =======
+### Version 1.3.3 release
+* Added ExpertEncoder to the JavaScript API
+  * Allows developers to set quantization options per attribute id
+* Bug fixes
+
 ### Version 1.3.2 release
 * Bug fixes
 

javascript/npm/draco3d/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draco3d",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.",
   "main": "draco3d.js",
   "scripts": {

javascript/npm/draco3dgltf/README.md

@@ -16,8 +16,13 @@ TODO: Add glTF branch url.
 
 News
 =======
+### Version 1.3.3 release
+* Added ExpertEncoder to the JavaScript API
+  * Allows developers to set quantization options per attribute id
+* Bug fixes
+
 ### Version 1.3.2 release
-* Bug Fixes
+* Bug fixes
 
 ### Version 1.3.1 release
 * Fix issue with multiple attributes when skipping an attribute transform

javascript/npm/draco3dgltf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draco3dgltf",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "This package contains a specific version of Draco 3D geometric compression library that is used for glTF Draco mesh compression extension.",
   "main": "draco3dgltf.js",
   "scripts": {

src/draco/compression/attributes/kd_tree_attributes_decoder.cc

@@ -49,9 +49,8 @@ class PointAttributeVectorOutputIterator {
     uint32_t required_decode_bytes = 0;
     for (auto index = 0; index < attributes_.size(); index++) {
       const AttributeTuple &att = attributes_[index];
-      required_decode_bytes =
-          (std::max)(required_decode_bytes,
-                     std::get<1>(att) * std::get<3>(att) * std::get<4>(att));
+      required_decode_bytes = (std::max)(required_decode_bytes,
+                                         std::get<3>(att) * std::get<4>(att));
     }
     memory_.resize(required_decode_bytes);
     data_ = memory_.data();

src/draco/compression/attributes/mesh_traversal_sequencer.h

@@ -55,6 +55,8 @@ class MeshTraversalSequencer : public PointsSequencer {
         const PointIndex point_id = face[p];
         const VertexIndex vert_id =
             corner_table->Vertex(CornerIndex(3 * f.value() + p));
+        if (vert_id == kInvalidVertexIndex)
+          return false;
         const AttributeValueIndex att_entry_id(
             encoding_data_
                 ->vertex_to_encoded_attribute_value_index_map[vert_id.value()]);

src/draco/compression/attributes/sequential_attribute_decoders_controller.cc

@@ -89,15 +89,17 @@ bool SequentialAttributeDecodersController::
     if (GetDecoder()->options()) {
       const PointAttribute *const attribute =
           sequential_decoders_[i]->attribute();
-      if (GetDecoder()->options()->GetAttributeBool(
+      const PointAttribute *const portable_attribute =
+          sequential_decoders_[i]->GetPortableAttribute();
+      if (portable_attribute &&
+          GetDecoder()->options()->GetAttributeBool(
               attribute->attribute_type(), "skip_attribute_transform", false)) {
         // Attribute transform should not be performed. In this case, we replace
         // the output geometry attribute with the portable attribute.
         // TODO(ostava): We can potentially avoid this copy by introducing a new
         // mechanism that would allow to use the final attributes as portable
         // attributes for predictors that may need them.
-        sequential_decoders_[i]->attribute()->CopyFrom(
-            *sequential_decoders_[i]->GetPortableAttribute());
+        sequential_decoders_[i]->attribute()->CopyFrom(*portable_attribute);
         continue;
       }
     }

src/draco/compression/decode_test.cc

@@ -150,4 +150,47 @@ TEST_F(DecodeTest, TestSkipAttributeTransformOnPointCloud) {
   TestSkipAttributeTransformOnPointCloudWithColor("pc_kd_color.drc");
 }
 
+TEST_F(DecodeTest, TestSkipAttributeTransformWithNoQuantization) {
+  // Tests that decoders can successfully skip attribute transform even though
+  // the input model was not quantized (it has no attribute transform).
+  const std::string file_name = "point_cloud_no_qp.drc";
+  std::ifstream input_file(draco::GetTestFileFullPath(file_name),
+                           std::ios::binary);
+  ASSERT_TRUE(input_file);
+
+  // Read the file stream into a buffer.
+  std::streampos file_size = 0;
+  input_file.seekg(0, std::ios::end);
+  file_size = input_file.tellg() - file_size;
+  input_file.seekg(0, std::ios::beg);
+  std::vector<char> data(file_size);
+  input_file.read(data.data(), file_size);
+
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type float32 since the attribute was
+  // not quantized.
+  ASSERT_EQ(pos_att->data_type(), draco::DT_FLOAT32);
+
+  // Make sure there is no attribute transform available for the attribute.
+  ASSERT_EQ(pos_att->GetAttributeTransformData(), nullptr);
+}
+
 }  // namespace

src/draco/compression/encode_test.cc

@@ -83,7 +83,7 @@ class EncodeTest : public ::testing::Test {
 
     // Initialize the attribute values.
     for (draco::PointIndex i(0); i < kNumPoints; ++i) {
-      const float pos_coord = float(i.value());
+      const float pos_coord = static_cast<float>(i.value());
       pc_builder.SetAttributeValueForPoint(
           pos_att_id, i,
           draco::Vector3f(pos_coord, -pos_coord, pos_coord).data());
@@ -148,15 +148,20 @@ class EncodeTest : public ::testing::Test {
       std::unique_ptr<draco::Mesh> mesh_tmp =
           draco::ReadMeshFromTestFile(file_name);
       mesh = mesh_tmp.get();
+      if (!mesh->DeduplicateAttributeValues())
+        return;
+      mesh->DeduplicatePointIds();
       geometry = std::move(mesh_tmp);
     } else {
       geometry = draco::ReadPointCloudFromTestFile(file_name);
     }
     ASSERT_NE(mesh, nullptr);
+
     draco::Encoder encoder;
-    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
-    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 15);
-    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 14);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 14);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 12);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 10);
+
     encoder.SetEncodingMethod(encoding_method);
 
     encoder.SetTrackEncodedProperties(true);
@@ -272,7 +277,7 @@ TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntries) {
 
 TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntriesNotSet) {
   // Tests that when tracing of encoded properties is disabled, the returned
-  // number of encoded faces and poitns is 0.
+  // number of encoded faces and points is 0.
   std::unique_ptr<draco::Mesh> mesh(
       draco::ReadMeshFromTestFile("cube_att.obj"));
   ASSERT_NE(mesh, nullptr);

src/draco/compression/mesh/mesh_edgebreaker_encoder.cc

@@ -95,6 +95,20 @@ void MeshEdgeBreakerEncoder::ComputeNumberOfEncodedPoints() {
       corner_table->num_vertices() - corner_table->NumIsolatedVertices();
 
   if (mesh()->num_attributes() > 1) {
+    // Gather all corner tables for all non-position attributes.
+    std::vector<const MeshAttributeCornerTable *> attribute_corner_tables;
+    for (int i = 0; i < mesh()->num_attributes(); ++i) {
+      if (mesh()->attribute(i)->attribute_type() == GeometryAttribute::POSITION)
+        continue;
+      const MeshAttributeCornerTable *const att_corner_table =
+          GetAttributeCornerTable(i);
+      // Attribute corner table may not be used in some configurations. For
+      // these cases we can assume the attribute connectivity to be the same as
+      // the connectivity of the position data.
+      if (att_corner_table)
+        attribute_corner_tables.push_back(att_corner_table);
+    }
+
     // Add a new point based on the configuration of interior attribute seams
     // (replicating what the decoder would do).
     for (VertexIndex vi(0); vi < corner_table->num_vertices(); ++vi) {
@@ -107,22 +121,40 @@ void MeshEdgeBreakerEncoder::ComputeNumberOfEncodedPoints() {
           mesh()->CornerToPointId(first_corner_index);
 
       PointIndex last_point_index = first_point_index;
+      CornerIndex last_corner_index = first_corner_index;
       CornerIndex corner_index = corner_table->SwingRight(first_corner_index);
       size_t num_attribute_seams = 0;
-      while (corner_index != kInvalidCornerIndex &&
-             corner_index != first_corner_index) {
+      while (corner_index != kInvalidCornerIndex) {
         const PointIndex point_index = mesh()->CornerToPointId(corner_index);
+        bool seam_found = false;
         if (point_index != last_point_index) {
-          // New attribute seam detected.
-          ++num_attribute_seams;
+          // Point index changed - new attribute seam detected.
+          seam_found = true;
           last_point_index = point_index;
+        } else {
+          // Even though point indices matches, there still may be a seam caused
+          // by non-manifold connectivity of non-position attribute data.
+          for (int i = 0; i < attribute_corner_tables.size(); ++i) {
+            if (attribute_corner_tables[i]->Vertex(corner_index) !=
+                attribute_corner_tables[i]->Vertex(last_corner_index)) {
+              seam_found = true;
+              break;  // No need to process other attributes.
+            }
+          }
         }
+        if (seam_found) {
+          ++num_attribute_seams;
+        }
+
+        if (corner_index == first_corner_index)
+          break;
+
         // Proceed to the next corner
+        last_corner_index = corner_index;
         corner_index = corner_table->SwingRight(corner_index);
       }
 
-      if (!corner_table->IsOnBoundary(vi) && num_attribute_seams > 0 &&
-          last_point_index == first_point_index) {
+      if (!corner_table->IsOnBoundary(vi) && num_attribute_seams > 0) {
         // If the last visited point index is the same as the first point index
         // we traveled all the way around the vertex. In this case the number of
         // new points should be num_attribute_seams - 1

src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc

@@ -231,6 +231,34 @@ TEST_F(PointCloudKdTreeEncodingTest,
   TestKdTreeEncoding(*pc);
 }
 
+// Test 16 only encoding for one attribute.
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncoding16Bit) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint16_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
 // Test 16 and 8 bit encoding with size bigger than 32bit encoding.
 TEST_F(PointCloudKdTreeEncodingTest,
        TestIntKdTreeEncodingHigherDimensionVariedTypesBig16BitEncoding) {

src/draco/core/draco_version.h

@@ -18,7 +18,7 @@
 namespace draco {
 
 // Draco version is comprised of <major>.<minor>.<revision>.
-static const char kDracoVersion[] = "1.3.2";
+static const char kDracoVersion[] = "1.3.3";
 
 const char *Version() { return kDracoVersion; }
 

src/draco/javascript/emscripten/draco_web_encoder.idl

@@ -180,3 +180,25 @@ interface Encoder {
   long GetNumberOfEncodedPoints();
   long GetNumberOfEncodedFaces();
 };
+
+interface ExpertEncoder {
+  void ExpertEncoder(PointCloud pc);
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(long att_id,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(long att_id,
+                                        long quantization_bits,
+                                        long num_components,
+                                        [Const] float[] origin,
+                                        float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(boolean flag);
+
+  long EncodeToDracoBuffer(boolean deduplicate_values,
+                           DracoInt8Array encoded_data);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  long GetNumberOfEncodedPoints();
+  long GetNumberOfEncodedFaces();
+};