54 float3x3 tangent_matrix = float3x3::identity();
58 Array<SurfacePoint> points = {};
67 Vector<GridCoord> grid_coords = {};
72struct LinearGridElement {
78 MutableSpan<LinearGridElement> elements = {};
89 Array<LinearGrid> grids;
92 Array<LinearGridElement> elements_storage;
98 const MultiresReshapeContext *reshape_context;
102 Array<Vertex> vertices;
105 Array<float> vert_sharpness;
117 Array<float> edge_sharpness;
120 Array<int> corner_verts;
122 Array<int> corner_grid_indices;
125 Array<int> face_offsets;
127 OffsetIndices<int> faces()
const
129 return OffsetIndices<int>(face_offsets, offset_indices::NoSortCheck());
135 LinearGrids linear_delta_grids;
138 BitVector<> loose_base_edges = {};
141 bke::subdiv::Subdiv *reshape_subdiv =
nullptr;
151 Array<SurfaceGrid> base_surface_grids;
161 MultiresReshapeSmoothContext(
const MultiresReshapeContext *reshape_context,
162 const MultiresSubdivideModeType smoothing_type)
163 : reshape_context(reshape_context),
165 linear_delta_grids(),
166 smoothing_type(smoothing_type)
169 ~MultiresReshapeSmoothContext();
172MultiresReshapeSmoothContext::~MultiresReshapeSmoothContext()
174 if (this->reshape_subdiv ==
nullptr) {
186static void linear_grids_allocate(LinearGrids *linear_grids,
int num_grids,
int level)
189 const size_t grid_area = grid_size * grid_size;
190 const size_t num_grid_elements = num_grids * grid_area;
192 linear_grids->num_grids = num_grids;
193 linear_grids->level = level;
194 linear_grids->grid_size = grid_size;
196 linear_grids->grids.reinitialize(num_grids);
197 linear_grids->elements_storage.reinitialize(num_grid_elements);
199 for (
int i = 0; i < num_grids; ++i) {
200 const size_t element_offset = grid_area * i;
201 linear_grids->grids[i].elements = linear_grids->elements_storage.as_mutable_span().slice(
202 element_offset, grid_area);
206static LinearGridElement *linear_grid_element_get(LinearGrids *linear_grids,
210 BLI_assert(grid_coord->grid_index < linear_grids->num_grids);
212 const int grid_size = linear_grids->grid_size;
214 const int grid_x = lround(grid_coord->u * (grid_size - 1));
215 const int grid_y = lround(grid_coord->v * (grid_size - 1));
216 const int grid_element_index = grid_y * grid_size + grid_x;
218 LinearGrid *grid = &linear_grids->grids[grid_coord->grid_index];
219 return &grid->elements[grid_element_index];
222static void linear_grid_element_init(LinearGridElement *linear_grid_element)
224 linear_grid_element->mask = 0.0f;
228static void linear_grid_element_sub(LinearGridElement *
result,
229 const LinearGridElement *a,
230 const LinearGridElement *
b)
232 result->mask = a->mask -
b->mask;
235static void linear_grid_element_interpolate(LinearGridElement *
result,
236 const LinearGridElement elements[4],
237 const float weights[4])
239 result->mask = elements[0].mask * weights[0] + elements[1].mask * weights[1] +
240 elements[2].mask * weights[2] + elements[3].mask * weights[3];
249static void base_surface_grids_allocate(MultiresReshapeSmoothContext *reshape_smooth_context)
253 const int num_grids = reshape_context->num_grids;
254 const int grid_size = reshape_context->top.grid_size;
255 const int grid_area = grid_size * grid_size;
257 reshape_smooth_context->base_surface_grids.reinitialize(num_grids);
259 for (
const int i : reshape_smooth_context->base_surface_grids.index_range()) {
260 reshape_smooth_context->base_surface_grids[i].points.reinitialize(grid_area);
264static SurfacePoint *base_surface_grids_read(MultiresReshapeSmoothContext *reshape_smooth_context,
269 const int grid_index = grid_coord->grid_index;
270 const int grid_size = reshape_context->top.grid_size;
271 const int grid_x = lround(grid_coord->u * (grid_size - 1));
272 const int grid_y = lround(grid_coord->v * (grid_size - 1));
273 const int grid_element_index = grid_y * grid_size + grid_x;
275 SurfaceGrid *surface_grid = &reshape_smooth_context->base_surface_grids[grid_index];
276 return &surface_grid->points[grid_element_index];
279static void base_surface_grids_write(MultiresReshapeSmoothContext *reshape_smooth_context,
284 SurfacePoint *point = base_surface_grids_read(reshape_smooth_context, grid_coord);
286 point->tangent_matrix = tangent_matrix;
296static int get_face_grid_index(
const MultiresReshapeSmoothContext *reshape_smooth_context,
299 const Span<int> corner_grid_indices = reshape_smooth_context->geometry.corner_grid_indices;
300 const int grid_index = corner_grid_indices[face.start()];
303 for (
const int corner_index : face) {
304 BLI_assert(corner_grid_indices[corner_index] == grid_index);
311static std::optional<GridCoord> vert_grid_coord_with_grid_index(
const Vertex *vert,
312 const int grid_index)
314 for (
const int i :
vert->grid_coords.index_range()) {
315 if (
vert->grid_coords[i].grid_index == grid_index) {
316 return vert->grid_coords[i];
324static std::array<std::optional<GridCoord>, 4> grid_coords_from_face_verts(
325 MultiresReshapeSmoothContext *reshape_smooth_context,
const IndexRange face)
327 std::array<std::optional<GridCoord>, 4>
result;
330 const int grid_index = get_face_grid_index(reshape_smooth_context, face);
333 for (
const int i : face.index_range()) {
334 const int corner_index = face[i];
335 const int vert_index = reshape_smooth_context->geometry.corner_verts[corner_index];
336 result[i] = vert_grid_coord_with_grid_index(
337 &reshape_smooth_context->geometry.vertices[vert_index], grid_index);
347static float lerp_f(
float t,
float a,
float b)
349 return (a + t * (
b - a));
352static GridCoord interpolate_grid_coord(
Span<std::optional<GridCoord>> face_grid_coords,
369 const float u01 = lerp_f(u, face_grid_coords[0]->u, face_grid_coords[1]->u);
370 const float u32 = lerp_f(u, face_grid_coords[3]->u, face_grid_coords[2]->u);
372 const float v03 = lerp_f(
v, face_grid_coords[0]->
v, face_grid_coords[3]->
v);
373 const float v12 = lerp_f(
v, face_grid_coords[1]->
v, face_grid_coords[2]->
v);
375 result.grid_index = face_grid_coords[0]->grid_index;
376 result.u = lerp_f(
v, u01, u32);
377 result.v = lerp_f(u, v03, v12);
382static void foreach_toplevel_grid_coord(
383 MultiresReshapeSmoothContext *reshape_smooth_context,
387 const int level_difference = (reshape_context->top.level - reshape_context->reshape.level);
389 const int inner_grid_size = (1 << level_difference) + 1;
390 const float inner_grid_size_1_inv = 1.0f /
float(inner_grid_size - 1);
394 for (const int face_index : range) {
395 const IndexRange face = faces[face_index];
396 std::array<std::optional<GridCoord>, 4> face_grid_coords = grid_coords_from_face_verts(
397 reshape_smooth_context, face);
399 for (int y = 0; y < inner_grid_size; ++y) {
400 const float ptex_v = float(y) * inner_grid_size_1_inv;
401 for (int x = 0; x < inner_grid_size; ++x) {
402 const float ptex_u = float(x) * inner_grid_size_1_inv;
404 PTexCoord ptex_coord;
405 ptex_coord.ptex_face_index = face_index;
406 ptex_coord.u = ptex_u;
407 ptex_coord.v = ptex_v;
409 const GridCoord grid_coord = interpolate_grid_coord(
410 Span(face_grid_coords), ptex_u, ptex_v);
412 callback(&ptex_coord, &grid_coord);
428static int get_reshape_level_resolution(
const MultiresReshapeContext *reshape_context)
430 return (1 << reshape_context->reshape.level) + 1;
433static bool is_crease_supported(
const MultiresReshapeSmoothContext *reshape_smooth_context)
435 return !
ELEM(reshape_smooth_context->smoothing_type,
436 MultiresSubdivideModeType::Linear,
437 MultiresSubdivideModeType::Simple);
442static float get_effective_crease(
const MultiresReshapeSmoothContext *reshape_smooth_context,
443 const int base_edge_index)
445 if (!is_crease_supported(reshape_smooth_context)) {
448 if (reshape_smooth_context->reshape_context->cd_edge_crease.is_empty()) {
451 return reshape_smooth_context->reshape_context->cd_edge_crease[base_edge_index];
454static float get_effective_crease_float(
const MultiresReshapeSmoothContext *reshape_smooth_context,
457 if (!is_crease_supported(reshape_smooth_context)) {
463static bool foreach_topology_info(
const bke::subdiv::ForeachContext *foreach_context,
464 const int num_vertices,
470 MultiresReshapeSmoothContext *reshape_smooth_context =
471 static_cast<MultiresReshapeSmoothContext *
>(foreach_context->user_data);
472 const int max_edges = reshape_smooth_context->smoothing_type ==
473 MultiresSubdivideModeType::Linear ?
475 reshape_smooth_context->geometry.max_edges;
477 reshape_smooth_context->geometry.vertices.reinitialize(num_vertices);
478 reshape_smooth_context->geometry.vert_sharpness = Array<float>(num_vertices, 0.0f);
480 reshape_smooth_context->geometry.max_edges = max_edges;
481 reshape_smooth_context->geometry.edges.reinitialize(max_edges);
482 reshape_smooth_context->geometry.edge_sharpness.reinitialize(max_edges);
484 reshape_smooth_context->geometry.corner_verts.reinitialize(num_loops);
485 reshape_smooth_context->geometry.corner_grid_indices.reinitialize(num_loops);
487 reshape_smooth_context->geometry.face_offsets.reinitialize(num_faces + 1);
488 offset_indices::fill_constant_group_size(4, 0, reshape_smooth_context->geometry.face_offsets);
489 reshape_smooth_context->geometry.face_offsets.last() = num_loops;
494static void foreach_single_vert(
const bke::subdiv::ForeachContext *foreach_context,
495 const GridCoord *grid_coord,
496 const int coarse_vert_index,
497 const int subdiv_vert_index)
499 MultiresReshapeSmoothContext *reshape_smooth_context =
500 static_cast<MultiresReshapeSmoothContext *
>(foreach_context->user_data);
502 BLI_assert(subdiv_vert_index < reshape_smooth_context->geometry.vertices.size());
504 Vertex *
vert = &reshape_smooth_context->geometry.vertices[subdiv_vert_index];
506 vert->grid_coords.append(*grid_coord);
508 if (coarse_vert_index == -1) {
512 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
513 if (reshape_context->cd_vert_crease.is_empty()) {
517 float crease = reshape_context->cd_vert_crease[coarse_vert_index];
518 if (crease == 0.0f) {
522 crease = get_effective_crease_float(reshape_smooth_context, crease);
523 reshape_smooth_context->geometry.vert_sharpness[subdiv_vert_index] =
524 bke::subdiv::crease_to_sharpness(crease);
528static void foreach_vert(
const bke::subdiv::ForeachContext *foreach_context,
529 const PTexCoord *ptex_coord,
530 const int coarse_vert_index,
531 const int subdiv_vert_index)
533 const MultiresReshapeSmoothContext *reshape_smooth_context =
534 static_cast<const MultiresReshapeSmoothContext *
>(foreach_context->user_data);
535 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
539 grid_coord.grid_index);
541 const int num_corners = reshape_context->base_faces[face_index].size();
542 const int start_grid_index = reshape_context->base_faces[face_index].start();
543 const int corner = grid_coord.grid_index - start_grid_index;
545 if (grid_coord.u == 0.0f && grid_coord.v == 0.0f) {
546 for (
int current_corner = 0; current_corner < num_corners; ++current_corner) {
547 GridCoord corner_grid_coord = grid_coord;
548 corner_grid_coord.grid_index = start_grid_index + current_corner;
550 foreach_context, &corner_grid_coord, coarse_vert_index, subdiv_vert_index);
555 foreach_single_vert(foreach_context, &grid_coord, coarse_vert_index, subdiv_vert_index);
557 if (grid_coord.u == 0.0f) {
558 GridCoord prev_grid_coord;
559 prev_grid_coord.grid_index = start_grid_index + ((corner + num_corners - 1) % num_corners);
560 prev_grid_coord.u = grid_coord.v;
561 prev_grid_coord.v = 0.0f;
563 foreach_single_vert(foreach_context, &prev_grid_coord, coarse_vert_index, subdiv_vert_index);
566 if (grid_coord.v == 0.0f) {
567 GridCoord next_grid_coord;
568 next_grid_coord.grid_index = start_grid_index + ((corner + 1) % num_corners);
569 next_grid_coord.u = 0.0f;
570 next_grid_coord.v = grid_coord.u;
572 foreach_single_vert(foreach_context, &next_grid_coord, coarse_vert_index, subdiv_vert_index);
576static void foreach_vert_inner(
const bke::subdiv::ForeachContext *foreach_context,
578 const int ptex_face_index,
579 const float ptex_face_u,
580 const float ptex_face_v,
583 const int subdiv_vert_index)
585 PTexCoord ptex_coord{};
586 ptex_coord.ptex_face_index = ptex_face_index;
587 ptex_coord.u = ptex_face_u;
588 ptex_coord.v = ptex_face_v;
589 foreach_vert(foreach_context, &ptex_coord, -1, subdiv_vert_index);
592static void foreach_vert_every_corner(
const bke::subdiv::ForeachContext *foreach_context,
594 const int ptex_face_index,
595 const float ptex_face_u,
596 const float ptex_face_v,
597 const int coarse_vert_index,
600 const int subdiv_vert_index)
602 PTexCoord ptex_coord{};
603 ptex_coord.ptex_face_index = ptex_face_index;
604 ptex_coord.u = ptex_face_u;
605 ptex_coord.v = ptex_face_v;
606 foreach_vert(foreach_context, &ptex_coord, coarse_vert_index, subdiv_vert_index);
609static void foreach_vert_every_edge(
const bke::subdiv::ForeachContext *foreach_context,
611 const int ptex_face_index,
612 const float ptex_face_u,
613 const float ptex_face_v,
617 const int subdiv_vert_index)
619 PTexCoord ptex_coord{};
620 ptex_coord.ptex_face_index = ptex_face_index;
621 ptex_coord.u = ptex_face_u;
622 ptex_coord.v = ptex_face_v;
623 foreach_vert(foreach_context, &ptex_coord, -1, subdiv_vert_index);
626static void foreach_loop(
const bke::subdiv::ForeachContext *foreach_context,
632 const int coarse_face_index,
633 const int coarse_corner,
634 const int subdiv_loop_index,
635 const int subdiv_vert_index,
638 MultiresReshapeSmoothContext *reshape_smooth_context =
639 static_cast<MultiresReshapeSmoothContext *
>(foreach_context->user_data);
640 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
642 auto &geometry = reshape_smooth_context->geometry;
643 BLI_assert(subdiv_loop_index < geometry.corner_verts.size());
645 geometry.corner_verts[subdiv_loop_index] = subdiv_vert_index;
647 const int first_grid_index = reshape_context->base_faces[coarse_face_index].start();
648 geometry.corner_grid_indices[subdiv_loop_index] = first_grid_index + coarse_corner;
651static void foreach_vert_of_loose_edge(
const bke::subdiv::ForeachContext *foreach_context,
655 const int vert_index)
657 MultiresReshapeSmoothContext *reshape_smooth_context =
658 static_cast<MultiresReshapeSmoothContext *
>(foreach_context->user_data);
662 if (!reshape_smooth_context->geometry.vertices[vert_index].grid_coords.is_empty()) {
667static void store_edge(MultiresReshapeSmoothContext *reshape_smooth_context,
675 BLI_assert(edge_index < reshape_smooth_context->geometry.max_edges);
677 reshape_smooth_context->geometry.edges[edge_index] =
int2(subdiv_v1, subdiv_v2);
678 reshape_smooth_context->geometry.edge_sharpness[edge_index] = bke::subdiv::crease_to_sharpness(
682static void foreach_edge(
const bke::subdiv::ForeachContext *foreach_context,
684 const int coarse_edge_index,
690 MultiresReshapeSmoothContext *reshape_smooth_context =
691 static_cast<MultiresReshapeSmoothContext *
>(foreach_context->user_data);
693 if (reshape_smooth_context->smoothing_type == MultiresSubdivideModeType::Linear) {
695 store_edge(reshape_smooth_context, subdiv_v1, subdiv_v2, 1.0f);
705 if (!reshape_smooth_context->loose_base_edges.is_empty()) {
706 if (reshape_smooth_context->loose_base_edges[coarse_edge_index]) {
711 const float crease = get_effective_crease(reshape_smooth_context, coarse_edge_index);
712 if (crease == 0.0f) {
715 store_edge(reshape_smooth_context, subdiv_v1, subdiv_v2, crease);
718static void geometry_init_loose_information(MultiresReshapeSmoothContext *reshape_smooth_context)
720 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
721 const Mesh *base_mesh = reshape_context->base_mesh;
723 const IndexMask &loose_edges = base_mesh->loose_edges();
724 if (!loose_edges.is_empty()) {
725 reshape_smooth_context->loose_base_edges.resize(base_mesh->edges_num);
726 loose_edges.to_bits(reshape_smooth_context->loose_base_edges);
729 IndexMaskMemory memory;
730 const IndexMask non_loose_edges = loose_edges.complement(IndexRange(base_mesh->edges_num),
732 int num_used_edges = 0;
733 non_loose_edges.foreach_index([&](
const int edge) {
734 const float crease = get_effective_crease(reshape_smooth_context, edge);
735 if (crease == 0.0f) {
741 const int resolution = get_reshape_level_resolution(reshape_context);
742 const int num_subdiv_vertices_per_base_edge = resolution - 2;
743 reshape_smooth_context->geometry.max_edges = num_used_edges *
744 (num_subdiv_vertices_per_base_edge + 1);
747static void geometry_create(MultiresReshapeSmoothContext *reshape_smooth_context)
749 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
751 bke::subdiv::ForeachContext foreach_context{};
752 foreach_context.topology_info = foreach_topology_info;
753 foreach_context.vert_inner = foreach_vert_inner;
754 foreach_context.vert_every_corner = foreach_vert_every_corner;
755 foreach_context.vert_every_edge = foreach_vert_every_edge;
756 foreach_context.loop = foreach_loop;
757 foreach_context.vert_of_loose_edge = foreach_vert_of_loose_edge;
758 foreach_context.edge = foreach_edge;
759 foreach_context.user_data = reshape_smooth_context;
761 geometry_init_loose_information(reshape_smooth_context);
763 bke::subdiv::ToMeshSettings mesh_settings;
764 mesh_settings.resolution = get_reshape_level_resolution(reshape_context);
765 mesh_settings.use_optimal_display =
false;
768 bke::subdiv::foreach_subdiv_geometry(
769 reshape_context->subdiv, &foreach_context, &mesh_settings, reshape_context->base_mesh);
783static void converter_init(
const MultiresReshapeSmoothContext *reshape_smooth_context,
786 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
787 const bke::subdiv::Settings &settings = reshape_context->subdiv->settings;
791 bke::subdiv::converter_vtx_boundary_interpolation_from_settings(&settings));
793 bke::subdiv::converter_fvar_linear_from_settings(&settings));
796 converter->
verts_num = reshape_smooth_context->geometry.vertices.size();
799 const int edges_num = int(reshape_smooth_context->geometry.num_edges);
800 converter->
edges = reshape_smooth_context->geometry.edges.as_span()
801 .take_front(edges_num)
802 .cast<std::pair<int, int>>();
803 converter->
face_offsets = reshape_smooth_context->geometry.face_offsets.as_span();
804 converter->
corner_verts = reshape_smooth_context->geometry.corner_verts;
805 converter->
edge_sharpness = reshape_smooth_context->geometry.edge_sharpness.as_span().take_front(
807 converter->
vert_sharpness = reshape_smooth_context->geometry.vert_sharpness;
827 converter->
user_data = (
void *)reshape_smooth_context;
831static void reshape_subdiv_create(MultiresReshapeSmoothContext *reshape_smooth_context)
833 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
834 const bke::subdiv::Settings *settings = &reshape_context->subdiv->settings;
837 converter_init(reshape_smooth_context, &converter);
839 bke::subdiv::Subdiv *reshape_subdiv = bke::subdiv::new_from_converter(settings, &converter);
842 bke::subdiv::eval_begin(
843 reshape_subdiv, bke::subdiv::SUBDIV_EVALUATOR_TYPE_CPU,
nullptr, &evaluator_settings);
845 reshape_smooth_context->reshape_subdiv = reshape_subdiv;
847 bke::subdiv::converter_free(&converter);
851using ReshapeSubdivCoarsePositionCb = void(
852 const MultiresReshapeSmoothContext *reshape_smooth_context,
const Vertex *vert,
float3 &r_P);
855static void reshape_subdiv_refine(
const MultiresReshapeSmoothContext *reshape_smooth_context,
856 ReshapeSubdivCoarsePositionCb coarse_position_cb)
858 bke::subdiv::Subdiv *reshape_subdiv = reshape_smooth_context->reshape_subdiv;
862 const int num_vertices = reshape_smooth_context->geometry.vertices.size();
863 for (
int i = 0; i < num_vertices; ++i) {
864 const Vertex *
vert = &reshape_smooth_context->geometry.vertices[i];
866 coarse_position_cb(reshape_smooth_context, vert,
P);
867 reshape_subdiv->evaluator->eval_output->setCoarsePositions(
P, i, 1);
869 reshape_subdiv->evaluator->eval_output->refine();
872BLI_INLINE const GridCoord *reshape_subdiv_refine_vert_grid_coord(
const Vertex *vert)
874 if (
vert->grid_coords.is_empty()) {
882 return vert->grid_coords.data();
886static void reshape_subdiv_refine_orig_P(
887 const MultiresReshapeSmoothContext *reshape_smooth_context,
const Vertex *vert,
float3 &r_P)
889 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
890 const GridCoord *grid_coord = reshape_subdiv_refine_vert_grid_coord(vert);
893 if (grid_coord ==
nullptr) {
901 reshape_context, grid_coord, limit_P, tangent_matrix);
903 const ReshapeConstGridElement orig_grid_element =
906 const float3 D = math::transform_direction(tangent_matrix, orig_grid_element.displacement);
910static void reshape_subdiv_refine_orig(
const MultiresReshapeSmoothContext *reshape_smooth_context)
912 reshape_subdiv_refine(reshape_smooth_context, reshape_subdiv_refine_orig_P);
916static void reshape_subdiv_refine_final_P(
917 const MultiresReshapeSmoothContext *reshape_smooth_context,
const Vertex *vert,
float3 &r_P)
919 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
920 const GridCoord *grid_coord = reshape_subdiv_refine_vert_grid_coord(vert);
923 if (grid_coord ==
nullptr) {
929 reshape_context, grid_coord);
933 r_P = *grid_element.displacement;
935static void reshape_subdiv_refine_final(
const MultiresReshapeSmoothContext *reshape_smooth_context)
937 reshape_subdiv_refine(reshape_smooth_context, reshape_subdiv_refine_final_P);
940static void reshape_subdiv_evaluate_limit_at_grid(
941 const MultiresReshapeSmoothContext *reshape_smooth_context,
942 const PTexCoord *ptex_coord,
943 const GridCoord *grid_coord,
947 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
951 bke::subdiv::eval_limit_point_and_derivatives(reshape_smooth_context->reshape_subdiv,
952 ptex_coord->ptex_face_index,
960 grid_coord->grid_index);
963 reshape_context, face_index, corner, dPdu, dPdv, r_tangent_matrix);
972static LinearGridElement linear_grid_element_orig_get(
973 const MultiresReshapeSmoothContext *reshape_smooth_context,
const GridCoord *grid_coord)
975 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
976 const ReshapeConstGridElement orig_grid_element =
979 LinearGridElement linear_grid_element;
980 linear_grid_element_init(&linear_grid_element);
982 linear_grid_element.mask = orig_grid_element.mask;
984 return linear_grid_element;
987static LinearGridElement linear_grid_element_final_get(
988 const MultiresReshapeSmoothContext *reshape_smooth_context,
const GridCoord *grid_coord)
990 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
992 reshape_context, grid_coord);
994 LinearGridElement linear_grid_element;
995 linear_grid_element_init(&linear_grid_element);
997 if (final_grid_element.mask !=
nullptr) {
998 linear_grid_element.mask = *final_grid_element.mask;
1001 return linear_grid_element;
1009static void linear_grid_element_delta_interpolate(
1010 const MultiresReshapeSmoothContext *reshape_smooth_context,
1011 const GridCoord *grid_coord,
1012 LinearGridElement *result)
1014 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1016 const int reshape_level = reshape_context->reshape.level;
1017 const int reshape_level_grid_size = bke::subdiv::grid_size_from_level(reshape_level);
1018 const int reshape_level_grid_size_1 = reshape_level_grid_size - 1;
1019 const float reshape_level_grid_size_1_inv = 1.0f /
float(reshape_level_grid_size_1);
1021 const float x_f = grid_coord->u * reshape_level_grid_size_1;
1022 const float y_f = grid_coord->v * reshape_level_grid_size_1;
1024 const int x_i = x_f;
1025 const int y_i = y_f;
1026 const int x_n_i = (x_i == reshape_level_grid_size - 1) ? (x_i) : (x_i + 1);
1027 const int y_n_i = (y_i == reshape_level_grid_size - 1) ? (y_i) : (y_i + 1);
1029 const int corners_int_coords[4][2] = {{x_i, y_i}, {x_n_i, y_i}, {x_n_i, y_n_i}, {x_i, y_n_i}};
1031 LinearGridElement corner_elements[4];
1032 for (
int i = 0; i < 4; ++i) {
1033 GridCoord corner_grid_coord;
1034 corner_grid_coord.grid_index = grid_coord->grid_index;
1035 corner_grid_coord.u = corners_int_coords[i][0] * reshape_level_grid_size_1_inv;
1036 corner_grid_coord.v = corners_int_coords[i][1] * reshape_level_grid_size_1_inv;
1038 const LinearGridElement orig_element = linear_grid_element_orig_get(reshape_smooth_context,
1039 &corner_grid_coord);
1040 const LinearGridElement final_element = linear_grid_element_final_get(reshape_smooth_context,
1041 &corner_grid_coord);
1042 linear_grid_element_sub(&corner_elements[i], &final_element, &orig_element);
1045 const float u = x_f - x_i;
1046 const float v = y_f - y_i;
1047 const float weights[4] = {(1.0f - u) * (1.0f - v), u * (1.0f -
v), u * v, (1.0f - u) *
v};
1049 linear_grid_element_interpolate(result, corner_elements, weights);
1052static void evaluate_linear_delta_grids(MultiresReshapeSmoothContext *reshape_smooth_context)
1054 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1055 const int num_grids = reshape_context->num_grids;
1056 const int top_level = reshape_context->top.level;
1058 linear_grids_allocate(&reshape_smooth_context->linear_delta_grids, num_grids, top_level);
1060 foreach_toplevel_grid_coord(reshape_smooth_context,
1061 [&](
const PTexCoord * ,
const GridCoord *grid_coord) {
1062 LinearGridElement *linear_delta_element = linear_grid_element_get(
1063 &reshape_smooth_context->linear_delta_grids, grid_coord);
1065 linear_grid_element_delta_interpolate(
1066 reshape_smooth_context, grid_coord, linear_delta_element);
1070static void propagate_linear_data_delta(MultiresReshapeSmoothContext *reshape_smooth_context,
1071 ReshapeGridElement *final_grid_element,
1072 const GridCoord *grid_coord)
1074 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1076 LinearGridElement *linear_delta_element = linear_grid_element_get(
1077 &reshape_smooth_context->linear_delta_grids, grid_coord);
1079 const ReshapeConstGridElement orig_grid_element =
1082 if (final_grid_element->mask !=
nullptr) {
1083 *final_grid_element->mask =
clamp_f(
1084 orig_grid_element.mask + linear_delta_element->mask, 0.0f, 1.0f);
1094static void evaluate_base_surface_grids(MultiresReshapeSmoothContext *reshape_smooth_context)
1096 foreach_toplevel_grid_coord(
1097 reshape_smooth_context, [&](
const PTexCoord *ptex_coord,
const GridCoord *grid_coord) {
1100 reshape_subdiv_evaluate_limit_at_grid(
1101 reshape_smooth_context, ptex_coord, grid_coord, limit_P, tangent_matrix);
1103 base_surface_grids_write(reshape_smooth_context, grid_coord, limit_P, tangent_matrix);
1115static void evaluate_final_original_point(
1116 const MultiresReshapeSmoothContext *reshape_smooth_context,
1117 const GridCoord *grid_coord,
1120 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1123 const ReshapeConstGridElement orig_grid_element =
1127 float3 base_mesh_limit_P;
1130 reshape_context, grid_coord, base_mesh_limit_P, base_mesh_tangent_matrix);
1133 const float3 orig_displacement = math::transform_direction(base_mesh_tangent_matrix,
1134 orig_grid_element.displacement);
1137 r_orig_final_P = base_mesh_limit_P + orig_displacement;
1140static void evaluate_higher_grid_positions_with_details(
1141 MultiresReshapeSmoothContext *reshape_smooth_context)
1143 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1144 foreach_toplevel_grid_coord(
1145 reshape_smooth_context, [&](
const PTexCoord *ptex_coord,
const GridCoord *grid_coord) {
1148 evaluate_final_original_point(reshape_smooth_context, grid_coord, orig_final_P);
1151 const SurfacePoint *orig_sculpt_point = base_surface_grids_read(reshape_smooth_context,
1155 const float3 original_detail_delta = orig_final_P - orig_sculpt_point->P;
1159 const float3x3 original_sculpt_tangent_matrix_inv = math::invert(
1160 orig_sculpt_point->tangent_matrix);
1161 float3 original_detail_delta_tangent = math::transform_direction(
1162 original_sculpt_tangent_matrix_inv, original_detail_delta);
1167 reshape_subdiv_evaluate_limit_at_grid(
1168 reshape_smooth_context, ptex_coord, grid_coord, smooth_limit_P, smooth_tangent_matrix);
1171 float3 smooth_delta = math::transform_direction(smooth_tangent_matrix,
1172 original_detail_delta_tangent);
1178 reshape_context, grid_coord);
1180 *grid_element.displacement = smooth_limit_P + smooth_delta;
1183 propagate_linear_data_delta(reshape_smooth_context, &grid_element, grid_coord);
1187static void evaluate_higher_grid_positions(MultiresReshapeSmoothContext *reshape_smooth_context)
1189 const MultiresReshapeContext *reshape_context = reshape_smooth_context->reshape_context;
1190 foreach_toplevel_grid_coord(
1191 reshape_smooth_context, [&](
const PTexCoord *ptex_coord,
const GridCoord *grid_coord) {
1192 bke::subdiv::Subdiv *reshape_subdiv = reshape_smooth_context->reshape_subdiv;
1195 reshape_context, grid_coord);
1198 const float3 P = bke::subdiv::eval_limit_point(
1199 reshape_subdiv, ptex_coord->ptex_face_index, ptex_coord->u, ptex_coord->v);
1201 *grid_element.displacement =
P;
1204 propagate_linear_data_delta(reshape_smooth_context, &grid_element, grid_coord);
1219#ifdef WITH_OPENSUBDIV
1220 const int level_difference = (reshape_context->
top.level - reshape_context->
reshape.level);
1221 if (level_difference == 0) {
1229 MultiresReshapeSmoothContext reshape_smooth_context(reshape_context, smoothing_type);
1230 geometry_create(&reshape_smooth_context);
1231 evaluate_linear_delta_grids(&reshape_smooth_context);
1233 reshape_subdiv_create(&reshape_smooth_context);
1235 base_surface_grids_allocate(&reshape_smooth_context);
1236 reshape_subdiv_refine_orig(&reshape_smooth_context);
1237 evaluate_base_surface_grids(&reshape_smooth_context);
1239 reshape_subdiv_refine_final(&reshape_smooth_context);
1240 evaluate_higher_grid_positions_with_details(&reshape_smooth_context);
1249#ifdef WITH_OPENSUBDIV
1250 const int level_difference = (reshape_context->
top.level - reshape_context->
reshape.level);
1251 if (level_difference == 0) {
1256 MultiresReshapeSmoothContext reshape_smooth_context(reshape_context, mode);
1257 geometry_create(&reshape_smooth_context);
1258 evaluate_linear_delta_grids(&reshape_smooth_context);
1260 reshape_subdiv_create(&reshape_smooth_context);
1262 reshape_subdiv_refine_final(&reshape_smooth_context);
1263 evaluate_higher_grid_positions(&reshape_smooth_context);
CustomData interface, see also DNA_customdata_types.h.
Read Blender memory allocation and freeing.
Provides wrapper around system-specific atomic primitives, and some extensions (faked-atomic operatio...
ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x)
VecBase< float, 3 > float3
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
void free(Subdiv *subdiv)
BLI_INLINE int grid_size_from_level(int level)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void multires_reshape_smooth_object_grids(const MultiresReshapeContext *reshape_context, MultiresSubdivideModeType mode)
int multires_reshape_grid_to_face_index(const MultiresReshapeContext *reshape_context, int grid_index)
void multires_reshape_smooth_object_grids_with_details(const MultiresReshapeContext *reshape_context)
GridCoord multires_reshape_ptex_coord_to_grid(const MultiresReshapeContext *reshape_context, const PTexCoord *ptex_coord)
ATTR_WARN_UNUSED_RESULT const BMVert * v
int multires_reshape_grid_to_corner(const MultiresReshapeContext *reshape_context, int grid_index)
MultiresSubdivideModeType
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
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 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
MINLINE float clamp_f(float value, float min, float max)
void vert(const int vert_id, float4 &position)
OpenSubdiv_FVarLinearInterpolation
OpenSubdiv_VtxBoundaryInterpolation
constexpr float OPENSUBDIV_SHARPNESS_INFINITE
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void(*) getFaceEdges(const OpenSubdiv_Converter *converter, const int face_index, int *face_edges)
OpenSubdiv_VtxBoundaryInterpolation vtx_boundary_interpolation
std::span< const float > edge_sharpness
OpenSubdiv_FVarLinearInterpolation fvar_linear_interpolation
std::span< const float > vert_sharpness
void(*) getVertexEdges(const OpenSubdiv_Converter *converter, const int vertex_index, int *vertex_edges)
int(*) getNumUVCoordinates(const OpenSubdiv_Converter *converter)
OpenSubdiv_SchemeType scheme_type
void(*) getVertexFaces(const OpenSubdiv_Converter *converter, const int vertex_index, int *vertex_faces)
int(*) getNumVertexFaces(const OpenSubdiv_Converter *converter, const int vertex_index)
std::span< const int > face_offsets
std::span< const std::pair< int, int > > edges
void(*) precalcUVLayer(const OpenSubdiv_Converter *converter, const int layer_index)
void(*) getEdgeFaces(const OpenSubdiv_Converter *converter, const int edge, int *edge_faces)
int(*) getNumVertexEdges(const OpenSubdiv_Converter *converter, const int vertex_index)
int(*) getNumUVLayers(const OpenSubdiv_Converter *converter)
std::span< const int > corner_verts
int(*) getFaceCornerUVIndex(const OpenSubdiv_Converter *converter, const int face_index, const int corner_index)
int(*) getNumEdgeFaces(const OpenSubdiv_Converter *converter, const int edge_index)
bool(*) specifiesFullTopology(const OpenSubdiv_Converter *converter)
void(*) finishUVLayer(const OpenSubdiv_Converter *converter)
void(*) freeUserData(const OpenSubdiv_Converter *converter)
struct blender::MultiresReshapeContext::@021252173372013124221256162374334156074326245244 top
bke::subdiv::Subdiv * subdiv
struct blender::MultiresReshapeContext::@034344347246210140240253130013212240027344072112 reshape