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.

1 files changed, 345 insertions, 198 deletions

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);
 }
 
 /* =============================================================================