[Bf-blender-cvs] [ce6e9d3] mesh-transfer-data: More cleanup & rename.

Bastien Montagne noreply at git.blender.org
Mon Dec 1 17:14:07 CET 2014


Commit: ce6e9d35270706eae50a252cbe427c69965fef36
Author: Bastien Montagne
Date:   Mon Dec 1 10:09:45 2014 +0100
Branches: mesh-transfer-data
https://developer.blender.org/rBce6e9d35270706eae50a252cbe427c69965fef36

More cleanup & rename.

===================================================================

M	source/blender/blenkernel/intern/mesh_remap.c

===================================================================

diff --git a/source/blender/blenkernel/intern/mesh_remap.c b/source/blender/blenkernel/intern/mesh_remap.c
index 381e6eb..73ddb18 100644
--- a/source/blender/blenkernel/intern/mesh_remap.c
+++ b/source/blender/blenkernel/intern/mesh_remap.c
@@ -783,48 +783,48 @@ void BKE_mesh_remap_calc_edges_from_dm(
 static void mesh_island_to_astar_graph_edge_process(
         MeshIslandStore *islands, const int island_index, BLI_AStarGraph *as_graph,
         MVert *verts, MPoly *polys, MLoop *loops,
-        const int edge_idx, BLI_bitmap *done_edges, MeshElemMap *edge_to_poly_map, const bool is_einnercut,
-        int *poly_isld_index_map, float (*poly_centers)[3], unsigned char *poly_status)
+        const int edge_idx, BLI_bitmap *done_edges, MeshElemMap *edge_to_poly_map, const bool is_edge_innercut,
+        int *poly_island_index_map, float (*poly_centers)[3], unsigned char *poly_status)
 {
-	int *p_isld_indices = BLI_array_alloca(p_isld_indices, (size_t)edge_to_poly_map[edge_idx].count);
+	int *poly_island_indices = BLI_array_alloca(poly_island_indices, (size_t)edge_to_poly_map[edge_idx].count);
 	int i, j;
 
 	for (i = 0; i < edge_to_poly_map[edge_idx].count; i++) {
-		const int p_idx = edge_to_poly_map[edge_idx].indices[i];
-		MPoly *mp = &polys[p_idx];
-		const int p_isld_idx = islands ? poly_isld_index_map[p_idx] : p_idx;
-		void *custom_data = is_einnercut ? SET_INT_IN_POINTER(edge_idx) : SET_INT_IN_POINTER(-1);
+		const int pidx = edge_to_poly_map[edge_idx].indices[i];
+		MPoly *mp = &polys[pidx];
+		const int pidx_isld = islands ? poly_island_index_map[pidx] : pidx;
+		void *custom_data = is_edge_innercut ? SET_INT_IN_POINTER(edge_idx) : SET_INT_IN_POINTER(-1);
 
 		if (UNLIKELY(islands && (islands->items_to_islands[mp->loopstart] != island_index))) {
 			/* poly not in current island, happens with border edges... */
-			p_isld_indices[i] = -1;
+			poly_island_indices[i] = -1;
 			continue;
 		}
 
-		if (poly_status[p_isld_idx] == POLY_COMPLETE) {
-			p_isld_indices[i] = p_isld_idx;
+		if (poly_status[pidx_isld] == POLY_COMPLETE) {
+			poly_island_indices[i] = pidx_isld;
 			continue;
 		}
 
-		if (poly_status[p_isld_idx] == POLY_UNSET) {
-			BKE_mesh_calc_poly_center(mp, &loops[mp->loopstart], verts, poly_centers[p_isld_idx]);
-			BLI_astar_node_init(as_graph, p_isld_idx, poly_centers[p_isld_idx]);
-			poly_status[p_isld_idx] = POLY_CENTER_INIT;
+		if (poly_status[pidx_isld] == POLY_UNSET) {
+			BKE_mesh_calc_poly_center(mp, &loops[mp->loopstart], verts, poly_centers[pidx_isld]);
+			BLI_astar_node_init(as_graph, pidx_isld, poly_centers[pidx_isld]);
+			poly_status[pidx_isld] = POLY_CENTER_INIT;
 		}
 
 		for (j = i; j--;) {
 			float dist_cost;
-			const int p_isld_idx_other = p_isld_indices[j];
+			const int pidx_isld_other = poly_island_indices[j];
 
-			if (p_isld_idx_other == -1 || poly_status[p_isld_idx_other] == POLY_COMPLETE) {
+			if (pidx_isld_other == -1 || poly_status[pidx_isld_other] == POLY_COMPLETE) {
 				/* If the other poly is complete, that link has already been added! */
 				continue;
 			}
-			dist_cost = len_v3v3(poly_centers[p_isld_idx_other], poly_centers[p_isld_idx]);
-			BLI_astar_node_link_add(as_graph, p_isld_idx_other, p_isld_idx, dist_cost, custom_data);
+			dist_cost = len_v3v3(poly_centers[pidx_isld_other], poly_centers[pidx_isld]);
+			BLI_astar_node_link_add(as_graph, pidx_isld_other, pidx_isld, dist_cost, custom_data);
 		}
 
-		p_isld_indices[i] = p_isld_idx;
+		poly_island_indices[i] = pidx_isld;
 	}
 
 	BLI_BITMAP_ENABLE(done_edges, edge_idx);
@@ -838,14 +838,14 @@ static void mesh_island_to_astar_graph(
 	MeshElemMap *island_poly_map = islands ? islands->islands[island_index] : NULL;
 	MeshElemMap *island_einnercut_map = islands ? islands->innercuts[island_index] : NULL;
 
-	int *poly_isld_index_map = NULL;
+	int *poly_island_index_map = NULL;
 	BLI_bitmap *done_edges = BLI_BITMAP_NEW(numedges, __func__);
 
 	const int node_num = islands ? island_poly_map->count : numpolys;
 	unsigned char *poly_status = MEM_callocN(sizeof(*poly_status) * (size_t)node_num, __func__);
 	float (*poly_centers)[3];
 
-	int p_isld_idx;
+	int pidx_isld;
 	int i;
 
 	BLI_astar_graph_init(r_as_graph, node_num, NULL);
@@ -853,28 +853,28 @@ static void mesh_island_to_astar_graph(
 	poly_centers = BLI_memarena_calloc(r_as_graph->mem, sizeof(*poly_centers) * (size_t)node_num);
 
 	if (islands) {
-		/* poly_isld_index_map is owned by graph memarena. */
-		poly_isld_index_map = BLI_memarena_calloc(r_as_graph->mem, sizeof(*poly_isld_index_map) * (size_t)numpolys);
+		/* poly_island_index_map is owned by graph memarena. */
+		poly_island_index_map = BLI_memarena_calloc(r_as_graph->mem, sizeof(*poly_island_index_map) * (size_t)numpolys);
 		for (i = island_poly_map->count; i--;) {
-			poly_isld_index_map[island_poly_map->indices[i]] = i;
+			poly_island_index_map[island_poly_map->indices[i]] = i;
 		}
 
-		r_as_graph->custom_data = poly_isld_index_map;
+		r_as_graph->custom_data = poly_island_index_map;
 
 		for (i = island_einnercut_map->count; i--;) {
 			mesh_island_to_astar_graph_edge_process(
 			        islands, island_index, r_as_graph, verts, polys, loops,
 			        island_einnercut_map->indices[i], done_edges, edge_to_poly_map, true,
-			        poly_isld_index_map, poly_centers, poly_status);
+			        poly_island_index_map, poly_centers, poly_status);
 		}
 	}
 
-	for (p_isld_idx = node_num; p_isld_idx--;) {
-		const int p_idx = islands ? island_poly_map->indices[p_isld_idx] : p_isld_idx;
-		MPoly *mp = &polys[p_idx];
+	for (pidx_isld = node_num; pidx_isld--;) {
+		const int pidx = islands ? island_poly_map->indices[pidx_isld] : pidx_isld;
+		MPoly *mp = &polys[pidx];
 		int pl_idx, l_idx;
 
-		if (poly_status[p_isld_idx] == POLY_COMPLETE) {
+		if (poly_status[pidx_isld] == POLY_COMPLETE) {
 			continue;
 		}
 
@@ -888,9 +888,9 @@ static void mesh_island_to_astar_graph(
 			mesh_island_to_astar_graph_edge_process(
 			        islands, island_index, r_as_graph, verts, polys, loops,
 			        (int)ml->e, done_edges, edge_to_poly_map, false,
-			        poly_isld_index_map, poly_centers, poly_status);
+			        poly_island_index_map, poly_centers, poly_status);
 		}
-		poly_status[p_isld_idx] = POLY_COMPLETE;
+		poly_status[pidx_isld] = POLY_COMPLETE;
 	}
 
 	MEM_freeN(done_edges);
@@ -919,7 +919,8 @@ static float mesh_remap_calc_loops_astar_f_cost(
 	}
 
 	/* Our heuristic part of current f_cost is distance from next node to destination one.
-	 * It is guaranteed to be less than actual shortest poly-path between next node and destination one. */
+	 * It is guaranteed to be less than (or equal to) actual shortest poly-path between next node and destination one.
+	 */
 	co_next = (float *)as_graph->nodes[node_idx_next].custom_data;
 	co_dest = (float *)as_graph->nodes[node_idx_dst].custom_data;
 	return (link ? (as_solution->g_costs[node_idx_curr] + link->cost) : 0.0f) + len_v3v3(co_next, co_dest);
@@ -938,7 +939,6 @@ void BKE_mesh_remap_calc_loops_from_dm(
 {
 	const float full_weight = 1.0f;
 	const float max_dist_sq = max_dist * max_dist;
-	const int isld_steps_src = (int)(ASTAR_STEPS_MAX * islands_precision_src + 0.499f);
 
 	int i;
 
@@ -968,6 +968,8 @@ void BKE_mesh_remap_calc_loops_from_dm(
 
 		BLI_AStarGraph *as_graphdata = NULL;
 		BLI_AStarSolution as_solution = {0};
+		const int isld_steps_src = islands_precision_src ?
+		                           max_ii((int)(ASTAR_STEPS_MAX * islands_precision_src + 0.499f), 1) : 0;
 
 		float (*poly_nors_src)[3] = NULL;
 		float (*loop_nors_src)[3] = NULL;
@@ -1398,9 +1400,10 @@ void BKE_mesh_remap_calc_loops_from_dm(
 			 *     of locale vars. Not worth sending all that through parameters (for now at least). */
 			{
 				BLI_AStarGraph *as_graph = NULL;
-				int *poly_isld_index_map = NULL;
+				int *poly_island_index_map = NULL;
 				int pidx_src_prev = -1;
 
+				MeshElemMap *best_island = NULL;
 				float best_island_fac = 0.0f;
 				int best_island_index = -1;
 
@@ -1419,8 +1422,9 @@ void BKE_mesh_remap_calc_loops_from_dm(
 				}
 
 				if (best_island_index != -1 && isld_steps_src) {
+					best_island = island_store.islands[best_island_index];
 					as_graph = &as_graphdata[best_island_index];
-					poly_isld_index_map = (int *)as_graph->custom_data;
+					poly_island_index_map = (int *)as_graph->custom_data;
 					BLI_astar_solution_init(as_graph, &as_solution, false);
 				}
 
@@ -1445,7 +1449,7 @@ void BKE_mesh_remap_calc_loops_from_dm(
 							/* If prev and curr poly are the same, no need to do anything more!!! */
 							if (!ELEM(pidx_src_prev, -1, pidx_src) && isld_steps_src) {
 								BLI_astar_graph_solve(
-								        as_graph, poly_isld_index_map[pidx_src_prev], poly_isld_index_map[pidx_src],
+								        as_graph, poly_island_index_map[pidx_src_prev], poly_island_index_map[pidx_src],
 								        mesh_remap_calc_loops_astar_f_cost, &as_solution, isld_steps_src);
 								if (GET_INT_FROM_POINTER(as_solution.custom_data) && (as_solution.steps > 0)) {
 									/* Find first 'cutting edge' on path, and bring back lidx_src on poly just
@@ -1455,20 +1459,20 @@ void BKE_mesh_remap_calc_loops_from_dm(
 									 * but this is one more level of complexity, better to first see if
 									 * simple solution works!
 									 */
-									int pisld_idx_src = poly_isld_index_map[pidx_src];
-									int last_valid_pisld_idx_src = -1;
+									int pidx_isld_src = poly_island_index_map[pidx_src];
+									int last_valid_pidx_isld_src = -1;
 									/* Note we go backward here, from dest to src poly. */
 									for (i = as_solution.steps - 1; i--;) {
-										BLI_AStarGNLink *as_link = as_solution.prev_links[pisld_idx_src];
-										int eidx = GET_INT_FROM_POINTER(as_link->custom_data);
-										pisld_idx_src = as_solution.prev_nodes[pisld_idx_src];
-										BLI_assert(pisld_idx_src != -1);
+										BLI_AStarGNLink *as_link = as_solution.prev_links[pidx_isld_src];
+										const int eidx = GET_INT_FROM_POINTER(as_link->custom_data);
+										pidx_isld_src = as_solution.prev_nodes[pidx_isld_src];
+										BLI_assert(pidx_isld_src != -1);
 										if (eidx != -1) {
 											/* we are 'crossing' a cutting edge. */
-											la

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list