Blender V5.3
multires_reshape_util.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2020 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "multires_reshape.hh"
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_key_types.h"
14#include "DNA_mesh_types.h"
15#include "DNA_meshdata_types.h"
16#include "DNA_modifier_types.h"
17#include "DNA_object_types.h"
18
19#include "BLI_math_matrix.hh"
20#include "BLI_math_matrix_c.hh"
21#include "BLI_math_vector_c.hh"
22#include "BLI_task_c.hh"
23
24#include "BKE_attribute.hh"
25#include "BKE_customdata.hh"
26#include "BKE_mesh_runtime.hh"
27#include "BKE_multires.hh"
28#include "BKE_subdiv.hh"
29#include "BKE_subdiv_ccg.hh"
30#include "BKE_subdiv_eval.hh"
31
33
34namespace blender {
35
36/* -------------------------------------------------------------------- */
39
41 /*const*/ Object *object,
42 const MultiresModifierData *mmd)
43{
44 using namespace blender::bke;
45 const Mesh *base_mesh;
46
47 if (depsgraph != nullptr) {
48 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
49 Object *object_eval = DEG_get_evaluated(depsgraph, object);
50 base_mesh = mesh_get_eval_deform(depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH);
51 }
52 else {
53 base_mesh = id_cast<Mesh *>(object->data);
54 }
55
56 subdiv::Settings subdiv_settings;
57 BKE_multires_subdiv_settings_init(&subdiv_settings, mmd);
58 subdiv::Subdiv *subdiv = subdiv::new_from_mesh(&subdiv_settings, base_mesh);
59 if (!subdiv) {
60 return nullptr;
61 }
64 return nullptr;
65 }
66 return subdiv;
67}
68
69static void context_zero(MultiresReshapeContext *reshape_context)
70{
71 *reshape_context = {};
72}
73
74static void context_init_lookup(MultiresReshapeContext *reshape_context,
75 const bool need_ptex_lookup)
76{
77 const OffsetIndices faces = reshape_context->base_faces;
78
79 reshape_context->num_grids = faces.total_size();
80 reshape_context->base_corner_to_face = reshape_context->base_mesh->corner_to_face_map();
81 if (!need_ptex_lookup) {
82 return;
83 }
84
85 int num_ptex_faces = 0;
86 for (const int face_index : faces.index_range()) {
87 const int num_corners = faces[face_index].size();
88 num_ptex_faces += (num_corners == 4) ? 1 : num_corners;
89 }
90
91 reshape_context->ptex_start_grid_index.reinitialize(num_ptex_faces);
92 for (int face_index = 0, ptex_index = 0; face_index < faces.size(); ++face_index) {
93 const int num_corners = faces[face_index].size();
94 const int num_face_ptex_faces = (num_corners == 4) ? 1 : num_corners;
95 const int grid_index = faces[face_index].start();
96 for (int i = 0; i < num_face_ptex_faces; ++i) {
97 reshape_context->ptex_start_grid_index[ptex_index + i] = grid_index + i;
98 }
99 ptex_index += num_face_ptex_faces;
100 }
101}
102
104{
105 Mesh *base_mesh = reshape_context->base_mesh;
106 reshape_context->mdisps = static_cast<MDisps *>(
108 reshape_context->grid_paint_masks = static_cast<GridPaintMask *>(CustomData_get_layer_for_write(
109 &base_mesh->corner_data, CD_GRID_PAINT_MASK, base_mesh->corners_num));
110}
111
112static void context_init_common(MultiresReshapeContext *reshape_context,
113 const bool need_ptex_lookup = true)
114{
115 BLI_assert(reshape_context->subdiv != nullptr);
116 BLI_assert(reshape_context->base_mesh != nullptr);
117
118 reshape_context->face_ptex_offset = bke::subdiv::face_ptex_offset_get(reshape_context->subdiv);
119
120 context_init_lookup(reshape_context, need_ptex_lookup);
121 context_init_grid_pointers(reshape_context);
122}
123
124static bool context_is_valid(MultiresReshapeContext *reshape_context)
125{
126 if (reshape_context->mdisps == nullptr) {
127 /* Multi-resolution displacement has been removed before current changes were applies. */
128 return false;
129 }
130 return true;
131}
132
134{
135 const bool is_valid = context_is_valid(reshape_context);
136 if (!is_valid) {
137 multires_reshape_context_free(reshape_context);
138 }
139 return is_valid;
140}
141
143 Depsgraph *depsgraph,
144 Object *object,
146{
147 context_zero(reshape_context);
148
149 const bool use_render_params = false;
150 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
151 Mesh *base_mesh = id_cast<Mesh *>(object->data);
152
153 reshape_context->depsgraph = depsgraph;
154 reshape_context->object = object;
155 reshape_context->mmd = mmd;
156
157 reshape_context->base_mesh = base_mesh;
158 reshape_context->base_positions = base_mesh->vert_positions();
159 reshape_context->base_edges = base_mesh->edges();
160 reshape_context->base_faces = base_mesh->faces();
161 reshape_context->base_corner_verts = base_mesh->corner_verts();
162 reshape_context->base_corner_edges = base_mesh->corner_edges();
163
164 reshape_context->subdiv = multires_reshape_create_subdiv(nullptr, object, mmd);
165 if (!reshape_context->subdiv) {
166 return false;
167 }
168 reshape_context->need_free_subdiv = true;
169
170 reshape_context->reshape.level = multires_get_level(
171 scene_eval, object, mmd, use_render_params, true);
172 reshape_context->reshape.grid_size = bke::subdiv::grid_size_from_level(
173 reshape_context->reshape.level);
174
175 reshape_context->top.level = mmd->totlvl;
176 reshape_context->top.grid_size = bke::subdiv::grid_size_from_level(reshape_context->top.level);
177
178 context_init_common(reshape_context);
179
180 return context_verify_or_free(reshape_context);
181}
182
184 Depsgraph *depsgraph,
185 Object *object,
187{
188 using namespace blender::bke;
189 context_zero(reshape_context);
190
191 const bool use_render_params = false;
192 Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
193 Mesh *base_mesh = id_cast<Mesh *>(object->data);
194
195 reshape_context->depsgraph = depsgraph;
196 reshape_context->object = object;
197 reshape_context->mmd = mmd;
198
199 reshape_context->base_mesh = base_mesh;
200 reshape_context->base_positions = base_mesh->vert_positions();
201 /* TODO: The following check can be replaced by ShapeKeyData struct member `basis_key_active`
202 * found in `sculpt_intern.hh`.*/
203 if (base_mesh->key && object->shapenr > 0) {
204 KeyBlock *kb = base_mesh->key->refkey;
205 reshape_context->basis_shape_key = kb;
206 }
207 reshape_context->base_edges = base_mesh->edges();
208 reshape_context->base_faces = base_mesh->faces();
209 reshape_context->base_corner_verts = base_mesh->corner_verts();
210 reshape_context->base_corner_edges = base_mesh->corner_edges();
211
212 reshape_context->subdiv = multires_reshape_create_subdiv(depsgraph, object, mmd);
213 if (!reshape_context->subdiv) {
214 return false;
215 }
216 reshape_context->need_free_subdiv = true;
217
218 reshape_context->reshape.level = multires_get_level(
219 scene_eval, object, mmd, use_render_params, true);
220 reshape_context->reshape.grid_size = subdiv::grid_size_from_level(
221 reshape_context->reshape.level);
222
223 reshape_context->top.level = mmd->totlvl;
224 reshape_context->top.grid_size = subdiv::grid_size_from_level(reshape_context->top.level);
225
226 const bke::AttributeAccessor attributes = base_mesh->attributes();
227 reshape_context->cd_vert_crease = *attributes.lookup<float>("crease_vert", AttrDomain::Point);
228 reshape_context->cd_edge_crease = *attributes.lookup<float>("crease_edge", AttrDomain::Edge);
229
230 context_init_common(reshape_context);
231
232 return context_verify_or_free(reshape_context);
233}
234
236 SubdivCCG *subdiv_ccg,
237 Mesh *base_mesh,
238 int top_level)
239{
240 context_zero(reshape_context);
241
242 reshape_context->base_mesh = base_mesh;
243 reshape_context->base_positions = base_mesh->vert_positions();
244 reshape_context->base_edges = base_mesh->edges();
245 reshape_context->base_faces = base_mesh->faces();
246 reshape_context->base_corner_verts = base_mesh->corner_verts();
247 reshape_context->base_corner_edges = base_mesh->corner_edges();
248
249 reshape_context->subdiv = subdiv_ccg->subdiv;
250 reshape_context->need_free_subdiv = false;
251
252 reshape_context->reshape.level = subdiv_ccg->level;
253 reshape_context->reshape.grid_size = bke::subdiv::grid_size_from_level(
254 reshape_context->reshape.level);
255
256 reshape_context->top.level = top_level;
257 reshape_context->top.grid_size = bke::subdiv::grid_size_from_level(reshape_context->top.level);
258
259 /* Mapping ptex coordinates back to grid coordinates is only needed by the detail smoothing pass,
260 * which is skipped when displacement is assigned at the top level. */
261 const bool need_ptex_lookup = reshape_context->top.level != reshape_context->reshape.level;
262 context_init_common(reshape_context, need_ptex_lookup);
263
264 return context_verify_or_free(reshape_context);
265}
266
268 Object *object,
270 int top_level)
271{
273
275 reshape_context, object, mmd, subdiv, top_level);
276
277 reshape_context->need_free_subdiv = true;
278
279 return result;
280}
281
283 Object *object,
286 int top_level)
287{
288 using namespace blender::bke;
289 context_zero(reshape_context);
290
291 Mesh *base_mesh = id_cast<Mesh *>(object->data);
292
293 reshape_context->mmd = mmd;
294 reshape_context->base_mesh = base_mesh;
295 reshape_context->base_positions = base_mesh->vert_positions();
296 reshape_context->base_edges = base_mesh->edges();
297 reshape_context->base_faces = base_mesh->faces();
298 reshape_context->base_corner_verts = base_mesh->corner_verts();
299 reshape_context->base_corner_edges = base_mesh->corner_edges();
300
301 const bke::AttributeAccessor attributes = base_mesh->attributes();
302 reshape_context->cd_vert_crease = *attributes.lookup<float>("crease_vert", AttrDomain::Point);
303
304 reshape_context->subdiv = subdiv;
305 reshape_context->need_free_subdiv = false;
306
307 reshape_context->reshape.level = mmd->totlvl;
308 reshape_context->reshape.grid_size = subdiv::grid_size_from_level(
309 reshape_context->reshape.level);
310
311 reshape_context->top.level = top_level;
312 reshape_context->top.grid_size = subdiv::grid_size_from_level(reshape_context->top.level);
313
314 context_init_common(reshape_context);
315
316 return context_verify_or_free(reshape_context);
317}
318
320{
321 MDisps *orig_mdisps = reshape_context->orig.mdisps;
322 GridPaintMask *orig_grid_paint_masks = reshape_context->orig.grid_paint_masks;
323
324 if (orig_mdisps == nullptr && orig_grid_paint_masks == nullptr) {
325 return;
326 }
327
328 const int num_grids = reshape_context->num_grids;
329 for (int grid_index = 0; grid_index < num_grids; grid_index++) {
330 if (orig_mdisps != nullptr) {
331 MDisps *orig_grid = &orig_mdisps[grid_index];
332 MEM_SAFE_DELETE(orig_grid->disps);
333 }
334 if (orig_grid_paint_masks != nullptr) {
335 GridPaintMask *orig_paint_mask_grid = &orig_grid_paint_masks[grid_index];
336 MEM_SAFE_DELETE(orig_paint_mask_grid->data);
337 }
338 }
339
340 MEM_SAFE_DELETE(orig_mdisps);
341 MEM_SAFE_DELETE(orig_grid_paint_masks);
342
343 reshape_context->orig.mdisps = nullptr;
344 reshape_context->orig.grid_paint_masks = nullptr;
345}
346
348{
349 if (reshape_context->need_free_subdiv) {
350 bke::subdiv::free(reshape_context->subdiv);
351 }
352
354}
355
357
358/* -------------------------------------------------------------------- */
361
363 int grid_index)
364{
365 BLI_assert(grid_index >= 0);
366 BLI_assert(grid_index < reshape_context->num_grids);
367
368 return reshape_context->base_corner_to_face[grid_index];
369}
370
371int multires_reshape_grid_to_corner(const MultiresReshapeContext *reshape_context, int grid_index)
372{
373 BLI_assert(grid_index >= 0);
374 BLI_assert(grid_index < reshape_context->num_grids);
375
376 const int face_index = multires_reshape_grid_to_face_index(reshape_context, grid_index);
377 return grid_index - reshape_context->base_faces[face_index].start();
378}
379
380bool multires_reshape_is_quad_face(const MultiresReshapeContext *reshape_context, int face_index)
381{
382 return reshape_context->base_faces[face_index].size() == 4;
383}
384
386 int grid_index)
387{
388 const int face_index = multires_reshape_grid_to_face_index(reshape_context, grid_index);
389 const int corner = multires_reshape_grid_to_corner(reshape_context, grid_index);
390 const bool is_quad = multires_reshape_is_quad_face(reshape_context, face_index);
391 return reshape_context->face_ptex_offset[face_index] + (is_quad ? 0 : corner);
392}
393
395 const GridCoord *grid_coord)
396{
397 PTexCoord ptex_coord;
398
399 ptex_coord.ptex_face_index = multires_reshape_grid_to_ptex_index(reshape_context,
400 grid_coord->grid_index);
401
402 float corner_u, corner_v;
403 bke::subdiv::grid_uv_to_ptex_face_uv(grid_coord->u, grid_coord->v, &corner_u, &corner_v);
404
405 const int face_index = multires_reshape_grid_to_face_index(reshape_context,
406 grid_coord->grid_index);
407 const int corner = multires_reshape_grid_to_corner(reshape_context, grid_coord->grid_index);
408 if (multires_reshape_is_quad_face(reshape_context, face_index)) {
409 float grid_u, grid_v;
410 bke::subdiv::ptex_face_uv_to_grid_uv(corner_u, corner_v, &grid_u, &grid_v);
411 bke::subdiv::rotate_grid_to_quad(corner, grid_u, grid_v, &ptex_coord.u, &ptex_coord.v);
412 }
413 else {
414 ptex_coord.u = corner_u;
415 ptex_coord.v = corner_v;
416 }
417
418 return ptex_coord;
419}
420
422 const PTexCoord *ptex_coord)
423{
424 GridCoord grid_coord;
425
426 /* The context must have been created knowing that ptex coordinates need to be mapped back to
427 * grid coordinates. */
428 BLI_assert(!reshape_context->ptex_start_grid_index.is_empty());
429
430 const int start_grid_index = reshape_context->ptex_start_grid_index[ptex_coord->ptex_face_index];
431 const int face_index = reshape_context->base_corner_to_face[start_grid_index];
432
433 int corner_delta;
434 if (multires_reshape_is_quad_face(reshape_context, face_index)) {
436 ptex_coord->u, ptex_coord->v, &grid_coord.u, &grid_coord.v);
437 }
438 else {
439 corner_delta = 0;
440 grid_coord.u = ptex_coord->u;
441 grid_coord.v = ptex_coord->v;
442 }
443 grid_coord.grid_index = start_grid_index + corner_delta;
444
445 bke::subdiv::ptex_face_uv_to_grid_uv(grid_coord.u, grid_coord.v, &grid_coord.u, &grid_coord.v);
446
447 return grid_coord;
448}
449
451 const int face_index,
452 const int corner,
453 const float3 &dPdu,
454 const float3 &dPdv,
455 float3x3 &r_tangent_matrix)
456{
457 /* For a quad faces we would need to flip the tangent, since they will use
458 * use different coordinates within displacement grid compared to the ptex face. */
459 const bool is_quad = multires_reshape_is_quad_face(reshape_context, face_index);
460 const int tangent_corner = is_quad ? corner : 0;
461 BKE_multires_construct_tangent_matrix(r_tangent_matrix, dPdu, dPdv, tangent_corner);
462}
463
465 const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord)
466{
467 ReshapeGridElement grid_element = {nullptr, nullptr};
468
469 const int grid_size = reshape_context->top.grid_size;
470 const int grid_x = lround(grid_coord->u * (grid_size - 1));
471 const int grid_y = lround(grid_coord->v * (grid_size - 1));
472 const int grid_element_index = grid_y * grid_size + grid_x;
473
474 if (reshape_context->mdisps != nullptr) {
475 MDisps *displacement_grid = &reshape_context->mdisps[grid_coord->grid_index];
476 grid_element.displacement = reinterpret_cast<float3 *>(
477 displacement_grid->disps[grid_element_index]);
478 }
479
480 if (reshape_context->grid_paint_masks != nullptr) {
481 GridPaintMask *grid_paint_mask = &reshape_context->grid_paint_masks[grid_coord->grid_index];
482 grid_element.mask = &grid_paint_mask->data[grid_element_index];
483 }
484
485 return grid_element;
486}
487
489 const MultiresReshapeContext *reshape_context, const PTexCoord *ptex_coord)
490{
491 GridCoord grid_coord = multires_reshape_ptex_coord_to_grid(reshape_context, ptex_coord);
492 return multires_reshape_grid_element_for_grid_coord(reshape_context, &grid_coord);
493}
494
496 const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord)
497{
498 ReshapeConstGridElement grid_element = {{0.0f, 0.0f, 0.0f}, 0.0f};
499
500 const MDisps *mdisps = reshape_context->orig.mdisps;
501 if (mdisps != nullptr) {
502 const int grid_size = reshape_context->orig.grid_size;
503 const MDisps *displacement_grid = &mdisps[grid_coord->grid_index];
504 if (displacement_grid->disps != nullptr) {
505 const int grid_x = lround(grid_coord->u * (grid_size - 1));
506 const int grid_y = lround(grid_coord->v * (grid_size - 1));
507 const int grid_element_index = grid_y * grid_size + grid_x;
508 grid_element.displacement = displacement_grid->disps[grid_element_index];
509 }
510 }
511
512 const GridPaintMask *grid_paint_masks = reshape_context->orig.grid_paint_masks;
513 if (grid_paint_masks != nullptr) {
514 const GridPaintMask *paint_mask_grid = &grid_paint_masks[grid_coord->grid_index];
515 if (paint_mask_grid->data != nullptr) {
516 const int grid_size = bke::subdiv::grid_size_from_level(paint_mask_grid->level);
517 const int grid_x = lround(grid_coord->u * (grid_size - 1));
518 const int grid_y = lround(grid_coord->v * (grid_size - 1));
519 const int grid_element_index = grid_y * grid_size + grid_x;
520 grid_element.mask = paint_mask_grid->data[grid_element_index];
521 }
522 }
523
524 return grid_element;
525}
526
528
529/* -------------------------------------------------------------------- */
532
534 const MultiresReshapeContext *reshape_context,
535 const GridCoord *grid_coord,
536 float3 &r_P,
537 float3x3 &r_tangent_matrix)
538{
539 float3 dPdu;
540 float3 dPdv;
541 const PTexCoord ptex_coord = multires_reshape_grid_coord_to_ptex(reshape_context, grid_coord);
542 bke::subdiv::Subdiv *subdiv = reshape_context->subdiv;
544 subdiv, ptex_coord.ptex_face_index, ptex_coord.u, ptex_coord.v, r_P, dPdu, dPdv);
545
546 const int face_index = multires_reshape_grid_to_face_index(reshape_context,
547 grid_coord->grid_index);
548 const int corner = multires_reshape_grid_to_corner(reshape_context, grid_coord->grid_index);
550 reshape_context, face_index, corner, dPdu, dPdv, r_tangent_matrix);
551}
552
554
555/* -------------------------------------------------------------------- */
558
559static void allocate_displacement_grid(MDisps *displacement_grid, const int grid_area)
560{
561 float (*disps)[3] = MEM_new_array_zeroed<float[3]>(grid_area, "multires disps");
562 if (displacement_grid->disps != nullptr) {
563 MEM_delete(displacement_grid->disps);
564 }
565 /* TODO(sergey): Preserve data on the old level. */
566 displacement_grid->disps = disps;
567 displacement_grid->totdisp = grid_area;
568}
569
570static void ensure_displacement_grid(MDisps *displacement_grid, const int grid_area)
571{
572 if (displacement_grid->disps != nullptr && displacement_grid->totdisp >= grid_area) {
573 return;
574 }
575 allocate_displacement_grid(displacement_grid, grid_area);
576}
577
578static void ensure_displacement_grids(Mesh *mesh, const int grid_level)
579{
580 const int num_grids = mesh->corners_num;
581 const int grid_size = bke::subdiv::grid_size_from_level(grid_level);
582 const int grid_area = grid_size * grid_size;
583 MDisps *mdisps = static_cast<MDisps *>(
584 CustomData_get_layer_for_write(&mesh->corner_data, CD_MDISPS, mesh->corners_num));
585 for (int grid_index = 0; grid_index < num_grids; grid_index++) {
586 ensure_displacement_grid(&mdisps[grid_index], grid_area);
587 }
588}
589
590static void ensure_mask_grids(Mesh *mesh, const int level)
591{
592 GridPaintMask *grid_paint_masks = static_cast<GridPaintMask *>(
593 CustomData_get_layer_for_write(&mesh->corner_data, CD_GRID_PAINT_MASK, mesh->corners_num));
594 if (grid_paint_masks == nullptr) {
595 return;
596 }
597 const int num_grids = mesh->corners_num;
598 const int grid_size = bke::subdiv::grid_size_from_level(level);
599 const int grid_area = grid_size * grid_size;
600 for (int grid_index = 0; grid_index < num_grids; grid_index++) {
601 GridPaintMask *grid_paint_mask = &grid_paint_masks[grid_index];
602 if (grid_paint_mask->level >= level) {
603 continue;
604 }
605 grid_paint_mask->level = level;
606 if (grid_paint_mask->data) {
607 MEM_delete(grid_paint_mask->data);
608 }
609 /* TODO(sergey): Preserve data on the old level. */
610 grid_paint_mask->data = MEM_new_array_zeroed<float>(grid_area, "gpm.data");
611 }
612}
613
615{
617 ensure_mask_grids(mesh, level);
618}
619
621
622/* -------------------------------------------------------------------- */
625
627{
628 const MDisps *mdisps = reshape_context->mdisps;
629 const GridPaintMask *grid_paint_masks = reshape_context->grid_paint_masks;
630
631 MDisps *orig_mdisps = MEM_dupalloc(mdisps);
632 GridPaintMask *orig_grid_paint_masks = nullptr;
633 if (grid_paint_masks != nullptr) {
634 orig_grid_paint_masks = MEM_dupalloc(grid_paint_masks);
635 }
636
637 const int num_grids = reshape_context->num_grids;
638 for (int grid_index = 0; grid_index < num_grids; grid_index++) {
639 MDisps *orig_grid = &orig_mdisps[grid_index];
640 /* Ignore possibly invalid/non-allocated original grids. They will be replaced with 0 original
641 * data when accessed during reshape process.
642 * Reshape process will ensure all grids are on top level, but that happens on separate set of
643 * grids which eventually replaces original one. */
644 if (orig_grid->disps != nullptr) {
645 orig_grid->disps = MEM_dupalloc(orig_grid->disps);
646 }
647 if (orig_grid_paint_masks != nullptr) {
648 GridPaintMask *orig_paint_mask_grid = &orig_grid_paint_masks[grid_index];
649 if (orig_paint_mask_grid->data != nullptr) {
650 orig_paint_mask_grid->data = MEM_dupalloc(orig_paint_mask_grid->data);
651 }
652 }
653 }
654
655 reshape_context->orig.mdisps = orig_mdisps;
656 reshape_context->orig.grid_paint_masks = orig_grid_paint_masks;
657 reshape_context->orig.grid_size = math::sqrt(mdisps->totdisp);
658}
659
660using ForeachGridCoordinateCallback = void (*)(const MultiresReshapeContext *reshape_context,
661 const GridCoord *grid_coord,
662 void *userdata_v);
663
673
674static void foreach_grid_face_coordinate_task(void *__restrict userdata_v,
675 const int face_index,
676 const TaskParallelTLS *__restrict /*tls*/)
677{
679
680 const MultiresReshapeContext *reshape_context = data->reshape_context;
681
682 const OffsetIndices faces = reshape_context->base_faces;
683 const int grid_size = data->grid_size;
684 const float grid_size_1_inv = 1.0f / (float(grid_size) - 1.0f);
685
686 const int num_corners = faces[face_index].size();
687 int grid_index = faces[face_index].start();
688 for (int corner = 0; corner < num_corners; ++corner, ++grid_index) {
689 for (int y = 0; y < grid_size; ++y) {
690 const float v = float(y) * grid_size_1_inv;
691 for (int x = 0; x < grid_size; ++x) {
692 const float u = float(x) * grid_size_1_inv;
693
694 GridCoord grid_coord;
695 grid_coord.grid_index = grid_index;
696 grid_coord.u = u;
697 grid_coord.v = v;
698
699 data->callback(data->reshape_context, &grid_coord, data->callback_userdata_v);
700 }
701 }
702 }
703}
704
705/* Run given callback for every grid coordinate at a given level. */
706static void foreach_grid_coordinate(const MultiresReshapeContext *reshape_context,
707 const int level,
709 void *userdata_v)
710{
712 data.reshape_context = reshape_context;
713 data.grid_size = bke::subdiv::grid_size_from_level(level);
714 data.grid_size_1_inv = 1.0f / (float(data.grid_size) - 1.0f);
715 data.callback = callback;
716 data.callback_userdata_v = userdata_v;
717
718 TaskParallelSettings parallel_range_settings;
719 BLI_parallel_range_settings_defaults(&parallel_range_settings);
720 parallel_range_settings.min_iter_per_thread = 1;
721
722 const Mesh *base_mesh = reshape_context->base_mesh;
723 const int num_faces = base_mesh->faces_num;
725 0, num_faces, &data, foreach_grid_face_coordinate_task, &parallel_range_settings);
726}
727
729 const MultiresReshapeContext *reshape_context,
730 const GridCoord *grid_coord,
731 void * /*userdata_v*/)
732{
733 float3 P;
734 float3x3 tangent_matrix;
736 reshape_context, grid_coord, P, tangent_matrix);
737
738 const float3x3 inv_tangent_matrix = math::invert(tangent_matrix);
739
741 grid_coord);
742
743 float3 D = *grid_element.displacement - P;
744
745 float3 tangent_D = math::transform_direction(inv_tangent_matrix, D);
746
747 *grid_element.displacement = tangent_D;
748}
749
751 const MultiresReshapeContext *reshape_context)
752{
753 foreach_grid_coordinate(reshape_context,
754 reshape_context->top.level,
756 nullptr);
757}
758
760
761/* -------------------------------------------------------------------- */
764
765/* TODO(sergey): Make foreach_grid_coordinate more accessible and move this functionality to
766 * its own file. */
767
769 const GridCoord *grid_coord,
770 void * /*userdata_v*/)
771{
772 float3 P;
773 float3x3 tangent_matrix;
775 reshape_context, grid_coord, P, tangent_matrix);
776
778 grid_coord);
779 const float3 D = math::transform_direction(tangent_matrix, *grid_element.displacement);
780
781 *grid_element.displacement = P + D;
782}
783
785 const MultiresReshapeContext *reshape_context)
786{
787 /* The final coordinates are calculated from the original grids. */
788 BLI_assert(reshape_context->orig.mdisps != nullptr);
789
791 reshape_context, reshape_context->top.level, assign_final_coords_from_mdisps, nullptr);
792}
793
795 const GridCoord *grid_coord,
796 void * /*userdata_v*/)
797{
798 float3 P;
799 float3x3 tangent_matrix;
801 reshape_context, grid_coord, P, tangent_matrix);
802
803 const ReshapeConstGridElement orig_grid_element =
804 multires_reshape_orig_grid_element_for_grid_coord(reshape_context, grid_coord);
805
806 float3 D = math::transform_direction(tangent_matrix, orig_grid_element.displacement);
807
809 grid_coord);
810 *grid_element.displacement = P + D;
811
812 if (grid_element.mask != nullptr) {
813 *grid_element.mask = orig_grid_element.mask;
814 }
815}
816
818 const MultiresReshapeContext *reshape_context)
819{
820 /* The final elements are calculated from the original grids. */
821 BLI_assert(reshape_context->orig.mdisps != nullptr);
822
823 foreach_grid_coordinate(reshape_context,
824 reshape_context->top.level,
826 nullptr);
827}
828
830
831} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
bool is_empty() const
Definition BLI_array.hh:275
GAttributeReader lookup(const StringRef name) const
void free(Subdiv *subdiv)
Definition subdiv.cc:192
bool eval_begin_from_mesh(Subdiv *subdiv, const Mesh *mesh, eSubdivEvaluatorType evaluator_type, Span< float3 > coarse_vert_positions={}, OpenSubdiv_EvaluatorCache *evaluator_cache=nullptr)
BLI_INLINE void rotate_grid_to_quad(int corner, float grid_u, float grid_v, float *r_quad_u, float *r_quad_v)
Subdiv * new_from_mesh(const Settings *settings, const Mesh *mesh)
Definition subdiv.cc:133
BLI_INLINE void grid_uv_to_ptex_face_uv(float grid_u, float grid_v, float *r_ptex_u, float *r_ptex_v)
BLI_INLINE void ptex_face_uv_to_grid_uv(float ptex_u, float ptex_v, float *r_grid_u, float *r_grid_v)
BLI_INLINE int grid_size_from_level(int level)
BLI_INLINE int rotate_quad_to_corner(float quad_u, float quad_v, float *r_corner_u, float *r_corner_v)
void eval_limit_point_and_derivatives(Subdiv *subdiv, int ptex_face_index, float u, float v, float3 &r_P, float3 &r_dPdu, float3 &r_dPdv)
Span< int > face_ptex_offset_get(Subdiv *subdiv)
Definition subdiv.cc:216
const Mesh * mesh_get_eval_deform(Depsgraph *depsgraph, const Scene *scene, Object *ob, const CustomData_MeshMasks *dataMask)
T sqrt(const T &a)
CartesianBasis invert(const CartesianBasis &basis)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void multires_reshape_assign_final_coords_from_mdisps(const MultiresReshapeContext *reshape_context)
void multires_reshape_store_original_grids(MultiresReshapeContext *reshape_context)
static bool context_is_valid(MultiresReshapeContext *reshape_context)
const CustomData_MeshMasks CD_MASK_BAREMESH
static void assign_final_coords_from_mdisps(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord, void *)
static void assign_final_elements_from_orig_mdisps(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord, void *)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
BLI_INLINE float D(const float *data, const int res[3], int x, int y, int z)
Definition voxel.cc:16
int multires_reshape_grid_to_face_index(const MultiresReshapeContext *reshape_context, int grid_index)
void multires_reshape_ensure_grids(Mesh *mesh, int level)
bke::subdiv::Subdiv * multires_reshape_create_subdiv(Depsgraph *depsgraph, Object *object, const MultiresModifierData *mmd)
GridCoord multires_reshape_ptex_coord_to_grid(const MultiresReshapeContext *reshape_context, const PTexCoord *ptex_coord)
bool multires_reshape_context_create_from_subdiv(MultiresReshapeContext *reshape_context, Object *object, MultiresModifierData *mmd, bke::subdiv::Subdiv *subdiv, int top_level)
BLI_INLINE void BKE_multires_construct_tangent_matrix(float3x3 &tangent_matrix, const float3 &dPdu, const float3 &dPdv, int corner)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
static void ensure_displacement_grid(MDisps *displacement_grid, const int grid_area)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void multires_reshape_assign_final_elements_from_orig_mdisps(const MultiresReshapeContext *reshape_context)
void BKE_multires_subdiv_settings_init(bke::subdiv::Settings *settings, const MultiresModifierData *mmd)
static bool context_verify_or_free(MultiresReshapeContext *reshape_context)
static void context_init_grid_pointers(MultiresReshapeContext *reshape_context)
ReshapeGridElement multires_reshape_grid_element_for_ptex_coord(const MultiresReshapeContext *reshape_context, const PTexCoord *ptex_coord)
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void multires_reshape_free_original_grids(MultiresReshapeContext *reshape_context)
int multires_reshape_grid_to_corner(const MultiresReshapeContext *reshape_context, int grid_index)
int multires_reshape_grid_to_ptex_index(const MultiresReshapeContext *reshape_context, int grid_index)
static void object_grid_element_to_tangent_displacement(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord, void *)
static void context_init_lookup(MultiresReshapeContext *reshape_context, const bool need_ptex_lookup)
bool multires_reshape_context_create_from_base_mesh(MultiresReshapeContext *reshape_context, Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
static void context_zero(MultiresReshapeContext *reshape_context)
static void context_init_common(MultiresReshapeContext *reshape_context, const bool need_ptex_lookup=true)
void multires_reshape_tangent_matrix_for_corner(const MultiresReshapeContext *reshape_context, int face_index, int corner, const float3 &dPdu, const float3 &dPdv, float3x3 &r_tangent_matrix)
MatBase< float, 3, 3 > float3x3
static void foreach_grid_coordinate(const MultiresReshapeContext *reshape_context, const int level, ForeachGridCoordinateCallback callback, void *userdata_v)
static void foreach_grid_face_coordinate_task(void *__restrict userdata_v, const int face_index, const TaskParallelTLS *__restrict)
int multires_get_level(const Scene *scene, const Object *ob, const MultiresModifierData *mmd, bool render, bool ignore_simplify)
Definition multires.cc:212
bool multires_reshape_context_create_from_object(MultiresReshapeContext *reshape_context, Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
void multires_reshape_context_free(MultiresReshapeContext *reshape_context)
void multires_reshape_object_grids_to_tangent_displacement(const MultiresReshapeContext *reshape_context)
ReshapeGridElement multires_reshape_grid_element_for_grid_coord(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord)
ReshapeConstGridElement multires_reshape_orig_grid_element_for_grid_coord(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord)
void(*)(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord, void *userdata_v) ForeachGridCoordinateCallback
static void ensure_mask_grids(Mesh *mesh, const int level)
static void allocate_displacement_grid(MDisps *displacement_grid, const int grid_area)
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
void multires_reshape_evaluate_base_mesh_limit_at_grid(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord, float3 &r_P, float3x3 &r_tangent_matrix)
VecBase< float, 3 > float3
PTexCoord multires_reshape_grid_coord_to_ptex(const MultiresReshapeContext *reshape_context, const GridCoord *grid_coord)
bool multires_reshape_context_create_from_modifier(MultiresReshapeContext *reshape_context, Object *object, MultiresModifierData *mmd, int top_level)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
bool multires_reshape_context_create_from_ccg(MultiresReshapeContext *reshape_context, SubdivCCG *subdiv_ccg, Mesh *base_mesh, int top_level)
bool multires_reshape_is_quad_face(const MultiresReshapeContext *reshape_context, int face_index)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static void ensure_displacement_grids(Mesh *mesh, const int grid_level)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
const MultiresReshapeContext * reshape_context
KeyBlock * refkey
struct Key * key
CustomData corner_data
struct blender::MultiresReshapeContext::@061205041363017306277142220221215107241001341347 orig
struct blender::MultiresReshapeContext::@021252173372013124221256162374334156074326245244 top
struct blender::MultiresReshapeContext::@034344347246210140240253130013212240027344072112 reshape
bke::subdiv::Subdiv * subdiv