29#ifdef DEBUG_PIXEL_NODES
56using namespace blender::bke::pbvh::pixels;
57using namespace blender::bke::image;
74 if (!canvas_image_data) {
78 std::unique_ptr<ImageData> image_data = std::make_unique<ImageData>();
79 image_data->image = canvas_image_data->first;
80 image_data->image_user = canvas_image_data->second;
92 std::unique_ptr<ImageData> image_data = std::make_unique<ImageData>();
93 image_data->image = settings.
stencil;
104 const bool is_mask_brush)
109 ImageUser tile_user = image_data.image_user_get();
110 tile_user.tile = tile.tile_number;
112 ImBuf *ibuf = BKE_image_acquire_ibuf(image_data.image, &tile_user, nullptr);
118 const int64_t tiles_x = (buffer->x + ED_IMAGE_UNDO_TILE_SIZE - 1) >>
119 ED_IMAGE_UNDO_TILE_BITS;
120 const int64_t tiles_y = (buffer->y + ED_IMAGE_UNDO_TILE_SIZE - 1) >>
121 ED_IMAGE_UNDO_TILE_BITS;
122 return Array<uint32_t>(tiles_x * tiles_y, 0);
125 const int tiles_x = (buffer->x + SEAM_TILE_SIZE - 1) >> SEAM_TILE_BITS;
126 const int tiles_y = (buffer->y + SEAM_TILE_SIZE - 1) >> SEAM_TILE_BITS;
127 return Array<uint8_t>(int64_t(tiles_x) * tiles_y, 0);
130 const ColorSpace &buffer_colorspace = buffer->float_data() ? buffer->float_colorspace() :
131 buffer->byte_colorspace();
133 TileColorspaceProcessor processor;
142 processor.is_srgb_byte =
true;
143 processor.is_noop =
false;
149 if (buffer_to_linear.
is_noop()) {
153 processor.buffer_to_linear_processor = std::move(buffer_to_linear);
154 processor.linear_to_buffer_processor =
156 processor.is_noop =
false;
185 const float3 start = P_start + P_delta * range.
start();
187 positions[i] = start + P_delta * i;
200 const Bounds<float3> brush_bounds(location - radius, location + radius);
204 const int3 &tri = corner_tris[tri_indices[i]];
224 const bool current = brush_test[i];
225 brush_test[i].set(current && select_poly[corner_tri_faces[tri_indices[i]]]);
253 return blend_settings;
258 const float brush_alpha,
264 const float4 paint_color = brush_color * (factor * brush_alpha);
277#ifdef DEBUG_PIXEL_NODES
278static float4 paint_debug_color(
float4 scene,
const int img_y)
280 if ((img_y >> 3) & 1) {
292template<
typename PixelT>
300 [[maybe_unused]]
const int img_y,
304 constexpr bool is_float = std::is_same_v<typename PixelT::base_type, float>;
310 if constexpr (is_float) {
311 scene_linear_pixels = image_pixels.
slice(img_x, size);
314 paint_pixels.
resize(size);
315 for (
int i = 0; i < size; i++) {
318 scene_linear_pixels = paint_pixels;
323 reinterpret_cast<float *
>(scene_linear_pixels.
data()), size, 1, 4,
false);
328 for (
int i = 0; i < size; i++) {
329 float4 scene = scene_linear_pixels[i];
330#ifdef DEBUG_PIXEL_NODES
331 scene = paint_debug_color(scene, img_y);
344 reinterpret_cast<float *
>(scene_linear_pixels.
data()), size, 1, 4,
false);
348 if constexpr (!is_float) {
349 for (
int i = 0; i < size; i++) {
359template<
typename PixelT>
370 constexpr bool is_float = std::is_same_v<typename PixelT::base_type, float>;
372 if (!fast_colorspace) {
375 settings, factors, start, size, image_pixels, img_x, img_y, processors, paint_pixels);
387 if constexpr (is_float) {
389 for (
int i = 0; i < size; i++) {
390 float4 scene = image_pixels[img_x + i];
391#ifdef DEBUG_PIXEL_NODES
392 scene = paint_debug_color(scene, img_y);
395 brush_color, brush_alpha, is_mix, blend_mode, factors[start + i], scene);
400 paint_pixels.
resize(size);
401 for (
int i = 0; i < size; i++) {
405#ifdef DEBUG_PIXEL_NODES
406 scene = paint_debug_color(scene, img_y);
409 brush_color, brush_alpha, is_mix, blend_mode, factors[start + i], scene);
415 reinterpret_cast<const float (*)[3]
>(
418 reinterpret_cast<const float (*)[4]
>(paint_pixels.
data()),
440 return {
int2(std::numeric_limits<int>::max()),
int2(std::numeric_limits<int>::lowest())};
451 const int img_x_start,
461 for (
int tile_x = tile_x_start; tile_x <= tile_x_end; tile_x++) {
462 const int tile_index = tile_y * undo_tiles_x + tile_x;
463 std::atomic_ref<uint32_t> pushed(tile_pushed[
tile_index]);
465 if (pushed.load(std::memory_order_acquire)) {
469 tile_user.
tile = tile_number;
472 undo_tiles, image_data.
image, &image_buffer, &tile_user, tile_x, tile_y,
nullptr,
nullptr);
473 pushed.store(1, std::memory_order_release);
489 const int tile_y_min = (tile_y > 0) ? tile_y - 1 : 0;
490 const int tile_y_max = (tile_y + 1 < tiles_y) ? tile_y + 1 : tiles_y - 1;
494 const int tile_x_min = (tile_x_start > 0) ? tile_x_start - 1 : 0;
495 const int tile_x_max = (tile_x_end + 1 < tiles_x) ? tile_x_end + 1 : tiles_x - 1;
497 for (
int dty = tile_y_min; dty <= tile_y_max; dty++) {
498 for (
int dtx = tile_x_min; dtx <= tile_x_max; dtx++) {
520 ss, corner_verts, corner_tris, pixel_node.
uv_primitives.tri_indices, positions_eval);
525 corner_tri_faces, pixel_node.
uv_primitives.tri_indices, select_poly, brush_test);
528#ifdef DEBUG_PIXEL_NODES
532 debug_color[0] =
float(
hash & 255) / 255.0f;
533 debug_color[1] =
float((
hash >> 8) & 255) / 255.0f;
534 debug_color[2] =
float((
hash >> 16) & 255) / 255.0f;
535 debug_color[3] = 1.0f;
538 bool pixels_updated =
false;
542 const Bounds<float3> brush_bounds(location - radius, location + radius);
546 if (image_buffer ==
nullptr) {
552 if (std::holds_alternative<std::monostate>(mutable_buffer)) {
569 for (
const int run_i : task_range) {
577 for (
int k = run_begin; k < run_end; k++) {
578 run_size += int(tile_data.
pixel_rows[k].num_pixels);
590 int run_active_begin = -1;
591 int run_active_end = -1;
592 int tri_skip_start = -1;
593 int tri_row_offset = 0;
596 for (
int k = run_begin; k < run_end; k++) {
598 const int tri_row_size = int(tri_row.
num_pixels);
601 const int tri_row_x = run_x + tri_row_offset;
604 const float3 P_delta = pixel_to_position[0];
605 const float3 P_start = P_delta * tri_row_x + pixel_to_position[1] * run_y +
606 pixel_to_position[2];
618 tri_factors.
fill(1.0f);
630 int tri_active_begin = -1;
631 int tri_active_end = -1;
632 for (
int i = 0; i < tri_row_size; i++) {
633 if (tri_factors[i] != 0.0f) {
634 if (tri_active_begin < 0) {
635 tri_active_begin = i;
641 if (tri_active_begin >= 0) {
642 if (run_active_begin < 0) {
643 run_active_begin = tri_row_offset + tri_active_begin;
645 else if (tri_skip_start >= 0) {
646 factors.
slice(tri_skip_start, tri_row_offset - tri_skip_start).
fill(0.0f);
649 run_active_end = tri_row_offset + tri_active_end;
654 if (run_active_begin >= 0 && tri_skip_start < 0) {
655 tri_skip_start = tri_row_offset;
658 tri_row_offset += tri_row_size;
661 if (run_active_begin < 0) {
666 const int run_active_size = run_active_end - run_active_begin + 1;
667 const int run_active_x = run_x + run_active_begin;
668 tls.
modified_spans.append({.x = run_active_x, .y = run_y, .size = run_active_size});
676 run_active_x + run_active_size - 1,
686 run_y * image_buffer->
x + run_active_x,
697 run_y * image_buffer->
x + run_active_x,
717 span.
x + span.
size - 1,
719 const int2 start(span.
x, span.
y);
728 if (tile_data.
flags.dirty) {
731 pixels_updated |= tile_data.
flags.dirty;
734 pixel_node.
flags.dirty |= pixels_updated;
756 if (image_buffer ==
nullptr) {
768 [&](
const int x_start,
const int x_end,
const int y) {
770 image_data, tile_number, *image_buffer, undo_tile_pushed, x_start, x_end, y);
773 seam_tile_modified.
fill(0);
825 corner_tri_faces =
mesh.corner_tri_faces();
A BVH for high poly meshes.
Object is a sort of wrapper for general info.
#define ED_IMAGE_UNDO_TILE_SIZE
#define ED_IMAGE_UNDO_TILE_BITS
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define POINTER_AS_UINT(i)
void apply(float *buffer, int width, int height, int channels, bool predivide) const
static ColormanageProcessor colorspace_processor_from_scene_linear_new(const ColorSpace &to_colorspace)
static ColormanageProcessor colorspace_processor_to_scene_linear_new(const ColorSpace &from_colorspace)
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
bool add_overwrite(const Key &key, const Value &value)
Value lookup_default(const Key &key, const Value &default_value) const
constexpr int64_t size() const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
constexpr T * data() const
constexpr void fill(const T &value) const
constexpr IndexRange index_range() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
void resize(const int64_t new_size)
GAttributeReader lookup(const StringRef name) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
float2x2 invert(float2x2 mat)
const ccl_global KernelWorkTile * tile
pbvh::Tree * pbvh_get(Object &object)
constexpr int SEAM_TILE_SIZE
constexpr int SEAM_TILE_BITS
void collect_dirty_tiles(PixelNode &pixel_node, Vector< image::TileNumber > &r_dirty_tiles)
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 mark_image_dirty(bke::pbvh::Node &node, PixelNode &pixel_node, Map< image::TileNumber, ImBuf * > &buffers)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
Bounds< T > merge(const Bounds< T > &a, const Bounds< T > &b)
bool scene_linear_is_rec709
float3x3 scene_linear_to_rec709
static void do_paint_pixels(const PaintBlendSettings &blend_settings, const Brush &brush, Object &object, Span< float3 > positions_eval, Span< int > corner_verts, Span< int3 > corner_tris, Span< int > corner_tri_faces, Span< bool > select_poly, ImageData &image_data, bke::pbvh::Node &, PixelNode &pixel_node)
static void push_undo_tiles(ImageData &image_data, const image::TileNumber tile_number, ImBuf &image_buffer, MutableSpan< uint32_t > tile_pushed, const int img_x_start, const int img_x_end, const int img_y)
static void paint_blend_pixels(const PaintBlendSettings &settings, const Span< float > factors, const int start, const int size, const MutableSpan< PixelT > image_pixels, const int img_x, const int img_y, const TileColorspaceProcessor &processors, Vector< float4 > &paint_pixels)
static void fix_non_manifold_seam_bleeding(bke::pbvh::Tree &pbvh, ImageData &image_data, Span< TileNumber > tile_numbers_to_fix)
static BitVector init_uv_primitives_brush_test(SculptSession &ss, const Span< int > corner_verts, const Span< int3 > corner_tris, const Span< int > tri_indices, const Span< float3 > positions)
std::variant< std::monostate, MutableSpan< float4 >, MutableSpan< uchar4 > > BufferType
static void fetch_image_buffers(ImageData &image_data, bke::pbvh::Node &, PixelNode &pixel_node, const bool is_mask_brush)
void do_3d_image_paint_brush(const Depsgraph &depsgraph, const Paint &paint, const Brush &brush, Object &ob, ImageData &image_data, const IndexMask &node_mask)
static void calc_pixel_row_positions(const float3 P_start, const float3 P_delta, const MutableSpan< float3 > positions, IndexRange range)
static BLI_NOINLINE void paint_blend_pixels_color_managed(const PaintBlendSettings &settings, const Span< float > factors, const int start, const int size, const MutableSpan< PixelT > image_pixels, const int img_x, const int img_y, const TileColorspaceProcessor &processors, Vector< float4 > &paint_pixels)
static void apply_selection_filter(const Span< int > corner_tri_faces, const Span< int > tri_indices, const Span< bool > select_poly, BitVector<> &brush_test)
static Bounds< int2 > negative_bounds()
BLI_INLINE float4 paint_blend_pixel(const float4 &brush_color, const float brush_alpha, const bool is_mix, const IMB_BlendMode blend_mode, const float factor, const float4 color)
static PaintBlendSettings mask_brush_blend_settings(const Brush &brush, const bool invert)
static void mark_seam_tiles_modified(MutableSpan< uint8_t > mask, const int tiles_x, const int tiles_y, const int x_start, const int x_end, const int y)
void calc_brush_strength_factors(const StrokeCache &cache, const Brush &brush, Span< float > distances, MutableSpan< float > factors)
void apply_hardness_to_distances(float radius, float hardness, MutableSpan< float > distances)
void filter_distances_with_radius(float radius, Span< float > distances, MutableSpan< float > factors)
void scale_factors(MutableSpan< float > factors, float strength)
void calc_brush_distances(const SculptSession &ss, Span< float3 > vert_positions, Span< int > vert, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
void calc_brush_texture_factors(PaintMode paint_mode, const SculptSession &ss, const Brush &brush, Span< float3 > vert_positions, Span< int > vert, MutableSpan< float > factors)
constexpr ParallelGrainSize grain_size(int grain_size)
void min_max(const T &value, T &min, T &max)
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)
VecBase< uint8_t, 4 > uchar4
MINLINE void rgba_uchar_to_float(float r_col[4], const unsigned char col_ub[4])
MINLINE void blend_color_mix_float(float dst[4], const float src1[4], const float src2[4])
bool IMB_colormanagement_space_is_srgb(const ColorSpace *colorspace)
size_t IMB_get_pixel_count(const ImBuf *ibuf)
Get the length of the data of the given image buffer in pixels.
MINLINE void srgb_to_linearrgb_uchar4(float linear[4], const unsigned char srgb[4])
void IMB_mark_dirty(ImBuf *ibuf)
PaintTileMap * ED_image_paint_tile_map_get()
VecBase< float, 4 > float4
VecBase< int32_t, 2 > int2
VecBase< int32_t, 3 > int3
BLI_INLINE unsigned int BLI_hash_int(unsigned int k)
BLI_INLINE void IMB_colormanagement_rec709_to_scene_linear(float scene_linear[3], const float rec709[3])
@ IMAGE_PAINT_BRUSH_TYPE_MASK
void IMB_blend_color_float(float dst[4], const float src1[4], const float src2[4], IMB_BlendMode mode)
MatBase< float, 3, 3 > float3x3
std::optional< CanvasImageData > BKE_paint_canvas_image_get(const ImagePaintSettings &settings, Object &object)
const ImBuf * ED_image_paint_tile_push(PaintTileMap *paint_tile_map, Image *image, ImBuf *ibuf, ImageUser *iuser, int x_tile, int y_tile, unsigned short **r_mask, bool **r_valid)
float3 BKE_brush_color_get(const Paint *paint, const Brush *brush)
VecBase< float, 3 > float3
bool isect_aabb_aabb_v3(const float min1[3], const float max1[3], const float min2[3], const float max2[3])
void linearrgb_to_srgb_uchar4_n(unsigned char(*srgb)[4], const float(*linear)[4], int size, const float(*matrix)[3]=nullptr)
MINLINE void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4])
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
float3 BKE_brush_secondary_color_get(const Paint *paint, const Brush *brush)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
bool intersects_segment(const T &start, const T &end) const
const uint8_t * byte_data() const
uint8_t * byte_data_for_write()
const float * float_data() const
float * float_data_for_write()
const c_style_mat & ptr() const
bke::ObjectRuntime * runtime
ed::sculpt_paint::StrokeCache * cache
SculptSession * sculpt_session
ushort uv_primitive_index
struct blender::bke::pbvh::pixels::PixelNode::@370321035024016012235212162017206013166215342344 flags
Vector< UDIMTilePixels, 0 > tiles
struct blender::bke::pbvh::pixels::PixelNode::@204347010204307204275117222140300103004304270323 uv_primitives
Vector< PackedPixelRow > pixel_rows
struct blender::bke::pbvh::pixels::UDIMTilePixels::@304110110127162000274075361305170307020300266014 flags
Vector< int > pixel_row_run_starts
image::TileNumber tile_number
void mark_dirty(const Bounds< int2 > &bounds)
Vector< ushort2 > pixel_row_run_start_coords
StrokeToggleSettings toggle_settings
Map< bke::image::TileNumber, Array< uint32_t > > undo_tile_pushed
static std::unique_ptr< ImageData > init_active_image(Object &ob, ImagePaintSettings &settings)
Map< bke::image::TileNumber, BufferType > data_buffers
Map< bke::image::TileNumber, Array< uint8_t > > seam_tile_modified
Map< bke::image::TileNumber, TileColorspaceProcessor > processors
const ImageUser & image_user_get() const
static std::unique_ptr< ImageData > init_mask_image(ImagePaintSettings &settings)
Map< bke::image::TileNumber, ImBuf * > image_buffers
PaintBlendSettings(const Paint &paint, const Brush &brush, const bool invert)
PaintBlendSettings()=default
Vector< float4 > paint_blend_pixels
Vector< ModifiedSpan > modified_spans
Vector< float3 > pixel_positions
Vector< float > distances
ColormanageProcessor linear_to_buffer_processor
ColormanageProcessor buffer_to_linear_processor
void resize(int new_size)