91 return c.
r == 0.0f && c.
g == 0.0f && c.
b == 0.0f && c.
a == 0.0f;
96 return c.
r == 0 && c.
g == 0 && c.
b == 0 && c.
a == 0;
101 if constexpr (std::is_same_v<Color, ColorPaint4b>) {
111 if constexpr (std::is_same_v<Color, ColorPaint4b>) {
139 return angle_cos > 0.0f;
171 ss.
cache = MEM_new<StrokeCache>(__func__);
247 return toggle_settings;
319 pbvh->update_bounds(depsgraph, ob);
326 float *r_brush_size_pressure,
327 float *r_brush_alpha_value,
328 float *r_brush_alpha_pressure)
351 CLOG_WARN(&
LOG,
"Unable to switch to the 'Blur' essentials brush asset");
420 return ColorPaint4f(brush_color.x, brush_color.y, brush_color.z, 1.0f);
424template<
typename Color,
typename Traits>
429 const typename Traits::ValueType alpha,
430 const typename Traits::BlendType brush_alpha_value)
432 using Value =
typename Traits::ValueType;
447 cp = (Value *)&color_blend;
448 ct = (Value *)&color_test;
449 co = (Value *)&color_orig;
451 for (a = 0; a < 4; a++) {
456 else if (cp[a] > co[a]) {
464 else if (cp[a] > ct[a]) {
474 cp = (Value *)&color_blend;
475 cc = (Value *)&color_curr;
489template<
typename Color,
typename Traits>
494 Color brush_mark_color,
495 float brush_mark_alpha,
496 float brush_strength,
505 prev_vertex_colors[
index] = vertex_colors[
index];
512 stroke_buffer[
index].a = 0;
517 stroke_buffer[
index],
518 stroke_buffer[
index].a);
521 vertex_colors[
index],
522 prev_vertex_colors[
index],
523 stroke_buffer[
index],
525 Traits::range * brush_strength);
529 vertex_colors[
index],
533 Traits::range * brush_strength);
555 const float co_ss_3d[3] = {co_ss[0], co_ss[1], 0.0f};
618 const bool is_mode_set = (ob.
mode & mode_flag) != 0;
655 ot->
name =
"Vertex Paint Mode";
656 ot->
idname =
"PAINT_OT_vertex_paint_toggle";
657 ot->
description =
"Toggle the vertex paint mode in 3D view";
689template<
typename Func>
733 std::unique_ptr<VPaintData> vpd = std::make_unique<VPaintData>();
736 vpd->domain = domain;
748 attribute.materialize(vpd->smear.color_prev.data());
750 vpd->smear.color_curr = vpd->smear.color_prev;
754 if (vpd->prev_colors.is_empty()) {
757 attribute.type().value_initialize_n(vpd->prev_colors.data(), vpd->prev_colors.size());
760 if (vpd->stroke_buffer.is_empty()) {
763 attribute.type().value_initialize_n(vpd->stroke_buffer.data(), vpd->stroke_buffer.size());
767 vpd->prev_colors = {};
768 vpd->stroke_buffer = {};
790 void redraw(
bool final)
override;
793 void done(
bool is_cancel,
bool stroke_started)
override;
820 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
828 const std::optional<bke::AttributeMetaData> meta_data =
mesh->attributes().lookup_meta_data(
829 mesh->active_color_attribute);
835 op, this->
vc, vp, *
mesh, meta_data->domain, meta_data->data_type,
brush);
862 if (!select_vert[verts[i]]) {
882 float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
884 ss, vp.
paint,
brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
891 ss,
brush.falloff_shape);
918 if (!select_vert.is_empty()) {
932 const int vert = verts[i];
933 if (factors[i] == 0.0f) {
938 const float angle_cos = use_normal ?
939 dot_v3v3(sculpt_normal_frontface, vert_normals[vert]) :
945 const float brush_fade = factors[i];
948 using T = decltype(dummy);
950 std::conditional_t<std::is_same_v<T, ColorGeometry4f>, ColorPaint4f, ColorPaint4b>;
951 using Traits = blender::color::Traits<Color>;
952 using Blend = typename Traits::BlendType;
953 MutableSpan<Color> previous_color = g_previous_color.typed<T>().template cast<Color>();
954 MutableSpan<Color> colors = attribute.typed<T>().template cast<Color>();
956 Color color_final(0, 0, 0, 0);
958 int total_hit_loops = 0;
959 Blend blend[4] = {0};
961 for (
const int face : vert_to_face[vert]) {
962 if (!select_poly.
is_empty() && !select_poly[face]) {
965 total_hit_loops += faces[face].
size();
966 for (
const int corner : faces[face]) {
967 const Color &col = colors[corner];
970 blend[0] +=
static_cast<Blend
>(col.r) *
static_cast<Blend
>(col.r);
971 blend[1] +=
static_cast<Blend
>(col.g) *
static_cast<Blend
>(col.g);
972 blend[2] +=
static_cast<Blend
>(col.b) *
static_cast<Blend
>(col.b);
973 blend[3] +=
static_cast<Blend
>(col.a) *
static_cast<Blend
>(col.a);
977 if (total_hit_loops == 0) {
982 Color *col = &color_final;
984 color_final.
r = Traits::round(
sqrtf(Traits::divide_round(blend[0], total_hit_loops)));
985 color_final.g = Traits::round(
sqrtf(Traits::divide_round(blend[1], total_hit_loops)));
986 color_final.b = Traits::round(
sqrtf(Traits::divide_round(blend[2], total_hit_loops)));
987 color_final.a = Traits::round(
sqrtf(Traits::divide_round(blend[3], total_hit_loops)));
991 for (
const int face : vert_to_face[vert]) {
993 faces[face], corner_verts, vert);
994 if (!select_poly.
is_empty() && !select_poly[face]) {
997 Color color_orig(0, 0, 0, 0);
999 if (!previous_color.is_empty()) {
1001 if (
isZero(previous_color[corner])) {
1002 previous_color[corner] = colors[corner];
1004 color_orig = previous_color[corner];
1006 const float final_alpha = Traits::range * brush_fade * brush_strength *
1007 brush_alpha_pressure;
1015 Traits::range * brush_strength);
1037 float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1039 ss, vp.
paint,
brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1046 ss,
brush.falloff_shape);
1072 if (!select_vert.is_empty()) {
1086 const int vert = verts[i];
1087 if (factors[i] == 0.0f) {
1092 const float angle_cos = use_normal ?
1093 dot_v3v3(sculpt_normal_frontface, vert_normals[vert]) :
1098 const float brush_fade = factors[i];
1102 using T = decltype(dummy);
1104 std::conditional_t<std::is_same_v<T, ColorGeometry4f>, ColorPaint4f, ColorPaint4b>;
1105 using Traits = blender::color::Traits<Color>;
1106 using Blend = typename Traits::BlendType;
1107 MutableSpan<Color> previous_color = g_previous_color.typed<T>().template cast<Color>();
1108 MutableSpan<Color> colors = attribute.typed<T>().template cast<Color>();
1109 Color color_final(0, 0, 0, 0);
1111 int total_hit_loops = 0;
1112 Blend blend[4] = {0};
1114 for (
const int face : vert_to_face[vert]) {
1115 if (!select_poly.
is_empty() && !select_poly[face]) {
1118 total_hit_loops += faces[face].
size();
1119 for (
const int vert : corner_verts.
slice(faces[face])) {
1120 const Color &col = colors[vert];
1123 blend[0] +=
static_cast<Blend
>(col.r) *
static_cast<Blend
>(col.r);
1124 blend[1] +=
static_cast<Blend
>(col.g) *
static_cast<Blend
>(col.g);
1125 blend[2] +=
static_cast<Blend
>(col.b) *
static_cast<Blend
>(col.b);
1126 blend[3] +=
static_cast<Blend
>(col.a) *
static_cast<Blend
>(col.a);
1130 if (total_hit_loops == 0) {
1134 color_final.r = Traits::round(
sqrtf(Traits::divide_round(blend[0], total_hit_loops)));
1135 color_final.g = Traits::round(
sqrtf(Traits::divide_round(blend[1], total_hit_loops)));
1136 color_final.b = Traits::round(
sqrtf(Traits::divide_round(blend[2], total_hit_loops)));
1137 color_final.a = Traits::round(
sqrtf(Traits::divide_round(blend[3], total_hit_loops)));
1139 Color color_orig(0, 0, 0, 0);
1141 if (!previous_color.is_empty()) {
1143 if (
isZero(previous_color[vert])) {
1144 previous_color[vert] = colors[vert];
1146 color_orig = previous_color[vert];
1148 const float final_alpha = Traits::range * brush_fade * brush_strength *
1149 brush_alpha_pressure;
1157 Traits::range * brush_strength);
1161 exec_mode::grain_size(1));
1186 float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1189 ss, vp.
paint,
brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1203 ss,
brush.falloff_shape);
1227 if (!select_vert.is_empty()) {
1241 const int vert = verts[i];
1242 if (factors[i] == 0.0f) {
1249 const float angle_cos = use_normal ?
1250 dot_v3v3(sculpt_normal_frontface, vert_normals[vert]) :
1255 const float brush_fade = factors[i];
1257 bool do_color =
false;
1260 float stroke_dot_max = 0.0f;
1265 using T = decltype(dummy);
1267 std::conditional_t<std::is_same_v<T, ColorGeometry4f>, ColorPaint4f, ColorPaint4b>;
1268 using Traits = blender::color::Traits<Color>;
1269 MutableSpan<Color> color_curr = g_color_curr.typed<T>().template cast<Color>();
1270 MutableSpan<Color> color_prev_smear =
1271 g_color_prev_smear.typed<T>().template cast<Color>();
1272 MutableSpan<Color> color_prev = g_color_prev.typed<T>().template cast<Color>();
1273 MutableSpan<Color> colors = attribute.typed<T>().template cast<Color>();
1275 Color color_final(0, 0, 0, 0);
1277 for (const int face : vert_to_face[vert]) {
1278 if (!select_poly.is_empty() && !select_poly[face]) {
1281 for (const int corner : faces[face]) {
1282 const int v_other_index = corner_verts[corner];
1283 if (v_other_index == vert) {
1290 sub_v3_v3v3(other_dir, vert_positions[vert], vert_positions[v_other_index]);
1291 project_plane_v3_v3v3(other_dir, other_dir, cache.view_normal_symm);
1293 normalize_v3(other_dir);
1295 const float stroke_dot = dot_v3v3(other_dir, brush_dir);
1298 if (vpd.domain == AttrDomain::Point) {
1299 elem_index = v_other_index;
1302 elem_index = corner;
1305 if (stroke_dot > stroke_dot_max) {
1306 stroke_dot_max = stroke_dot;
1307 color_final = color_prev_smear[elem_index];
1317 const float final_alpha = Traits::range * brush_fade * brush_strength *
1318 brush_alpha_pressure;
1322 for (
const int face : vert_to_face[vert]) {
1325 if (vpd.
domain == AttrDomain::Point) {
1330 faces[face], corner_verts, vert);
1332 if (!select_poly.
is_empty() && !select_poly[face]) {
1337 Color color_orig(0, 0, 0, 0);
1339 if (!color_prev.is_empty()) {
1341 if (
isZero(color_prev[elem_index])) {
1342 color_prev[elem_index] = colors[elem_index];
1344 color_orig = color_prev[elem_index];
1353 Traits::range * brush_strength);
1355 color_curr[elem_index] = colors[elem_index];
1360 exec_mode::grain_size(1));
1390 using T = decltype(dummy);
1392 std::conditional_t<std::is_same_v<T, ColorGeometry4f>, ColorPaint4f, ColorPaint4b>;
1393 using Traits = blender::color::Traits<Color>;
1394 using Blend = typename Traits::BlendType;
1395 const Span<Color> colors = attribute.typed<T>().template cast<Color>();
1397 Array<VPaintAverageAccum<Blend>> accum(nodes.size(), {0, {0, 0, 0}});
1407 if (!select_vert.is_empty()) {
1418 const int vert = verts[i];
1419 if (factors[i] == 0.0f) {
1423 accum2.
len += vert_to_face[vert].
size();
1425 for (
const int face : vert_to_face[vert]) {
1427 if (vpd.
domain == AttrDomain::Corner) {
1429 faces[face], corner_verts, vert);
1436 const Color &col = colors[elem_index];
1437 accum2.
value[0] += col.r * col.r;
1438 accum2.
value[1] += col.g * col.g;
1439 accum2.
value[2] += col.b * col.b;
1445 Blend accum_len = 0;
1446 Blend accum_value[3] = {0};
1447 Color blend(0, 0, 0, 0);
1450 accum_len += accum[i].len;
1451 accum_value[0] += accum[i].value[0];
1452 accum_value[1] += accum[i].value[1];
1453 accum_value[2] += accum[i].value[2];
1455 if (accum_len != 0) {
1456 blend.r = Traits::round(
sqrtf(Traits::divide_round(accum_value[0], accum_len)));
1457 blend.g = Traits::round(
sqrtf(Traits::divide_round(accum_value[1], accum_len)));
1458 blend.b = Traits::round(
sqrtf(Traits::divide_round(accum_value[2], accum_len)));
1459 blend.a = Traits::range;
1466template<
typename Color>
1469 const float v_co[3],
1488 float3 brush_color =
float3(paint_color.
r, paint_color.
g, paint_color.
b);
1489 const std::optional<BrushColorJitterSettings> color_jitter_settings =
1491 if (color_jitter_settings) {
1514 float brush_size_pressure, brush_alpha_value, brush_alpha_pressure;
1516 ss, vp.
paint,
brush, &brush_size_pressure, &brush_alpha_value, &brush_alpha_pressure);
1523 ss,
brush.falloff_shape);
1552 if (!select_vert.is_empty()) {
1565 automask_factors.
fill(1.0f);
1572 const int vert = verts[i];
1573 if (factors[i] == 0.0f) {
1580 const float angle_cos = use_normal ?
1581 dot_v3v3(sculpt_normal_frontface, vert_normals[vert]) :
1586 const float brush_fade = factors[i];
1589 using T = decltype(dummy);
1591 std::conditional_t<std::is_same_v<T, ColorGeometry4f>, ColorPaint4f, ColorPaint4b>;
1592 using Traits = blender::color::Traits<Color>;
1593 MutableSpan<Color> colors = attribute.typed<T>().template cast<Color>();
1594 MutableSpan<Color> previous_color = g_previous_color.typed<T>().template cast<Color>();
1595 MutableSpan<Color> stroke_buffer = g_stroke_buffer.typed<T>().template cast<Color>();
1597 Color color_final = fromFloat<Color>(
1598 ColorPaint4f(brush_color[0], brush_color[1], brush_color[2], 1.0));
1601 float tex_alpha = 1.0;
1602 if (vpd.is_texbrush) {
1610 float3 position = vert_positions[vert];
1611 if (cache.radial_symmetry_pass) {
1612 position = math::transform_point(cache.symm_rot_mat_inv, position);
1614 const float3 symm_point = ed::sculpt_paint::symmetry_flip(
1615 position, cache.mirror_symmetry_pass);
1617 tex_alpha = paint_and_tex_color_alpha<Color>(vp, vpd, symm_point, &color_final);
1623 const float automask_factor = automask_factors.
is_empty() ? 1.0f : automask_factors[i];
1624 const float final_alpha = Traits::frange * brush_fade * brush_strength * tex_alpha *
1625 brush_alpha_pressure;
1627 if (vpd.
domain == AttrDomain::Point) {
1628 colors[vert] = vpaint_blend_stroke<Color, Traits>(vp,
1634 brush_strength * automask_factor,
1639 for (const int face : vert_to_face[vert]) {
1640 const int corner = bke::mesh::face_find_corner_from_vert(
1641 faces[face], corner_verts, vert);
1642 if (!select_poly.is_empty() && !select_poly[face]) {
1645 colors[corner] = vpaint_blend_stroke<Color, Traits>(vp,
1659 exec_mode::grain_size(1));
1671 if (vpd.
domain == AttrDomain::Point) {
1729 mesh.active_color_attribute);
1832 stroke->
exec(
C, op);
1853 ot->
name =
"Vertex Paint";
1854 ot->
idname =
"PAINT_OT_vertex_paint";
1855 ot->
description =
"Paint a stroke in the active color attribute layer";
1867 "override_location",
1869 "Override Location",
1870 "Override the given \"location\" array by recalculating object space positions from the "
1871 "provided \"mouse_event\" positions");
1881namespace ed::sculpt_paint {
1887 const int cd_offset,
1888 const bool use_vert_sel,
1889 const bool only_visible =
false)
1900 if (domain == AttrDomain::Corner) {
1903 else if (domain == AttrDomain::Point) {
1916 const bool use_vert_sel,
1917 const bool use_face_sel,
1918 const bool affect_alpha,
1919 const bool only_visible =
false)
1936 if (only_visible && !hide_poly.
is_empty() && hide_poly[i]) {
1939 if (!select_poly.
is_empty() && !select_poly[i]) {
1942 for (
const int corner : faces[i]) {
1943 const int vert = corner_verts[corner];
1944 if (!select_vert.is_empty() && !select_vert[vert]) {
1947 const int data_index = domain == AttrDomain::Corner ? corner : vert;
1948 data[data_index].r = value.r;
1949 data[data_index].g = value.g;
1950 data[data_index].b = value.b;
1952 data[data_index].a = value.a;
1963 const bool use_vert_sel,
1964 const bool use_face_sel,
1965 const bool affect_alpha,
1966 const bool only_visible =
false)
2013 bool only_selected =
true,
2014 bool affect_alpha =
true,
2015 const bool only_visible =
false)
2026 mesh->active_color_attribute,
2073 pbvh.tag_attribute_changed(node_mask,
mesh->active_color_attribute);
2081 ot->
name =
"Set Vertex Colors";
2082 ot->
idname =
"PAINT_OT_vertex_color_set";
2083 ot->
description =
"Fill the active vertex color layer with the current paint color";
2094 "Set color completely opaque instead of reusing existing alpha");
Generic geometry attributes built on CustomData.
General operations, lookup, etc. for blender objects.
#define CLOG_WARN(clg_ref,...)
#define ID_IS_EDITABLE(_id)
Object is a sort of wrapper for general info.
#define OPERATOR_RETVAL_CHECK(ret)
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_flag_test(ele, hflag)
#define BM_ITER_MESH(ele, iter, bm, itype)
void fill(const T &value) const
void reinitialize(const int64_t new_size)
GArray(Allocator allocator={}) noexcept
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
GAttributeReader lookup(const StringRef name) const
constexpr bool is_empty() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange index_range() const
void common_pressure_curves_init(Brush &brush)
int face_find_corner_from_vert(const IndexRange face, const Span< int > corner_verts, const int vert)
pbvh::Tree * pbvh_get(Object &object)
void stroke_track_location(Paint &paint, float3 location)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
BLI_INLINE ColorSceneLinear4f< Alpha > decode(const ColorSceneLinearByteEncoded4b< Alpha > &color)
BLI_INLINE Color BLI_mix_colors(const IMB_BlendMode tool, const Color a, const Color b, const typename Traits::BlendType alpha)
BLI_INLINE ColorSceneLinearByteEncoded4b< Alpha > encode(const ColorSceneLinear4f< Alpha > &color)
bool mode_compat_set(bContext *C, Object *ob, eObjectMode mode, ReportList *reports)
Cache & stroke_cache_ensure(const Depsgraph &depsgraph, const Paint &paint, const Brush *brush, Object &ob)
bool is_enabled(const Paint &paint, const Object &object, const Brush *br)
void calc_vert_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::MeshNode &node, Span< int > verts, MutableSpan< float > factors)
StrokeToggleSettings create_toggle_settings(const wmOperator &op, Main &bmain, Paint &paint)
void update_cache_variants(Depsgraph &depsgraph, ViewContext &vc, VPaint &vp, const PaintMode paint_mode, Object &ob, Base &base, const PaintStroke::StrokeStep &stroke_step)
bool use_normal(const VPaint &vp)
void update_cache_invariants(VPaint &vp, SculptSession &ss, wmOperator *op, const float mval[2])
void update_sculpt_normal(const Depsgraph &depsgraph, const Object &ob, const VPaint &vp, const Brush &brush, const IndexMask node_mask)
bool brush_use_accumulate_ex(const Brush &brush, const eObjectMode ob_mode)
void get_brush_alpha_data(const SculptSession &ss, const Paint &paint, const Brush &brush, float *r_brush_size_pressure, float *r_brush_alpha_value, float *r_brush_alpha_pressure)
void smooth_brush_toggle_on(Main *bmain, Paint *paint, StrokeToggleSettings &toggle_settings)
bool brush_use_accumulate(const VPaint &vp)
bool mode_toggle_poll_test(bContext *C)
void smooth_brush_toggle_off(Paint *paint, StrokeCache *cache)
bool test_brush_angle_falloff(const Brush &brush, const float angle_cos)
void init_stroke(const wmOperator &op, Main &main, Paint &paint, Depsgraph &depsgraph, Object &ob)
void mode_exit_generic(Scene &scene, Object &ob, const eObjectMode mode_flag)
IndexMask gather_brush_nodes(const Object &ob, const Brush &brush, IndexMaskMemory &memory, FunctionRef< bool(const bke::pbvh::Node &)> node_ignore_fn)
void mode_enter_generic(Main &bmain, Depsgraph &depsgraph, Scene &scene, Object &ob, const eObjectMode mode_flag)
void calc_brush_strength_factors(const StrokeCache &cache, const Brush &brush, Span< float > distances, MutableSpan< float > factors)
void filter_distances_with_radius(float radius, Span< float > distances, MutableSpan< float > factors)
void filter_region_clip_factors(const SculptSession &ss, Span< float3 > vert_positions, Span< int > verts, MutableSpan< float > factors)
bool stroke_is_first_brush_step_of_symmetry_pass(const StrokeCache &cache)
void do_symmetrical_brush_actions(const Depsgraph &depsgraph, const Scene &scene, const Paint &paint, Object &object, const BrushActionFn action_fn, PaintModeData *paint_mode_data)
bool paint_supports_dynamic_size(const Brush &br, PaintMode mode)
void scale_factors(MutableSpan< float > factors, float strength)
static void fill_mesh_face_or_corner_attribute(Mesh &mesh, const T &value, const AttrDomain domain, const MutableSpan< T > data, const bool use_vert_sel, const bool use_face_sel, const bool affect_alpha, const bool only_visible=false)
std::optional< float3 > stroke_get_location_bvh(Depsgraph &depsgraph, ViewContext &vc, const Sculpt &sd, const Brush *brush, const float mval[2], const bool force_original)
void calc_brush_distances(const SculptSession &ss, Span< float3 > vert_positions, Span< int > vert, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
void stroke_cache_common_init(ViewContext &vc, const Paint &paint, const Brush &brush, Object &object, const float2 mval)
std::optional< float3 > calc_area_normal(const Depsgraph &depsgraph, const Brush &brush, const Object &ob, const IndexMask &node_mask)
const float * brush_frontface_normal_from_falloff_shape(const SculptSession &ss, char falloff_shape)
static bool fill_active_color(Object &ob, ColorPaint4f fill_color, bool only_selected=true, bool affect_alpha=true, const bool only_visible=false)
bool object_active_color_init(Object &ob, const float fill_color[4])
std::optional< CursorGeometryInfo > cursor_geometry_info_update(bContext *C, const float2 &mval, const bool use_sampled_normal)
void fill_factor_from_hide(Span< bool > hide_vert, Span< int > verts, MutableSpan< float > r_factors)
static void fill_mesh_color(Mesh &mesh, const ColorPaint4f &color, const StringRef name, const bool use_vert_sel, const bool use_face_sel, const bool affect_alpha, const bool only_visible=false)
static void fill_bm_face_or_corner_attribute(BMesh &bm, const T &value, const AttrDomain domain, const int cd_offset, const bool use_vert_sel, const bool only_visible=false)
constexpr ParallelGrainSize grain_size(int grain_size)
static std::unique_ptr< VPaintData > vpaint_init_vpaint(wmOperator *op, const ViewContext &vc, VPaint &vp, Mesh &mesh, const AttrDomain domain, const bke::AttrType type, const Brush &brush)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void vpaint_do_draw(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, GMutableSpan attribute)
ScrArea * CTX_wm_area(const bContext *C)
static Color vpaint_blend_stroke(const VPaint &vp, MutableSpan< Color > prev_vertex_colors, MutableSpan< Color > vertex_colors, MutableSpan< Color > stroke_buffer, Color brush_mark_color, float brush_mark_alpha, float brush_strength, int index)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static void filter_factors_with_selection(const Span< bool > select_vert, const Span< int > verts, const MutableSpan< float > factors)
static bool isZero(ColorPaint4f c)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
MINLINE void copy_v3_v3(float r[3], const float a[3])
float BKE_brush_sample_tex_3d(const Paint *paint, const Brush *br, const MTex *mtex, const float3 &point, float4 &rgba, int thread, ImagePool *pool)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
bool vertex_paint_poll_ignore_tool(bContext *C)
eV3DProjStatus ED_view3d_project_float_object(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
void PAINT_OT_vertex_color_set(wmOperatorType *ot)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
@ PAINT_FALLOFF_SHAPE_SPHERE
@ PAINT_FALLOFF_SHAPE_TUBE
void PAINT_OT_vertex_paint(wmOperatorType *ot)
@ WPAINT_BRUSH_TYPE_SMEAR
static void to_static_color_type(const bke::AttrType type, const Func &func)
static wmOperatorStatus vpaint_mode_toggle_exec(bContext *C, wmOperator *op)
void BKE_mesh_tessface_clear(Mesh *mesh)
static bool vertex_paint_poll_ex(bContext *C, bool check_tool)
void ED_region_tag_redraw(ARegion *region)
Base * CTX_data_active_base(const bContext *C)
bool BKE_brush_use_alpha_pressure(const Brush *brush)
static void paint_and_tex_color_alpha_intern(const VPaint &vp, const ViewContext *vc, const float3 &co, float4 &r_rgba)
void BKE_brush_unprojected_size_set(Paint *paint, Brush *brush, float unprojected_size)
VecBase< float, 4 > float4
MINLINE void zero_v4(float r[4])
static Color vpaint_blend(const VPaint &vp, Color color_curr, Color color_orig, Color color_paint, const typename Traits::ValueType alpha, const typename Traits::BlendType brush_alpha_value)
ColorSceneLinearByteEncoded4b< eAlpha::Straight > ColorPaint4b
static wmOperatorStatus vpaint_modal(bContext *C, wmOperator *op, const wmEvent *event)
void BKE_curvemapping_init(CurveMapping *cumap)
static void vpaint_do_blur(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, GMutableSpan attribute)
VecBase< float, 2 > float2
MINLINE void mul_v3_v3(float r[3], const float a[3])
void DEG_id_tag_update(ID *id, unsigned int flags)
static Color fromFloat(const ColorPaint4f &c)
BMesh const char void * data
static wmOperatorStatus vpaint_exec(bContext *C, wmOperator *op)
static void do_vpaint_brush_smear(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, GMutableSpan attribute)
Mesh * BKE_mesh_from_object(Object *ob)
void BKE_mesh_batch_cache_dirty_tag(Mesh *mesh, eMeshBatchDirtyMode mode)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static void vpaint_paint_leaves(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, GMutableSpan attribute, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask)
static wmOperatorStatus vpaint_invoke(bContext *C, wmOperator *op, const wmEvent *event)
float3 BKE_paint_seed_hsv_jitter()
static void do_vpaint_brush_blur_verts(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, GMutableSpan attribute)
bool vertex_paint_poll(bContext *C)
static float paint_and_tex_color_alpha(const VPaint &vp, VPaintData &vpd, const float v_co[3], Color *r_color)
void WM_toolsystem_update_from_context_view3d(bContext *C)
static ColorPaint4f vpaint_get_current_col(VPaint &vp, bool secondary)
void PAINT_OT_vertex_paint_toggle(wmOperatorType *ot)
void ED_object_vpaintmode_exit_ex(Scene &scene, Object &ob)
int BKE_brush_size_get(const Paint *paint, const Brush *brush)
BMDataLayerLookup BM_data_layer_lookup(const BMesh &bm, const StringRef name)
ToolSettings * CTX_data_tool_settings(const bContext *C)
bool BKE_paint_brush_set(Paint *paint, Brush *brush)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void BKE_brush_size_set(Paint *paint, Brush *brush, int size)
bool ED_mesh_color_ensure(Mesh *mesh, const char *name)
static void do_vpaint_brush_blur_loops(const Depsgraph &depsgraph, const VPaint &vp, VPaintData &vpd, Object &ob, Mesh &mesh, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, GMutableSpan attribute)
const MTex * BKE_brush_mask_texture_get(const Brush *brush, PaintMode paint_mode)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmMsgBus * CTX_wm_message_bus(const bContext *C)
ColorSceneLinear4f< eAlpha::Straight > ColorPaint4f
void project_plane_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
@ BRUSH_AUTOMASKING_CAVITY_ALL
void paint_stroke_operator_properties(wmOperatorType *ot)
static ColorPaint4f toFloat(const Color &c)
bool BKE_brush_use_size_pressure(const Brush *brush)
const Brush * BKE_paint_brush_for_read(const Paint *paint)
MINLINE float normalize_v3(float n[3])
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
Depsgraph * CTX_data_depsgraph_on_load(const bContext *C)
Main * CTX_data_main(const bContext *C)
bool vertex_paint_mode_poll(bContext *C)
bool WM_toolsystem_active_tool_is_brush(const bContext *C)
float paint_calc_object_space_radius(const ViewContext &vc, const float3 ¢er, float pixel_radius)
bool BKE_paint_is_bmesh_face_hidden(const BMFace *f)
void ED_object_vpaintmode_enter(bContext *C, Depsgraph &depsgraph)
bool BKE_pbvh_node_fully_hidden_get(const bke::pbvh::Node &node)
@ V3D_PROJ_TEST_CLIP_NEAR
void BKE_sculptsession_update_for_edit(Depsgraph *depsgraph, Object *ob_orig, bool is_paint_tool)
static void calculate_average_color(VPaintData &vpd, Object &ob, Mesh &mesh, const Brush &brush, const GSpan attribute, const Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask)
std::optional< BrushColorJitterSettings > BKE_brush_color_jitter_get_settings(const Paint *paint, const Brush *brush)
void ED_object_vpaintmode_exit(bContext *C)
Brush * BKE_paint_brush(Paint *paint)
Scene * CTX_data_scene(const bContext *C)
float3 BKE_brush_color_get(const Paint *paint, const Brush *brush)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
void ED_object_vpaintmode_enter_ex(Main &bmain, Depsgraph &depsgraph, Scene &scene, Object &ob)
VecBase< float, 3 > float3
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
static float3 get_brush_color(const Paint *paint, const Brush *brush, const StrokeCache &cache, const ColorPaint4f &paint_color)
@ BKE_MESH_BATCH_DIRTY_ALL
bool BKE_paint_brush_set_essentials(Main *bmain, Paint *paint, const char *name)
float3 BKE_paint_randomize_color(const BrushColorJitterSettings &color_jitter, const float3 &initial_hsv_jitter, const float distance, const float pressure, const float3 &color)
Object * CTX_data_active_object(const bContext *C)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
ARegion * CTX_wm_region(const bContext *C)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
float BKE_brush_alpha_get(const Paint *paint, const Brush *brush)
ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied > ColorGeometry4b
static wmOperatorStatus vertex_color_set_exec(bContext *C, wmOperator *op)
static void vpaint_do_paint(const Depsgraph &depsgraph, const Scene &scene, const Brush &brush, Object &ob, PaintModeData *paint_mode_data)
static void init_session_data(Object &ob)
@ VPAINT_BRUSH_TYPE_SMEAR
@ VPAINT_BRUSH_TYPE_AVERAGE
float3 BKE_brush_secondary_color_get(const Paint *paint, const Brush *brush)
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_saturation
eBrushVertexPaintType vertex_brush_type
struct CurveMapping * curve_rand_hue
eMTex_BrushMapMode brush_map_mode
bke::ObjectRuntime * runtime
bke::PaintRuntime * runtime
struct ToolSettings * toolsettings
ed::sculpt_paint::StrokeCache * cache
struct blender::VPaintData::@061176217167105244271012330276020027300325355275 smear
bool test_start(wmOperator *op, float2 mouse) override
VertexPaintStroke(bContext *C, wmOperator *op, const wmEvent *event)
void update_step(wmOperator *op, const StrokeStep &stroke_step) override
std::optional< float3 > get_location(float2 mouse, bool force_original) override
bool test_cancel() override
void redraw(bool final) override
void done(bool is_cancel, bool stroke_started) override
SculptSession * sculpt_session
float stroke_distance() const
wmOperatorStatus modal(bContext *C, wmOperator *op, const wmEvent *event)
wmOperatorStatus exec(bContext *C, wmOperator *op)
std::unique_ptr< PaintModeData > mode_data_
StrokeToggleSettings toggle_settings
float base_brush_strength
std::optional< float3 > initial_hsv_jitter
float3 sculpt_normal_symm
std::unique_ptr< auto_mask::Cache > automasking
float3 last_location_symm
Brush * original_active_brush
void calc_cavity_factor(const Depsgraph &depsgraph, const Object &object, const IndexMask &node_mask)
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
struct wmOperatorType * type
#define WM_msg_publish_rna_prop(mbus, id_, data_, type_, prop_)