Subsurf: Cleanup, remove unused mappings and topology queries

1 files changed, 31 insertions, 271 deletions

diff --git a/source/blender/blenkernel/intern/subdiv_converter_mesh.c b/source/blender/blenkernel/intern/subdiv_converter_mesh.c
index 83b1e4a6ce9..5e320678814 100644
--- a/source/blender/blenkernel/intern/subdiv_converter_mesh.c
+++ b/source/blender/blenkernel/intern/subdiv_converter_mesh.c
@@ -45,31 +45,15 @@
 #  include "opensubdiv_converter_capi.h"
 #endif
 
-/* Use mesh element mapping structures during conversion.
- * Uses more memory but is much faster than naive algorithm.
- */
-#define USE_MESH_ELEMENT_MAPPING
-
 #ifdef WITH_OPENSUBDIV
 typedef struct ConverterStorage {
 	SubdivSettings settings;
 	const Mesh *mesh;
-
-#ifdef USE_MESH_ELEMENT_MAPPING
-	MeshElemMap *vert_edge_map;
-	MeshElemMap *vert_poly_map;
-	MeshElemMap *edge_poly_map;
-	int *vert_edge_mem;
-	int *vert_poly_mem;
-	int *edge_poly_mem;
-#endif
-
 	/* Indexed by loop index, value denotes index of face-varying vertex
 	 * which corresponds to the UV coordinate.
 	 */
 	int *loop_uv_indices;
 	int num_uv_coordinates;
-
 	/* Indexed by coarse mesh elements, gives index of corresponding element
 	 * with ignoring all non-manifold entities.
 	 *
@@ -78,7 +62,6 @@ typedef struct ConverterStorage {
 	 * or vertices in the mesh.
 	 */
 	int *manifold_vertex_index;
-	int *manifold_edge_index;
 	/* Indexed by vertex index from mesh, corresponds to whether this vertex has
 	 * infinite sharpness due to non-manifol topology.
 	 */
@@ -154,19 +137,6 @@ static void get_face_vertices(const OpenSubdiv_Converter *converter,
 	}
 }
 
-static void get_face_edges(const OpenSubdiv_Converter *converter,
-                           int manifold_face_index,
-                           int *manifold_face_edges)
-{
-	ConverterStorage *storage = converter->user_data;
-	const MPoly *poly = &storage->mesh->mpoly[manifold_face_index];
-	const MLoop *mloop = storage->mesh->mloop;
-	for (int corner = 0; corner < poly->totloop; corner++) {
-		manifold_face_edges[corner] =
-		        storage->manifold_edge_index[mloop[poly->loopstart + corner].e];
-	}
-}
-
 static void get_edge_vertices(const OpenSubdiv_Converter *converter,
                               int manifold_edge_index,
                               int *manifold_edge_vertices)
@@ -179,68 +149,6 @@ static void get_edge_vertices(const OpenSubdiv_Converter *converter,
 	manifold_edge_vertices[1] = storage->manifold_vertex_index[edge->v2];
 }
 
-static int get_num_edge_faces(const OpenSubdiv_Converter *converter,
-                              int manifold_edge_index)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int edge_index =
-	        storage->manifold_edge_index_reverse[manifold_edge_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	return storage->edge_poly_map[edge_index].count;
-#else
-	const Mesh *mesh = storage->mesh;
-	const MPoly *mpoly = mesh->mpoly;
-	const MLoop *mloop = mesh->mloop;
-	int num = 0;
-	for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
-		const MPoly *poly = &mpoly[poly_index];
-		for (int corner = 0; corner < poly->totloop; corner++) {
-			const MLoop *loop = &mloop[poly->loopstart + corner];
-			if (storage->manifold_edge_index[loop->e] == -1) {
-				continue;
-			}
-			if (loop->e == edge_index) {
-				++num;
-				break;
-			}
-		}
-	}
-	return num;
-#endif
-}
-
-static void get_edge_faces(const OpenSubdiv_Converter *converter,
-                           int manifold_edge_index,
-                           int *manifold_edge_faces)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int edge_index =
-	        storage->manifold_edge_index_reverse[manifold_edge_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	memcpy(manifold_edge_faces,
-	       storage->edge_poly_map[edge_index].indices,
-	       sizeof(int) * storage->edge_poly_map[edge_index].count);
-#else
-	const Mesh *mesh = storage->mesh;
-	const MPoly *mpoly = mesh->mpoly;
-	const MLoop *mloop = mesh->mloop;
-	int num = 0;
-	for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
-		const MPoly *poly = &mpoly[poly_index];
-		for (int corner = 0; corner < mpoly->totloop; corner++) {
-			const MLoop *loop = &mloop[poly->loopstart + corner];
-			if (storage->manifold_edge_index[loop->e] == -1) {
-				continue;
-			}
-			if (loop->e == edge_index) {
-				manifold_edge_faces[num++] = poly_index;
-				break;
-			}
-		}
-	}
-#endif
-}
-
 static float get_edge_sharpness(const OpenSubdiv_Converter *converter,
                                 int manifold_edge_index)
 {
@@ -252,134 +160,6 @@ static float get_edge_sharpness(const OpenSubdiv_Converter *converter,
 	return edge_crease * storage->settings.level;
 }
 
-static int get_num_vertex_edges(const OpenSubdiv_Converter *converter,
-                                int manifold_vertex_index)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int vertex_index =
-	        storage->manifold_vertex_index_reverse[manifold_vertex_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	const int num_vertex_edges = storage->vert_edge_map[vertex_index].count;
-	int num_manifold_vertex_edges = 0;
-	for (int i = 0; i < num_vertex_edges; i++) {
-		const int edge_index = storage->vert_edge_map[vertex_index].indices[i];
-		const int manifold_edge_index =
-		        storage->manifold_edge_index[edge_index];
-		if (manifold_edge_index == -1) {
-			continue;
-		}
-		num_manifold_vertex_edges++;
-	}
-	return num_manifold_vertex_edges;
-#else
-	const Mesh *mesh = storage->mesh;
-	const MEdge *medge = mesh->medge;
-	int num = 0;
-	for (int edge_index = 0; edge_index < mesh->totedge; edge_index++) {
-		const MEdge *edge = &medge[edge_index];
-		if (storage->manifold_edge_index[edge_index] == -1) {
-			continue;
-		}
-		if (edge->v1 == vertex_index || edge->v2 == vertex_index) {
-			++num;
-		}
-	}
-	return num;
-#endif
-}
-
-static void get_vertex_edges(const OpenSubdiv_Converter *converter,
-                             int manifold_vertex_index,
-                             int *manifold_vertex_edges)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int vertex_index =
-	        storage->manifold_vertex_index_reverse[manifold_vertex_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	const int num_vertex_edges = storage->vert_edge_map[vertex_index].count;
-	int num_manifold_vertex_edges = 0;
-	for (int i = 0; i < num_vertex_edges; i++) {
-		const int edge_index = storage->vert_edge_map[vertex_index].indices[i];
-		const int manifold_edge_index =
-		        storage->manifold_edge_index[edge_index];
-		if (manifold_edge_index == -1) {
-			continue;
-		}
-		manifold_vertex_edges[num_manifold_vertex_edges] = manifold_edge_index;
-		num_manifold_vertex_edges++;
-	}
-#else
-	const Mesh *mesh = storage->mesh;
-	const MEdge *medge = mesh->medge;
-	int num = 0;
-	for (int edge_index = 0; edge_index < mesh->totedge; edge_index++) {
-		const MEdge *edge = &medge[edge_index];
-		if (storage->manifold_edge_index[edge_index] == -1) {
-			continue;
-		}
-		if (edge->v1 == vertex_index || edge->v2 == vertex_index) {
-			manifold_vertex_edges[num++] =
-			        storage->manifold_edge_index[edge_index];
-		}
-	}
-#endif
-}
-
-static int get_num_vertex_faces(const OpenSubdiv_Converter *converter,
-                                int manifold_vertex_index)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int vertex_index =
-	        storage->manifold_vertex_index_reverse[manifold_vertex_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	return storage->vert_poly_map[vertex_index].count;
-#else
-	const Mesh *mesh = storage->mesh;
-	const MPoly *mpoly = mesh->mpoly;
-	const MLoop *mloop = mesh->mloop;
-	int num = 0;
-	for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
-		const MPoly *poly = &mpoly[poly_index];
-		for (int corner = 0; corner < mpoly->totloop; corner++) {
-			const MLoop *loop = &mloop[poly->loopstart + corner];
-			if (loop->v == vertex_index) {
-				++num;
-				break;
-			}
-		}
-	}
-	return num;
-#endif
-}
-
-static void get_vertex_faces(const OpenSubdiv_Converter *converter,
-                            int manifold_vertex_index,
-                            int *manifold_vertex_faces)
-{
-	ConverterStorage *storage = converter->user_data;
-	const int vertex_index =
-	        storage->manifold_vertex_index_reverse[manifold_vertex_index];
-#ifdef USE_MESH_ELEMENT_MAPPING
-	memcpy(manifold_vertex_faces,
-	       storage->vert_poly_map[vertex_index].indices,
-	       sizeof(int) * storage->vert_poly_map[vertex_index].count);
-#else
-	const Mesh *mesh = storage->mesh;
-	const MPoly *mpoly = mesh->mpoly;
-	const MLoop *mloop = mesh->mloop;
-	int num = 0;
-	for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
-		const MPoly *poly = &mpoly[poly_index];
-		for (int corner = 0; corner < mpoly->totloop; corner++) {
-			const MLoop *loop = &mloop[poly->loopstart + corner];
-			if (loop->v == vertex_index) {
-				manifold_vertex_faces[num++] = poly_index;
-				break;
-			}
-		}
-	}
-#endif
-}
 
 static bool is_infinite_sharp_vertex(const OpenSubdiv_Converter *converter,
                                      int manifold_vertex_index)
@@ -467,16 +247,7 @@ static void free_user_data(const OpenSubdiv_Converter *converter)
 {
 	ConverterStorage *user_data = converter->user_data;
 	MEM_SAFE_FREE(user_data->loop_uv_indices);
-#ifdef USE_MESH_ELEMENT_MAPPING
-	MEM_freeN(user_data->vert_edge_map);
-	MEM_freeN(user_data->vert_edge_mem);
-	MEM_freeN(user_data->vert_poly_map);
-	MEM_freeN(user_data->vert_poly_mem);
-	MEM_freeN(user_data->edge_poly_map);
-	MEM_freeN(user_data->edge_poly_mem);
-#endif
 	MEM_freeN(user_data->manifold_vertex_index);
-	MEM_freeN(user_data->manifold_edge_index);
 	MEM_freeN(user_data->infinite_sharp_vertices_map);
 	MEM_freeN(user_data->manifold_vertex_index_reverse);
 	MEM_freeN(user_data->manifold_edge_index_reverse);
@@ -495,17 +266,17 @@ static void init_functions(OpenSubdiv_Converter *converter)
 
 	converter->getNumFaceVertices = get_num_face_vertices;
 	converter->getFaceVertices = get_face_vertices;
-	converter->getFaceEdges = get_face_edges;
+	converter->getFaceEdges = NULL;
 
 	converter->getEdgeVertices = get_edge_vertices;
-	converter->getNumEdgeFaces = get_num_edge_faces;
-	converter->getEdgeFaces = get_edge_faces;
+	converter->getNumEdgeFaces = NULL;
+	converter->getEdgeFaces = NULL;
 	converter->getEdgeSharpness = get_edge_sharpness;
 
-	converter->getNumVertexEdges = get_num_vertex_edges;
-	converter->getVertexEdges = get_vertex_edges;
-	converter->getNumVertexFaces = get_num_vertex_faces;
-	converter->getVertexFaces = get_vertex_faces;
+	converter->getNumVertexEdges = NULL;
+	converter->getVertexEdges = NULL;
+	converter->getNumVertexFaces = NULL;
+	converter->getVertexFaces = NULL;
 	converter->isInfiniteSharpVertex = is_infinite_sharp_vertex;
 
 	converter->getNumUVLayers = get_num_uv_layers;
@@ -517,55 +288,45 @@ static void init_functions(OpenSubdiv_Converter *converter)
 	converter->freeUserData = free_user_data;
 }
 
-static void create_element_maps_if_needed(ConverterStorage *storage)
-{
-#ifdef USE_MESH_ELEMENT_MAPPING
-	const Mesh *mesh = storage->mesh;
-	BKE_mesh_vert_edge_map_create(&storage->vert_edge_map,
-	                              &storage->vert_edge_mem,
-	                              mesh->medge,
-	                              mesh->totvert,
-	                              mesh->totedge);
-	BKE_mesh_vert_poly_map_create(&storage->vert_poly_map,
-	                              &storage->vert_poly_mem,
-	                              mesh->mpoly,
-	                              mesh->mloop,
-	                              mesh->totvert,
-	                              mesh->totpoly,
-	                              mesh->totloop);
-	BKE_mesh_edge_poly_map_create(&storage->edge_poly_map,
-	                              &storage->edge_poly_mem,
-	                              mesh->medge, mesh->totedge,
-	                              mesh->mpoly, mesh->totpoly,
-	                              mesh->mloop, mesh->totloop);
-#else
-	(void) storage;  /* Ignored. */
-#endif
-}
-
 static void initialize_manifold_index_array(const BLI_bitmap *used_map,
                                             const int num_elements,
                                             int **indices_r,
                                             int **indices_reverse_r,
                                             int *num_manifold_elements_r)
 {
-	int *indices = MEM_malloc_arrayN(
+	int *indices = NULL;
+	if (indices_r != NULL) {
+		indices = MEM_malloc_arrayN(
 	        num_elements, sizeof(int), "manifold indices");
-	int *indices_reverse = MEM_malloc_arrayN(
+	}
+	int *indices_reverse = NULL;
+	if (indices_reverse_r != NULL) {
+		indices_reverse = MEM_malloc_arrayN(
 	        num_elements, sizeof(int), "manifold indices reverse");
+	}
 	int offset = 0;
 	for (int i = 0; i < num_elements; i++) {
 		if (BLI_BITMAP_TEST_BOOL(used_map, i)) {
-			indices[i] = i - offset;
-			indices_reverse[i - offset] = i;
+			if (indices != NULL) {
+				indices[i] = i - offset;
+			}
+			if (indices_reverse != NULL) {
+				indices_reverse[i - offset] = i;
+			}
 		}
 		else {
-			indices[i] = -1;
+			if (indices != NULL) {
+				indices[i] = -1;
+			}
 			offset++;
 		}
 	}
-	*indices_r = indices;
-	*indices_reverse_r = indices_reverse;
+	if (indices_r != NULL) {
+		*indices_r = indices;
+	}
+	if (indices_reverse_r != NULL) {
+		*indices_reverse_r = indices_reverse;
+	}
 	*num_manifold_elements_r = num_elements - offset;
 }
 
@@ -593,7 +354,7 @@ static void initialize_manifold_indices(ConverterStorage *storage)
 	                                &storage->num_manifold_vertices);
 	initialize_manifold_index_array(edge_used_map,
 	                                mesh->totedge,
-	                                &storage->manifold_edge_index,
+	                                NULL,
 	                                &storage->manifold_edge_index_reverse,
 	                                &storage->num_manifold_edges);
 	/* Initialize infinite sharp mapping. */
@@ -620,7 +381,6 @@ static void init_user_data(OpenSubdiv_Converter *converter,
 	user_data->settings = *settings;
 	user_data->mesh = mesh;
 	user_data->loop_uv_indices = NULL;
-	create_element_maps_if_needed(user_data);
 	initialize_manifold_indices(user_data);
 	converter->user_data = user_data;
 }