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;
69 const float3 dP_du = (
b.y * e0 - a.y * e1) / det;
70 const float3 dP_dv = (a.x * e1 -
b.x * e0) / det;
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;
78 return float3x3(delta_x, delta_y, start_position);
95 const ImBuf *image_buffer,
97 const int uv_island_index,
98 const int uv_primitive_index,
101 const float inv_w = 1.0f / image_buffer->
x;
102 const float inv_h = 1.0f / image_buffer->
y;
106 const float mask_scale_x = mask_resolution_x * inv_w;
107 const float mask_scale_y = mask_resolution_y * inv_h;
109 const int2 image_size(image_buffer->
x, image_buffer->
y);
110 const TriRasterizer rasterizer(uvs[0], uvs[1], uvs[2], image_size);
114 bool start_detected =
false;
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);
124 const float fx =
float(
x) + 0.5f;
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);
131 if (!start_detected && is_inside && is_masked) {
132 start_detected =
true;
135 else if (start_detected && (!is_inside || !is_masked)) {
140 if (!start_detected) {
144 build_rows.
append(pixel_row);
160 const int64_t geom_primitive_len,
166 r_offsets =
Array<int>(geom_primitive_len + 1, 0);
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]++;
177 for (
const int uv_island_index :
uv_islands.index_range()) {
183 for (
int k = 0; k < 3; k++) {
187 r_data[current_offset[uv_primitive.
primitive_i]++] = border_tri;
196 const int n = build_rows.
size();
220 prev.start_image_coordinate.y &&
222 prev.start_image_coordinate.x + prev.num_pixels;
245 mesh_data.
uv_map[corner_tri[1]],
246 mesh_data.
uv_map[corner_tri[2]]};
250 fn(border_tri.uvs, border_tri.uv_island_index);
265 pixel_node.
tiles.is_empty()));
272 pixel_to_position.
reserve(
node.faces().size() * 2);
279 int2 tiles_max(INT_MIN);
284 for (
const int face :
node.faces()) {
287 mesh_data, border_tris, tri, [&](
const float2 uvs[3],
const int ) {
290 for (
int i = 0; i < 3; i++) {
297 for (
int ty = tile_min.y; ty <= tile_max.y; ty++) {
298 for (
int tx = tile_min.x; tx <= tile_max.x; tx++) {
314 if (multi_tile && !node_tiles.
contains(tile_offset_i)) {
321 if (mask_tile ==
nullptr) {
327 if (image_buffer ==
nullptr) {
330 const float inv_w = 1.0f / image_buffer->
x;
331 const float inv_h = 1.0f / image_buffer->
y;
337 for (
const int face :
node.faces()) {
340 mesh_data, border_tris, tri, [&](
const float2 tri_uvs[3],
const int island_index) {
342 tri_uvs[0] - tile_offset,
343 tri_uvs[1] - tile_offset,
344 tri_uvs[2] - tile_offset,
346 const int uv_prim_index = tri_indices.
size();
349 build_rows, image_buffer, *mask_tile, island_index, uv_prim_index, uvs);
352 if (build_rows.
size() == build_rows_num) {
371 pixel_node.
tiles.append(tile_data);
391 if (
pbvh.pixels_ ==
nullptr) {
392 pbvh.pixels_ = MEM_new<PixelData>(__func__);
393 pbvh.pixels_->nodes.reinitialize(
nodes.size());
402 return pixel_nodes[i].flags.rebuild;
406 return nodes_to_update;
409 nodes_to_update.
foreach_index([&](
const int i) { pixel_nodes[i].clear_data(); });
411 return nodes_to_update;
421 if (image_buffer ==
nullptr) {
434 if (tile_node_data ==
nullptr) {
439 for (
int run_i = 0; run_i < num_runs; run_i++) {
444 for (
int k = run_begin; k < run_end; k++) {
446 int pixel_offset = run_y * image_buffer->
x + run_x;
449 copy_v4_fl(&data_float[pixel_offset * 4], 1.0);
452 uint8_t *dest = &data_byte[pixel_offset * 4];
453 dest[0] = dest[1] = dest[2] = dest[3] = 255;
493 mesh.vert_to_face_map(),
501 mesh_data.uv_island_ids,
502 mesh_data.uv_island_len,
503 island_tri_offset_data,
504 island_tri_index_data);
512 if (tile_buffer ==
nullptr) {
516 ushort2(tile_buffer->
x, tile_buffer->
y));
519 uv_masks.
add(mesh_data, tris_by_island);
523 mesh_data, tris_by_island, uv_masks);
528 mesh_data, mesh_data.corner_tris.size(),
islands, border_tri_offsets, border_tri_data);
536 mesh_data, uv_masks, border_tris,
image, image_user,
nodes[i], pixel_nodes[i]);
547 nodes_to_update.
foreach_index([&](
const int i) { pixel_nodes[i].flags.rebuild =
false; });
549 pbvh.pixels_->flags.dirty =
false;
552#ifdef DO_PRINT_STATISTICS
566 fmt::print(
"Encoded {} pixels in {} bytes ({} bytes per pixel)\n",
569 double(rows_bytes) /
double(num_pixels));
588 if (pixel_node.
flags.dirty) {
591 if (image_buffer ==
nullptr) {
597 pixel_node.
flags.dirty =
false;
603 node.collect_dirty_tiles(r_dirty_tiles);
623 MEM_delete(pbvh_data);
624 pbvh->pixels_ =
nullptr;
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
void reinitialize(const int64_t new_size)
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
bool contains(const T &value) const
void append(const T &value)
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
const ccl_global KernelWorkTile * tile
IndexRange face_triangles_range(OffsetIndices< int > faces, int face_i)
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)
void pixels_free(bke::pbvh::Tree *pbvh)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
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 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)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void IMB_mark_dirty(ImBuf *ibuf)
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
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)
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()
float * float_data_for_write()
int get_tile_y_offset() const
int get_tile_x_offset() const
TileNumber get_tile_number() const
int2 get_tile_offset() const
bool inside(const int x, const int y) const
ushort uv_primitive_index
ushort2 start_image_coordinate
Vector< PixelNode > nodes
UDIMTilePixels * find_tile_data(const image::ImageTileWrapper &image_tile)
struct blender::bke::pbvh::pixels::PixelNode::@370321035024016012235212162017206013166215342344 flags
Vector< UDIMTilePixels, 0 > tiles
struct blender::bke::pbvh::pixels::PixelNode::@204347010204307204275117222140300103004304270323 uv_primitives
void mark_region(UDIMTilePixels &tile, ImBuf &image_buffer)
Vector< PackedPixelRow > pixel_rows
Vector< int > pixel_row_run_starts
image::TileNumber tile_number
Vector< ushort2 > pixel_row_run_start_coords
OffsetIndices< int > faces
Span< float3 > vert_positions
Array< int > uv_island_ids
Vector< UVPrimitive > uv_primitives
int64_t num_original_primitives
Vector< UVVert > uv_verts
bool is_masked(uint16_t island_index, float2 uv) const
void dilate(int max_iterations)
void add(const MeshData &mesh_data, GroupedSpan< int > tris_by_island)
const Tile * find_tile(float2 uv) const
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