[Bf-blender-cvs] [5d6ec23e3ea] blender2.8: Multires: Refactor propagation to the higher levels
Sergey Sharybin
noreply at git.blender.org
Tue Nov 6 12:41:47 CET 2018
Commit: 5d6ec23e3ea30bb1546cf091df2a5ecee48e9ee5
Author: Sergey Sharybin
Date: Tue Nov 6 11:44:02 2018 +0100
Branches: blender2.8
https://developer.blender.org/rB5d6ec23e3ea30bb1546cf091df2a5ecee48e9ee5
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.
===================================================================
M 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
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list