OpenSubdiv: Use explicit storage for edge sharpness

Similar to previous change in vertex sharpness, explicitly store value
provided by the converter.

Allows to avoid rather fragile check for boundary edges.

Also allows to avoid need in constructing edge map. This lowers memory
footprint of the comparison process and avoids memory allocations
during the comparison (which is an extra benefit from the performance
point of view).

1 files changed, 18 insertions, 83 deletions

diff --git a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
index d51d0eb7f54..06612a9e6a1 100644
--- a/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
+++ b/intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
@@ -18,7 +18,6 @@
 
 #include "internal/topology/topology_refiner_impl.h"
 
-#include "internal/base/edge_map.h"
 #include "internal/base/type.h"
 #include "internal/base/type_convert.h"
 #include "internal/topology/mesh_topology.h"
@@ -233,102 +232,37 @@ bool checkGeometryMatches(const TopologyRefinerImpl *topology_refiner_impl,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Compare attributes which affects on topology
+// Compare attributes which affects on topology.
 
-inline bool checkSingleEdgeSharpnessMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
-                                          int base_level_edge_index,
-                                          const OpenSubdiv_Converter *converter,
-                                          int converter_edge_index)
+// TODO(sergey): Make this function usable by factory as well.
+float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int edge_index)
 {
-  // NOTE: Boundary and non-manifold edges are internally forced to an infinite
-  // sharpness. So we can not reliably compare those.
-  //
-  // TODO(sergey): Watch for NON_MANIFOLD_SHARP option.
-  if (base_level.IsEdgeBoundary(base_level_edge_index) ||
-      base_level.IsEdgeNonManifold(base_level_edge_index)) {
-    return true;
-  }
-  const float sharpness = base_level.GetEdgeSharpness(base_level_edge_index);
-  const float converter_sharpness = converter->getEdgeSharpness(converter, converter_edge_index);
-  if (sharpness != converter_sharpness) {
-    return false;
+  if (converter->getEdgeSharpness != nullptr) {
+    return converter->getEdgeSharpness(converter, edge_index);
   }
-  return true;
-}
 
-inline bool checkSingleEdgeTagMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
-                                    int base_level_edge_index,
-                                    const OpenSubdiv_Converter *converter,
-                                    int converter_edge_index)
-{
-  return checkSingleEdgeSharpnessMatch(
-      base_level, base_level_edge_index, converter, converter_edge_index);
+  return 0.0f;
 }
 
-// Compares edge tags between topology refiner and converter in a case when
-// converter specifies a full topology.
-// This is simplest loop, since we know that order of edges matches.
-bool checkEdgeTagsMatchFullTopology(const TopologyRefinerImpl *topology_refiner_impl,
-                                    const OpenSubdiv_Converter *converter)
+bool checkEdgeTagsMatch(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_edges = base_level.GetNumEdges();
-  for (int edge_index = 0; edge_index < num_edges; ++edge_index) {
-    if (!checkSingleEdgeTagMatch(base_level, edge_index, converter, edge_index)) {
-      return false;
-    }
-  }
-  return true;
-}
+  const MeshTopology &base_mesh_topology = topology_refiner_impl->base_mesh_topology;
 
-// Compares tags of edges in the case when orientation of edges is left up to
-// OpenSubdiv. In this case we do need to take care of mapping edges from the
-// converter to current topology refiner, since the order is not guaranteed.
-bool checkEdgeTagsMatchAutoOrient(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_edges = base_level.GetNumEdges();
-  // Create mapping for quick lookup of edge index from its vertices indices.
-  //
-  // TODO(sergey): Consider caching it in some sort of wrapper around topology
-  // refiner.
-  EdgeTagMap<int> edge_map;
+  const int num_edges = base_mesh_topology.getNumEdges();
   for (int edge_index = 0; edge_index < num_edges; ++edge_index) {
-    ConstIndexArray edge_vertices = base_level.GetEdgeVertices(edge_index);
-    edge_map.insert(edge_vertices[0], edge_vertices[1], edge_index);
-  }
-  // Compare all edges.
-  for (int converter_edge_index = 0; converter_edge_index < num_edges; ++converter_edge_index) {
-    // Get edge vertices indices, and lookup corresponding edge index in the
-    // base topology level.
-    int edge_vertices[2];
-    converter->getEdgeVertices(converter, converter_edge_index, edge_vertices);
-    const int base_level_edge_index = edge_map.at(edge_vertices[0], edge_vertices[1]);
-    // Perform actual test.
-    if (!checkSingleEdgeTagMatch(
-            base_level, base_level_edge_index, converter, converter_edge_index)) {
+    const float current_sharpness = base_mesh_topology.getEdgeSharpness(edge_index);
+    const float requested_sharpness = getEffectiveEdgeSharpness(converter, edge_index);
+
+    if (current_sharpness != requested_sharpness) {
       return false;
     }
   }
-  return true;
-}
 
-bool checkEdgeTagsMatch(const TopologyRefinerImpl *topology_refiner_impl,
-                        const OpenSubdiv_Converter *converter)
-{
-  if (converter->specifiesFullTopology(converter)) {
-    return checkEdgeTagsMatchFullTopology(topology_refiner_impl, converter);
-  }
-  else {
-    return checkEdgeTagsMatchAutoOrient(topology_refiner_impl, converter);
-  }
+  return true;
 }
 
+// TODO(sergey): Make this function usable by factory as well.
 float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter, const int vertex_index)
 {
   if (converter->isInfiniteSharpVertex != nullptr &&
@@ -350,13 +284,14 @@ bool checkVertexSharpnessMatch(const TopologyRefinerImpl *topology_refiner_impl,
 
   const int num_vertices = base_mesh_topology.getNumVertices();
   for (int vertex_index = 0; vertex_index < num_vertices; ++vertex_index) {
-    const float current_sharpness = base_mesh_topology.vertices[vertex_index].sharpness;
+    const float current_sharpness = base_mesh_topology.getVertexSharpness(vertex_index);
     const float requested_sharpness = getEffectiveVertexSharpness(converter, vertex_index);
 
     if (current_sharpness != requested_sharpness) {
       return false;
     }
   }
+
   return true;
 }