Blender V5.3
pbvh_pixels.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10
11#include "BKE_attribute.hh"
12#include "BKE_customdata.hh"
13#include "BKE_mesh.hh"
14#include "BKE_paint_bvh.hh"
16
17#include "DNA_image_types.h"
18#include "DNA_object_types.h"
19
20#include "BLI_listbase.hh"
21#include "BLI_math_geom_c.hh"
23#include "BLI_math_vector_c.hh"
24
25#include "BKE_image_wrappers.hh"
26#include "BKE_paint.hh"
27
28#include "IMB_partial_update.hh"
29
30#include "PRF_profile.hh"
31
32#include "pbvh_intern.hh"
33#include "pbvh_pixels_copy.hh"
35#include "pbvh_uv_islands.hh"
36
37#include <algorithm>
38
39namespace blender {
40
41namespace bke::pbvh::pixels {
42
47 const int tri,
48 const float2 uvs[3],
49 const float inv_w,
50 const float inv_h)
51{
52 const int3 &corner_tri = mesh_data.corner_tris[tri];
53 const float3 v0 = mesh_data.vert_positions[mesh_data.corner_verts[corner_tri[0]]];
54 const float3 v1 = mesh_data.vert_positions[mesh_data.corner_verts[corner_tri[1]]];
55 const float3 v2 = mesh_data.vert_positions[mesh_data.corner_verts[corner_tri[2]]];
56
57 /* Solve for coefficient so that:
58 * P = pixel_to_position * (pixel_x, pixel_y, 1) */
59 const float3 e0 = v0 - v2;
60 const float3 e1 = v1 - v2;
61 const float2 a = uvs[0] - uvs[2];
62 const float2 b = uvs[1] - uvs[2];
63 const float det = a.x * b.y - a.y * b.x;
64 if (det == 0.0f) {
65 /* Degenerate UV triangle. */
66 return float3x3(float3(0.0f), float3(0.0f), v2);
67 }
68
69 const float3 dP_du = (b.y * e0 - a.y * e1) / det;
70 const float3 dP_dv = (a.x * e1 - b.x * e0) / det;
71
72 /* Per-pixel steps, and the position at pixel (0, 0), i.e. uv (0.5 / w, 0.5 / h). */
73 const float3 delta_x = dP_du * inv_w;
74 const float3 delta_y = dP_dv * inv_h;
75 const float3 start_position = dP_du * (0.5f * inv_w - uvs[2].x) +
76 dP_dv * (0.5f * inv_h - uvs[2].y) + v2;
77
78 return float3x3(delta_x, delta_y, start_position);
79}
80
85constexpr bool USE_WATERTIGHT_CHECK = false;
86
93
95 const ImBuf *image_buffer,
96 const uv_islands::UVIslandsMask::Tile &mask_tile,
97 const int uv_island_index,
98 const int uv_primitive_index,
99 const float2 uvs[3])
100{
101 const float inv_w = 1.0f / image_buffer->x;
102 const float inv_h = 1.0f / image_buffer->y;
103
104 const int mask_resolution_x = mask_tile.mask_resolution.x;
105 const int mask_resolution_y = mask_tile.mask_resolution.y;
106 const float mask_scale_x = mask_resolution_x * inv_w;
107 const float mask_scale_y = mask_resolution_y * inv_h;
108
109 const int2 image_size(image_buffer->x, image_buffer->y);
110 const TriRasterizer rasterizer(uvs[0], uvs[1], uvs[2], image_size);
111 const Bounds<int2> bounds = rasterizer.bounds;
112
113 for (int y = bounds.min.y; y < bounds.max.y; y++) {
114 bool start_detected = false;
115 BuildPixelRow pixel_row;
116 pixel_row.uv_primitive_index = uv_primitive_index;
117 pixel_row.num_pixels = 0;
118 int x;
119
120 const float fy = float(y) + 0.5f;
121 const int mask_y = std::clamp(int(fy * mask_scale_y), 0, mask_resolution_y - 1);
122
123 for (x = bounds.min.x; x < bounds.max.x; x++) {
124 const float fx = float(x) + 0.5f;
125
126 /* The mask UV is always in range, since loop pixels are inside the clamped bounding box. */
127 const int mask_x = std::clamp(int(fx * mask_scale_x), 0, mask_resolution_x - 1);
128 const bool is_masked = mask_tile.is_masked(uv_island_index, mask_x, mask_y);
129 const bool is_inside = rasterizer.inside(x, y);
130
131 if (!start_detected && is_inside && is_masked) {
132 start_detected = true;
133 pixel_row.start_image_coordinate = ushort2(x, y);
134 }
135 else if (start_detected && (!is_inside || !is_masked)) {
136 break;
137 }
138 }
139
140 if (!start_detected) {
141 continue;
142 }
143 pixel_row.num_pixels = x - pixel_row.start_image_coordinate.x;
144 build_rows.append(pixel_row);
145 }
146}
147
153
159 const uv_islands::MeshData &mesh_data,
160 const int64_t geom_primitive_len,
162 Array<int> &r_offsets,
163 Array<BorderTriangle> &r_data)
164{
165 /* Count border extension triangles per original triangle. */
166 r_offsets = Array<int>(geom_primitive_len + 1, 0);
167 for (const uv_islands::UVIsland &uv_island : uv_islands) {
168 for (int64_t i = uv_island.num_original_primitives; i < uv_island.uv_primitives.size(); i++) {
169 r_offsets[uv_island.uv_primitives[i].primitive_i]++;
170 }
171 }
173
174 /* Fill in the border triangles grouped by original triangle. */
175 r_data.reinitialize(offsets.total_size());
176 Array<int> current_offset(r_offsets.as_span().drop_back(1));
177 for (const int uv_island_index : uv_islands.index_range()) {
178 uv_islands::UVIsland &uv_island = uv_islands[uv_island_index];
179 for (int64_t i = uv_island.num_original_primitives; i < uv_island.uv_primitives.size(); i++) {
180 const uv_islands::UVPrimitive &uv_primitive = uv_island.uv_primitives[i];
181 BorderTriangle border_tri;
182 border_tri.uv_island_index = uv_island_index;
183 for (int k = 0; k < 3; k++) {
184 border_tri.uvs[k] =
185 uv_island.uv_verts[uv_primitive.get_uv_vert(uv_island, mesh_data, k)].uv;
186 }
187 r_data[current_offset[uv_primitive.primitive_i]++] = border_tri;
188 }
189 }
190
191 return GroupedSpan<BorderTriangle>(offsets, r_data);
192}
193
195{
196 const int n = build_rows.size();
197
198 /* Sort pixel rows by (y, x), to group contiguous pixel rows runs from adjacent triangles.
199 * Stable sort for deterministic results with overlapping triangles. */
200 std::ranges::stable_sort(build_rows, [](const BuildPixelRow &a, const BuildPixelRow &b) {
201 if (a.start_image_coordinate.y != b.start_image_coordinate.y) {
202 return a.start_image_coordinate.y < b.start_image_coordinate.y;
203 }
204 return a.start_image_coordinate.x < b.start_image_coordinate.x;
205 });
206
207 /* Build runs of packed rows from build rows. */
208 tile_data.pixel_rows.reserve(n);
209 tile_data.pixel_row_run_starts.clear();
210 tile_data.pixel_row_run_start_coords.clear();
211 for (const int i : build_rows.index_range()) {
212 const BuildPixelRow &build_row = build_rows[i];
213 if (i == 0) {
214 tile_data.pixel_row_run_starts.append(0);
215 tile_data.pixel_row_run_start_coords.append(build_row.start_image_coordinate);
216 }
217 else {
218 const BuildPixelRow &prev = build_rows[i - 1];
219 const bool contiguous = build_row.start_image_coordinate.y ==
220 prev.start_image_coordinate.y &&
221 build_row.start_image_coordinate.x ==
222 prev.start_image_coordinate.x + prev.num_pixels;
223 if (!contiguous) {
224 tile_data.pixel_row_run_starts.append(i);
225 tile_data.pixel_row_run_start_coords.append(build_row.start_image_coordinate);
226 }
227 }
228 tile_data.pixel_rows.append({build_row.num_pixels, build_row.uv_primitive_index});
229 }
230 tile_data.pixel_row_run_starts.append(n);
231}
232
237template<typename Fn>
238inline void foreach_uv_triangle(const uv_islands::MeshData &mesh_data,
239 const GroupedSpan<BorderTriangle> border_tris,
240 const int tri,
241 Fn &&fn)
242{
243 const int3 &corner_tri = mesh_data.corner_tris[tri];
244 const float2 uvs[3] = {mesh_data.uv_map[corner_tri[0]],
245 mesh_data.uv_map[corner_tri[1]],
246 mesh_data.uv_map[corner_tri[2]]};
247 fn(uvs, int(mesh_data.uv_island_ids[tri]));
248
249 for (const BorderTriangle &border_tri : border_tris[tri]) {
250 fn(border_tri.uvs, border_tri.uv_island_index);
251 }
252}
253
254static void do_encode_pixels(const uv_islands::MeshData &mesh_data,
255 const uv_islands::UVIslandsMask &uv_masks,
256 const GroupedSpan<BorderTriangle> border_tris,
257 Image &image,
258 const ImageUser &image_user,
259 MeshNode &node,
260 PixelNode &pixel_node)
261{
263 BLI_assert(pixel_node.flags.rebuild || (pixel_node.uv_primitives.tri_indices.is_empty() &&
264 pixel_node.uv_primitives.pixel_to_position.is_empty() &&
265 pixel_node.tiles.is_empty()));
266
267 Vector<int> tri_indices;
268 Vector<float3x3> pixel_to_position;
269
270 /* Assuming a quad mesh, we'll have at least 2 * faces entries. */
271 tri_indices.reserve(node.faces().size() * 2);
272 pixel_to_position.reserve(node.faces().size() * 2);
273
274 /* For multiple UDIM tiles, compute which ones this node overlaps with. */
275 const bool multi_tile = BLI_listbase_count(&image.tiles) > 1;
276 Vector<int2, 8> node_tiles;
277 if (multi_tile) {
278 int2 tiles_min(INT_MAX);
279 int2 tiles_max(INT_MIN);
280 for (ImageTile &tile : image.tiles) {
281 math::min_max(image::ImageTileWrapper(&tile).get_tile_offset(), tiles_min, tiles_max);
282 }
283
284 for (const int face : node.faces()) {
285 for (const int tri : bke::mesh::face_triangles_range(mesh_data.faces, face)) {
287 mesh_data, border_tris, tri, [&](const float2 uvs[3], const int /*island_index*/) {
288 float2 uv_min(FLT_MAX);
289 float2 uv_max(-FLT_MAX);
290 for (int i = 0; i < 3; i++) {
291 uv_min = math::min(uv_min, uvs[i]);
292 uv_max = math::max(uv_max, uvs[i]);
293 }
294 /* Bound by UDIM tiles to guard against very large UV coordinates. */
295 const int2 tile_min = math::clamp(int2(math::floor(uv_min)), tiles_min, tiles_max);
296 const int2 tile_max = math::clamp(int2(math::floor(uv_max)), tiles_min, tiles_max);
297 for (int ty = tile_min.y; ty <= tile_max.y; ty++) {
298 for (int tx = tile_min.x; tx <= tile_max.x; tx++) {
299 node_tiles.append_non_duplicates(int2(tx, ty));
300 }
301 }
302 });
303 }
304 }
305 }
306
307 ImageUser tile_user = image_user;
308 for (ImageTile &tile : image.tiles) {
309 image::ImageTileWrapper image_tile(&tile);
310 const int2 tile_offset_i = image_tile.get_tile_offset();
311 const float2 tile_offset = float2(tile_offset_i);
312
313 /* Skip UDIM tiles none of the node's primitives cover. */
314 if (multi_tile && !node_tiles.contains(tile_offset_i)) {
315 continue;
316 }
317
318 /* Skip UDIM tiles that have no mask. */
319 const uv_islands::UVIslandsMask::Tile *mask_tile = uv_masks.find_tile(tile_offset +
320 float2(0.5f, 0.5f));
321 if (mask_tile == nullptr) {
322 continue;
323 }
324
325 tile_user.tile = image_tile.get_tile_number();
326 ImBuf *image_buffer = BKE_image_acquire_ibuf(&image, &tile_user, nullptr);
327 if (image_buffer == nullptr) {
328 continue;
329 }
330 const float inv_w = 1.0f / image_buffer->x;
331 const float inv_h = 1.0f / image_buffer->y;
332
333 UDIMTilePixels tile_data;
334 tile_data.tile_number = image_tile.get_tile_number();
335 Vector<BuildPixelRow> build_rows;
336
337 for (const int face : node.faces()) {
338 for (const int tri : bke::mesh::face_triangles_range(mesh_data.faces, face)) {
340 mesh_data, border_tris, tri, [&](const float2 tri_uvs[3], const int island_index) {
341 float2 uvs[3] = {
342 tri_uvs[0] - tile_offset,
343 tri_uvs[1] - tile_offset,
344 tri_uvs[2] - tile_offset,
345 };
346 const int uv_prim_index = tri_indices.size();
347 const int64_t build_rows_num = build_rows.size();
349 build_rows, image_buffer, *mask_tile, island_index, uv_prim_index, uvs);
350
351 /* Don't append primitive if no pixels were written to this tile. */
352 if (build_rows.size() == build_rows_num) {
353 return;
354 }
355 tri_indices.append(tri);
356 pixel_to_position.append(
357 calc_pixel_to_position_map(mesh_data, tri, uvs, inv_w, inv_h));
358 });
359 }
360 }
361 BKE_image_release_ibuf(&image, image_buffer, nullptr);
362
363 if (build_rows.is_empty()) {
364 continue;
365 }
366
367 build_pixel_row_runs(build_rows, tile_data);
368
369 BLI_assert(pixel_to_position.size() == tri_indices.size());
370
371 pixel_node.tiles.append(tile_data);
372 }
373
374 /* Assign to Array, to avoid wasting reserved space. */
375 pixel_node.uv_primitives.tri_indices = tri_indices.as_span();
376 pixel_node.uv_primitives.pixel_to_position = pixel_to_position.as_span();
377}
378
389{
391 if (pbvh.pixels_ == nullptr) {
392 pbvh.pixels_ = MEM_new<PixelData>(__func__);
393 pbvh.pixels_->nodes.reinitialize(nodes.size());
394 }
395
396 PixelData &pixel_data = *pbvh.pixels_;
397 MutableSpan<PixelNode> pixel_nodes = pixel_data.nodes;
398 IndexMask leaf_nodes = all_leaf_nodes(pbvh, memory);
399 IndexMask nodes_to_update = pbvh.pixels_->flags.dirty ?
400 leaf_nodes :
401 IndexMask::from_predicate(leaf_nodes, memory, [&](const int i) {
402 return pixel_nodes[i].flags.rebuild;
403 });
404
405 if (nodes_to_update.is_empty()) {
406 return nodes_to_update;
407 }
408
409 nodes_to_update.foreach_index([&](const int i) { pixel_nodes[i].clear_data(); });
410
411 return nodes_to_update;
412}
413
414static void apply_watertight_check(Tree &pbvh, Image &image, const ImageUser &image_user)
415{
416 ImageUser watertight = image_user;
417 for (ImageTile &tile_data : image.tiles) {
418 image::ImageTileWrapper image_tile(&tile_data);
419 watertight.tile = image_tile.get_tile_number();
420 ImBuf *image_buffer = BKE_image_acquire_ibuf(&image, &watertight, nullptr);
421 if (image_buffer == nullptr) {
422 continue;
423 }
424
425 float *data_float = image_buffer->float_data_for_write();
426 uint8_t *data_byte = image_buffer->byte_data_for_write();
427
428 IndexMaskMemory memory;
429 IndexMask leaf_nodes = all_leaf_nodes(pbvh, memory);
430 PixelData &pixel_data = *pbvh.pixels_;
431 leaf_nodes.foreach_index([&](const int i) {
432 PixelNode &pixel_node = pixel_data.nodes[i];
433 UDIMTilePixels *tile_node_data = pixel_node.find_tile_data(image_tile);
434 if (tile_node_data == nullptr) {
435 return;
436 }
437
438 const int num_runs = tile_node_data->pixel_row_run_starts.size() - 1;
439 for (int run_i = 0; run_i < num_runs; run_i++) {
440 int run_x = tile_node_data->pixel_row_run_start_coords[run_i].x;
441 const int run_y = tile_node_data->pixel_row_run_start_coords[run_i].y;
442 const int run_begin = tile_node_data->pixel_row_run_starts[run_i];
443 const int run_end = tile_node_data->pixel_row_run_starts[run_i + 1];
444 for (int k = run_begin; k < run_end; k++) {
445 const PackedPixelRow &pixel_row = tile_node_data->pixel_rows[k];
446 int pixel_offset = run_y * image_buffer->x + run_x;
447 for (int x = 0; x < pixel_row.num_pixels; x++) {
448 if (data_float) {
449 copy_v4_fl(&data_float[pixel_offset * 4], 1.0);
450 }
451 if (data_byte) {
452 uint8_t *dest = &data_byte[pixel_offset * 4];
453 dest[0] = dest[1] = dest[2] = dest[3] = 255;
454 }
455 pixel_offset += 1;
456 }
457 run_x += pixel_row.num_pixels;
458 }
459 }
460 });
461 IMB_partial_update_mark_full(image_buffer);
462 IMB_mark_dirty(image_buffer);
463 BKE_image_release_ibuf(&image, image_buffer, nullptr);
464 }
465}
466
467static bool update_pixels(const Depsgraph &depsgraph,
468 const Object &object,
469 Tree &pbvh,
470 Image &image,
471 const ImageUser &image_user)
472{
473 IndexMaskMemory memory;
474 const IndexMask nodes_to_update = find_nodes_to_update(pbvh, memory);
475 if (nodes_to_update.is_empty()) {
476 return false;
477 }
478
479 const Mesh &mesh = *id_cast<const Mesh *>(object.data);
480 const StringRef active_uv_name = mesh.active_uv_map_name();
481 if (active_uv_name.is_empty()) {
482 return false;
483 }
484
485 const AttributeAccessor attributes = mesh.attributes();
486 const VArraySpan uv_map = *attributes.lookup<float2>(active_uv_name, AttrDomain::Corner);
487
488 uv_islands::MeshData mesh_data(mesh.faces(),
489 mesh.corner_tris(),
490 mesh.corner_verts(),
491 mesh.corner_edges(),
492 mesh.edges(),
493 mesh.vert_to_face_map(),
494 uv_map,
495 bke::pbvh::vert_positions_eval(depsgraph, object));
496
497 /* Group primitives by island. */
498 Array<int> island_tri_offset_data;
499 Array<int> island_tri_index_data;
501 mesh_data.uv_island_ids,
502 mesh_data.uv_island_len,
503 island_tri_offset_data,
504 island_tri_index_data);
505
507 ImageUser tile_user = image_user;
508 for (ImageTile &tile_data : image.tiles) {
509 image::ImageTileWrapper image_tile(&tile_data);
510 tile_user.tile = image_tile.get_tile_number();
511 ImBuf *tile_buffer = BKE_image_acquire_ibuf(&image, &tile_user, nullptr);
512 if (tile_buffer == nullptr) {
513 continue;
514 }
515 uv_masks.add_tile(float2(image_tile.get_tile_x_offset(), image_tile.get_tile_y_offset()),
516 ushort2(tile_buffer->x, tile_buffer->y));
517 BKE_image_release_ibuf(&image, tile_buffer, nullptr);
518 }
519 uv_masks.add(mesh_data, tris_by_island);
520 uv_masks.dilate(image.seam_margin);
521
523 mesh_data, tris_by_island, uv_masks);
524
525 Array<int> border_tri_offsets;
526 Array<BorderTriangle> border_tri_data;
528 mesh_data, mesh_data.corner_tris.size(), islands, border_tri_offsets, border_tri_data);
529
531 MutableSpan<PixelNode> pixel_nodes = pbvh.pixels_->nodes;
532
533 nodes_to_update.foreach_index(
534 [&](const int i) {
536 mesh_data, uv_masks, border_tris, image, image_user, nodes[i], pixel_nodes[i]);
537 },
540 apply_watertight_check(pbvh, image, image_user);
541 }
542
543 /* Add solution for non-manifold parts of the model. */
544 copy_update(pbvh, image, image_user, mesh_data);
545
546 /* Clear the UpdatePixels flag. */
547 nodes_to_update.foreach_index([&](const int i) { pixel_nodes[i].flags.rebuild = false; });
548
549 pbvh.pixels_->flags.dirty = false;
550
551// #define DO_PRINT_STATISTICS
552#ifdef DO_PRINT_STATISTICS
553 /* Print statistics about the pixel row encoding size. */
554 {
555 int64_t rows_bytes = 0;
556 int64_t num_pixels = 0;
557 for (const PixelNode &pixel_node : pbvh.pixels_->nodes) {
558 rows_bytes += int64_t(pixel_node.uv_primitives.pixel_to_position.size()) * sizeof(float3x3);
559 for (const UDIMTilePixels &tile : pixel_node.tiles) {
560 rows_bytes += int64_t(tile.pixel_rows.size()) * sizeof(PackedPixelRow);
561 for (const PackedPixelRow &row : tile.pixel_rows) {
562 num_pixels += row.num_pixels;
563 }
564 }
565 }
566 fmt::print("Encoded {} pixels in {} bytes ({} bytes per pixel)\n",
567 num_pixels,
568 rows_bytes,
569 double(rows_bytes) / double(num_pixels));
570 }
571#endif
572
573 return true;
574}
575
577{
578 BLI_assert(pbvh.pixels_ != nullptr);
579 PixelData *data = pbvh.pixels_;
580 return *data;
581}
582
584 PixelNode &pixel_node,
586{
588 if (pixel_node.flags.dirty) {
589 for (UDIMTilePixels &tile : pixel_node.tiles) {
590 ImBuf *image_buffer = buffers.lookup_default(tile.tile_number, nullptr);
591 if (image_buffer == nullptr) {
592 continue;
593 }
594
595 pixel_node.mark_region(tile, *image_buffer);
596 }
597 pixel_node.flags.dirty = false;
598 }
599}
600
602{
603 node.collect_dirty_tiles(r_dirty_tiles);
604}
605
606} // namespace bke::pbvh::pixels
607
608namespace bke::pbvh {
609
610void build_pixels(const Depsgraph &depsgraph,
611 Object &object,
612 Image &image,
613 const ImageUser &image_user)
614{
616 Tree &pbvh = *object::pbvh_get(object);
617 pixels::update_pixels(depsgraph, object, pbvh, image, image_user);
618}
619
621{
622 pixels::PixelData *pbvh_data = pbvh->pixels_;
623 MEM_delete(pbvh_data);
624 pbvh->pixels_ = nullptr;
625}
626
627} // namespace bke::pbvh
628} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
A BVH for high poly meshes.
Object is a sort of wrapper for general info.
#define PRF_scope(category)
Span< T > as_span() const
Definition BLI_array.hh:254
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
int64_t size() const
bool contains(const T &value) const
void append(const T &value)
bool is_empty() const
IndexRange index_range() const
void reserve(const int64_t min_capacity)
void append_non_duplicates(const T &value)
Span< T > as_span() const
GAttributeReader lookup(const StringRef name) const
constexpr bool is_empty() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define FLT_MAX
#define INT_MAX
const ccl_global KernelWorkTile * tile
IndexRange face_triangles_range(OffsetIndices< int > faces, int face_i)
Definition BKE_mesh.hh:359
pbvh::Tree * pbvh_get(Object &object)
static bool update_pixels(const Depsgraph &depsgraph, const Object &object, Tree &pbvh, Image &image, const ImageUser &image_user)
static void build_pixel_row_runs(Vector< BuildPixelRow > &build_rows, UDIMTilePixels &tile_data)
constexpr bool USE_WATERTIGHT_CHECK
static void do_encode_pixels(const uv_islands::MeshData &mesh_data, const uv_islands::UVIslandsMask &uv_masks, const GroupedSpan< BorderTriangle > border_tris, Image &image, const ImageUser &image_user, MeshNode &node, PixelNode &pixel_node)
PixelData & data_get(bke::pbvh::Tree &pbvh)
void foreach_uv_triangle(const uv_islands::MeshData &mesh_data, const GroupedSpan< BorderTriangle > border_tris, const int tri, Fn &&fn)
static void extract_barycentric_pixels(Vector< BuildPixelRow > &build_rows, const ImBuf *image_buffer, const uv_islands::UVIslandsMask::Tile &mask_tile, const int uv_island_index, const int uv_primitive_index, const float2 uvs[3])
static GroupedSpan< BorderTriangle > build_border_triangles(const uv_islands::MeshData &mesh_data, const int64_t geom_primitive_len, MutableSpan< uv_islands::UVIsland > uv_islands, Array< int > &r_offsets, Array< BorderTriangle > &r_data)
static float3x3 calc_pixel_to_position_map(const uv_islands::MeshData &mesh_data, const int tri, const float2 uvs[3], const float inv_w, const float inv_h)
void collect_dirty_tiles(PixelNode &pixel_node, Vector< image::TileNumber > &r_dirty_tiles)
void mark_image_dirty(bke::pbvh::Node &node, PixelNode &pixel_node, Map< image::TileNumber, ImBuf * > &buffers)
void copy_update(bke::pbvh::Tree &pbvh, Image &image, const ImageUser &image_user, const uv_islands::MeshData &mesh_data)
static IndexMask find_nodes_to_update(Tree &pbvh, IndexMaskMemory &memory)
static void apply_watertight_check(Tree &pbvh, Image &image, const ImageUser &image_user)
Array< UVIsland > build_uv_islands(const MeshData &mesh_data, const GroupedSpan< int > tris_by_island, const UVIslandsMask &uv_masks)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
Definition pbvh.cc:2522
void pixels_free(bke::pbvh::Tree *pbvh)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
Definition pbvh.cc:933
void build_pixels(const Depsgraph &depsgraph, Object &object, Image &image, const ImageUser &image_user)
constexpr ParallelGrainSize grain_size(int grain_size)
T clamp(const T &a, const T &min, const T &max)
T floor(const T &a)
T min(const T &a, const T &b)
void min_max(const T &value, T &min, T &max)
T max(const T &a, const T &b)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
GroupedSpan< int > build_groups_from_indices(Span< int > indices, int groups_num, Array< int > &offset_data, Array< int > &index_data)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
__int64 int64_t
Definition BKE_text.h:90
void IMB_mark_dirty(ImBuf *ibuf)
unsigned short ushort
Definition BKE_text.h:56
MINLINE void copy_v4_fl(float r[4], float f)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
BMesh const char void * data
unsigned char uint8_t
Definition BKE_text.h:79
VecBase< uint16_t, 2 > ushort2
void IMB_partial_update_mark_full(ImBuf *ibuf)
MatBase< float, 3, 3 > float3x3
int BLI_listbase_count(const ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:531
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
VecBase< float, 3 > float3
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
uint8_t * byte_data_for_write()
Definition allocimbuf.cc:60
float * float_data_for_write()
Definition allocimbuf.cc:79
bool inside(const int x, const int y) const
UDIMTilePixels * find_tile_data(const image::ImageTileWrapper &image_tile)
struct blender::bke::pbvh::pixels::PixelNode::@370321035024016012235212162017206013166215342344 flags
struct blender::bke::pbvh::pixels::PixelNode::@204347010204307204275117222140300103004304270323 uv_primitives
void mark_region(UDIMTilePixels &tile, ImBuf &image_buffer)
bool is_masked(uint16_t island_index, float2 uv) const
void add(const MeshData &mesh_data, GroupedSpan< int > tris_by_island)
void add_tile(float2 udim_offset, ushort2 resolution)
int get_uv_vert(const UVIsland &island, const MeshData &mesh_data, uint8_t mesh_vert_index) const