[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