53template<CoordSpace Space>
struct Vertex {
57template<CoordSpace Space>
struct Edge {
85 BLI_rcti_init(&clamping_bounds, 0, resolution.x - 1, 0, resolution.y - 1);
91 const int2 tile_resolution)
99 const int2 tile_resolution)
113 int num_non_manifold_edges = count_non_manifold_edges(mesh_data);
114 reserve(num_non_manifold_edges);
115 for (
const int primitive_id : mesh_data.
corner_tris.index_range()) {
119 for (
int j = 0; j < 3; j++) {
120 const int edge_id = real_edges[j];
132 "Incorrect number of non manifold edges added. ");
136 const int2 tile_resolution)
const
141 uv_edge, image_tile, tile_resolution);
151 for (
const int primitive_id : mesh_data.
corner_tris.index_range()) {
156 for (
int j = 0; j < 3; j++) {
157 const int edge_id = real_edges[j];
179 nodes.foreach_index([&](
const int i) {
append(*pixel_nodes[i].find_tile_data(image_tile)); });
185 if (
node.find_tile_data(image_tile) ==
nullptr) {
196 PixelData &pixel_data = *
pbvh.pixels_;
200 return should_add_node(pixel_nodes[i], image_tile);
250 SelectedForCloserExamination,
256 float distance = std::numeric_limits<float>::max();
288 const int num_runs = tile_pixels.pixel_row_run_starts.size() - 1;
290 for (
const int run_i : range) {
291 int x = tile_pixels.pixel_row_run_start_coords[run_i].x;
292 const int y = tile_pixels.pixel_row_run_start_coords[run_i].y;
293 const int run_begin = tile_pixels.pixel_row_run_starts[run_i];
294 const int run_end = tile_pixels.pixel_row_run_starts[run_i + 1];
295 for (
int k = run_begin; k < run_end; k++) {
296 const int num_pixels = tile_pixels.pixel_rows[k].num_pixels;
297 for (
int px = 0; px < num_pixels; px++,
x++) {
322 max_ii(first_source.x - 1, 0),
324 max_ii(first_source.y - 1, 0),
328 int2 found_source = first_source;
329 float found_distance = std::numeric_limits<float>::max();
334 if (source == first_source) {
343 if (new_distance < found_distance) {
344 found_distance = new_distance;
345 found_source = source;
358 if (source_1 == source_2) {
371 (destination_lambda - source_1_lambda) / (source_2_lambda - source_1_lambda), 0.0f, 1.0f);
387 float found_distance = std::numeric_limits<float>::max();
388 int2 found_source(0);
398 if (new_distance < found_distance) {
399 found_source =
int2(sx, sy);
400 found_distance = new_distance;
405 if (found_distance == std::numeric_limits<float>::max()) {
423 for (const int64_t i : range) {
424 find_copy_source(selected_pixels[i], r_commands[i], tile_edges);
432 selected_pixels.
reserve(10000);
434 for (
int tile_edge_index : tile_edges.
index_range()) {
448 "PixelType::CopyFromClosestEdge isn't allowed to be set as it is set "
449 "when finding the pixels to copy.");
451 const float2 point(sx, sy);
452 float2 closest_edge_point;
457 float distance_to_edge =
math::distance(closest_edge_point, point);
458 if (distance_to_edge <
margin && distance_to_edge < pixel.
distance) {
469 return selected_pixels;
476 std::optional<std::reference_wrapper<CopyPixelGroup>> last_group = std::nullopt;
477 std::optional<CopyPixelCommand> last_command = std::nullopt;
479 int last_seam_tile = -1;
489 seam_tile != last_seam_tile)
495 last_seam_tile = seam_tile;
496 copy_tile.
groups.append(new_group);
497 last_group = copy_tile.
groups.last();
506 last_group->get().num_deltas++;
524 while (start <
groups.size()) {
537 return (
int64_t(coordinate.y) * width + coordinate.x) * 4;
547 std::copy_n(&value.x, 4, &buffer[
pixel_offset(width, coordinate)]);
559 const int2 coordinate,
573 .source_1 = group.start_source_1,
574 .source_2 = group.start_source_1,
578 Span(&command_deltas[group.start_delta_index], group.num_deltas))
599 groups.as_span().slice(group_range),
605 groups.as_span().slice(group_range),
615 printf(
"Tile %d compression rate: %d->%d = %d%%\n",
619 int(100.0 *
float(encoded_size) /
float(decoded_size)));
631 if (non_manifold_edges.
is_empty()) {
642 if (tile_buffer ==
nullptr) {
647 int2 tile_resolution(tile_buffer->
x, tile_buffer->
y);
654 Rows rows(tile_resolution,
image.seam_margin);
660 rows.
pack_into(selected_pixels, selected_commands, copy_tile);
674 const FunctionRef<
void(
int x_start,
int x_end,
int y)> push_undo_tiles)
677 std::optional<std::reference_wrapper<CopyPixelTile>> pixel_tile =
679 if (!pixel_tile.has_value()) {
685 if (tile_buffer ==
nullptr) {
693 for (
const auto item :
tile.seam_tile_to_groups.items()) {
695 if (!seam_tiles_modified[item.key]) {
702 push_undo_tiles(group.start_destination.x + 1,
703 group.start_destination.x + group.num_deltas,
704 group.start_destination.y);
707 tile.copy_pixels(*tile_buffer, group_range);
A BVH for high poly meshes.
#define PRF_scope(category)
#define BLI_assert_msg(a, msg)
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
constexpr IndexRange()=default
Value lookup_default(const Key &key, const Value &default_value) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
void append(const T &value)
void reserve(const int64_t min_capacity)
NonManifoldTileEdges extract_tile_edges(const image::ImageTileWrapper image_tile, const int2 tile_resolution) const
NonManifoldUVEdges(const uv_islands::MeshData &mesh_data)
PixelNodesTileData(bke::pbvh::Tree &pbvh, const image::ImageTileWrapper &image_tile)
void append(const Edge< CoordSpace::UV > &value)
IndexRange index_range() const
void reserve(const int64_t min_capacity)
const ccl_global KernelWorkTile * tile
int3 corner_tri_get_real_edges(Span< int2 > edges, Span< int > corner_verts, Span< int > corner_edges, const int3 &corner_tri)
constexpr int SEAM_TILE_SIZE
static void clamp(rcti &bounds, int2 resolution)
static bool can_be_extended(const CopyPixelCommand &previous, const CopyPixelCommand &next)
PixelData & data_get(bke::pbvh::Tree &pbvh)
static Vertex< CoordSpace::Tile > convert_coord_space(const Vertex< CoordSpace::UV > &uv_vertex, const image::ImageTileWrapper image_tile, const int2 tile_resolution)
static float4 read_pixel(const float *buffer, const int width, const int2 coordinate)
static void add_margin(rcti &bounds, int margin)
constexpr int SEAM_TILE_BITS
static rcti get_bounds(const Edge< CoordSpace::Tile > &tile_edge)
static DeltaCopyPixelCommand encode_delta(const CopyPixelCommand &previous, const CopyPixelCommand &next)
static void write_pixel(float *buffer, const int width, const int2 coordinate, const float4 &value)
const int THREADING_GRAIN_SIZE
void copy_pixels(bke::pbvh::Tree &pbvh, Map< image::TileNumber, ImBuf * > &buffers, image::TileNumber tile_number, Span< uint8_t > seam_tiles_modified, FunctionRef< void(int x_start, int x_end, int y)> push_undo_tiles)
void copy_update(bke::pbvh::Tree &pbvh, Image &image, const ImageUser &image_user, const uv_islands::MeshData &mesh_data)
static int64_t pixel_offset(const int width, const int2 coordinate)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
T reduce_max(const VecBase< T, Size > &a)
T distance(const T &a, const T &b)
T interpolate(const T &a, const T &b, const FactorT &t)
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)
MINLINE void rgba_uchar_to_float(float r_col[4], const unsigned char col_ub[4])
bool BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest)
VecBase< int8_t, 2 > char2
void BLI_rcti_init_minmax(struct rcti *rect)
MINLINE int max_ii(int a, int b)
void BLI_rcti_do_minmax_v(struct rcti *rect, const int xy[2])
VecBase< float, 4 > float4
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
float closest_to_line_v2(float r_close[2], const float p[2], const float l1[2], const float l2[2])
float closest_to_line_segment_v2(float r_close[2], const float p[2], const float l1[2], const float l2[2])
MINLINE int min_ii(int a, int b)
MINLINE void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4])
MINLINE float clamp_f(float value, float min, float max)
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()
const float * float_data() const
float * float_data_for_write()
TileNumber get_tile_number() const
int2 get_tile_offset() const
void build_seam_tile_map(const int2 resolution)
image::TileNumber tile_number
static int seam_tile_index(const int2 source, const int seam_tiles_x)
Vector< CopyPixelGroup > groups
Vector< DeltaCopyPixelCommand > command_deltas
void print_compression_rate() const
void copy_pixels(ImBuf &tile_buffer, IndexRange group_range) const
Map< int, IndexRange > seam_tile_to_groups
Vector< CopyPixelTile > tiles
std::optional< std::reference_wrapper< CopyPixelTile > > find_tile(image::TileNumber tile_number)
DeltaCopyPixelCommand(char2 delta_source_1, char2 delta_source_2, uint8_t mix_factor)
Vector< PixelNode > nodes
CopyPixelTiles tiles_copy_pixels
Vector< int64_t > filter_pixels_for_closer_examination(const NonManifoldTileEdges &tile_edges)
void find_copy_source(const Span< int64_t > selected_pixels, MutableSpan< CopyPixelCommand > r_commands, const NonManifoldTileEdges &tile_edges)
void mark_pixels_effected_by_brush(const PixelNodesTileData &nodes_tile_pixels)
int2 coordinate_of(const int64_t index) const
Rows(int2 resolution, int margin)
float determine_mix_factor(const int2 destination, const int2 source_1, const int2 source_2, const Edge< CoordSpace::Tile > &edge)
int2 find_second_source(int2 destination, int2 first_source)
void find_copy_source(const int64_t index, CopyPixelCommand &r_command, const NonManifoldTileEdges &tile_edges)
void pack_into(const Span< int64_t > selected_pixels, const Span< CopyPixelCommand > commands, CopyPixelTile ©_tile) const
@ SelectedForCloserExamination
bool is_edge_manifold(const int edge_id) const