1 files changed, 0 insertions, 147 deletions
diff --git a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
index 3506d93b7aa..41727d5664a 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
@@ -86,150 +86,6 @@ bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Geometry comparison.
-
-// A thin wrapper around index like array which does cyclic access. This means,
-// it basically does indices[requested_index % num_indices].
-//
-// NOTE: This array does not own the memory.
-//
-// TODO(sergey): Consider moving this to a more reusable place.
-class CyclicArray {
- public:
-  typedef int value_type;
-  typedef int size_type;
-  static constexpr size_type npos = -1;
-
-  explicit CyclicArray(const std::vector<int> &data) : data_(data.data()), size_(data.size())
-  {
-  }
-
-  explicit CyclicArray(const OpenSubdiv::Far::ConstIndexArray &data)
-      : data_(&data[0]), size_(data.size())
-  {
-  }
-
-  inline value_type operator[](int index) const
-  {
-    assert(index >= 0);
-    // TODO(sergey): Check whether doing check for element index exceeding total
-    // number of indices prior to modulo helps performance.
-    return data_[index % size()];
-  }
-
-  inline size_type size() const
-  {
-    return size_;
-  }
-
-  // Find index of first occurrence of a given value.
-  inline size_type find(const value_type value) const
-  {
-    const int num_indices = size();
-    for (size_type i = 0; i < num_indices; ++i) {
-      if (value == (*this)[i]) {
-        return i;
-      }
-    }
-    return npos;
-  }
-
- protected:
-  const value_type *data_;
-  const size_type size_;
-};
-
-bool compareCyclicForward(const CyclicArray &array_a,
-                          const int start_a,
-                          const CyclicArray &array_b,
-                          const int start_b)
-{
-  const int num_elements = array_a.size();
-  for (int i = 0; i < num_elements; ++i) {
-    if (array_a[start_a + i] != array_b[start_b + i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool compareCyclicBackward(const CyclicArray &array_a,
-                           const int start_a,
-                           const CyclicArray &array_b,
-                           const int start_b)
-{
-  const int num_elements = array_a.size();
-  // TODO(sergey): Some optimization might be possible with memcmp trickery.
-  for (int i = 0; i < num_elements; ++i) {
-    if (array_a[start_a + (num_elements - i - 1)] != array_b[start_b + (num_elements - i - 1)]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Utility function dedicated for checking whether whether vertices indices
-// used by two faces match.
-// The tricky part here is that we can't trust 1:1 array match here, since it's
-// possible that OpenSubdiv oriented edges of a face to make it compatible with
-// an internal representation of non-manifold meshes.
-//
-// TODO(sergey): Check whether this is needed, ot whether OpenSubdiv is only
-// creating edges in a proper orientation without modifying indices of face
-// vertices.
-bool checkVerticesOfFacesMatch(const CyclicArray &indices_a, const CyclicArray &indices_b)
-{
-  if (indices_a.size() != indices_b.size()) {
-    return false;
-  }
-  // "Align" the arrays so we know first matched element.
-  const int start_b = indices_b.find(indices_a[0]);
-  if (start_b == indices_b.npos) {
-    return false;
-  }
-  // Check match in both directions, for the case OpenSubdiv did orient face in
-  // a way which made normals more consistent internally.
-  if (compareCyclicForward(indices_a, 0, indices_b, start_b)) {
-    return true;
-  }
-  if (compareCyclicBackward(indices_a, 0, indices_b, start_b)) {
-    return true;
-  }
-  return false;
-}
-
-bool checkGeometryFacesMatch(const TopologyRefinerImpl *topology_refiner_impl,
-                             const OpenSubdiv_Converter *converter)
-{
-  using OpenSubdiv::Far::ConstIndexArray;
-  using OpenSubdiv::Far::TopologyLevel;
-  const TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner_impl);
-  const int num_faces = base_level.GetNumFaces();
-  // TODO(sergey): Consider using data structure which keeps handful of
-  // elements on stack before doing heep allocation.
-  vector<int> conv_face_vertices;
-  for (int face_index = 0; face_index < num_faces; ++face_index) {
-    const ConstIndexArray &face_vertices = base_level.GetFaceVertices(face_index);
-    const int num_face_vertices = face_vertices.size();
-    if (num_face_vertices != converter->getNumFaceVertices(converter, face_index)) {
-      return false;
-    }
-    conv_face_vertices.resize(num_face_vertices);
-    converter->getFaceVertices(converter, face_index, &conv_face_vertices[0]);
-    if (!checkVerticesOfFacesMatch(CyclicArray(conv_face_vertices), CyclicArray(face_vertices))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool checkGeometryMatches(const TopologyRefinerImpl *topology_refiner_impl,
-                          const OpenSubdiv_Converter *converter)
-{
-  return checkGeometryFacesMatch(topology_refiner_impl, converter);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // Compare attributes which affects on topology.
 
 bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
@@ -286,9 +142,6 @@ bool TopologyRefinerImpl::isEqualToConverter(const OpenSubdiv_Converter *convert
   if (!blender::opensubdiv::checkPreliminaryMatches(this, converter)) {
     return false;
   }
-  if (!blender::opensubdiv::checkGeometryMatches(this, converter)) {
-    return false;
-  }
   if (!blender::opensubdiv::checkTopologyAttributesMatch(this, converter)) {
     return false;
   }