From 5d6ec23e3ea30bb1546cf091df2a5ecee48e9ee5 Mon Sep 17 00:00:00 2001 From: Sergey Sharybin Date: Tue, 6 Nov 2018 11:44:02 +0100 Subject: Multires: Refactor propagation to the higher levels Now it is forumlated in terms of deltas, and consists of the following steps: - Original displacement at the reshape level are being backed up. - New displacement is being written by the reshape routines. - Delta of the displacement is calculated. - Deltas are propagated to the higher levels, which also includes their interpolation/ - Original displacement is restored. - New interpolated displacements are added to the original ones. This is a base ground for the upcoming change related on using Catmull-Clark smoothing for the deltas instead of linear interpolation. Currently is no changes for artists, just preparing for upcoming work. --- .../blender/blenkernel/intern/multires_reshape.c | 543 +++++++++++++-------- 1 file changed, 345 insertions(+), 198 deletions(-) (limited to 'source/blender/blenkernel/intern/multires_reshape.c') diff --git a/source/blender/blenkernel/intern/multires_reshape.c b/source/blender/blenkernel/intern/multires_reshape.c index d5fa9e7bee6..fe4bc5ca3e0 100644 --- a/source/blender/blenkernel/intern/multires_reshape.c +++ b/source/blender/blenkernel/intern/multires_reshape.c @@ -325,22 +325,122 @@ static void multires_reshape_vertex_from_final_data( */ typedef struct MultiresPropagateData { + /* Number of displacement grids. */ + int num_grids; + /* Resolution level up to which displacement is known. */ int reshape_level; + /* Resolution up to which propagation is happening, affecting all the + * levels in [reshape_level + 1, top_level]. + */ int top_level; - int num_grids; + /* Grid sizes at the corresponding levels. */ int reshape_grid_size; int top_grid_size; - MDisps *old_displacement_grids; - MDisps *new_displacement_grids; + /* Keys to access CCG at different levels. */ + CCGKey reshape_level_key; + CCGKey top_level_key; + /* Original grid data, before any updates for reshape. + * Contains data at the reshape_level resolution level. + */ + CCGElem **orig_grids_data; + /* Custom data layers from a coarse mesh. */ + MDisps *mdisps; GridPaintMask *grid_paint_mask; } MultiresPropagateData; -typedef struct MultiresPropagateCornerData { - float old_coord[3]; - float new_coord[3]; - float coord_delta[3]; - float mask; -} MultiresPropagateCornerData; +static CCGElem **allocate_grids(CCGKey *key, int num_grids) +{ + CCGElem **grids = MEM_calloc_arrayN( + num_grids, sizeof(CCGElem *), "reshape grids*"); + for (int grid_index = 0; grid_index < num_grids; grid_index++) { + grids[grid_index] = MEM_calloc_arrayN( + key->elem_size, + key->grid_area, + "reshape orig_grids_data elems"); + } + return grids; +} + +static void free_grids(CCGElem **grids, int num_grids) +{ + if (grids == NULL) { + return; + } + for (int grid_index = 0; grid_index < num_grids; grid_index++) { + MEM_freeN(grids[grid_index]); + } + MEM_freeN(grids); +} + +/* Initialize element sizes and offsets. */ +static void multires_reshape_init_key_layers( + CCGKey *key, + const MultiresPropagateData *data) +{ + key->elem_size = 3 * sizeof(float); + if (data->grid_paint_mask != NULL) { + key->mask_offset = 3 * sizeof(float); + key->elem_size += sizeof(float); + key->has_mask = true; + } + else { + key->mask_offset = -1; + key->has_mask = false; + } + /* We never have normals in original grids. */ + key->normal_offset = -1; + key->has_normals = false; +} + +/* Initialize key used to access reshape grids at given level. */ +static void multires_reshape_init_level_key( + CCGKey *key, + const MultiresPropagateData *data, + const int level) +{ + key->level = level; + /* Init layers. */ + multires_reshape_init_key_layers(key, data); + /* By default, only 3 floats for coordinate, */ + key->grid_size = BKE_subdiv_grid_size_from_level(key->level); + key->grid_area = key->grid_size * key->grid_size; + key->grid_bytes = key->elem_size * key->grid_area; +} + +static void multires_reshape_store_original_grids( + MultiresPropagateData *data) +{ + const int num_grids = data->num_grids; + /* Original data to be backed up. */ + const MDisps *mdisps = data->mdisps; + const GridPaintMask *grid_paint_mask = data->grid_paint_mask; + /* Allocate grids for backup. */ + CCGKey *orig_key = &data->reshape_level_key; + CCGElem **orig_grids_data = allocate_grids(orig_key, num_grids); + /* Fill in grids. */ + const int orig_grid_size = data->reshape_grid_size; + const int top_grid_size = data->top_grid_size; + const int skip = (top_grid_size - 1) / (orig_grid_size - 1); + for (int grid_index = 0; grid_index < num_grids; grid_index++) { + CCGElem *orig_grid = orig_grids_data[grid_index]; + for (int y = 0; y < orig_grid_size; y++) { + const int top_y = y * skip; + for (int x = 0; x < orig_grid_size; x++) { + const int top_x = x * skip; + const int top_index = top_y * top_grid_size + top_x; + memcpy(CCG_grid_elem_co(orig_key, orig_grid, x, y), + mdisps[grid_index].disps[top_index], + sizeof(float) * 3); + if (orig_key->has_mask) { + *CCG_grid_elem_mask(orig_key, orig_grid, x, y) = + grid_paint_mask[grid_index].data[top_index]; + } + } + } + } + /* Store in the context. */ + data->orig_grids_data = orig_grids_data; +} static void multires_reshape_propagate_prepare( MultiresPropagateData *data, @@ -349,37 +449,28 @@ static void multires_reshape_propagate_prepare( const int top_level) { BLI_assert(reshape_level <= top_level); - data->old_displacement_grids = NULL; + memset(data, 0, sizeof(*data)); + data->num_grids = coarse_mesh->totloop; + data->reshape_level = reshape_level; + data->top_level = top_level; if (reshape_level == top_level) { /* Nothing to do, reshape will happen on the whole grid content. */ return; } - const int num_grids = coarse_mesh->totloop; - MDisps *mdisps = CustomData_get_layer(&coarse_mesh->ldata, CD_MDISPS); - MDisps *old_mdisps = MEM_dupallocN(mdisps); - for (int grid_index = 0; grid_index < num_grids; grid_index++) { - MDisps *displacement_grid = &mdisps[grid_index]; - MDisps *old_displacement_grid = &old_mdisps[grid_index]; - old_displacement_grid->totdisp = displacement_grid->totdisp; - old_displacement_grid->level = displacement_grid->level; - if (displacement_grid->disps) { - displacement_grid->disps = MEM_dupallocN(displacement_grid->disps); - } - else { - old_displacement_grid->disps = NULL; - } - /* TODO(sergey): This might be needed for proper propagation. */ - old_displacement_grid->hidden = NULL; - } - data->reshape_level = reshape_level; - data->top_level = top_level; - data->num_grids = num_grids; - data->reshape_grid_size = BKE_subdiv_grid_size_from_level(reshape_level); - data->top_grid_size = BKE_subdiv_grid_size_from_level(top_level); - data->old_displacement_grids = old_mdisps; - data->new_displacement_grids = mdisps; + data->mdisps = CustomData_get_layer(&coarse_mesh->ldata, CD_MDISPS); data->grid_paint_mask = CustomData_get_layer(&coarse_mesh->ldata, CD_GRID_PAINT_MASK); + data->top_grid_size = BKE_subdiv_grid_size_from_level(top_level); + data->reshape_grid_size = BKE_subdiv_grid_size_from_level(reshape_level); + /* Initialize keys to access CCG at different levels. */ + multires_reshape_init_level_key( + &data->reshape_level_key, data, data->reshape_level); + multires_reshape_init_level_key( + &data->top_level_key, data, data->top_level); + /* Make a copy of grids before reshaping, so we can calculate deltas + * later on. + */ + multires_reshape_store_original_grids(data); } static void multires_reshape_propagate_prepare_from_mmd( @@ -390,6 +481,7 @@ static void multires_reshape_propagate_prepare_from_mmd( const int top_level, const bool use_render_params) { + /* TODO(sergey): Find mode reliable way of getting current level. */ Scene *scene_eval = DEG_get_evaluated_scene(depsgraph); Mesh *mesh = object->data; const int level = multires_get_level( @@ -397,208 +489,263 @@ static void multires_reshape_propagate_prepare_from_mmd( multires_reshape_propagate_prepare(data, mesh, level, top_level); } -static void multires_reshape_propagate_corner_data( - MultiresPropagateCornerData *corner, - const MDisps *old_displacement_grid, - const MDisps *new_displacement_grid, - const GridPaintMask *grid_paint_mask, - const int grid_size, - const int grid_skip, - const int reshape_x, const int reshape_y) +/* Calculate delta of changed reshape level data layers. Delta goes to a + * grids at top level (meaning, the result grids are only partially filled + * in). + */ +static void multires_reshape_calculate_delta( + MultiresPropagateData *data, + CCGElem **delta_grids_data) { - const int x = reshape_x * grid_skip; - const int y = reshape_y * grid_skip; - const int grid_index = y * grid_size + x; - if (old_displacement_grid->disps != NULL) { - copy_v3_v3(corner->old_coord, old_displacement_grid->disps[grid_index]); - } - else { - zero_v3(corner->old_coord); - } - copy_v3_v3(corner->new_coord, new_displacement_grid->disps[grid_index]); - sub_v3_v3v3(corner->coord_delta, corner->new_coord, corner->old_coord); - if (grid_paint_mask != NULL) { - corner->mask = grid_paint_mask->data[grid_index]; - } - else { - corner->mask = 0.0f; + const int num_grids = data->num_grids; + /* At this point those custom data layers has updated data for the + * level we are propagating from. + */ + const MDisps *mdisps = data->mdisps; + const GridPaintMask *grid_paint_mask = data->grid_paint_mask; + CCGKey *reshape_key = &data->reshape_level_key; + CCGKey *delta_level_key = &data->top_level_key; + /* Calculate delta. */ + const int top_grid_size = data->top_grid_size; + const int reshape_grid_size = data->reshape_grid_size; + const int delta_grid_size = data->top_grid_size; + const int skip = (top_grid_size - 1) / (reshape_grid_size - 1); + for (int grid_index = 0; grid_index < num_grids; grid_index++) { + /*const*/ CCGElem *orig_grid = data->orig_grids_data[grid_index]; + CCGElem *delta_grid = delta_grids_data[grid_index]; + for (int y = 0; y < reshape_grid_size; y++) { + const int top_y = y * skip; + for (int x = 0; x < reshape_grid_size; x++) { + const int top_x = x * skip; + const int top_index = top_y * delta_grid_size + top_x; + sub_v3_v3v3( + CCG_grid_elem_co( + delta_level_key, delta_grid, top_x, top_y), + mdisps[grid_index].disps[top_index], + CCG_grid_elem_co(reshape_key, orig_grid, x, y)); + if (delta_level_key->has_mask) { + const float old_mask_value = *CCG_grid_elem_mask( + reshape_key, orig_grid, x, y); + const float new_mask_value = + grid_paint_mask[grid_index].data[top_index]; + *CCG_grid_elem_mask( + delta_level_key, delta_grid, top_x, top_y) = + new_mask_value - old_mask_value; + } + } + } } } -static void multires_reshape_propagate_all_corners_data( - MultiresPropagateCornerData corners[4], - const MDisps *old_displacement_grid, - const MDisps *new_displacement_grid, - const GridPaintMask *grid_paint_mask, - const int grid_size, - const int grid_skip, - const int reshape_x, const int reshape_y) +/* Makes it so delta is propagated onto all the higher levels, but is also + * that this delta is smoothed in a way that it does not cause artifacts on + * boundaries. + */ + +typedef struct MultiresPropagateCornerData { + float coord_delta[3]; + float mask_delta; +} MultiresPropagateCornerData; + +BLI_INLINE void multires_reshape_propagate_init_patch_corners( + MultiresPropagateData *data, + CCGElem *delta_grid, + const int patch_x, const int patch_y, + MultiresPropagateCornerData r_corners[4]) { - int corner_index = 0; - for (int dy = 0; dy <= 1; dy++) { - for (int dx = 0; dx <= 1; dx++) { - multires_reshape_propagate_corner_data( - &corners[corner_index], - old_displacement_grid, - new_displacement_grid, - grid_paint_mask, - grid_size, - grid_skip, - reshape_x + dx, reshape_y + dy); - corner_index++; - } + CCGKey *delta_level_key = &data->top_level_key; + const int orig_grid_size = data->reshape_grid_size; + const int top_grid_size = data->top_grid_size; + const int skip = (top_grid_size - 1) / (orig_grid_size - 1); + const int x = patch_x * skip; + const int y = patch_y * skip; + /* Store coordinate deltas. */ + copy_v3_v3(r_corners[0].coord_delta, + CCG_grid_elem_co(delta_level_key, delta_grid, x, y)); + copy_v3_v3(r_corners[1].coord_delta, + CCG_grid_elem_co(delta_level_key, delta_grid, x + skip, y)); + copy_v3_v3(r_corners[2].coord_delta, + CCG_grid_elem_co(delta_level_key, delta_grid, x, y + skip)); + copy_v3_v3(r_corners[3].coord_delta, + CCG_grid_elem_co(delta_level_key, delta_grid, + x + skip, y + skip)); + if (delta_level_key->has_mask) { + r_corners[0].mask_delta = + *CCG_grid_elem_mask(delta_level_key, delta_grid, x, y); + r_corners[1].mask_delta = + *CCG_grid_elem_mask(delta_level_key, delta_grid, + x + skip, y); + r_corners[2].mask_delta = + *CCG_grid_elem_mask(delta_level_key, delta_grid, + x, y + skip); + r_corners[3].mask_delta = + *CCG_grid_elem_mask(delta_level_key, delta_grid, + x + skip, y + skip); } } -static void multires_reshape_propagate_interpolate_coord( - MDisps *new_displacement_grid, +BLI_INLINE void multires_reshape_propagate_interpolate_coord( + float delta[3], const MultiresPropagateCornerData corners[4], - const float weights[4], - const int x, const int y, - const int grid_size) + const float weights[4]) { - float delta[3]; interp_v3_v3v3v3v3( - delta, - corners[0].coord_delta, corners[1].coord_delta, - corners[2].coord_delta, corners[3].coord_delta, - weights); - const int index = y * grid_size + x; - float *new_displacement = new_displacement_grid->disps[index]; - add_v3_v3(new_displacement, delta); + delta, + corners[0].coord_delta, corners[1].coord_delta, + corners[2].coord_delta, corners[3].coord_delta, + weights); } -static void multires_reshape_propagate_interpolate_mask( - GridPaintMask *grid_paint_mask, +BLI_INLINE float multires_reshape_propagate_interpolate_mask( const MultiresPropagateCornerData corners[4], - const float weights[4], - const int x, const int y, - const int grid_size) + const float weights[4]) { - const int index = y * grid_size + x; - grid_paint_mask->data[index] = - corners[0].mask * weights[0] + - corners[1].mask * weights[1] + - corners[2].mask * weights[2] + - corners[3].mask * weights[3]; + return corners[0].mask_delta * weights[0] + + corners[1].mask_delta * weights[1] + + corners[2].mask_delta * weights[2] + + corners[3].mask_delta * weights[3]; } -static void multires_reshape_propagate_grid( +BLI_INLINE void multires_reshape_propagate_and_smooth_delta_grid_patch( MultiresPropagateData *data, - const MDisps *old_displacement_grid, - MDisps *new_displacement_grid, - GridPaintMask *grid_paint_mask) + CCGElem *delta_grid, + const int patch_x, const int patch_y) { - const int reshape_grid_size = data->reshape_grid_size; + CCGKey *delta_level_key = &data->top_level_key; + const int orig_grid_size = data->reshape_grid_size; const int top_grid_size = data->top_grid_size; - const int grid_skip = (top_grid_size - 1) / (reshape_grid_size - 1); - const float grid_skip_inv = 1.0f / (float)grid_skip; - for (int reshape_y = 0; - reshape_y < reshape_grid_size - 1; - reshape_y++) - { - for (int reshape_x = 0; - reshape_x < reshape_grid_size - 1; - reshape_x++) - { - MultiresPropagateCornerData corners[4]; - multires_reshape_propagate_all_corners_data( + const int skip = (top_grid_size - 1) / (orig_grid_size - 1); + const float skip_inv = 1.0f / (float)skip; + MultiresPropagateCornerData corners[4]; + multires_reshape_propagate_init_patch_corners( + data, delta_grid, patch_x, patch_y, corners); + const int start_x = patch_x * skip; + const int start_y = patch_y * skip; + for (int y = 0; y <= skip; y++) { + const float v = (float)y * skip_inv; + const int final_y = start_y + y; + for (int x = 0; x <= skip; x++) { + const float u = (float)x * skip_inv; + const int final_x = start_x + x; + const float linear_weights[4] = {(1.0f - u) * (1.0f - v), + u * (1.0f - v), + (1.0f - u) * v, + u * v}; + multires_reshape_propagate_interpolate_coord( + CCG_grid_elem_co(delta_level_key, delta_grid, + final_x, final_y), corners, - old_displacement_grid, new_displacement_grid, - grid_paint_mask, - top_grid_size, - grid_skip, - reshape_x, reshape_y); - /* Propagate to higher levels. */ - for (int y = 0; y <= grid_skip; y++) { - const float v = (float)y * grid_skip_inv; - for (int x = 0; x <= grid_skip; x++) { - /* Ignorevalues at the exact locations of grid which was - * reshape. Those points already have proper displacement. - */ - if ((x == 0 && y == 0) || - (x == grid_skip && y == 0) || - (x == grid_skip && y == grid_skip) || - (x == 0 && y == grid_skip)) - { - continue; - } - /* Ignore right-most column and top-most row, unless this - * is a boundary of the grid, to prevent displacement - * being affected twice. - */ - if (x == grid_skip && reshape_x != reshape_grid_size - 2) { - continue; - } - if (y == grid_skip && reshape_y != reshape_grid_size - 2) { - continue; - } - const float u = (float)x * grid_skip_inv; - const int final_x = reshape_x * grid_skip + x; - const int final_y = reshape_y * grid_skip + y; - const float linear_weights[4] = {(1.0f - u) * (1.0f - v), - u * (1.0f - v), - (1.0f - u) * v, - u * v}; - multires_reshape_propagate_interpolate_coord( - new_displacement_grid, - corners, - linear_weights, - final_x, final_y, - top_grid_size); - if (grid_paint_mask != NULL) { - multires_reshape_propagate_interpolate_mask( - grid_paint_mask, - corners, - linear_weights, - final_x, final_y, - top_grid_size); - } - } + linear_weights); + if (delta_level_key->has_mask) { + float *mask = CCG_grid_elem_mask(delta_level_key, delta_grid, + final_x, final_y); + *mask = multires_reshape_propagate_interpolate_mask( + corners, linear_weights); } } } } -static void multires_reshape_propagate(MultiresPropagateData *data) +BLI_INLINE void multires_reshape_propagate_and_smooth_delta_grid( + MultiresPropagateData *data, + CCGElem *delta_grid) { - if (data->old_displacement_grids == NULL) { - return; + const int orig_grid_size = data->reshape_grid_size; + for (int patch_y = 0; patch_y < orig_grid_size - 1; patch_y++) { + for (int patch_x = 0; patch_x < orig_grid_size - 1; patch_x++) { + multires_reshape_propagate_and_smooth_delta_grid_patch( + data, delta_grid, patch_x, patch_y); + } } +} + +/* Entry point to propagate+smooth. */ +static void multires_reshape_propagate_and_smooth_delta( + MultiresPropagateData *data, + CCGElem **delta_grids_data) +{ const int num_grids = data->num_grids; for (int grid_index = 0; grid_index < num_grids; grid_index++) { - const MDisps *old_displacement_grid = - &data->old_displacement_grids[grid_index]; - MDisps *new_displacement_grid = - &data->new_displacement_grids[grid_index]; - if (old_displacement_grid->level != new_displacement_grid->level) { - continue; - } - GridPaintMask *grid_paint_mask = - data->grid_paint_mask != NULL - ? &data->grid_paint_mask[grid_index] - : NULL; - multires_reshape_propagate_grid( - data, old_displacement_grid, - new_displacement_grid, - grid_paint_mask); + CCGElem *delta_grid = delta_grids_data[grid_index]; + multires_reshape_propagate_and_smooth_delta_grid(data, delta_grid); } } -static void multires_reshape_propagate_free(MultiresPropagateData *data) +/* Apply smoothed deltas on the actual data layers. */ +static void multires_reshape_propagate_apply_delta( + MultiresPropagateData *data, + CCGElem **delta_grids_data) { - if (data->old_displacement_grids == NULL) { - return; - } const int num_grids = data->num_grids; - MDisps *old_mdisps = data->old_displacement_grids; + /* At this point those custom data layers has updated data for the + * level we are propagating from. + */ + MDisps *mdisps = data->mdisps; + GridPaintMask *grid_paint_mask = data->grid_paint_mask; + CCGKey *orig_key = &data->reshape_level_key; + CCGKey *delta_level_key = &data->top_level_key; + CCGElem **orig_grids_data = data->orig_grids_data; + const int orig_grid_size = data->reshape_grid_size; + const int top_grid_size = data->top_grid_size; + const int skip = (top_grid_size - 1) / (orig_grid_size - 1); + /* Restore grid values at the reshape level. Those values are to be changed + * to the accommodate for the smooth delta. + */ + for (int grid_index = 0; grid_index < num_grids; grid_index++) { + CCGElem *orig_grid = orig_grids_data[grid_index]; + for (int y = 0; y < orig_grid_size; y++) { + const int top_y = y * skip; + for (int x = 0; x < orig_grid_size; x++) { + const int top_x = x * skip; + const int top_index = top_y * top_grid_size + top_x; + copy_v3_v3(mdisps[grid_index].disps[top_index], + CCG_grid_elem_co(orig_key, orig_grid, x, y)); + if (grid_paint_mask != NULL) { + grid_paint_mask[grid_index].data[top_index] = + *CCG_grid_elem_mask(orig_key, orig_grid, x, y); + } + } + } + } + /* Add smoothed delta to all the levels. */ for (int grid_index = 0; grid_index < num_grids; grid_index++) { - MDisps *old_displacement_grid = &old_mdisps[grid_index]; - if (old_displacement_grid->disps) { - MEM_freeN(old_displacement_grid->disps); + CCGElem *delta_grid = delta_grids_data[grid_index]; + for (int y = 0; y < top_grid_size; y++) { + for (int x = 0; x < top_grid_size; x++) { + const int top_index = y * top_grid_size + x; + add_v3_v3(mdisps[grid_index].disps[top_index], + CCG_grid_elem_co(delta_level_key, delta_grid, x, y)); + if (delta_level_key->has_mask) { + grid_paint_mask[grid_index].data[top_index] += + *CCG_grid_elem_mask( + delta_level_key, delta_grid, x, y); + } + } } } - MEM_freeN(data->old_displacement_grids); +} + +static void multires_reshape_propagate(MultiresPropagateData *data) +{ + if (data->reshape_level == data->top_level) { + return; + } + const int num_grids = data->num_grids; + /* Calculate delta made at the reshape level. */ + CCGKey *delta_level_key = &data->top_level_key; + CCGElem **delta_grids_data = allocate_grids(delta_level_key, num_grids); + multires_reshape_calculate_delta(data, delta_grids_data); + /* Propagate deltas to the higher levels. */ + multires_reshape_propagate_and_smooth_delta(data, delta_grids_data); + /* Finally, apply smoothed deltas. */ + multires_reshape_propagate_apply_delta(data, delta_grids_data); + /* Cleanup. */ + free_grids(delta_grids_data, num_grids); +} + +static void multires_reshape_propagate_free(MultiresPropagateData *data) +{ + free_grids(data->orig_grids_data, data->num_grids); } /* ============================================================================= -- cgit v1.2.3