Update version to 1.2.3

This fixes #300

README.md

@@ -5,6 +5,9 @@
 
 News
 =======
+### Version 1.2.3 release
+* Fixed Visual Studio building issue
+
 ### Version 1.2.2 release
 The latest version of Draco brings a number of small bug fixes
 * Fixed issues when parsing ill-formatted .obj files

src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h

@@ -77,6 +77,7 @@ class MeshPredictionSchemeConstrainedMultiParallelogramEncoder
   // the edges are processed. For better compression, the flags are stored in
   // in separate contexts based on the number of available parallelograms at a
   // given vertex.
+  // TODO(scottgodfrey) reconsider std::vector<bool> (performance/space).
   std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
   Mode selected_mode_;
 };
@@ -190,6 +191,7 @@ bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
       // Mark all parallelograms as excluded.
       std::fill(exluded_parallelograms,
                 exluded_parallelograms + num_parallelograms, true);
+      // TODO(scottgodfrey) maybe this should be another std::fill.
       // Mark the first |num_used_parallelograms| as not excluded.
       for (int j = 0; j < num_used_parallelograms; ++j) {
         exluded_parallelograms[j] = false;

src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h

@@ -22,6 +22,8 @@
 
 namespace draco {
 
+// TODO(scottgodfrey) consolidate Vertex/next/previous queries to one call
+// (performance).
 template <class CornerTableT>
 inline void GetParallelogramEntries(
     const CornerIndex ci, const CornerTableT *table,

src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h

@@ -40,78 +40,100 @@ struct MeshPredictionSchemeDecoderFactory {
   // for all mesh prediction schemes. The specialization is done in compile time
   // to prevent instantiations of unneeded combinations of prediction schemes +
   // prediction transforms.
-  template <
+  template <class TransformT, class MeshDataT,
-      class TransformT, class MeshDataT,
+            PredictionSchemeTransformType Method>
-      typename std::enable_if<
+  struct DispatchFunctor {
-          TransformT::GetType() == PREDICTION_TRANSFORM_WRAP, int>::type = 0>
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
-  std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
-      PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
-      const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
-      uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_PARALLELOGRAM) {
-    if (method == MESH_PREDICTION_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
-          new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
-                                                       MeshDataT>(
-              attribute, transform, mesh_data));
-    }
-#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
-    else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-          new MeshPredictionSchemeMultiParallelogramDecoder<
-              DataTypeT, TransformT, MeshDataT>(attribute, transform,
-                                                mesh_data));
-    }
-#endif
-    else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-          new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
-              DataTypeT, TransformT, MeshDataT>(attribute, transform,
-                                                mesh_data));
-    }
-#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
-    else if (method == MESH_PREDICTION_TEX_COORDS) {
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-          new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
-                                                   MeshDataT>(
-              attribute, transform, mesh_data, bitstream_version));
-    }
-#endif
-    else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-          new MeshPredictionSchemeTexCoordsPortableDecoder<
-              DataTypeT, TransformT, MeshDataT>(attribute, transform,
-                                                mesh_data));
-    } else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
-          new MeshPredictionSchemeGeometricNormalDecoder<DataTypeT, TransformT,
                                                          MeshDataT>(
-              attribute, transform, mesh_data));
+                attribute, transform, mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_TEX_COORDS) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
+                                                     MeshDataT>(
+                attribute, transform, mesh_data, bitstream_version));
+      }
+#endif
+      else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsPortableDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      } else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
     }
-    return nullptr;
+  };
-  }
 
   // Operator () specialized for normal octahedron transforms. These transforms
   // are currently used only by the geometric normal prediction scheme (the
   // transform is also used by delta coding, but delta predictor is not
   // constructed in this function).
-  template <
+  template <class TransformT, class MeshDataT>
-      class TransformT, class MeshDataT,
+  struct DispatchFunctor<TransformT, MeshDataT,
-      typename std::enable_if<
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
-          TransformT::GetType() ==
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
-                  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED ||
+        PredictionSchemeMethod method, const PointAttribute *attribute,
-              TransformT::GetType() == PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON,
+        const TransformT &transform, const MeshDataT &mesh_data,
-          int>::type = 0>
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+
+  template <class TransformT, class MeshDataT>
   std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
       PredictionSchemeMethod method, const PointAttribute *attribute,
       const TransformT &transform, const MeshDataT &mesh_data,
       uint16_t bitstream_version) {
-    if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+    return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
-      return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+        method, attribute, transform, mesh_data, bitstream_version);
-          new MeshPredictionSchemeGeometricNormalDecoder<DataTypeT, TransformT,
-                                                         MeshDataT>(
-              attribute, transform, mesh_data));
-    }
-    return nullptr;
   }
 };
 

src/draco/compression/config/compression_shared.h

@@ -33,6 +33,7 @@ static constexpr uint16_t kDracoBitstreamVersion = DRACO_BITSTREAM_VERSION(
     kDracoBitstreamVersionMajor, kDracoBitstreamVersionMinor);
 
 // Currently, we support point cloud and triangular mesh encoding.
+// TODO(scottgodfrey) convert enum to enum class (safety, not performance).
 enum EncodedGeometryType {
   INVALID_GEOMETRY_TYPE = -1,
   POINT_CLOUD = 0,

src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc

@@ -356,16 +356,9 @@ bool MeshEdgeBreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity() {
   }
 
   traversal_decoder_.Init(this);
-#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  // Add one extra vertex for each split symbol.
-  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+  traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
-    traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_);
+                                           num_encoded_split_symbols);
-  } else
-#endif
-  {
-    // Add one extra vertex for each split symbol.
-    traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
-                                             num_encoded_split_symbols);
-  }
   traversal_decoder_.SetNumAttributeData(num_attribute_data);
 
   DecoderBuffer traversal_end_buffer;

src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc

@@ -28,7 +28,7 @@
 #include "draco/mesh/prediction_degree_traverser.h"
 
 namespace draco {
-
+// TODO(scottgodfrey) consider converting 'typedef' to 'using' and deduplicate.
 typedef CornerIndex CornerIndex;
 typedef FaceIndex FaceIndex;
 typedef VertexIndex VertexIndex;

src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h

@@ -44,8 +44,8 @@ class MeshEdgeBreakerTraversalPredictiveDecoder
     int32_t num_split_symbols;
     if (!out_buffer->Decode(&num_split_symbols) || num_split_symbols < 0)
       return false;
-    // Add one vertex for each split symbol.
+    if (num_split_symbols >= num_vertices_)
-    num_vertices_ += num_split_symbols;
+      return false;
     // Set the valences of all initial vertices to 0.
     vertex_valences_.resize(num_vertices_, 0);
     if (!prediction_decoder_.StartDecoding(out_buffer))

src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h

@@ -64,8 +64,8 @@ class MeshEdgeBreakerTraversalValenceDecoder
         if (!DecodeVarint(&num_split_symbols, out_buffer))
           return false;
       }
-      // Add one extra vertex for each split symbol.
+      if (num_split_symbols >= num_vertices_)
-      num_vertices_ += num_split_symbols;
+        return false;
 
       int8_t mode;
       if (!out_buffer->Decode(&mode))

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.2.2";
+static const char kDracoVersion[] = "1.2.3";
 
 const char *Version() { return kDracoVersion; }
 

src/draco/io/obj_decoder.cc

@@ -623,8 +623,8 @@ bool ObjDecoder::ParseMaterialFile(const std::string &file_name, bool *error) {
   buffer_.Init(&data[0], file_size);
 
   num_materials_ = 0;
-  while (ParseMaterialFileDefinition(error))
+  while (ParseMaterialFileDefinition(error)) {
-    ;
+  }
 
   // Restore the original buffer.
   buffer_ = old_buffer;

src/draco/tools/draco_encoder.cc

@@ -49,7 +49,8 @@ Options::Options()
       normals_deleted(false),
       generic_quantization_bits(8),
       generic_deleted(false),
-      compression_level(7) {}
+      compression_level(7),
+      use_metadata(false) {}
 
 void Usage() {
   printf("Usage: draco_encoder [options] -i input\n");