14#define DNA_DEPRECATED_ALLOW
82 std::optional<Library *> ,
87 Brush *brush_dst =
reinterpret_cast<Brush *
>(id_dst);
88 const Brush *brush_src =
reinterpret_cast<const Brush *
>(id_src);
171 if (
brush->gpencil_settings !=
nullptr) {
183 MEM_SAFE_DELETE(
brush->gpencil_settings);
185 if (
brush->curves_sculpt_settings !=
nullptr) {
187 MEM_delete(
brush->curves_sculpt_settings);
189 if (
brush->mesh_automasking_settings !=
nullptr) {
191 MEM_delete(
brush->mesh_automasking_settings);
194 MEM_SAFE_DELETE(
brush->gradient);
208 bool force_local, force_copy;
218 else if (force_copy) {
241 if (
brush->gpencil_settings) {
255 fn.single(
brush->secondary_color);
256 if (
brush->gradient) {
270 if (
brush->curve_distance_falloff) {
274 if (
brush->automasking_cavity_curve) {
278 if (
brush->curve_rand_hue) {
281 if (
brush->curve_rand_saturation) {
284 if (
brush->curve_rand_value) {
288 if (
brush->curve_size) {
291 if (
brush->curve_strength) {
294 if (
brush->curve_jitter) {
297 if (
brush->curve_hardness) {
300 if (
brush->curve_auto_smooth) {
303 if (
brush->curve_spacing) {
307 if (
brush->gpencil_settings) {
310 if (
brush->gpencil_settings->curve_sensitivity) {
313 if (
brush->gpencil_settings->curve_strength) {
316 if (
brush->gpencil_settings->curve_jitter) {
319 if (
brush->gpencil_settings->curve_rand_pressure) {
322 if (
brush->gpencil_settings->curve_rand_strength) {
325 if (
brush->gpencil_settings->curve_rand_uv) {
328 if (
brush->gpencil_settings->curve_rand_hue) {
331 if (
brush->gpencil_settings->curve_rand_saturation) {
334 if (
brush->gpencil_settings->curve_rand_value) {
338 if (
brush->curves_sculpt_settings) {
342 if (
brush->mesh_automasking_settings) {
347 if (
brush->gradient) {
363 if (
brush->curve_distance_falloff) {
371 if (
brush->automasking_cavity_curve) {
379 if (
brush->curve_rand_hue) {
387 if (
brush->curve_rand_saturation) {
395 if (
brush->curve_rand_value) {
403 if (
brush->curve_size) {
411 if (
brush->curve_strength) {
419 if (
brush->curve_jitter) {
427 if (
brush->curve_hardness) {
435 if (
brush->curve_auto_smooth) {
443 if (
brush->curve_spacing) {
452 if (
brush->gpencil_settings !=
nullptr) {
464 if (
brush->gpencil_settings->curve_sensitivity) {
468 if (
brush->gpencil_settings->curve_strength) {
472 if (
brush->gpencil_settings->curve_jitter) {
476 if (
brush->gpencil_settings->curve_rand_pressure) {
480 if (
brush->gpencil_settings->curve_rand_strength) {
484 if (
brush->gpencil_settings->curve_rand_uv) {
488 if (
brush->gpencil_settings->curve_rand_hue) {
492 if (
brush->gpencil_settings->curve_rand_saturation) {
496 if (
brush->gpencil_settings->curve_rand_value) {
502 if (
brush->curves_sculpt_settings) {
504 if (
brush->curves_sculpt_settings->curve_parameter_falloff) {
510 if (
brush->mesh_automasking_settings) {
512 if (
brush->mesh_automasking_settings->cavity_curve) {
517 brush->mesh_automasking_settings->cavity_curve_op =
nullptr;
523 brush->has_unsaved_changes =
false;
531 if (
brush->gpencil_settings !=
nullptr) {
533 if (!
brush->gpencil_settings->material) {
538 brush->gpencil_settings->material =
nullptr;
551 constexpr std::array mode_map{
552 std::tuple{
"use_paint_sculpt",
OB_MODE_SCULPT,
"sculpt_brush_type"},
557 std::tuple{
"use_paint_uv_sculpt",
OB_MODE_EDIT,
"image_brush_type"},
568 for (
const auto &[prop_name, mode, tool_prop_name] : mode_map) {
570 if (!(
brush->ob_mode & mode)) {
592 .id_code = Brush::id_type,
598 .name_plural =
N_(
"brushes"),
608 .foreach_cache =
nullptr,
609 .foreach_path =
nullptr,
611 .foreach_asset_weak_reference =
nullptr,
612 .owner_pointer_get =
nullptr,
618 .blend_read_undo_preserve =
nullptr,
620 .lib_override_apply_post =
nullptr,
642 const Brush brush_def = {};
644#define FROM_DEFAULT(member) \
645 memcpy((void *)&brush->member, (void *)&brush_def.member, sizeof(brush->member))
646#define FROM_DEFAULT_PTR(member) memcpy(brush->member, brush_def.member, sizeof(brush->member))
690#undef FROM_DEFAULT_PTR
699 brush->ob_mode = ob_mode;
704 else if (
ELEM(ob_mode,
721 if (
brush->gpencil_settings ==
nullptr) {
722 brush->gpencil_settings = MEM_new<BrushGpencilSettings>(
"BrushGpencilSettings");
725 brush->gpencil_settings->draw_smoothlvl = 1;
728 brush->gpencil_settings->draw_strength = 1.0f;
729 brush->gpencil_settings->draw_jitter = 0.0f;
764 uint duplicate_options)
771 if (!is_subprocess) {
799 if (!is_subprocess) {
821 if (
brush->mesh_automasking_settings ==
nullptr) {
822 brush->mesh_automasking_settings = MEM_new<MeshAutomaskingSettings>(__func__);
829 if (
brush->curves_sculpt_settings ==
nullptr) {
830 brush->curves_sculpt_settings = MEM_new<BrushCurvesSculptSettings>(__func__);
846 brush->has_unsaved_changes =
true;
856#define BR_TEST(field, t) \
857 if (br->field != def.field) { \
858 printf("br->" #field " = %" #t ";\n", br->field); \
862#define BR_TEST_FLAG(_f) \
863 if ((br->flag & _f) && !(def.flag & _f)) { \
864 printf("br->flag |= " #_f ";\n"); \
866 else if (!(br->flag & _f) && (def.flag & _f)) { \
867 printf("br->flag &= ~" #_f ";\n"); \
871#define BR_TEST_FLAG_OVERLAY(_f) \
872 if ((br->overlay_flags & _f) && !(def.overlay_flags & _f)) { \
873 printf("br->overlay_flags |= " #_f ";\n"); \
875 else if (!(br->overlay_flags & _f) && (def.overlay_flags & _f)) { \
876 printf("br->overlay_flags &= ~" #_f ";\n"); \
915 BR_TEST(smooth_stroke_radius, d);
916 BR_TEST(smooth_stroke_factor, f);
927 BR_TEST(topology_rake_factor, f);
929 BR_TEST(crease_pinch_factor, f);
933 BR_TEST(texture_sample_bias, f);
934 BR_TEST(texture_overlay_alpha, d);
956 if (!
b->curve_distance_falloff) {
959 cumap =
b->curve_distance_falloff;
963 cuma =
b->curve_distance_falloff->cm;
974 return &
brush->mask_mtex;
980 return &
brush->mask_mtex;
994 float intensity = 1.0;
997 if (mtex ==
nullptr || mtex->
tex ==
nullptr) {
1006 float rotation = -mtex->
rot;
1007 const float2 point_2d = point.xy();
1013 if (rotation > 0.001f || rotation < -0.001f) {
1015 const float flen =
sqrtf(
x *
x +
y *
y);
1032 float rotation = -mtex->
rot;
1033 const float2 point_2d = point.xy();
1034 float x = 0.0f,
y = 0.0f;
1035 float invradius = 1.0f;
1042 x = point_2d[0] - paint_runtime->
tex_mouse[0];
1043 y = point_2d[1] - paint_runtime->
tex_mouse[1];
1060 x = point_2d[0] - paint_runtime->
tex_mouse[0];
1061 y = point_2d[1] - paint_runtime->
tex_mouse[1];
1072 if (rotation > 0.001f || rotation < -0.001f) {
1074 const float flen =
sqrtf(
x *
x +
y *
y);
1088 rgba[0] = intensity;
1089 rgba[1] = intensity;
1090 rgba[2] = intensity;
1113 float rotation = -mtex->
rot;
1114 const float2 point_2d = point;
1121 if (rotation > 0.001f || rotation < -0.001f) {
1123 const float flen =
sqrtf(
x *
x +
y *
y);
1143 float rotation = -mtex->
rot;
1144 const float2 point_2d = point;
1145 float x = 0.0f,
y = 0.0f;
1146 float invradius = 1.0f;
1184 if (rotation > 0.001f || rotation < -0.001f) {
1186 const float flen =
sqrtf(
x *
x +
y *
y);
1199 CLAMP(intensity, 0.0f, 1.0f);
1256 return paint->unified_paint_settings.color;
1258 return brush->color;
1267 return std::nullopt;
1283 return std::nullopt;
1287 brush->color_jitter_flag,
1288 brush->hsv_jitter[0],
1289 brush->hsv_jitter[1],
1290 brush->hsv_jitter[2],
1291 brush->curve_rand_hue,
1292 brush->curve_rand_saturation,
1293 brush->curve_rand_value,
1300 return paint->unified_paint_settings.secondary_color;
1302 return brush->secondary_color;
1373 const short us_flag =
paint->unified_paint_settings.flag;
1398 brush->unprojected_size = unprojected_size;
1409 return brush->unprojected_size;
1421 float scale = new_brush_size;
1423 if (old_brush_size != 0) {
1426 (*unprojected_size) *=
scale;
1430 float new_unprojected_size,
1431 float old_unprojected_size)
1433 float scale = new_unprojected_size;
1435 if (old_unprojected_size != 0) {
1436 scale /= new_unprojected_size;
1438 (*r_brush_size) = int(
float(*r_brush_size) *
scale);
1449 brush->alpha = alpha;
1461 return brush->alpha;
1480 brush->weight = value;
1491 brush->input_samples;
1502 brush->input_samples = value;
1521 diameter = 2 *
brush.jitter_absolute;
1526 spread =
brush.jitter;
1529 return float2(pos[0] + 2 * rand_pos[0] * diameter * spread,
1530 pos[1] + 2 * rand_pos[1] * diameter * spread);
1564 const float brush_radius,
1570 const float radius_rcp =
math::rcp(brush_radius);
1574 const float distance = distances[i];
1585 const float distance = distances[i];
1590 const float factor = 1.0f -
distance * radius_rcp;
1591 factors[i] *= factor * factor;
1597 const float distance = distances[i];
1602 const float factor = 1.0f -
distance * radius_rcp;
1603 factors[i] *= 3.0f * factor * factor - 2.0f * factor * factor * factor;
1609 const float distance = distances[i];
1614 const float factor = 1.0f -
distance * radius_rcp;
1615 factors[i] *=
pow3f(factor) * (factor * (factor * 6.0f - 15.0f) + 10.0f);
1621 const float distance = distances[i];
1626 const float factor = 1.0f -
distance * radius_rcp;
1627 factors[i] *=
sqrtf(factor);
1633 const float distance = distances[i];
1638 const float factor = 1.0f -
distance * radius_rcp;
1639 factors[i] *= factor;
1645 const float distance = distances[i];
1654 const float distance = distances[i];
1659 const float factor = 1.0f -
distance * radius_rcp;
1660 factors[i] *=
sqrtf(2 * factor - factor * factor);
1666 const float distance = distances[i];
1671 const float factor = 1.0f -
distance * radius_rcp;
1672 factors[i] *= factor * factor * factor * factor;
1678 const float distance = distances[i];
1683 const float factor = 1.0f -
distance * radius_rcp;
1684 factors[i] *= factor * (2.0f - factor);
1694 const float brush_radius)
1700 float strength = 1.0f;
1702 if (p >= brush_radius) {
1706 p = p / brush_radius;
1717 strength = 3.0f * p * p - 2.0f * p * p * p;
1720 strength =
pow3f(p) * (p * (p * 6.0f - 15.0f) + 10.0f);
1723 strength =
sqrtf(p);
1732 strength =
sqrtf(2 * p - p * p);
1735 strength = p * p * p * p;
1738 strength = p * (2.0f - p);
1755 CLAMP(strength, 0.0f, 1.0f);
1763 const bool use_secondary,
1767 if (mtex->
tex ==
nullptr) {
1771 const float step = 2.0 / side;
1776 for (
y = -1.0, iy = 0; iy < side; iy++,
y +=
step) {
1777 for (
x = -1.0, ix = 0; ix < side; ix++,
x +=
step) {
1778 const float co[3] = {
x,
y, 0.0f};
1781 float rgba_dummy[4];
1784 rect[iy * side + ix] = intensity;
1794 int half = side / 2;
1802 if (display_gradient || have_texture) {
1804 for (
int i = 0; i < side; i++) {
1805 for (
int j = 0; j < side; j++) {
1808 float_data[i * side + j] = (have_texture) ? float_data[i * side + j] * strength : strength;
1818 switch (paint_mode) {
1825 (
brush->tip_roundness < 1.0f ||
brush->tip_scale_x != 1.0f))
1845 return brush.normal_weight;
1848 return brush.normal_weight == 0.0f;
1852 switch (
brush.image_brush_type) {
Low-level operations for grease pencil.
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define FOREACH_MAIN_ID_END
#define FOREACH_MAIN_ID_BEGIN(_bmain, _id)
General operations, lookup, etc. for materials.
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_BRUSH
ID and Library types, which are fundamental for SDNA.
#define ID_EXTRA_USERS(id)
#define ID_IS_LINKED(_id)
#define ID_REAL_USERS(id)
#define ID_NEW_SET(_id, _idn)
#define MAX_BRUSH_PIXEL_DIAMETER
Read Blender memory allocation and freeing.
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define BR_TEST(field, t)
#define FROM_DEFAULT(member)
#define BR_TEST_FLAG_OVERLAY(_f)
#define FROM_DEFAULT_PTR(member)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
constexpr int64_t size() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
float distance(float, float) RET
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
bool supports_sculpt_plane(const Brush &brush)
bool supports_secondary_cursor_color(const Brush &brush)
bool supports_auto_smooth(const Brush &brush)
bool supports_jitter(const Brush &brush)
bool supports_space_attenuation(const Brush &brush)
bool supports_size_pressure(const Brush &brush)
bool supports_persistence(const Brush &brush)
bool supports_tilt(const Brush &brush)
bool supports_inverted_direction(const Brush &brush)
bool supports_hardness(const Brush &brush)
bool supports_auto_smooth_pressure(const Brush &brush)
bool supports_rake_factor(const Brush &brush)
bool supports_plane_depth(const Brush &brush)
static bool is_paint_tool(const Brush &brush)
bool supports_accumulate(const Brush &brush)
static bool is_grab_tool(const Brush &brush)
bool supports_gravity(const Brush &brush)
bool supports_hardness_pressure(const Brush &brush)
bool supports_smooth_stroke(const Brush &brush)
bool supports_plane_offset(const Brush &brush)
bool supports_pinch_factor(const Brush &brush)
float normal_weight_get(const Brush &brush, bool invert)
bool supports_normal_radius(const Brush &brush)
bool supports_color(const Brush &brush)
void common_pressure_curves_init(Brush &brush)
bool supports_random_texture_angle(const Brush &brush)
bool supports_strength_pressure(const Brush &brush)
bool supports_dyntopo(const Brush &brush)
bool supports_height(const Brush &brush)
bool supports_topology_rake(const Brush &brush)
bool implements_3d_texture_paint(const Brush &brush)
bool supports_plane_height(const Brush &brush)
bool supports_normal_weight(const Brush &brush)
bool supports_tip_roundness(const Brush &brush)
std::unique_ptr< IDProperty, IDPropertyDeleter > create_bool(StringRef prop_name, bool value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_BOOLEAN, set its name and value.
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRef prop_name, int32_t value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_INT, set its name and value.
internal::ShallowZeroInitializeTag shallow_zero_initialize()
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
uint32_t struct_size(Span< shader::ShaderCreateInfo::PushConst > push_constants)
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
void BKE_brush_init_curves_sculpt_settings(Brush *brush)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void brush_free_data(ID *id)
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
const MTex * BKE_brush_color_texture_get(const Brush *brush, PaintMode paint_mode)
void BKE_previewimg_id_free(ID *id)
void BKE_brush_system_init()
void linearrgb_to_srgb_v3_v3(float srgb[3], const float linear[3])
void BKE_asset_metadata_idprop_ensure(AssetMetaData *asset_data, IDProperty *prop)
void BKE_id_delete(Main *bmain, void *idv, const BKEIDDeleteOptions &options={}) ATTR_NONNULL()
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BKE_previewimg_blend_read(BlendDataReader *reader, PreviewImage *prv)
void BKE_libblock_relink_to_newid(Main *bmain, ID *id, int remap_flag) ATTR_NONNULL()
float BKE_brush_sample_tex_3d(const Paint *paint, const Brush *br, const MTex *mtex, const float3 &point, float4 &rgba, int thread, ImagePool *pool)
float BKE_brush_sample_masktex(const Paint *paint, Brush *br, const float2 &point, int thread, ImagePool *pool)
void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
static void brush_init_data(ID *id)
void BKE_previewimg_blend_write(BlendWriter *writer, const PreviewImage *prv)
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
void void BKE_libblock_remap(Main *bmain, void *old_idv, void *new_idv, int remap_flags) ATTR_NONNULL(1
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
void BKE_brush_init_gpencil_settings(Brush *brush)
ID * BKE_id_copy_for_duplicate(Main *bmain, ID *id, eDupli_ID_Flags duplicate_flags, int copy_flags)
Brush * BKE_brush_duplicate(Main *bmain, Brush *brush, eDupli_ID_Flags dupflag, uint duplicate_options)
@ ID_REMAP_SKIP_INDIRECT_USAGE
@ ID_REMAP_SKIP_USER_CLEAR
static void brush_blend_read_after_liblink(BlendLibReader *, ID *id)
static void brush_defaults(Brush *brush)
void BKE_brush_calc_curve_factors(eBrushCurvePreset preset, const CurveMapping *cumap, Span< float > distances, float brush_radius, MutableSpan< float > factors)
void BKE_brush_scale_size(int *r_brush_size, float new_unprojected_size, float old_unprojected_size)
ImBuf * BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
void BKE_brush_init_mesh_automasking_settings(Brush *brush)
void BKE_curvemapping_free(CurveMapping *cumap)
void id_fake_user_set(ID *id)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
struct RNG * BLI_rng_new(unsigned int seed)
@ BRUSH_CLOTH_DEFORM_GRAB
MINLINE float pow3f(float x)
bool BKE_brush_delete(Main *bmain, Brush *brush)
bool BKE_brush_use_alpha_pressure(const Brush *brush)
static void brush_make_local(Main *bmain, ID *id, const int flags)
MINLINE float pow2f(float x)
@ BRUSH_CURVES_SCULPT_FLAG_INTERPOLATE_RADIUS
@ SCULPT_BRUSH_TYPE_INFLATE
@ SCULPT_BRUSH_TYPE_SMEAR
@ SCULPT_BRUSH_TYPE_CLOTH
@ SCULPT_BRUSH_TYPE_SIMPLIFY
@ SCULPT_BRUSH_TYPE_SMOOTH
@ SCULPT_BRUSH_TYPE_CLAY_STRIPS
@ SCULPT_BRUSH_TYPE_CREASE
@ SCULPT_BRUSH_TYPE_DRAW_FACE_SETS
@ SCULPT_BRUSH_TYPE_PAINT
@ SCULPT_BRUSH_TYPE_PLANE
@ SCULPT_BRUSH_TYPE_SLIDE_RELAX
@ SCULPT_BRUSH_TYPE_PINCH
@ SCULPT_BRUSH_TYPE_ROTATE
@ SCULPT_BRUSH_TYPE_LAYER
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_ERASER
@ SCULPT_BRUSH_TYPE_BOUNDARY
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_SMEAR
@ SCULPT_BRUSH_TYPE_DRAW_SHARP
@ SCULPT_BRUSH_TYPE_SNAKE_HOOK
@ SCULPT_BRUSH_TYPE_CLAY_THUMB
@ SCULPT_BRUSH_TYPE_MULTIPLANE_SCRAPE
@ SCULPT_BRUSH_TYPE_SCENE_PROJECT
@ SCULPT_BRUSH_TYPE_THUMB
@ SCULPT_BRUSH_TYPE_ELASTIC_DEFORM
@ BRUSH_MASK_PRESSURE_CUTOFF
@ BRUSH_MASK_PRESSURE_RAMP
float BKE_brush_unprojected_radius_get(const Paint *paint, const Brush *brush)
void BKE_colorband_foreach_working_space_color(ColorBand *coba, const IDTypeForeachColorFunctionCallback &fn)
void BKE_brush_tag_unsaved_changes(Brush *brush)
void BKE_brush_unprojected_size_set(Paint *paint, Brush *brush, float unprojected_size)
void BKE_lib_id_make_local_generic_action_define(Main *bmain, ID *id, int flags, bool *r_force_local, bool *r_force_copy)
VecBase< float, 4 > float4
@ LIB_ID_DUPLICATE_IS_SUBPROCESS
@ LIB_ID_DUPLICATE_IS_ROOT_ID
MINLINE void zero_v4(float r[4])
void BKE_curvemapping_init(CurveMapping *cumap)
float2 BKE_brush_jitter_pos(const Paint &paint, const Brush &brush, const float2 &pos)
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
bool BKE_brush_use_unified_strength(const Paint *paint, const Brush *brush)
void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], const ColorSpace *colorspace)
static void brush_asset_metadata_ensure(void *asset_ptr, AssetMetaData *asset_data)
VecBase< float, 2 > float2
static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
@ OB_MODE_VERTEX_GREASE_PENCIL
@ OB_MODE_SCULPT_GREASE_PENCIL
@ OB_MODE_WEIGHT_GREASE_PENCIL
@ OB_MODE_PAINT_GREASE_PENCIL
BMesh const char void * data
void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, CurveMapSlopeType slope)
void BLI_rng_srandom(struct RNG *rng, unsigned int seed) ATTR_NONNULL(1)
void BKE_lib_id_clear_library_data(Main *bmain, ID *id, int flags)
void BKE_brush_color_set(Paint *paint, Brush *brush, const float3 &color)
void BKE_curvemapping_changed(CurveMapping *cumap, bool rem_doubles)
CurveMapping * BKE_paint_default_curve_inverted()
@ IMAGE_PAINT_BRUSH_TYPE_DRAW
@ IMAGE_PAINT_BRUSH_TYPE_MASK
float BKE_brush_curve_strength(eBrushCurvePreset preset, const CurveMapping *cumap, float distance, float brush_radius)
CurveMapping * BKE_sculpt_default_cavity_curve()
int BKE_brush_size_get(const Paint *paint, const Brush *brush)
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
bool BKE_brush_use_locked_size(const Paint *paint, const Brush *brush)
void BKE_brush_color_sync_legacy(Brush *brush)
void BKE_brush_size_set(Paint *paint, Brush *brush, int size)
const MTex * BKE_brush_mask_texture_get(const Brush *brush, PaintMode paint_mode)
void BKE_brush_randomize_texture_coords(Paint *paint, bool mask)
void BKE_brush_scale_unprojected_size(float *unprojected_size, int new_brush_size, int old_brush_size)
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
bool RE_texture_evaluate(const MTex *mtex, const float vec[3], const int thread, ImagePool *pool, const bool skip_load_image, const bool texnode_preview, float *r_intensity, float r_rgba[4])
bool BKE_brush_use_unified_size(const Paint *paint, const Brush *brush)
void BKE_brush_debug_print_state(Brush *br)
void BKE_lib_id_expand_local(Main *bmain, ID *id, int flags)
bool BKE_brush_use_size_pressure(const Brush *brush)
float BKE_brush_curve_strength_clamped(const Brush *br, float p, float len)
void BKE_main_id_newptr_and_tag_clear(Main *bmain)
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
@ BRUSH_USE_UNIFIED_PAINT_INPUT_SAMPLES
@ BRUSH_USE_UNIFIED_PAINT_WEIGHT
@ BRUSH_USE_UNIFIED_PAINT_SIZE
@ BRUSH_USE_UNIFIED_PAINT_ALPHA
@ BRUSH_USE_UNIFIED_PAINT_COLOR
void BKE_brush_system_exit()
void BKE_brush_input_samples_set(Paint *paint, Brush *brush, int value)
bool BKE_brush_has_cube_tip(const Brush *brush, PaintMode paint_mode)
void BKE_brush_weight_set(Paint *paint, Brush *brush, float value)
ID_Type GS(const char *name)
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
float BKE_brush_unprojected_size_get(const Paint *paint, const Brush *brush)
MINLINE float square_f(float a)
std::optional< int > BKE_paint_get_brush_type_from_obmode(const Brush *brush, eObjectMode ob_mode)
CurveMapping * BKE_paint_default_curve()
std::optional< BrushColorJitterSettings > BKE_brush_color_jitter_get_settings(const Paint *paint, const Brush *brush)
float3 BKE_brush_color_get(const Paint *paint, const Brush *brush)
static void brush_foreach_working_space_color(ID *id, const IDTypeForeachColorFunctionCallback &fn)
static void brush_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int flag)
@ LIB_ID_MAKELOCAL_FULL_LIBRARY
@ UNIFIED_PAINT_BRUSH_LOCK_SIZE
@ UNIFIED_PAINT_COLOR_JITTER
float BKE_brush_weight_get(const Paint *paint, const Brush *brush)
bool BKE_library_ID_is_indirectly_used(Main *bmain, void *idv)
@ IDWALK_CB_EMBEDDED_NOT_OWNING
VecBase< float, 3 > float3
@ BRUSH_OVERLAY_SECONDARY
@ BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE
@ GP_BRUSH_USE_JITTER_PRESSURE
@ GP_BRUSH_MATERIAL_PINNED
static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
void BKE_brush_alpha_set(Paint *paint, Brush *brush, float alpha)
static AssetTypeInfo AssetType_BR
ID * BKE_id_copy(Main *bmain, const ID *id)
Brush * BKE_brush_add(Main *bmain, const char *name, eObjectMode ob_mode)
void BKE_library_foreach_ID_link(Main *bmain, ID *id, FunctionRef< LibraryIDLinkCallback > callback, void *user_data, LibraryForeachIDFlag flag)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
void * BKE_id_new(Main *bmain, short type, const char *name)
float BKE_brush_alpha_get(const Paint *paint, const Brush *brush)
static bool brush_gen_texture(const Brush *br, const int side, const bool use_secondary, float *rect)
@ CUMA_EXTEND_EXTRAPOLATE
bool BKE_brush_use_unified_color(const Paint *paint, const Brush *brush)
static void brush_blend_read_data(BlendDataReader *reader, ID *id)
float3 BKE_brush_secondary_color_get(const Paint *paint, const Brush *brush)
int BKE_brush_input_samples_get(const Paint *paint, const Brush *brush)
@ IDTYPE_FLAGS_NO_MEMFILE_UNDO
@ IDTYPE_FLAGS_NO_ANIMDATA
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
eBrushCurvesSculptFlag flag
struct CurveMapping * curve_parameter_falloff
struct CurveMapping * curve_rand_saturation
struct CurveMapping * curve_sensitivity
struct CurveMapping * curve_jitter
struct CurveMapping * curve_rand_strength
struct CurveMapping * curve_rand_uv
struct CurveMapping * curve_rand_hue
struct CurveMapping * curve_rand_pressure
struct CurveMapping * curve_strength
struct CurveMapping * curve_rand_value
float mask_stencil_dimension[2]
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_saturation
struct BrushGpencilSettings * gpencil_settings
struct CurveMapping * curve_jitter
eBrushCurvePreset curve_distance_falloff_preset
DNA_DEPRECATED struct CurveMapping * automasking_cavity_curve
struct CurveMapping * curve_distance_falloff
struct CurveMapping * curve_spacing
struct CurveMapping * curve_auto_smooth
float stencil_dimension[2]
BrushMaskPressureFlags mask_pressure
float texture_sample_bias
struct MeshAutomaskingSettings * mesh_automasking_settings
struct CurveMapping * curve_hardness
float mask_stencil_pos[2]
struct CurveMapping * curve_size
struct CurveMapping * curve_rand_hue
struct BrushCurvesSculptSettings * curves_sculpt_settings
struct CurveMapping * curve_strength
eCurveMappingPreset preset
float * float_data_for_write()
eMTex_BrushMapMode brush_map_mode
struct CurveMapping * cavity_curve_op
struct CurveMapping * cavity_curve
DNA_DEPRECATED float rgb[3]
struct CurveMapping * curve_rand_saturation
DNA_DEPRECATED float secondary_rgb[3]
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_hue
float size_pressure_value
bool do_linear_conversion
const ocio::ColorSpace * colorspace