Blender  V3.3
brush.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 #include "MEM_guardedalloc.h"
8 
9 #include "DNA_brush_types.h"
10 #include "DNA_defaults.h"
11 #include "DNA_gpencil_types.h"
12 #include "DNA_material_types.h"
13 #include "DNA_object_types.h"
14 #include "DNA_scene_types.h"
15 
16 #include "BLI_listbase.h"
17 #include "BLI_math.h"
18 #include "BLI_rand.h"
19 
20 #include "BLT_translation.h"
21 
22 #include "BKE_bpath.h"
23 #include "BKE_brush.h"
24 #include "BKE_colortools.h"
25 #include "BKE_context.h"
26 #include "BKE_gpencil.h"
27 #include "BKE_icons.h"
28 #include "BKE_idtype.h"
29 #include "BKE_lib_id.h"
30 #include "BKE_lib_query.h"
31 #include "BKE_lib_remap.h"
32 #include "BKE_main.h"
33 #include "BKE_material.h"
34 #include "BKE_paint.h"
35 #include "BKE_texture.h"
36 
37 #include "IMB_colormanagement.h"
38 #include "IMB_imbuf.h"
39 #include "IMB_imbuf_types.h"
40 
41 #include "RE_texture.h" /* RE_texture_evaluate */
42 
43 #include "BLO_read_write.h"
44 
45 static void brush_init_data(ID *id)
46 {
47  Brush *brush = (Brush *)id;
49 
51 
52  /* enable fake user by default */
53  id_fake_user_set(&brush->id);
54 
55  /* the default alpha falloff curve */
57 }
58 
59 static void brush_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
60 {
61  Brush *brush_dst = (Brush *)id_dst;
62  const Brush *brush_src = (const Brush *)id_src;
63  if (brush_src->icon_imbuf) {
64  brush_dst->icon_imbuf = IMB_dupImBuf(brush_src->icon_imbuf);
65  }
66 
67  if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
68  BKE_previewimg_id_copy(&brush_dst->id, &brush_src->id);
69  }
70  else {
71  brush_dst->preview = nullptr;
72  }
73 
74  brush_dst->curve = BKE_curvemapping_copy(brush_src->curve);
75  if (brush_src->gpencil_settings != nullptr) {
76  brush_dst->gpencil_settings = MEM_cnew(__func__, *(brush_src->gpencil_settings));
80  brush_src->gpencil_settings->curve_strength);
82  brush_src->gpencil_settings->curve_jitter);
83 
89  brush_src->gpencil_settings->curve_rand_uv);
91  brush_src->gpencil_settings->curve_rand_hue);
96  }
97  if (brush_src->curves_sculpt_settings != nullptr) {
98  brush_dst->curves_sculpt_settings = MEM_cnew(__func__, *(brush_src->curves_sculpt_settings));
99  }
100 
101  /* enable fake user by default */
102  id_fake_user_set(&brush_dst->id);
103 }
104 
105 static void brush_free_data(ID *id)
106 {
107  Brush *brush = (Brush *)id;
108  if (brush->icon_imbuf) {
109  IMB_freeImBuf(brush->icon_imbuf);
110  }
112 
113  if (brush->gpencil_settings != nullptr) {
117 
124 
126  }
127  if (brush->curves_sculpt_settings != nullptr) {
129  }
130 
131  MEM_SAFE_FREE(brush->gradient);
132 
133  BKE_previewimg_free(&(brush->preview));
134 }
135 
136 static void brush_make_local(Main *bmain, ID *id, const int flags)
137 {
138  if (!ID_IS_LINKED(id)) {
139  return;
140  }
141 
142  Brush *brush = (Brush *)id;
143  const bool lib_local = (flags & LIB_ID_MAKELOCAL_FULL_LIBRARY) != 0;
144 
145  bool force_local, force_copy;
146  BKE_lib_id_make_local_generic_action_define(bmain, id, flags, &force_local, &force_copy);
147 
148  if (brush->clone.image) {
149  /* Special case: ima always local immediately. Clone image should only have one user anyway. */
150  /* FIXME: Recursive calls affecting other non-embedded IDs are really bad and should be avoided
151  * in IDType callbacks. Higher-level ID management code usually does not expect such things and
152  * does not deal properly with it. */
153  /* NOTE: assert below ensures that the comment above is valid, and that exception is
154  * acceptable for the time being. */
155  BKE_lib_id_make_local(bmain, &brush->clone.image->id, 0);
156  BLI_assert(!ID_IS_LINKED(brush->clone.image) && brush->clone.image->id.newid == nullptr);
157  }
158 
159  if (force_local) {
160  BKE_lib_id_clear_library_data(bmain, &brush->id, flags);
161  BKE_lib_id_expand_local(bmain, &brush->id, flags);
162 
163  /* enable fake user by default */
164  id_fake_user_set(&brush->id);
165  }
166  else if (force_copy) {
167  Brush *brush_new = (Brush *)BKE_id_copy(bmain, &brush->id); /* Ensures FAKE_USER is set */
168 
169  brush_new->id.us = 0;
170 
171  /* setting newid is mandatory for complex make_lib_local logic... */
172  ID_NEW_SET(brush, brush_new);
173 
174  if (!lib_local) {
175  BKE_libblock_remap(bmain, brush, brush_new, ID_REMAP_SKIP_INDIRECT_USAGE);
176  }
177  }
178 }
179 
181 {
182  Brush *brush = (Brush *)id;
183 
187  if (brush->gpencil_settings) {
189  }
193 }
194 
195 static void brush_foreach_path(ID *id, BPathForeachPathData *bpath_data)
196 {
197  Brush *brush = (Brush *)id;
198  if (brush->icon_filepath[0] != '\0') {
200  }
201 }
202 
203 static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
204 {
205  Brush *brush = (Brush *)id;
206 
207  BLO_write_id_struct(writer, Brush, id_address, &brush->id);
208  BKE_id_blend_write(writer, &brush->id);
209 
210  if (brush->curve) {
211  BKE_curvemapping_blend_write(writer, brush->curve);
212  }
213 
214  if (brush->gpencil_settings) {
216 
217  if (brush->gpencil_settings->curve_sensitivity) {
219  }
220  if (brush->gpencil_settings->curve_strength) {
222  }
223  if (brush->gpencil_settings->curve_jitter) {
225  }
228  }
231  }
232  if (brush->gpencil_settings->curve_rand_uv) {
234  }
235  if (brush->gpencil_settings->curve_rand_hue) {
237  }
240  }
241  if (brush->gpencil_settings->curve_rand_value) {
243  }
244  }
245  if (brush->curves_sculpt_settings) {
247  }
248  if (brush->gradient) {
249  BLO_write_struct(writer, ColorBand, brush->gradient);
250  }
251 }
252 
253 static void brush_blend_read_data(BlendDataReader *reader, ID *id)
254 {
255  Brush *brush = (Brush *)id;
256 
257  /* Falloff curve. */
258  BLO_read_data_address(reader, &brush->curve);
259 
260  BLO_read_data_address(reader, &brush->gradient);
261 
262  if (brush->curve) {
263  BKE_curvemapping_blend_read(reader, brush->curve);
264  }
265  else {
267  }
268 
269  /* grease pencil */
270  BLO_read_data_address(reader, &brush->gpencil_settings);
271  if (brush->gpencil_settings != nullptr) {
275 
282 
283  if (brush->gpencil_settings->curve_sensitivity) {
285  }
286 
287  if (brush->gpencil_settings->curve_strength) {
289  }
290 
291  if (brush->gpencil_settings->curve_jitter) {
293  }
294 
297  }
298 
301  }
302 
303  if (brush->gpencil_settings->curve_rand_uv) {
305  }
306 
307  if (brush->gpencil_settings->curve_rand_hue) {
309  }
310 
313  }
314 
315  if (brush->gpencil_settings->curve_rand_value) {
317  }
318  }
319 
321 
322  brush->preview = nullptr;
323  brush->icon_imbuf = nullptr;
324 }
325 
326 static void brush_blend_read_lib(BlendLibReader *reader, ID *id)
327 {
328  Brush *brush = (Brush *)id;
329 
330  /* brush->(mask_)mtex.obj is ignored on purpose? */
331  BLO_read_id_address(reader, brush->id.lib, &brush->mtex.tex);
332  BLO_read_id_address(reader, brush->id.lib, &brush->mask_mtex.tex);
333  BLO_read_id_address(reader, brush->id.lib, &brush->clone.image);
334  BLO_read_id_address(reader, brush->id.lib, &brush->toggle_brush);
335  BLO_read_id_address(reader, brush->id.lib, &brush->paint_curve);
336 
337  /* link default grease pencil palette */
338  if (brush->gpencil_settings != nullptr) {
340  BLO_read_id_address(reader, brush->id.lib, &brush->gpencil_settings->material);
341 
342  if (!brush->gpencil_settings->material) {
344  }
345  }
346  else {
347  brush->gpencil_settings->material = nullptr;
348  }
349  }
350 }
351 
352 static void brush_blend_read_expand(BlendExpander *expander, ID *id)
353 {
354  Brush *brush = (Brush *)id;
355  BLO_expand(expander, brush->mtex.tex);
356  BLO_expand(expander, brush->mask_mtex.tex);
357  BLO_expand(expander, brush->clone.image);
358  BLO_expand(expander, brush->paint_curve);
359  if (brush->gpencil_settings != nullptr) {
360  BLO_expand(expander, brush->gpencil_settings->material);
361  }
362 }
363 
365 {
366  BlendLibReader *reader = (BlendLibReader *)cb_data->user_data;
367  ID *id_old = *cb_data->id_pointer;
368  /* Old data has not been remapped to new values of the pointers, if we want to keep the old
369  * pointer here we need its new address. */
370  ID *id_old_new = id_old != nullptr ? BLO_read_get_new_id_address(reader, id_old->lib, id_old) :
371  nullptr;
372  BLI_assert(id_old_new == nullptr || ELEM(id_old, id_old_new, id_old_new->orig_id));
373  if (cb_data->cb_flag & IDWALK_CB_USER) {
374  id_us_plus_no_lib(id_old_new);
375  id_us_min(id_old);
376  }
377  *cb_data->id_pointer = id_old_new;
378  return IDWALK_RET_NOP;
379 }
380 
381 static void brush_undo_preserve(BlendLibReader *reader, ID *id_new, ID *id_old)
382 {
383  /* Whole Brush is preserved across undo-steps. */
384  BKE_lib_id_swap(nullptr, id_new, id_old);
385 
386  /* `id_new` now has content from `id_old`, we need to ensure those old ID pointers are valid.
387  * NOTE: Since we want to re-use all old pointers here, code is much simpler than for Scene. */
389 
390  /* NOTE: We do not swap IDProperties, as dealing with potential ID pointers in those would be
391  * fairly delicate. */
392  SWAP(IDProperty *, id_new->properties, id_old->properties);
393 }
394 
396  /* id_code */ ID_BR,
397  /* id_filter */ FILTER_ID_BR,
398  /* main_listbase_index */ INDEX_ID_BR,
399  /* struct_size */ sizeof(Brush),
400  /* name */ "Brush",
401  /* name_plural */ "brushes",
402  /* translation_context */ BLT_I18NCONTEXT_ID_BRUSH,
403  /* flags */ IDTYPE_FLAGS_NO_ANIMDATA,
404  /* asset_type_info */ nullptr,
405 
406  /* init_data */ brush_init_data,
407  /* copy_data */ brush_copy_data,
408  /* free_data */ brush_free_data,
409  /* make_local */ brush_make_local,
410  /* foreach_id */ brush_foreach_id,
411  /* foreach_cache */ nullptr,
412  /* foreach_path */ brush_foreach_path,
413  /* owner_get */ nullptr,
414 
415  /* blend_write */ brush_blend_write,
416  /* blend_read_data */ brush_blend_read_data,
417  /* blend_read_lib */ brush_blend_read_lib,
418  /* blend_read_expand */ brush_blend_read_expand,
419 
420  /* blend_read_undo_preserve */ brush_undo_preserve,
421 
422  /* lib_override_apply_post */ nullptr,
423 };
424 
425 static RNG *brush_rng;
426 
428 {
429  brush_rng = BLI_rng_new(0);
430  BLI_rng_srandom(brush_rng, 31415682);
431 }
432 
434 {
435  if (brush_rng == nullptr) {
436  return;
437  }
439  brush_rng = nullptr;
440 }
441 
442 static void brush_defaults(Brush *brush)
443 {
444 
445  const Brush *brush_def = DNA_struct_default_get(Brush);
446 
447 #define FROM_DEFAULT(member) \
448  memcpy((void *)&brush->member, (void *)&brush_def->member, sizeof(brush->member))
449 #define FROM_DEFAULT_PTR(member) memcpy(brush->member, brush_def->member, sizeof(brush->member))
450 
452  FROM_DEFAULT(flag);
453  FROM_DEFAULT(weight);
455  FROM_DEFAULT(alpha);
456  FROM_DEFAULT(hardness);
457  FROM_DEFAULT(autosmooth_factor);
458  FROM_DEFAULT(topology_rake_factor);
459  FROM_DEFAULT(crease_pinch_factor);
460  FROM_DEFAULT(normal_radius_factor);
461  FROM_DEFAULT(wet_paint_radius_factor);
462  FROM_DEFAULT(area_radius_factor);
463  FROM_DEFAULT(disconnected_distance_max);
464  FROM_DEFAULT(sculpt_plane);
465  FROM_DEFAULT(plane_offset);
466  FROM_DEFAULT(clone.alpha);
467  FROM_DEFAULT(normal_weight);
468  FROM_DEFAULT(fill_threshold);
469  FROM_DEFAULT(flag);
470  FROM_DEFAULT(sampling_flag);
472  FROM_DEFAULT_PTR(secondary_rgb);
473  FROM_DEFAULT(spacing);
474  FROM_DEFAULT(smooth_stroke_radius);
475  FROM_DEFAULT(smooth_stroke_factor);
476  FROM_DEFAULT(rate);
477  FROM_DEFAULT(jitter);
478  FROM_DEFAULT(texture_sample_bias);
479  FROM_DEFAULT(texture_overlay_alpha);
480  FROM_DEFAULT(mask_overlay_alpha);
481  FROM_DEFAULT(cursor_overlay_alpha);
483  FROM_DEFAULT_PTR(add_col);
484  FROM_DEFAULT_PTR(sub_col);
485  FROM_DEFAULT(stencil_pos);
486  FROM_DEFAULT(stencil_dimension);
487  FROM_DEFAULT(mtex);
488  FROM_DEFAULT(mask_mtex);
489 
490 #undef FROM_DEFAULT
491 #undef FROM_DEFAULT_PTR
492 }
493 
494 /* Datablock add/copy/free/make_local */
495 
496 Brush *BKE_brush_add(Main *bmain, const char *name, const eObjectMode ob_mode)
497 {
498  Brush *brush = (Brush *)BKE_id_new(bmain, ID_BR, name);
499 
500  brush->ob_mode = ob_mode;
501 
502  if (ob_mode == OB_MODE_SCULPT_CURVES) {
504  }
505 
506  return brush;
507 }
508 
510 {
511  if (brush->gpencil_settings == nullptr) {
512  brush->gpencil_settings = MEM_cnew<BrushGpencilSettings>("BrushGpencilSettings");
513  }
514 
515  brush->gpencil_settings->draw_smoothlvl = 1;
516  brush->gpencil_settings->flag = 0;
518  brush->gpencil_settings->draw_strength = 1.0f;
519  brush->gpencil_settings->draw_jitter = 0.0f;
522 
523  /* curves */
524  brush->gpencil_settings->curve_sensitivity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
525  brush->gpencil_settings->curve_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
526  brush->gpencil_settings->curve_jitter = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
527 
528  brush->gpencil_settings->curve_rand_pressure = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
529  brush->gpencil_settings->curve_rand_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
530  brush->gpencil_settings->curve_rand_uv = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
531  brush->gpencil_settings->curve_rand_hue = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
532  brush->gpencil_settings->curve_rand_saturation = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
533  brush->gpencil_settings->curve_rand_value = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
534 }
535 
536 Brush *BKE_brush_add_gpencil(Main *bmain, ToolSettings *ts, const char *name, eObjectMode mode)
537 {
538  Paint *paint = nullptr;
539  Brush *brush;
540  switch (mode) {
541  case OB_MODE_PAINT_GPENCIL: {
542  paint = &ts->gp_paint->paint;
543  break;
544  }
545  case OB_MODE_SCULPT_GPENCIL: {
546  paint = &ts->gp_sculptpaint->paint;
547  break;
548  }
549  case OB_MODE_WEIGHT_GPENCIL: {
550  paint = &ts->gp_weightpaint->paint;
551  break;
552  }
553  case OB_MODE_VERTEX_GPENCIL: {
554  paint = &ts->gp_vertexpaint->paint;
555  break;
556  }
557  default:
558  paint = &ts->gp_paint->paint;
559  }
560 
561  brush = BKE_brush_add(bmain, name, mode);
562 
563  BKE_paint_brush_set(paint, brush);
564  id_us_min(&brush->id);
565 
566  brush->size = 3;
567 
568  /* grease pencil basic settings */
570 
571  /* return brush */
572  return brush;
573 }
574 
575 bool BKE_brush_delete(Main *bmain, Brush *brush)
576 {
577  if (brush->id.tag & LIB_TAG_INDIRECT) {
578  return false;
579  }
580  if (ID_REAL_USERS(brush) <= 1 && ID_EXTRA_USERS(brush) == 0 &&
581  BKE_library_ID_is_indirectly_used(bmain, brush)) {
582  return false;
583  }
584 
585  BKE_id_delete(bmain, brush);
586 
587  return true;
588 }
589 
592  GPCURVE_PRESET_PENCIL = 0,
593  GPCURVE_PRESET_INK = 1,
594  GPCURVE_PRESET_INKNOISE = 2,
595  GPCURVE_PRESET_MARKER = 3,
596  GPCURVE_PRESET_CHISEL_SENSIVITY = 4,
597  GPCURVE_PRESET_CHISEL_STRENGTH = 5,
598 };
599 
600 static void brush_gpencil_curvemap_reset(CurveMap *cuma, int tot, int preset)
601 {
602  if (cuma->curve) {
603  MEM_freeN(cuma->curve);
604  }
605 
606  cuma->totpoint = tot;
607  cuma->curve = (CurveMapPoint *)MEM_callocN(cuma->totpoint * sizeof(CurveMapPoint), __func__);
608 
609  switch (preset) {
610  case GPCURVE_PRESET_PENCIL:
611  cuma->curve[0].x = 0.0f;
612  cuma->curve[0].y = 0.0f;
613  cuma->curve[1].x = 0.75115f;
614  cuma->curve[1].y = 0.25f;
615  cuma->curve[2].x = 1.0f;
616  cuma->curve[2].y = 1.0f;
617  break;
618  case GPCURVE_PRESET_INK:
619  cuma->curve[0].x = 0.0f;
620  cuma->curve[0].y = 0.0f;
621  cuma->curve[1].x = 0.63448f;
622  cuma->curve[1].y = 0.375f;
623  cuma->curve[2].x = 1.0f;
624  cuma->curve[2].y = 1.0f;
625  break;
626  case GPCURVE_PRESET_INKNOISE:
627  cuma->curve[0].x = 0.0f;
628  cuma->curve[0].y = 0.0f;
629  cuma->curve[1].x = 0.55f;
630  cuma->curve[1].y = 0.45f;
631  cuma->curve[2].x = 0.85f;
632  cuma->curve[2].y = 1.0f;
633  break;
634  case GPCURVE_PRESET_MARKER:
635  cuma->curve[0].x = 0.0f;
636  cuma->curve[0].y = 0.0f;
637  cuma->curve[1].x = 0.38f;
638  cuma->curve[1].y = 0.22f;
639  cuma->curve[2].x = 0.65f;
640  cuma->curve[2].y = 0.68f;
641  cuma->curve[3].x = 1.0f;
642  cuma->curve[3].y = 1.0f;
643  break;
644  case GPCURVE_PRESET_CHISEL_SENSIVITY:
645  cuma->curve[0].x = 0.0f;
646  cuma->curve[0].y = 0.0f;
647  cuma->curve[1].x = 0.25f;
648  cuma->curve[1].y = 0.40f;
649  cuma->curve[2].x = 1.0f;
650  cuma->curve[2].y = 1.0f;
651  break;
652  case GPCURVE_PRESET_CHISEL_STRENGTH:
653  cuma->curve[0].x = 0.0f;
654  cuma->curve[0].y = 0.0f;
655  cuma->curve[1].x = 0.31f;
656  cuma->curve[1].y = 0.22f;
657  cuma->curve[2].x = 0.61f;
658  cuma->curve[2].y = 0.88f;
659  cuma->curve[3].x = 1.0f;
660  cuma->curve[3].y = 1.0f;
661  break;
662  default:
663  break;
664  }
665 
666  MEM_SAFE_FREE(cuma->table);
667 }
668 
669 void BKE_gpencil_brush_preset_set(Main *bmain, Brush *brush, const short type)
670 {
671 #define SMOOTH_STROKE_RADIUS 40
672 #define SMOOTH_STROKE_FACTOR 0.9f
673 #define ACTIVE_SMOOTH 0.35f
674 
675  CurveMapping *custom_curve = nullptr;
676 
677  /* Optionally assign a material preset. */
678  enum {
679  PRESET_MATERIAL_NONE = 0,
680  PRESET_MATERIAL_DOT_STROKE,
681  } material_preset = PRESET_MATERIAL_NONE;
682 
683  /* Set general defaults at brush level. */
686 
687  brush->rgb[0] = 0.498f;
688  brush->rgb[1] = 1.0f;
689  brush->rgb[2] = 0.498f;
690 
691  brush->secondary_rgb[0] = 1.0f;
692  brush->secondary_rgb[1] = 1.0f;
693  brush->secondary_rgb[2] = 1.0f;
694 
696 
697  if (brush->gpencil_settings == nullptr) {
698  return;
699  }
700 
701  /* Set preset type. */
703 
704  /* Set vertex mix factor. */
706  brush->gpencil_settings->vertex_factor = 1.0f;
707 
708  switch (type) {
710  brush->size = 300.0f;
712 
713  brush->gpencil_settings->draw_strength = 0.4f;
715 
716  brush->gpencil_settings->input_samples = 10;
718  brush->gpencil_settings->draw_angle = 0.0f;
719  brush->gpencil_settings->draw_angle_factor = 0.0f;
720  brush->gpencil_settings->hardeness = 0.9f;
722 
725 
726  zero_v3(brush->secondary_rgb);
727 
728  material_preset = PRESET_MATERIAL_DOT_STROKE;
729 
730  break;
731  }
733 
734  brush->size = 60.0f;
736 
737  brush->gpencil_settings->draw_strength = 1.0f;
738 
739  brush->gpencil_settings->input_samples = 10;
741  brush->gpencil_settings->draw_angle = 0.0f;
742  brush->gpencil_settings->draw_angle_factor = 0.0f;
743  brush->gpencil_settings->hardeness = 1.0f;
745 
747  brush->gpencil_settings->draw_smoothfac = 0.1f;
748  brush->gpencil_settings->draw_smoothlvl = 1;
749  brush->gpencil_settings->draw_subdivide = 0;
750  brush->gpencil_settings->simplify_f = 0.002f;
751 
752  brush->gpencil_settings->draw_random_press = 0.0f;
753  brush->gpencil_settings->draw_jitter = 0.0f;
755 
756  /* Curve. */
757  custom_curve = brush->gpencil_settings->curve_sensitivity;
758  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
759  BKE_curvemapping_init(custom_curve);
760  brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INK);
761 
764 
765  zero_v3(brush->secondary_rgb);
766  break;
767  }
769  brush->size = 60.0f;
771 
772  brush->gpencil_settings->draw_strength = 1.0f;
773 
774  brush->gpencil_settings->input_samples = 10;
776  brush->gpencil_settings->draw_angle = 0.0f;
777  brush->gpencil_settings->draw_angle_factor = 0.0f;
778  brush->gpencil_settings->hardeness = 1.0f;
780 
782  brush->gpencil_settings->draw_smoothfac = 0.0f;
783  brush->gpencil_settings->draw_smoothlvl = 2;
784  brush->gpencil_settings->draw_subdivide = 0;
785  brush->gpencil_settings->simplify_f = 0.000f;
786 
788  brush->gpencil_settings->draw_random_press = 0.6f;
789  brush->gpencil_settings->draw_random_strength = 0.0f;
790  brush->gpencil_settings->draw_jitter = 0.0f;
792 
793  /* Curve. */
794  custom_curve = brush->gpencil_settings->curve_sensitivity;
795  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
796  BKE_curvemapping_init(custom_curve);
797  brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INKNOISE);
798 
801 
802  zero_v3(brush->secondary_rgb);
803  break;
804  }
806  brush->size = 150.0f;
808 
809  brush->gpencil_settings->draw_strength = 0.3f;
810 
811  brush->gpencil_settings->input_samples = 10;
813  brush->gpencil_settings->draw_angle = 0.0f;
814  brush->gpencil_settings->draw_angle_factor = 0.0f;
815  brush->gpencil_settings->hardeness = 1.0f;
817 
819  brush->gpencil_settings->draw_smoothfac = 0.1f;
820  brush->gpencil_settings->draw_smoothlvl = 1;
821  brush->gpencil_settings->draw_subdivide = 0;
822  brush->gpencil_settings->simplify_f = 0.002f;
823 
825  brush->gpencil_settings->draw_random_press = 0.0f;
826  brush->gpencil_settings->draw_random_strength = 0.0f;
827  brush->gpencil_settings->draw_jitter = 0.0f;
829 
830  /* Curve. */
831  custom_curve = brush->gpencil_settings->curve_sensitivity;
832  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
833  BKE_curvemapping_init(custom_curve);
834  brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_MARKER);
835 
838 
839  zero_v3(brush->secondary_rgb);
840  break;
841  }
843  brush->size = 150.0f;
845 
846  brush->gpencil_settings->draw_strength = 1.0f;
847 
848  brush->gpencil_settings->input_samples = 10;
849  brush->gpencil_settings->active_smooth = 0.3f;
850  brush->gpencil_settings->draw_angle = DEG2RAD(35.0f);
851  brush->gpencil_settings->draw_angle_factor = 0.5f;
852  brush->gpencil_settings->hardeness = 1.0f;
854 
856  brush->gpencil_settings->draw_smoothfac = 0.0f;
857  brush->gpencil_settings->draw_smoothlvl = 1;
858  brush->gpencil_settings->draw_subdivide = 0;
859  brush->gpencil_settings->simplify_f = 0.002f;
860 
862  brush->gpencil_settings->draw_random_press = 0.0f;
863  brush->gpencil_settings->draw_jitter = 0.0f;
865 
866  /* Curve. */
867  custom_curve = brush->gpencil_settings->curve_sensitivity;
868  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
869  BKE_curvemapping_init(custom_curve);
870  brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_CHISEL_SENSIVITY);
871 
872  custom_curve = brush->gpencil_settings->curve_strength;
873  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
874  BKE_curvemapping_init(custom_curve);
875  brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_CHISEL_STRENGTH);
876 
879 
880  zero_v3(brush->secondary_rgb);
881  break;
882  }
883  case GP_BRUSH_PRESET_PEN: {
884  brush->size = 25.0f;
886 
887  brush->gpencil_settings->draw_strength = 1.0f;
889 
890  brush->gpencil_settings->input_samples = 10;
892  brush->gpencil_settings->draw_angle = 0.0f;
893  brush->gpencil_settings->draw_angle_factor = 0.0f;
894  brush->gpencil_settings->hardeness = 1.0f;
896 
898  brush->gpencil_settings->draw_smoothfac = 0.0f;
899  brush->gpencil_settings->draw_smoothlvl = 1;
900  brush->gpencil_settings->draw_subdivide = 1;
901  brush->gpencil_settings->simplify_f = 0.002f;
902 
903  brush->gpencil_settings->draw_random_press = 0.0f;
904  brush->gpencil_settings->draw_random_strength = 0.0f;
905  brush->gpencil_settings->draw_jitter = 0.0f;
907 
910 
911  zero_v3(brush->secondary_rgb);
912  break;
913  }
915  brush->size = 80.0f;
917 
918  brush->gpencil_settings->draw_strength = 0.4f;
920 
921  brush->gpencil_settings->input_samples = 10;
923  brush->gpencil_settings->draw_angle = 0.0f;
924  brush->gpencil_settings->draw_angle_factor = 0.0f;
925  brush->gpencil_settings->hardeness = 0.8f;
927 
929  brush->gpencil_settings->draw_smoothfac = 0.0f;
930  brush->gpencil_settings->draw_smoothlvl = 1;
931  brush->gpencil_settings->draw_subdivide = 0;
932  brush->gpencil_settings->simplify_f = 0.000f;
933 
934  brush->gpencil_settings->draw_random_press = 0.0f;
935  brush->gpencil_settings->draw_random_strength = 0.0f;
936  brush->gpencil_settings->draw_jitter = 0.0f;
938 
941 
942  zero_v3(brush->secondary_rgb);
943 
944  material_preset = PRESET_MATERIAL_DOT_STROKE;
945 
946  break;
947  }
948  case GP_BRUSH_PRESET_PENCIL: {
949  brush->size = 20.0f;
951 
952  brush->gpencil_settings->draw_strength = 0.6f;
954 
955  brush->gpencil_settings->input_samples = 10;
957  brush->gpencil_settings->draw_angle = 0.0f;
958  brush->gpencil_settings->draw_angle_factor = 0.0f;
959  brush->gpencil_settings->hardeness = 1.0f;
961 
963  brush->gpencil_settings->draw_smoothfac = 0.0f;
964  brush->gpencil_settings->draw_smoothlvl = 1;
965  brush->gpencil_settings->draw_subdivide = 0;
966  brush->gpencil_settings->simplify_f = 0.002f;
967 
968  brush->gpencil_settings->draw_random_press = 0.0f;
969  brush->gpencil_settings->draw_jitter = 0.0f;
971 
974 
975  zero_v3(brush->secondary_rgb);
976  break;
977  }
979  brush->size = 5.0f;
980 
981  brush->gpencil_settings->fill_leak = 3;
982  brush->gpencil_settings->fill_threshold = 0.1f;
983  brush->gpencil_settings->fill_simplylvl = 1;
984  brush->gpencil_settings->fill_factor = 1.0f;
985 
986  brush->gpencil_settings->draw_strength = 1.0f;
987  brush->gpencil_settings->hardeness = 1.0f;
989  brush->gpencil_settings->draw_smoothfac = 0.1f;
990  brush->gpencil_settings->draw_smoothlvl = 1;
991  brush->gpencil_settings->draw_subdivide = 1;
992  brush->gpencil_settings->dilate_pixels = 1;
993 
995 
999 
1000  zero_v3(brush->secondary_rgb);
1001  break;
1002  }
1004  brush->size = 30.0f;
1005  brush->gpencil_settings->draw_strength = 0.5f;
1012  brush->gpencil_settings->era_strength_f = 100.0f;
1013  brush->gpencil_settings->era_thickness_f = 10.0f;
1014 
1015  break;
1016  }
1018  brush->size = 30.0f;
1019  brush->gpencil_settings->draw_strength = 1.0f;
1021  brush->gpencil_settings->era_strength_f = 100.0f;
1022  brush->gpencil_settings->era_thickness_f = 50.0f;
1023 
1026 
1027  break;
1028  }
1030  brush->size = 30.0f;
1032 
1035 
1036  break;
1037  }
1039  brush->size = 30.0f;
1041 
1044 
1045  break;
1046  }
1047  case GP_BRUSH_PRESET_TINT: {
1049  brush->gpencil_tool = GPAINT_TOOL_TINT;
1050 
1051  brush->size = 25.0f;
1053 
1054  brush->gpencil_settings->draw_strength = 0.8f;
1056 
1057  zero_v3(brush->secondary_rgb);
1058  break;
1059  }
1063 
1064  brush->size = 25.0f;
1066 
1067  brush->gpencil_settings->draw_strength = 0.8f;
1069 
1070  zero_v3(brush->secondary_rgb);
1071  break;
1072  }
1076 
1077  brush->size = 25.0f;
1079 
1080  brush->gpencil_settings->draw_strength = 0.8f;
1082 
1083  zero_v3(brush->secondary_rgb);
1084  break;
1085  }
1089 
1090  brush->size = 25.0f;
1092 
1093  brush->gpencil_settings->draw_strength = 0.8f;
1095 
1096  zero_v3(brush->secondary_rgb);
1097  break;
1098  }
1102 
1103  brush->size = 25.0f;
1105 
1106  brush->gpencil_settings->draw_strength = 0.8f;
1108 
1109  zero_v3(brush->secondary_rgb);
1110  break;
1111  }
1115 
1116  brush->size = 25.0f;
1118 
1119  brush->gpencil_settings->draw_strength = 0.8f;
1121 
1122  zero_v3(brush->secondary_rgb);
1123  break;
1124  }
1128 
1129  brush->size = 25.0f;
1131 
1132  brush->gpencil_settings->draw_strength = 0.3f;
1136 
1137  break;
1138  }
1142 
1143  brush->size = 25.0f;
1145 
1146  brush->gpencil_settings->draw_strength = 0.3f;
1149 
1150  break;
1151  }
1155 
1156  brush->size = 25.0f;
1158 
1159  brush->gpencil_settings->draw_strength = 0.5f;
1162 
1163  break;
1164  }
1169 
1170  brush->size = 25.0f;
1171 
1172  brush->gpencil_settings->draw_strength = 0.3f;
1175 
1176  break;
1177  }
1181 
1182  brush->size = 25.0f;
1184 
1185  brush->gpencil_settings->draw_strength = 0.3f;
1188 
1189  break;
1190  }
1194 
1195  brush->size = 50.0f;
1197 
1198  brush->gpencil_settings->draw_strength = 0.3f;
1201 
1202  break;
1203  }
1207 
1208  brush->size = 50.0f;
1210 
1211  brush->gpencil_settings->draw_strength = 0.5f;
1214 
1215  break;
1216  }
1220 
1221  brush->size = 25.0f;
1223 
1224  brush->gpencil_settings->draw_strength = 0.5f;
1227 
1228  break;
1229  }
1234 
1235  brush->size = 25.0f;
1236 
1237  brush->gpencil_settings->draw_strength = 1.0f;
1240 
1241  break;
1242  }
1246 
1247  brush->size = 25.0f;
1249 
1250  brush->gpencil_settings->draw_strength = 0.8f;
1253 
1254  break;
1255  }
1256  default:
1257  break;
1258  }
1259 
1260  switch (material_preset) {
1261  case PRESET_MATERIAL_NONE:
1262  break;
1263  case PRESET_MATERIAL_DOT_STROKE: {
1264  /* Create and link Black Dots material to brush.
1265  * This material is required because the brush uses the material
1266  * to define how the stroke is drawn. */
1267  const char *ma_id = "Dots Stroke";
1268  Material *ma = (Material *)BLI_findstring(&bmain->materials, ma_id, offsetof(ID, name) + 2);
1269  if (ma == nullptr) {
1270  ma = BKE_gpencil_material_add(bmain, ma_id);
1272  BLI_assert(ma->id.us == 1);
1273  id_us_min(&ma->id);
1274  }
1275 
1276  BKE_gpencil_brush_material_set(brush, ma);
1277 
1278  /* Pin the material to the brush. */
1280  break;
1281  }
1282  }
1283 }
1284 
1286  Main *bmain, ToolSettings *ts, const char *brush_name, eObjectMode mode, bool *r_new)
1287 {
1288  *r_new = false;
1289  Brush *brush = (Brush *)BLI_findstring(&bmain->brushes, brush_name, offsetof(ID, name) + 2);
1290 
1291  /* If the brush exist, but the type is not GPencil or the mode is wrong, create a new one. */
1292  if ((brush != nullptr) && ((brush->gpencil_settings == nullptr) || (brush->ob_mode != mode))) {
1293  brush = nullptr;
1294  }
1295 
1296  if (brush == nullptr) {
1297  brush = BKE_brush_add_gpencil(bmain, ts, brush_name, mode);
1298  *r_new = true;
1299  }
1300 
1301  if (brush->gpencil_settings == nullptr) {
1303  }
1304 
1305  return brush;
1306 }
1307 
1309 {
1310  bool r_new = false;
1311 
1312  Paint *paint = &ts->gp_paint->paint;
1313  Brush *brush_prev = paint->brush;
1314  Brush *brush, *deft_draw;
1315  /* Airbrush brush. */
1316  brush = gpencil_brush_ensure(bmain, ts, "Airbrush", OB_MODE_PAINT_GPENCIL, &r_new);
1317  if ((reset) || (r_new)) {
1319  }
1320 
1321  /* Ink Pen brush. */
1322  brush = gpencil_brush_ensure(bmain, ts, "Ink Pen", OB_MODE_PAINT_GPENCIL, &r_new);
1323  if ((reset) || (r_new)) {
1325  }
1326 
1327  /* Ink Pen Rough brush. */
1328  brush = gpencil_brush_ensure(bmain, ts, "Ink Pen Rough", OB_MODE_PAINT_GPENCIL, &r_new);
1329  if ((reset) || (r_new)) {
1331  }
1332 
1333  /* Marker Bold brush. */
1334  brush = gpencil_brush_ensure(bmain, ts, "Marker Bold", OB_MODE_PAINT_GPENCIL, &r_new);
1335  if ((reset) || (r_new)) {
1337  }
1338 
1339  /* Marker Chisel brush. */
1340  brush = gpencil_brush_ensure(bmain, ts, "Marker Chisel", OB_MODE_PAINT_GPENCIL, &r_new);
1341  if ((reset) || (r_new)) {
1343  }
1344 
1345  /* Pen brush. */
1346  brush = gpencil_brush_ensure(bmain, ts, "Pen", OB_MODE_PAINT_GPENCIL, &r_new);
1347  if ((reset) || (r_new)) {
1349  }
1350 
1351  /* Pencil Soft brush. */
1352  brush = gpencil_brush_ensure(bmain, ts, "Pencil Soft", OB_MODE_PAINT_GPENCIL, &r_new);
1353  if ((reset) || (r_new)) {
1355  }
1356 
1357  /* Pencil brush. */
1358  brush = gpencil_brush_ensure(bmain, ts, "Pencil", OB_MODE_PAINT_GPENCIL, &r_new);
1359  if ((reset) || (r_new)) {
1361  }
1362  deft_draw = brush; /* save default brush. */
1363 
1364  /* Fill brush. */
1365  brush = gpencil_brush_ensure(bmain, ts, "Fill Area", OB_MODE_PAINT_GPENCIL, &r_new);
1366  if ((reset) || (r_new)) {
1368  }
1369 
1370  /* Soft Eraser brush. */
1371  brush = gpencil_brush_ensure(bmain, ts, "Eraser Soft", OB_MODE_PAINT_GPENCIL, &r_new);
1372  if ((reset) || (r_new)) {
1374  }
1375 
1376  /* Hard Eraser brush. */
1377  brush = gpencil_brush_ensure(bmain, ts, "Eraser Hard", OB_MODE_PAINT_GPENCIL, &r_new);
1378  if ((reset) || (r_new)) {
1380  }
1381 
1382  /* Point Eraser brush. */
1383  brush = gpencil_brush_ensure(bmain, ts, "Eraser Point", OB_MODE_PAINT_GPENCIL, &r_new);
1384  if ((reset) || (r_new)) {
1386  }
1387 
1388  /* Stroke Eraser brush. */
1389  brush = gpencil_brush_ensure(bmain, ts, "Eraser Stroke", OB_MODE_PAINT_GPENCIL, &r_new);
1390  if ((reset) || (r_new)) {
1392  }
1393 
1394  /* Tint brush. */
1395  brush = gpencil_brush_ensure(bmain, ts, "Tint", OB_MODE_PAINT_GPENCIL, &r_new);
1396  if ((reset) || (r_new)) {
1398  }
1399 
1400  /* Set default Draw brush. */
1401  if ((reset == false) && (brush_prev != nullptr)) {
1402  BKE_paint_brush_set(paint, brush_prev);
1403  }
1404  else {
1405  BKE_paint_brush_set(paint, deft_draw);
1406  }
1407 }
1408 
1410 {
1411  bool r_new = false;
1412 
1413  Paint *vertexpaint = &ts->gp_vertexpaint->paint;
1414  Brush *brush_prev = vertexpaint->brush;
1415  Brush *brush, *deft_vertex;
1416  /* Vertex Draw brush. */
1417  brush = gpencil_brush_ensure(bmain, ts, "Vertex Draw", OB_MODE_VERTEX_GPENCIL, &r_new);
1418  if ((reset) || (r_new)) {
1420  }
1421  deft_vertex = brush; /* save default brush. */
1422 
1423  /* Vertex Blur brush. */
1424  brush = gpencil_brush_ensure(bmain, ts, "Vertex Blur", OB_MODE_VERTEX_GPENCIL, &r_new);
1425  if ((reset) || (r_new)) {
1427  }
1428  /* Vertex Average brush. */
1429  brush = gpencil_brush_ensure(bmain, ts, "Vertex Average", OB_MODE_VERTEX_GPENCIL, &r_new);
1430  if ((reset) || (r_new)) {
1432  }
1433  /* Vertex Smear brush. */
1434  brush = gpencil_brush_ensure(bmain, ts, "Vertex Smear", OB_MODE_VERTEX_GPENCIL, &r_new);
1435  if ((reset) || (r_new)) {
1437  }
1438  /* Vertex Replace brush. */
1439  brush = gpencil_brush_ensure(bmain, ts, "Vertex Replace", OB_MODE_VERTEX_GPENCIL, &r_new);
1440  if ((reset) || (r_new)) {
1442  }
1443 
1444  /* Set default Vertex brush. */
1445  if (reset || brush_prev == nullptr) {
1446  BKE_paint_brush_set(vertexpaint, deft_vertex);
1447  }
1448  else {
1449  if (brush_prev != nullptr) {
1450  BKE_paint_brush_set(vertexpaint, brush_prev);
1451  }
1452  }
1453 }
1454 
1456 {
1457  bool r_new = false;
1458 
1459  Paint *sculptpaint = &ts->gp_sculptpaint->paint;
1460  Brush *brush_prev = sculptpaint->brush;
1461  Brush *brush, *deft_sculpt;
1462 
1463  /* Smooth brush. */
1464  brush = gpencil_brush_ensure(bmain, ts, "Smooth Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1465  if ((reset) || (r_new)) {
1467  }
1468  deft_sculpt = brush;
1469 
1470  /* Strength brush. */
1471  brush = gpencil_brush_ensure(bmain, ts, "Strength Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1472  if ((reset) || (r_new)) {
1474  }
1475 
1476  /* Thickness brush. */
1477  brush = gpencil_brush_ensure(bmain, ts, "Thickness Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1478  if ((reset) || (r_new)) {
1480  }
1481 
1482  /* Grab brush. */
1483  brush = gpencil_brush_ensure(bmain, ts, "Grab Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1484  if ((reset) || (r_new)) {
1486  }
1487 
1488  /* Push brush. */
1489  brush = gpencil_brush_ensure(bmain, ts, "Push Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1490  if ((reset) || (r_new)) {
1492  }
1493 
1494  /* Twist brush. */
1495  brush = gpencil_brush_ensure(bmain, ts, "Twist Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1496  if ((reset) || (r_new)) {
1498  }
1499 
1500  /* Pinch brush. */
1501  brush = gpencil_brush_ensure(bmain, ts, "Pinch Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1502  if ((reset) || (r_new)) {
1504  }
1505 
1506  /* Randomize brush. */
1507  brush = gpencil_brush_ensure(bmain, ts, "Randomize Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1508  if ((reset) || (r_new)) {
1510  }
1511 
1512  /* Clone brush. */
1513  brush = gpencil_brush_ensure(bmain, ts, "Clone Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1514  if ((reset) || (r_new)) {
1516  }
1517 
1518  /* Set default brush. */
1519  if (reset || brush_prev == nullptr) {
1520  BKE_paint_brush_set(sculptpaint, deft_sculpt);
1521  }
1522  else {
1523  if (brush_prev != nullptr) {
1524  BKE_paint_brush_set(sculptpaint, brush_prev);
1525  }
1526  }
1527 }
1528 
1530 {
1531  bool r_new = false;
1532 
1533  Paint *weightpaint = &ts->gp_weightpaint->paint;
1534  Brush *brush_prev = weightpaint->brush;
1535  Brush *brush, *deft_weight;
1536  /* Vertex Draw brush. */
1537  brush = gpencil_brush_ensure(bmain, ts, "Draw Weight", OB_MODE_WEIGHT_GPENCIL, &r_new);
1538  if ((reset) || (r_new)) {
1540  }
1541  deft_weight = brush; /* save default brush. */
1542 
1543  /* Set default brush. */
1544  if (reset || brush_prev == nullptr) {
1545  BKE_paint_brush_set(weightpaint, deft_weight);
1546  }
1547  else {
1548  if (brush_prev != nullptr) {
1549  BKE_paint_brush_set(weightpaint, brush_prev);
1550  }
1551  }
1552 }
1553 
1555 {
1556  if (brush->curves_sculpt_settings == nullptr) {
1557  brush->curves_sculpt_settings = MEM_cnew<BrushCurvesSculptSettings>(__func__);
1558  }
1560  settings->add_amount = 1;
1561  settings->points_per_curve = 8;
1562  settings->minimum_length = 0.01f;
1563  settings->curve_length = 0.3f;
1564  settings->density_add_attempts = 100;
1565 }
1566 
1567 struct Brush *BKE_brush_first_search(struct Main *bmain, const eObjectMode ob_mode)
1568 {
1569  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
1570  if (brush->ob_mode & ob_mode) {
1571  return brush;
1572  }
1573  }
1574  return nullptr;
1575 }
1576 
1578 {
1579  /* create a fake brush and set it to the defaults */
1580  Brush def = {{nullptr}};
1581  brush_defaults(&def);
1582 
1583 #define BR_TEST(field, t) \
1584  if (br->field != def.field) { \
1585  printf("br->" #field " = %" #t ";\n", br->field); \
1586  } \
1587  ((void)0)
1588 
1589 #define BR_TEST_FLAG(_f) \
1590  if ((br->flag & _f) && !(def.flag & _f)) { \
1591  printf("br->flag |= " #_f ";\n"); \
1592  } \
1593  else if (!(br->flag & _f) && (def.flag & _f)) { \
1594  printf("br->flag &= ~" #_f ";\n"); \
1595  } \
1596  ((void)0)
1597 
1598 #define BR_TEST_FLAG_OVERLAY(_f) \
1599  if ((br->overlay_flags & _f) && !(def.overlay_flags & _f)) { \
1600  printf("br->overlay_flags |= " #_f ";\n"); \
1601  } \
1602  else if (!(br->overlay_flags & _f) && (def.overlay_flags & _f)) { \
1603  printf("br->overlay_flags &= ~" #_f ";\n"); \
1604  } \
1605  ((void)0)
1606 
1607  /* print out any non-default brush state */
1608  BR_TEST(normal_weight, f);
1609 
1610  BR_TEST(blend, d);
1611  BR_TEST(size, d);
1612 
1613  /* br->flag */
1637 
1644 
1645  BR_TEST(jitter, f);
1646  BR_TEST(spacing, d);
1649  BR_TEST(rate, f);
1650 
1651  BR_TEST(alpha, f);
1652 
1653  BR_TEST(sculpt_plane, d);
1654 
1655  BR_TEST(plane_offset, f);
1656 
1658 
1660 
1662 
1663  BR_TEST(plane_trim, f);
1664 
1667 
1668  BR_TEST(add_col[0], f);
1669  BR_TEST(add_col[1], f);
1670  BR_TEST(add_col[2], f);
1671  BR_TEST(add_col[3], f);
1672  BR_TEST(sub_col[0], f);
1673  BR_TEST(sub_col[1], f);
1674  BR_TEST(sub_col[2], f);
1675  BR_TEST(sub_col[3], f);
1676 
1677  printf("\n");
1678 
1679 #undef BR_TEST
1680 #undef BR_TEST_FLAG
1681 }
1682 
1684 {
1685  /* enable this to see any non-default
1686  * settings used by a brush: */
1687  // BKE_brush_debug_print_state(br);
1688 
1689  brush_defaults(br);
1691 
1692  /* Use the curve presets by default */
1694 
1695  /* Note that sculpt defaults where set when 0.5 was the default (now it's 1.0)
1696  * assign this so logic below can remain the same. */
1697  br->alpha = 0.5f;
1698 
1699  /* Brush settings */
1700  switch (br->sculpt_tool) {
1702  br->flag |= BRUSH_DIR_IN;
1704  br->spacing = 5;
1705  break;
1708  br->spacing = 10;
1709  br->alpha = 1.0f;
1710  break;
1712  br->spacing = 10;
1713  br->alpha = 1.0f;
1715  break;
1716  case SCULPT_TOOL_CLAY:
1717  br->flag |= BRUSH_SIZE_PRESSURE;
1718  br->spacing = 3;
1719  br->autosmooth_factor = 0.25f;
1720  br->normal_radius_factor = 0.75f;
1721  br->hardness = 0.65f;
1722  break;
1724  br->alpha = 0.5f;
1725  br->normal_radius_factor = 1.0f;
1726  br->spacing = 6;
1727  br->hardness = 0.5f;
1728  br->flag |= BRUSH_SIZE_PRESSURE;
1729  br->flag &= ~BRUSH_SPACE_ATTEN;
1730  break;
1733  br->flag &= ~BRUSH_SPACE_ATTEN;
1734  br->alpha = 0.6f;
1735  br->spacing = 5;
1736  br->normal_radius_factor = 1.55f;
1737  br->tip_roundness = 0.18f;
1739  break;
1742  br->alpha = 0.7f;
1743  br->normal_radius_factor = 0.70f;
1744  br->multiplane_scrape_angle = 60;
1746  br->spacing = 5;
1747  break;
1748  case SCULPT_TOOL_CREASE:
1749  br->flag |= BRUSH_DIR_IN;
1750  br->alpha = 0.25;
1751  break;
1752  case SCULPT_TOOL_SCRAPE:
1753  case SCULPT_TOOL_FILL:
1754  br->alpha = 0.7f;
1755  br->area_radius_factor = 0.5f;
1756  br->spacing = 7;
1757  br->flag |= BRUSH_ACCUMULATE;
1759  break;
1760  case SCULPT_TOOL_ROTATE:
1761  br->alpha = 1.0;
1762  break;
1763  case SCULPT_TOOL_SMOOTH:
1764  br->flag &= ~BRUSH_SPACE_ATTEN;
1765  br->spacing = 5;
1766  br->alpha = 0.7f;
1768  br->surface_smooth_current_vertex = 0.5f;
1769  br->surface_smooth_iterations = 4;
1770  break;
1772  br->alpha = 1.0f;
1773  br->rake_factor = 1.0f;
1774  break;
1775  case SCULPT_TOOL_THUMB:
1776  br->size = 75;
1777  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1778  br->flag &= ~BRUSH_SPACE;
1779  br->flag &= ~BRUSH_SPACE_ATTEN;
1780  break;
1784  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1785  br->flag &= ~BRUSH_SPACE;
1786  br->flag &= ~BRUSH_SPACE_ATTEN;
1787  break;
1788  case SCULPT_TOOL_POSE:
1789  br->pose_smooth_iterations = 4;
1790  br->pose_ik_segments = 1;
1792  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1793  br->flag &= ~BRUSH_SPACE;
1794  br->flag &= ~BRUSH_SPACE_ATTEN;
1795  break;
1796  case SCULPT_TOOL_BOUNDARY:
1797  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1798  br->flag &= ~BRUSH_SPACE;
1799  br->flag &= ~BRUSH_SPACE_ATTEN;
1801  break;
1803  br->alpha = 0.5f;
1804  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1805  br->flag &= ~BRUSH_SPACE;
1806  br->flag &= ~BRUSH_SPACE_ATTEN;
1807  break;
1808  case SCULPT_TOOL_GRAB:
1809  br->alpha = 0.4f;
1810  br->size = 75;
1811  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1812  br->flag &= ~BRUSH_SPACE;
1813  br->flag &= ~BRUSH_SPACE_ATTEN;
1814  break;
1815  case SCULPT_TOOL_CLOTH:
1816  br->cloth_mass = 1.0f;
1817  br->cloth_damping = 0.01f;
1818  br->cloth_sim_limit = 2.5f;
1819  br->cloth_sim_falloff = 0.75f;
1822  break;
1823  case SCULPT_TOOL_LAYER:
1824  br->flag &= ~BRUSH_SPACE_ATTEN;
1825  br->hardness = 0.35f;
1826  br->alpha = 1.0f;
1827  br->height = 0.05f;
1828  break;
1829  case SCULPT_TOOL_PAINT:
1830  br->hardness = 0.4f;
1831  br->spacing = 10;
1832  br->alpha = 0.6f;
1833  br->flow = 1.0f;
1834  br->tip_scale_x = 1.0f;
1835  br->tip_roundness = 1.0f;
1836  br->density = 1.0f;
1837  br->flag &= ~BRUSH_SPACE_ATTEN;
1838  copy_v3_fl(br->rgb, 1.0f);
1839  zero_v3(br->secondary_rgb);
1840  break;
1841  case SCULPT_TOOL_SMEAR:
1842  br->alpha = 1.0f;
1843  br->spacing = 5;
1844  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1845  br->flag &= ~BRUSH_SPACE_ATTEN;
1847  break;
1849  br->alpha = 1.0f;
1850  br->spacing = 5;
1851  br->hardness = 0.7f;
1852  br->flag &= ~BRUSH_ALPHA_PRESSURE;
1853  br->flag &= ~BRUSH_SPACE_ATTEN;
1855  break;
1856  default:
1857  break;
1858  }
1859 
1860  /* Cursor colors */
1861 
1862  /* Default Alpha */
1863  br->add_col[3] = 0.90f;
1864  br->sub_col[3] = 0.90f;
1865 
1866  switch (br->sculpt_tool) {
1867  case SCULPT_TOOL_DRAW:
1869  case SCULPT_TOOL_CLAY:
1872  case SCULPT_TOOL_LAYER:
1873  case SCULPT_TOOL_INFLATE:
1874  case SCULPT_TOOL_BLOB:
1875  case SCULPT_TOOL_CREASE:
1876  br->add_col[0] = 0.0f;
1877  br->add_col[1] = 0.5f;
1878  br->add_col[2] = 1.0f;
1879  br->sub_col[0] = 0.0f;
1880  br->sub_col[1] = 0.5f;
1881  br->sub_col[2] = 1.0f;
1882  break;
1883 
1884  case SCULPT_TOOL_SMOOTH:
1885  case SCULPT_TOOL_FLATTEN:
1886  case SCULPT_TOOL_FILL:
1887  case SCULPT_TOOL_SCRAPE:
1889  br->add_col[0] = 0.877f;
1890  br->add_col[1] = 0.142f;
1891  br->add_col[2] = 0.117f;
1892  br->sub_col[0] = 0.877f;
1893  br->sub_col[1] = 0.142f;
1894  br->sub_col[2] = 0.117f;
1895  break;
1896 
1897  case SCULPT_TOOL_PINCH:
1898  case SCULPT_TOOL_GRAB:
1900  case SCULPT_TOOL_THUMB:
1901  case SCULPT_TOOL_NUDGE:
1902  case SCULPT_TOOL_ROTATE:
1904  case SCULPT_TOOL_POSE:
1905  case SCULPT_TOOL_BOUNDARY:
1907  br->add_col[0] = 1.0f;
1908  br->add_col[1] = 0.95f;
1909  br->add_col[2] = 0.005f;
1910  br->sub_col[0] = 1.0f;
1911  br->sub_col[1] = 0.95f;
1912  br->sub_col[2] = 0.005f;
1913  break;
1914 
1915  case SCULPT_TOOL_SIMPLIFY:
1916  case SCULPT_TOOL_PAINT:
1917  case SCULPT_TOOL_MASK:
1921  br->add_col[0] = 0.75f;
1922  br->add_col[1] = 0.75f;
1923  br->add_col[2] = 0.75f;
1924  br->sub_col[0] = 0.75f;
1925  br->sub_col[1] = 0.75f;
1926  br->sub_col[2] = 0.75f;
1927  break;
1928 
1929  case SCULPT_TOOL_CLOTH:
1930  br->add_col[0] = 1.0f;
1931  br->add_col[1] = 0.5f;
1932  br->add_col[2] = 0.1f;
1933  br->sub_col[0] = 1.0f;
1934  br->sub_col[1] = 0.5f;
1935  br->sub_col[2] = 0.1f;
1936  break;
1937  default:
1938  break;
1939  }
1940 }
1941 
1943 {
1944  CurveMapping *cumap = nullptr;
1945  CurveMap *cuma = nullptr;
1946 
1947  if (!b->curve) {
1948  b->curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
1949  }
1950  cumap = b->curve;
1951  cumap->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1952  cumap->preset = preset;
1953 
1954  cuma = b->curve->cm;
1955  BKE_curvemap_reset(cuma, &cumap->clipr, cumap->preset, CURVEMAP_SLOPE_NEGATIVE);
1956  BKE_curvemapping_changed(cumap, false);
1957 }
1958 
1960  const Brush *br,
1961  const float point[3],
1962  float rgba[4],
1963  const int thread,
1964  struct ImagePool *pool)
1965 {
1967  const MTex *mtex = &br->mtex;
1968  float intensity = 1.0;
1969  bool hasrgb = false;
1970 
1971  if (!mtex->tex) {
1972  intensity = 1;
1973  }
1974  else if (mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
1975  /* Get strength by feeding the vertex
1976  * location directly into a texture */
1977  hasrgb = RE_texture_evaluate(mtex, point, thread, pool, false, false, &intensity, rgba);
1978  }
1979  else if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
1980  float rotation = -mtex->rot;
1981  const float point_2d[2] = {point[0], point[1]};
1982  float x, y;
1983  float co[3];
1984 
1985  x = point_2d[0] - br->stencil_pos[0];
1986  y = point_2d[1] - br->stencil_pos[1];
1987 
1988  if (rotation > 0.001f || rotation < -0.001f) {
1989  const float angle = atan2f(y, x) + rotation;
1990  const float flen = sqrtf(x * x + y * y);
1991 
1992  x = flen * cosf(angle);
1993  y = flen * sinf(angle);
1994  }
1995 
1996  if (fabsf(x) > br->stencil_dimension[0] || fabsf(y) > br->stencil_dimension[1]) {
1997  zero_v4(rgba);
1998  return 0.0f;
1999  }
2000  x /= (br->stencil_dimension[0]);
2001  y /= (br->stencil_dimension[1]);
2002 
2003  co[0] = x;
2004  co[1] = y;
2005  co[2] = 0.0f;
2006 
2007  hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2008  }
2009  else {
2010  float rotation = -mtex->rot;
2011  const float point_2d[2] = {point[0], point[1]};
2012  float x = 0.0f, y = 0.0f; /* Quite warnings */
2013  float invradius = 1.0f; /* Quite warnings */
2014  float co[3];
2015 
2017  /* keep coordinates relative to mouse */
2018 
2019  rotation += ups->brush_rotation;
2020 
2021  x = point_2d[0] - ups->tex_mouse[0];
2022  y = point_2d[1] - ups->tex_mouse[1];
2023 
2024  /* use pressure adjusted size for fixed mode */
2025  invradius = 1.0f / ups->pixel_radius;
2026  }
2027  else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
2028  /* leave the coordinates relative to the screen */
2029 
2030  /* use unadjusted size for tiled mode */
2031  invradius = 1.0f / ups->start_pixel_radius;
2032 
2033  x = point_2d[0];
2034  y = point_2d[1];
2035  }
2036  else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
2037  rotation += ups->brush_rotation;
2038  /* these contain a random coordinate */
2039  x = point_2d[0] - ups->tex_mouse[0];
2040  y = point_2d[1] - ups->tex_mouse[1];
2041 
2042  invradius = 1.0f / ups->pixel_radius;
2043  }
2044 
2045  x *= invradius;
2046  y *= invradius;
2047 
2048  /* it is probably worth optimizing for those cases where
2049  * the texture is not rotated by skipping the calls to
2050  * atan2, sqrtf, sin, and cos. */
2051  if (rotation > 0.001f || rotation < -0.001f) {
2052  const float angle = atan2f(y, x) + rotation;
2053  const float flen = sqrtf(x * x + y * y);
2054 
2055  x = flen * cosf(angle);
2056  y = flen * sinf(angle);
2057  }
2058 
2059  co[0] = x;
2060  co[1] = y;
2061  co[2] = 0.0f;
2062 
2063  hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2064  }
2065 
2066  intensity += br->texture_sample_bias;
2067 
2068  if (!hasrgb) {
2069  rgba[0] = intensity;
2070  rgba[1] = intensity;
2071  rgba[2] = intensity;
2072  rgba[3] = 1.0f;
2073  }
2074  /* For consistency, sampling always returns color in linear space */
2075  else if (ups->do_linear_conversion) {
2077  }
2078 
2079  return intensity;
2080 }
2081 
2083  const Scene *scene, Brush *br, const float point[2], const int thread, struct ImagePool *pool)
2084 {
2086  MTex *mtex = &br->mask_mtex;
2087  float rgba[4], intensity;
2088 
2089  if (!mtex->tex) {
2090  return 1.0f;
2091  }
2093  float rotation = -mtex->rot;
2094  const float point_2d[2] = {point[0], point[1]};
2095  float x, y;
2096  float co[3];
2097 
2098  x = point_2d[0] - br->mask_stencil_pos[0];
2099  y = point_2d[1] - br->mask_stencil_pos[1];
2100 
2101  if (rotation > 0.001f || rotation < -0.001f) {
2102  const float angle = atan2f(y, x) + rotation;
2103  const float flen = sqrtf(x * x + y * y);
2104 
2105  x = flen * cosf(angle);
2106  y = flen * sinf(angle);
2107  }
2108 
2109  if (fabsf(x) > br->mask_stencil_dimension[0] || fabsf(y) > br->mask_stencil_dimension[1]) {
2110  zero_v4(rgba);
2111  return 0.0f;
2112  }
2113  x /= (br->mask_stencil_dimension[0]);
2114  y /= (br->mask_stencil_dimension[1]);
2115 
2116  co[0] = x;
2117  co[1] = y;
2118  co[2] = 0.0f;
2119 
2120  RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2121  }
2122  else {
2123  float rotation = -mtex->rot;
2124  const float point_2d[2] = {point[0], point[1]};
2125  float x = 0.0f, y = 0.0f; /* Quite warnings */
2126  float invradius = 1.0f; /* Quite warnings */
2127  float co[3];
2128 
2130  /* keep coordinates relative to mouse */
2131 
2132  rotation += ups->brush_rotation_sec;
2133 
2134  x = point_2d[0] - ups->mask_tex_mouse[0];
2135  y = point_2d[1] - ups->mask_tex_mouse[1];
2136 
2137  /* use pressure adjusted size for fixed mode */
2138  invradius = 1.0f / ups->pixel_radius;
2139  }
2140  else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
2141  /* leave the coordinates relative to the screen */
2142 
2143  /* use unadjusted size for tiled mode */
2144  invradius = 1.0f / ups->start_pixel_radius;
2145 
2146  x = point_2d[0];
2147  y = point_2d[1];
2148  }
2149  else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
2150  rotation += ups->brush_rotation_sec;
2151  /* these contain a random coordinate */
2152  x = point_2d[0] - ups->mask_tex_mouse[0];
2153  y = point_2d[1] - ups->mask_tex_mouse[1];
2154 
2155  invradius = 1.0f / ups->pixel_radius;
2156  }
2157 
2158  x *= invradius;
2159  y *= invradius;
2160 
2161  /* it is probably worth optimizing for those cases where
2162  * the texture is not rotated by skipping the calls to
2163  * atan2, sqrtf, sin, and cos. */
2164  if (rotation > 0.001f || rotation < -0.001f) {
2165  const float angle = atan2f(y, x) + rotation;
2166  const float flen = sqrtf(x * x + y * y);
2167 
2168  x = flen * cosf(angle);
2169  y = flen * sinf(angle);
2170  }
2171 
2172  co[0] = x;
2173  co[1] = y;
2174  co[2] = 0.0f;
2175 
2176  RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2177  }
2178 
2179  CLAMP(intensity, 0.0f, 1.0f);
2180 
2181  switch (br->mask_pressure) {
2183  intensity = ((1.0f - intensity) < ups->size_pressure_value) ? 1.0f : 0.0f;
2184  break;
2186  intensity = ups->size_pressure_value + intensity * (1.0f - ups->size_pressure_value);
2187  break;
2188  default:
2189  break;
2190  }
2191 
2192  return intensity;
2193 }
2194 
2195 /* Unified Size / Strength / Color */
2196 
2197 /* XXX: be careful about setting size and unprojected radius
2198  * because they depend on one another
2199  * these functions do not set the other corresponding value
2200  * this can lead to odd behavior if size and unprojected
2201  * radius become inconsistent.
2202  * the biggest problem is that it isn't possible to change
2203  * unprojected radius because a view context is not
2204  * available. my usual solution to this is to use the
2205  * ratio of change of the size to change the unprojected
2206  * radius. Not completely convinced that is correct.
2207  * In any case, a better solution is needed to prevent
2208  * inconsistency. */
2209 
2210 const float *BKE_brush_color_get(const struct Scene *scene, const struct Brush *brush)
2211 {
2213  return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->rgb : brush->rgb;
2214 }
2215 
2216 const float *BKE_brush_secondary_color_get(const struct Scene *scene, const struct Brush *brush)
2217 {
2219  return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->secondary_rgb : brush->secondary_rgb;
2220 }
2221 
2222 void BKE_brush_color_set(struct Scene *scene, struct Brush *brush, const float color[3])
2223 {
2225 
2226  if (ups->flag & UNIFIED_PAINT_COLOR) {
2227  copy_v3_v3(ups->rgb, color);
2228  }
2229  else {
2230  copy_v3_v3(brush->rgb, color);
2231  }
2232 }
2233 
2235 {
2237 
2238  /* make sure range is sane */
2240 
2241  if (ups->flag & UNIFIED_PAINT_SIZE) {
2242  ups->size = size;
2243  }
2244  else {
2245  brush->size = size;
2246  }
2247 }
2248 
2249 int BKE_brush_size_get(const Scene *scene, const Brush *brush)
2250 {
2252  int size = (ups->flag & UNIFIED_PAINT_SIZE) ? ups->size : brush->size;
2253 
2254  return size;
2255 }
2256 
2257 bool BKE_brush_use_locked_size(const Scene *scene, const Brush *brush)
2258 {
2259  const short us_flag = scene->toolsettings->unified_paint_settings.flag;
2260 
2261  return (us_flag & UNIFIED_PAINT_SIZE) ? (us_flag & UNIFIED_PAINT_BRUSH_LOCK_SIZE) :
2262  (brush->flag & BRUSH_LOCK_SIZE);
2263 }
2264 
2266 {
2267  return brush->flag & BRUSH_SIZE_PRESSURE;
2268 }
2269 
2271 {
2272  return brush->flag & BRUSH_ALPHA_PRESSURE;
2273 }
2274 
2276 {
2277  return ELEM(brush->sculpt_tool,
2292 }
2293 
2295 {
2297 
2298  if (ups->flag & UNIFIED_PAINT_SIZE) {
2300  }
2301  else {
2303  }
2304 }
2305 
2307 {
2309 
2310  return (ups->flag & UNIFIED_PAINT_SIZE) ? ups->unprojected_radius : brush->unprojected_radius;
2311 }
2312 
2314 {
2316 
2317  if (ups->flag & UNIFIED_PAINT_ALPHA) {
2318  ups->alpha = alpha;
2319  }
2320  else {
2321  brush->alpha = alpha;
2322  }
2323 }
2324 
2325 float BKE_brush_alpha_get(const Scene *scene, const Brush *brush)
2326 {
2328 
2329  return (ups->flag & UNIFIED_PAINT_ALPHA) ? ups->alpha : brush->alpha;
2330 }
2331 
2332 float BKE_brush_weight_get(const Scene *scene, const Brush *brush)
2333 {
2335 
2336  return (ups->flag & UNIFIED_PAINT_WEIGHT) ? ups->weight : brush->weight;
2337 }
2338 
2339 void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
2340 {
2342 
2343  if (ups->flag & UNIFIED_PAINT_WEIGHT) {
2344  ups->weight = value;
2345  }
2346  else {
2347  brush->weight = value;
2348  }
2349 }
2350 
2352  int new_brush_size,
2353  int old_brush_size)
2354 {
2355  float scale = new_brush_size;
2356  /* avoid division by zero */
2357  if (old_brush_size != 0) {
2358  scale /= (float)old_brush_size;
2359  }
2360  (*unprojected_radius) *= scale;
2361 }
2362 
2363 void BKE_brush_scale_size(int *r_brush_size,
2364  float new_unprojected_radius,
2365  float old_unprojected_radius)
2366 {
2367  float scale = new_unprojected_radius;
2368  /* avoid division by zero */
2369  if (old_unprojected_radius != 0) {
2370  scale /= new_unprojected_radius;
2371  }
2372  (*r_brush_size) = (int)((float)(*r_brush_size) * scale);
2373 }
2374 
2375 void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
2376 {
2377  float rand_pos[2];
2378  float spread;
2379  int diameter;
2380 
2381  do {
2382  rand_pos[0] = BLI_rng_get_float(brush_rng) - 0.5f;
2383  rand_pos[1] = BLI_rng_get_float(brush_rng) - 0.5f;
2384  } while (len_squared_v2(rand_pos) > square_f(0.5f));
2385 
2386  if (brush->flag & BRUSH_ABSOLUTE_JITTER) {
2387  diameter = 2 * brush->jitter_absolute;
2388  spread = 1.0;
2389  }
2390  else {
2391  diameter = 2 * BKE_brush_size_get(scene, brush);
2392  spread = brush->jitter;
2393  }
2394  /* find random position within a circle of diameter 1 */
2395  jitterpos[0] = pos[0] + 2 * rand_pos[0] * diameter * spread;
2396  jitterpos[1] = pos[1] + 2 * rand_pos[1] * diameter * spread;
2397 }
2398 
2400 {
2401  /* we multiply with brush radius as an optimization for the brush
2402  * texture sampling functions */
2403  if (mask) {
2406  }
2407  else {
2410  }
2411 }
2412 
2413 float BKE_brush_curve_strength(const Brush *br, float p, const float len)
2414 {
2415  float strength = 1.0f;
2416 
2417  if (p >= len) {
2418  return 0;
2419  }
2420 
2421  p = p / len;
2422  p = 1.0f - p;
2423 
2424  switch (br->curve_preset) {
2425  case BRUSH_CURVE_CUSTOM:
2426  strength = BKE_curvemapping_evaluateF(br->curve, 0, 1.0f - p);
2427  break;
2428  case BRUSH_CURVE_SHARP:
2429  strength = p * p;
2430  break;
2431  case BRUSH_CURVE_SMOOTH:
2432  strength = 3.0f * p * p - 2.0f * p * p * p;
2433  break;
2434  case BRUSH_CURVE_SMOOTHER:
2435  strength = pow3f(p) * (p * (p * 6.0f - 15.0f) + 10.0f);
2436  break;
2437  case BRUSH_CURVE_ROOT:
2438  strength = sqrtf(p);
2439  break;
2440  case BRUSH_CURVE_LIN:
2441  strength = p;
2442  break;
2443  case BRUSH_CURVE_CONSTANT:
2444  strength = 1.0f;
2445  break;
2446  case BRUSH_CURVE_SPHERE:
2447  strength = sqrtf(2 * p - p * p);
2448  break;
2449  case BRUSH_CURVE_POW4:
2450  strength = p * p * p * p;
2451  break;
2452  case BRUSH_CURVE_INVSQUARE:
2453  strength = p * (2.0f - p);
2454  break;
2455  }
2456 
2457  return strength;
2458 }
2459 
2460 float BKE_brush_curve_strength_clamped(const Brush *br, float p, const float len)
2461 {
2462  float strength = BKE_brush_curve_strength(br, p, len);
2463 
2464  CLAMP(strength, 0.0f, 1.0f);
2465 
2466  return strength;
2467 }
2468 
2469 /* TODO: should probably be unified with BrushPainter stuff? */
2470 static bool brush_gen_texture(const Brush *br,
2471  const int side,
2472  const bool use_secondary,
2473  float *rect)
2474 {
2475  const MTex *mtex = (use_secondary) ? &br->mask_mtex : &br->mtex;
2476  if (mtex->tex == nullptr) {
2477  return false;
2478  }
2479 
2480  const float step = 2.0 / side;
2481  int ix, iy;
2482  float x, y;
2483 
2484  /* Do normalized canonical view coords for texture. */
2485  for (y = -1.0, iy = 0; iy < side; iy++, y += step) {
2486  for (x = -1.0, ix = 0; ix < side; ix++, x += step) {
2487  const float co[3] = {x, y, 0.0f};
2488 
2489  float intensity;
2490  float rgba_dummy[4];
2491  RE_texture_evaluate(mtex, co, 0, nullptr, false, false, &intensity, rgba_dummy);
2492 
2493  rect[iy * side + ix] = intensity;
2494  }
2495  }
2496 
2497  return true;
2498 }
2499 
2500 struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
2501 {
2502  ImBuf *im = MEM_cnew<ImBuf>("radial control texture");
2503  int side = 512;
2504  int half = side / 2;
2505 
2507  im->rect_float = (float *)MEM_callocN(sizeof(float) * side * side, "radial control rect");
2508  im->x = im->y = side;
2509 
2510  const bool have_texture = brush_gen_texture(br, side, secondary, im->rect_float);
2511 
2512  if (display_gradient || have_texture) {
2513  for (int i = 0; i < side; i++) {
2514  for (int j = 0; j < side; j++) {
2515  const float magn = sqrtf(pow2f(i - half) + pow2f(j - half));
2516  const float strength = BKE_brush_curve_strength_clamped(br, magn, half);
2517  im->rect_float[i * side + j] = (have_texture) ? im->rect_float[i * side + j] * strength :
2518  strength;
2519  }
2520  }
2521  }
2522 
2523  return im;
2524 }
typedef float(TangentPoint)[2]
bool BKE_bpath_foreach_path_fixed_process(struct BPathForeachPathData *bpath_data, char *path)
Definition: bpath.c:121
void BKE_curvemapping_changed(struct CurveMapping *cumap, bool rem_doubles)
Definition: colortools.c:855
void BKE_curvemapping_init(struct CurveMapping *cumap)
Definition: colortools.c:1235
void BKE_curvemapping_set_defaults(struct CurveMapping *cumap, int tot, float minx, float miny, float maxx, float maxy)
Definition: colortools.c:37
struct CurveMapping * BKE_curvemapping_copy(const struct CurveMapping *cumap)
float BKE_curvemapping_evaluateF(const struct CurveMapping *cumap, int cur, float value)
void BKE_curvemapping_blend_read(struct BlendDataReader *reader, struct CurveMapping *cumap)
Definition: colortools.c:1300
void BKE_curvemap_reset(struct CurveMap *cuma, const struct rctf *clipr, int preset, int slope)
void BKE_curvemapping_blend_write(struct BlendWriter *writer, const struct CurveMapping *cumap)
void BKE_curvemapping_free(struct CurveMapping *cumap)
Definition: colortools.c:103
@ CURVEMAP_SLOPE_NEGATIVE
struct CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition: colortools.c:72
void BKE_gpencil_brush_material_set(struct Brush *brush, struct Material *material)
Definition: gpencil.c:1687
void BKE_previewimg_free(struct PreviewImage **prv)
Definition: icons.cc:283
void BKE_previewimg_id_copy(struct ID *new_id, const struct ID *old_id)
@ IDTYPE_FLAGS_NO_ANIMDATA
Definition: BKE_idtype.h:41
struct ID * BKE_id_copy(struct Main *bmain, const struct ID *id)
@ LIB_ID_COPY_NO_PREVIEW
Definition: BKE_lib_id.h:150
void id_us_min(struct ID *id)
Definition: lib_id.c:313
bool void BKE_lib_id_clear_library_data(struct Main *bmain, struct ID *id, int flags)
Definition: lib_id.c:177
void id_fake_user_set(struct ID *id)
Definition: lib_id.c:343
@ LIB_ID_MAKELOCAL_FULL_LIBRARY
Definition: BKE_lib_id.h:360
void BKE_lib_id_expand_local(struct Main *bmain, struct ID *id, int flags)
Definition: lib_id.c:427
void BKE_id_blend_write(struct BlendWriter *writer, struct ID *id)
Definition: lib_id.c:2008
void id_us_plus_no_lib(struct ID *id)
Definition: lib_id.c:289
void * BKE_id_new(struct Main *bmain, short type, const char *name)
Definition: lib_id.c:1159
bool BKE_lib_id_make_local(struct Main *bmain, struct ID *id, int flags)
Definition: lib_id.c:533
void BKE_id_delete(struct Main *bmain, void *idv) ATTR_NONNULL()
void BKE_lib_id_swap(struct Main *bmain, struct ID *id_a, struct ID *id_b)
Definition: lib_id.c:752
void BKE_lib_id_make_local_generic_action_define(struct Main *bmain, struct ID *id, int flags, bool *r_force_local, bool *r_force_copy)
Definition: lib_id.c:444
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(_data, _id_super, _cb_flag)
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(_data, _func_call)
void BKE_library_foreach_ID_link(struct Main *bmain, struct ID *id, LibraryIDLinkCallback callback, void *user_data, int flag)
Definition: lib_query.c:350
@ IDWALK_NOP
bool BKE_library_ID_is_indirectly_used(struct Main *bmain, void *idv)
Definition: lib_query.c:615
@ IDWALK_CB_USER
Definition: BKE_lib_query.h:73
@ IDWALK_CB_NOP
Definition: BKE_lib_query.h:33
@ IDWALK_RET_NOP
Definition: BKE_lib_query.h:83
@ ID_REMAP_SKIP_INDIRECT_USAGE
Definition: BKE_lib_remap.h:36
void void BKE_libblock_remap(struct Main *bmain, void *old_idv, void *new_idv, short remap_flags) ATTR_NONNULL(1
General operations, lookup, etc. for materials.
struct Material * BKE_gpencil_material_add(struct Main *bmain, const char *name)
Definition: material.c:298
void BKE_paint_brush_set(struct Paint *paint, struct Brush *br)
Definition: paint.c:617
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
Definition: texture.c:221
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void * BLI_findstring(const struct ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
MINLINE float pow2f(float x)
MINLINE float square_f(float a)
MINLINE float pow3f(float x)
#define DEG2RAD(_deg)
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void zero_v4(float r[4])
MINLINE void copy_v3_fl(float r[3], float f)
MINLINE void zero_v3(float r[3])
MINLINE void copy_v2_fl(float r[2], float f)
Random number functions.
void BLI_rng_srandom(struct RNG *rng, unsigned int seed) ATTR_NONNULL(1)
Definition: rand.cc:68
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
Definition: rand.cc:58
struct RNG * BLI_rng_new(unsigned int seed)
Definition: rand.cc:39
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition: rand.cc:93
#define SWAP(type, a, b)
#define UNUSED(x)
#define ELEM(...)
#define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member)
#define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)
#define BLO_read_data_address(reader, ptr_p)
ID * BLO_read_get_new_id_address(BlendLibReader *reader, struct Library *lib, struct ID *id)
Definition: readfile.c:5138
#define BLO_write_id_struct(writer, struct_name, id_address, id)
#define BLO_write_struct(writer, struct_name, data_ptr)
#define BLO_read_id_address(reader, lib, id_ptr_p)
#define BLO_expand(expander, id)
#define BLT_I18NCONTEXT_ID_BRUSH
#define ID_EXTRA_USERS(id)
Definition: DNA_ID.h:554
#define FILTER_ID_BR
Definition: DNA_ID.h:901
@ INDEX_ID_BR
Definition: DNA_ID.h:1046
#define ID_IS_LINKED(_id)
Definition: DNA_ID.h:566
@ LIB_TAG_INDIRECT
Definition: DNA_ID.h:677
#define ID_REAL_USERS(id)
Definition: DNA_ID.h:553
#define ID_NEW_SET(_id, _idn)
Definition: DNA_ID.h:617
@ ID_BR
Definition: DNA_ID_enums.h:69
@ GPAINT_TOOL_ERASE
@ GPAINT_TOOL_FILL
@ GPAINT_TOOL_DRAW
@ GPAINT_TOOL_TINT
@ GPWEIGHT_TOOL_DRAW
@ GPVERTEX_TOOL_AVERAGE
@ GPVERTEX_TOOL_REPLACE
@ GPVERTEX_TOOL_DRAW
@ GPVERTEX_TOOL_BLUR
@ GPVERTEX_TOOL_SMEAR
@ GP_SCULPT_FLAGMODE_APPLY_POSITION
@ GP_SCULPT_FLAGMODE_APPLY_THICKNESS
@ BRUSH_CURVE_CUSTOM
@ BRUSH_CURVE_SHARP
@ BRUSH_CURVE_INVSQUARE
@ BRUSH_CURVE_SPHERE
@ BRUSH_CURVE_CONSTANT
@ BRUSH_CURVE_POW4
@ BRUSH_CURVE_ROOT
@ BRUSH_CURVE_SMOOTH
@ BRUSH_CURVE_SMOOTHER
@ BRUSH_CURVE_LIN
@ GP_BRUSH_GROUP_RANDOM
@ GP_BRUSH_DEFAULT_ERASER
@ GP_BRUSH_USE_STRENGTH_PRESSURE
@ GP_BRUSH_GROUP_SETTINGS
@ GP_BRUSH_MATERIAL_PINNED
@ GP_BRUSH_FILL_SHOW_EXTENDLINES
@ GP_BRUSH_USE_JITTER_PRESSURE
@ GP_BRUSH_USE_PRESSURE
@ BRUSH_OFFSET_PRESSURE
@ BRUSH_ORIGINAL_NORMAL
@ BRUSH_ALPHA_PRESSURE
@ BRUSH_SPACE_ATTEN
@ BRUSH_LOCK_ALPHA
@ BRUSH_FRONTFACE
@ BRUSH_ADAPTIVE_SPACE
@ BRUSH_DRAG_DOT
@ BRUSH_SPACING_PRESSURE
@ BRUSH_EDGE_TO_EDGE
@ BRUSH_SMOOTH_STROKE
@ BRUSH_ACCUMULATE
@ BRUSH_DIR_IN
@ BRUSH_ANCHORED
@ BRUSH_CUSTOM_ICON
@ BRUSH_JITTER_PRESSURE
@ BRUSH_PLANE_TRIM
@ BRUSH_LOCK_SIZE
@ BRUSH_INVERSE_SMOOTH_PRESSURE
@ BRUSH_ABSOLUTE_JITTER
@ BRUSH_PERSISTENT
@ BRUSH_SIZE_PRESSURE
@ BRUSH_AIRBRUSH
@ BRUSH_SPACE
@ BRUSH_INVERT_TO_SCRAPE_FILL
@ BRUSH_CLOTH_DEFORM_DRAG
@ SCULPT_TOOL_SMOOTH
@ SCULPT_TOOL_CLOTH
@ SCULPT_TOOL_DRAW_SHARP
@ SCULPT_TOOL_NUDGE
@ SCULPT_TOOL_SCRAPE
@ SCULPT_TOOL_THUMB
@ SCULPT_TOOL_SIMPLIFY
@ SCULPT_TOOL_DRAW_FACE_SETS
@ SCULPT_TOOL_GRAB
@ SCULPT_TOOL_INFLATE
@ SCULPT_TOOL_CLAY_THUMB
@ SCULPT_TOOL_DRAW
@ SCULPT_TOOL_FLATTEN
@ SCULPT_TOOL_BOUNDARY
@ SCULPT_TOOL_PAINT
@ SCULPT_TOOL_PINCH
@ SCULPT_TOOL_BLOB
@ SCULPT_TOOL_FILL
@ SCULPT_TOOL_POSE
@ SCULPT_TOOL_LAYER
@ SCULPT_TOOL_DISPLACEMENT_ERASER
@ SCULPT_TOOL_SLIDE_RELAX
@ SCULPT_TOOL_SMEAR
@ SCULPT_TOOL_DISPLACEMENT_SMEAR
@ SCULPT_TOOL_CLAY
@ SCULPT_TOOL_MASK
@ SCULPT_TOOL_MULTIPLANE_SCRAPE
@ SCULPT_TOOL_ROTATE
@ SCULPT_TOOL_ELASTIC_DEFORM
@ SCULPT_TOOL_SNAKE_HOOK
@ SCULPT_TOOL_CLAY_STRIPS
@ SCULPT_TOOL_CREASE
@ BRUSH_MASK_PRESSURE_RAMP
@ BRUSH_MASK_PRESSURE_CUTOFF
@ GP_BRUSH_ERASER_SOFT
@ GP_BRUSH_ERASER_STROKE
@ GP_BRUSH_ERASER_HARD
@ BRUSH_ELASTIC_DEFORM_GRAB_TRISCALE
@ GPSCULPT_TOOL_GRAB
@ GPSCULPT_TOOL_TWIST
@ GPSCULPT_TOOL_PUSH
@ GPSCULPT_TOOL_STRENGTH
@ GPSCULPT_TOOL_PINCH
@ GPSCULPT_TOOL_SMOOTH
@ GPSCULPT_TOOL_CLONE
@ GPSCULPT_TOOL_THICKNESS
@ GPSCULPT_TOOL_RANDOMIZE
@ BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_SECONDARY
@ BRUSH_OVERLAY_CURSOR
@ BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_PRIMARY
@ GP_BRUSH_ICON_ERASE_SOFT
@ GP_BRUSH_ICON_GPBRUSH_RANDOMIZE
@ GP_BRUSH_ICON_VERTEX_BLUR
@ GP_BRUSH_ICON_TINT
@ GP_BRUSH_ICON_FILL
@ GP_BRUSH_ICON_PENCIL
@ GP_BRUSH_ICON_GPBRUSH_GRAB
@ GP_BRUSH_ICON_GPBRUSH_STRENGTH
@ GP_BRUSH_ICON_INKNOISE
@ GP_BRUSH_ICON_GPBRUSH_TWIST
@ GP_BRUSH_ICON_PEN
@ GP_BRUSH_ICON_VERTEX_REPLACE
@ GP_BRUSH_ICON_MARKER
@ GP_BRUSH_ICON_VERTEX_DRAW
@ GP_BRUSH_ICON_GPBRUSH_WEIGHT
@ GP_BRUSH_ICON_INK
@ GP_BRUSH_ICON_GPBRUSH_PINCH
@ GP_BRUSH_ICON_VERTEX_SMEAR
@ GP_BRUSH_ICON_GPBRUSH_THICKNESS
@ GP_BRUSH_ICON_AIRBRUSH
@ GP_BRUSH_ICON_GPBRUSH_CLONE
@ GP_BRUSH_ICON_CHISEL
@ GP_BRUSH_ICON_ERASE_STROKE
@ GP_BRUSH_ICON_ERASE_HARD
@ GP_BRUSH_ICON_GPBRUSH_SMOOTH
@ GP_BRUSH_ICON_GPBRUSH_PUSH
@ GP_BRUSH_ICON_VERTEX_AVERAGE
@ GP_BRUSH_PRESET_PENCIL_SOFT
@ GP_BRUSH_PRESET_TWIST_STROKE
@ GP_BRUSH_PRESET_PUSH_STROKE
@ GP_BRUSH_PRESET_MARKER_CHISEL
@ GP_BRUSH_PRESET_ERASER_HARD
@ GP_BRUSH_PRESET_VERTEX_AVERAGE
@ GP_BRUSH_PRESET_INK_PEN
@ GP_BRUSH_PRESET_INK_PEN_ROUGH
@ GP_BRUSH_PRESET_PENCIL
@ GP_BRUSH_PRESET_ERASER_STROKE
@ GP_BRUSH_PRESET_DRAW_WEIGHT
@ GP_BRUSH_PRESET_ERASER_POINT
@ GP_BRUSH_PRESET_VERTEX_BLUR
@ GP_BRUSH_PRESET_MARKER_BOLD
@ GP_BRUSH_PRESET_FILL_AREA
@ GP_BRUSH_PRESET_VERTEX_DRAW
@ GP_BRUSH_PRESET_VERTEX_REPLACE
@ GP_BRUSH_PRESET_SMOOTH_STROKE
@ GP_BRUSH_PRESET_GRAB_STROKE
@ GP_BRUSH_PRESET_AIRBRUSH
@ GP_BRUSH_PRESET_TINT
@ GP_BRUSH_PRESET_CLONE_STROKE
@ GP_BRUSH_PRESET_ERASER_SOFT
@ GP_BRUSH_PRESET_THICKNESS_STROKE
@ GP_BRUSH_PRESET_STRENGTH_STROKE
@ GP_BRUSH_PRESET_RANDOMIZE_STROKE
@ GP_BRUSH_PRESET_VERTEX_SMEAR
@ GP_BRUSH_PRESET_PINCH_STROKE
@ GP_BRUSH_PRESET_PEN
#define MAX_BRUSH_PIXEL_RADIUS
@ BRUSH_MULTIPLANE_SCRAPE_PLANES_PREVIEW
@ BRUSH_MULTIPLANE_SCRAPE_DYNAMIC
@ BRUSH_USE_CONNECTED_ONLY
@ BRUSH_POSE_IK_ANCHORED
@ GPPAINT_MODE_FILL
@ GPPAINT_MODE_BOTH
@ BRUSH_SLIDE_DEFORM_DRAG
struct Brush Brush
@ CUMA_EXTEND_EXTRAPOLATE
eCurveMappingPreset
@ CURVE_PRESET_SMOOTH
@ CURVE_PRESET_SHARP
#define DNA_struct_default_get(struct_name)
Definition: DNA_defaults.h:29
@ GP_MATERIAL_MODE_DOT
eObjectMode
@ OB_MODE_VERTEX_GPENCIL
@ OB_MODE_WEIGHT_GPENCIL
@ OB_MODE_SCULPT_CURVES
@ OB_MODE_SCULPT_GPENCIL
@ OB_MODE_PAINT_GPENCIL
Object is a sort of wrapper for general info.
@ UNIFIED_PAINT_WEIGHT
@ UNIFIED_PAINT_SIZE
@ UNIFIED_PAINT_BRUSH_LOCK_SIZE
@ UNIFIED_PAINT_ALPHA
@ UNIFIED_PAINT_COLOR
#define MTEX_MAP_MODE_VIEW
#define MTEX_MAP_MODE_3D
#define MTEX_MAP_MODE_STENCIL
#define MTEX_MAP_MODE_TILED
#define MTEX_MAP_MODE_RANDOM
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint y
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], struct ColorSpace *colorspace)
struct ImBuf * IMB_dupImBuf(const struct ImBuf *ibuf1)
Contains defines and structs used throughout the imbuf module.
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a point
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a color
void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
Definition: brush.cc:2339
float BKE_brush_curve_strength_clamped(const Brush *br, float p, const float len)
Definition: brush.cc:2460
static void brush_defaults(Brush *brush)
Definition: brush.cc:442
bool BKE_brush_use_alpha_pressure(const Brush *brush)
Definition: brush.cc:2270
void BKE_brush_randomize_texture_coords(UnifiedPaintSettings *ups, bool mask)
Definition: brush.cc:2399
float BKE_brush_weight_get(const Scene *scene, const Brush *brush)
Definition: brush.cc:2332
void BKE_brush_gpencil_sculpt_presets(Main *bmain, ToolSettings *ts, const bool reset)
Definition: brush.cc:1455
float BKE_brush_unprojected_radius_get(const Scene *scene, const Brush *brush)
Definition: brush.cc:2306
static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition: brush.cc:203
#define BR_TEST(field, t)
int BKE_brush_size_get(const Scene *scene, const Brush *brush)
Definition: brush.cc:2249
static void brush_free_data(ID *id)
Definition: brush.cc:105
static void brush_blend_read_expand(BlendExpander *expander, ID *id)
Definition: brush.cc:352
void BKE_brush_gpencil_weight_presets(Main *bmain, ToolSettings *ts, const bool reset)
Definition: brush.cc:1529
void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius)
Definition: brush.cc:2294
void BKE_gpencil_brush_preset_set(Main *bmain, Brush *brush, const short type)
Definition: brush.cc:669
void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
Definition: brush.cc:2234
static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
Definition: brush.cc:180
#define FROM_DEFAULT(member)
Brush * BKE_brush_add(Main *bmain, const char *name, const eObjectMode ob_mode)
Definition: brush.cc:496
#define BR_TEST_FLAG_OVERLAY(_f)
void BKE_brush_alpha_set(Scene *scene, Brush *brush, float alpha)
Definition: brush.cc:2313
void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
Definition: brush.cc:2375
bool BKE_brush_use_size_pressure(const Brush *brush)
Definition: brush.cc:2265
void BKE_brush_system_exit(void)
Definition: brush.cc:433
float BKE_brush_curve_strength(const Brush *br, float p, const float len)
Definition: brush.cc:2413
Brush * BKE_brush_add_gpencil(Main *bmain, ToolSettings *ts, const char *name, eObjectMode mode)
Definition: brush.cc:536
static void brush_init_data(ID *id)
Definition: brush.cc:45
static void brush_gpencil_curvemap_reset(CurveMap *cuma, int tot, int preset)
Definition: brush.cc:600
static void brush_undo_preserve(BlendLibReader *reader, ID *id_new, ID *id_old)
Definition: brush.cc:381
static void brush_make_local(Main *bmain, ID *id, const int flags)
Definition: brush.cc:136
#define ACTIVE_SMOOTH
void BKE_brush_gpencil_paint_presets(Main *bmain, ToolSettings *ts, const bool reset)
Definition: brush.cc:1308
void BKE_brush_init_curves_sculpt_settings(Brush *brush)
Definition: brush.cc:1554
const float * BKE_brush_secondary_color_get(const struct Scene *scene, const struct Brush *brush)
Definition: brush.cc:2216
float BKE_brush_sample_masktex(const Scene *scene, Brush *br, const float point[2], const int thread, struct ImagePool *pool)
Definition: brush.cc:2082
#define FROM_DEFAULT_PTR(member)
static bool brush_gen_texture(const Brush *br, const int side, const bool use_secondary, float *rect)
Definition: brush.cc:2470
static RNG * brush_rng
Definition: brush.cc:425
void BKE_brush_sculpt_reset(Brush *br)
Definition: brush.cc:1683
const float * BKE_brush_color_get(const struct Scene *scene, const struct Brush *brush)
Definition: brush.cc:2210
void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
Definition: brush.cc:1942
static void brush_blend_read_data(BlendDataReader *reader, ID *id)
Definition: brush.cc:253
bool BKE_brush_sculpt_has_secondary_color(const Brush *brush)
Definition: brush.cc:2275
void BKE_brush_system_init(void)
Definition: brush.cc:427
void BKE_brush_init_gpencil_settings(Brush *brush)
Definition: brush.cc:509
static void brush_foreach_path(ID *id, BPathForeachPathData *bpath_data)
Definition: brush.cc:195
IDTypeInfo IDType_ID_BR
Definition: brush.cc:395
void BKE_brush_scale_size(int *r_brush_size, float new_unprojected_radius, float old_unprojected_radius)
Definition: brush.cc:2363
float BKE_brush_alpha_get(const Scene *scene, const Brush *brush)
Definition: brush.cc:2325
#define SMOOTH_STROKE_RADIUS
void BKE_brush_debug_print_state(Brush *br)
Definition: brush.cc:1577
void BKE_brush_gpencil_vertex_presets(Main *bmain, ToolSettings *ts, const bool reset)
Definition: brush.cc:1409
static void brush_blend_read_lib(BlendLibReader *reader, ID *id)
Definition: brush.cc:326
float BKE_brush_sample_tex_3d(const Scene *scene, const Brush *br, const float point[3], float rgba[4], const int thread, struct ImagePool *pool)
Definition: brush.cc:1959
bool BKE_brush_delete(Main *bmain, Brush *brush)
Definition: brush.cc:575
bool BKE_brush_use_locked_size(const Scene *scene, const Brush *brush)
Definition: brush.cc:2257
#define SMOOTH_STROKE_FACTOR
void BKE_brush_color_set(struct Scene *scene, struct Brush *brush, const float color[3])
Definition: brush.cc:2222
void BKE_brush_scale_unprojected_radius(float *unprojected_radius, int new_brush_size, int old_brush_size)
Definition: brush.cc:2351
static int brush_undo_preserve_cb(LibraryIDLinkCallbackData *cb_data)
Definition: brush.cc:364
static void brush_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
Definition: brush.cc:59
struct ImBuf * BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
Definition: brush.cc:2500
static Brush * gpencil_brush_ensure(Main *bmain, ToolSettings *ts, const char *brush_name, eObjectMode mode, bool *r_new)
Definition: brush.cc:1285
#define BR_TEST_FLAG(_f)
struct Brush * BKE_brush_first_search(struct Main *bmain, const eObjectMode ob_mode)
Definition: brush.cc:1567
enum eGPCurveMappingPreset { GPCURVE_PRESET_PENCIL=0, GPCURVE_PRESET_INK=1, GPCURVE_PRESET_INKNOISE=2, GPCURVE_PRESET_MARKER=3, GPCURVE_PRESET_CHISEL_SENSIVITY=4, GPCURVE_PRESET_CHISEL_STRENGTH=5, } eGPCurveMappingPreset
Definition: brush.cc:598
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition: btVector3.h:356
Definition: half.h:41
Definition: thread.h:34
#define sinf(x)
Definition: cuda/compat.h:102
#define cosf(x)
Definition: cuda/compat.h:101
Scene scene
int len
Definition: draw_manager.c:108
uint pos
void IMB_freeImBuf(ImBuf *UNUSED(ibuf))
ccl_gpu_kernel_postfix ccl_global float int int int int float bool reset
clear internal cached data and reset random seed
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
Definition: math_float4.h:513
#define atan2f(x, y)
Definition: metal/compat.h:227
#define fabsf(x)
Definition: metal/compat.h:219
#define sqrtf(x)
Definition: metal/compat.h:243
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
static const pxr::TfToken rgba("rgba", pxr::TfToken::Immortal)
static const pxr::TfToken rgb("rgb", pxr::TfToken::Immortal)
static ePaintOverlayControlFlags overlay_flags
Definition: paint.c:225
struct Image * image
struct CurveMapping * curve_sensitivity
struct CurveMapping * curve_strength
struct CurveMapping * curve_jitter
struct CurveMapping * curve_rand_pressure
struct CurveMapping * curve_rand_strength
struct CurveMapping * curve_rand_saturation
struct CurveMapping * curve_rand_hue
struct CurveMapping * curve_rand_uv
struct Material * material
struct CurveMapping * curve_rand_value
float cloth_mass
float multiplane_scrape_angle
float alpha
float topology_rake_factor
float jitter
struct ImBuf * icon_imbuf
struct ColorBand * gradient
int sculpt_plane
struct BrushClone clone
int cloth_deform_type
float area_radius_factor
float density
int slide_deform_type
int elastic_deform_type
float add_col[4]
float normal_radius_factor
struct MTex mtex
int pose_smooth_iterations
float stencil_pos[2]
int texture_overlay_alpha
float normal_weight
float rake_factor
float elastic_deform_volume_preservation
float unprojected_radius
float smooth_stroke_factor
short ob_mode
float cloth_sim_falloff
float stencil_dimension[2]
int smooth_stroke_radius
char gpencil_weight_tool
int curve_preset
struct CurveMapping * curve
char gpencil_vertex_tool
float tip_scale_x
float texture_sample_bias
float plane_trim
int jitter_absolute
float mask_stencil_pos[2]
float rgb[3]
float hardness
struct BrushGpencilSettings * gpencil_settings
float flow
float cloth_sim_limit
struct Brush * toggle_brush
float height
char icon_filepath[1024]
PreviewImage * preview
float sub_col[4]
int pose_ik_segments
struct BrushCurvesSculptSettings * curves_sculpt_settings
char gpencil_sculpt_tool
float crease_pinch_factor
char sculpt_tool
char gpencil_tool
struct MTex mask_mtex
int mask_pressure
float mask_stencil_dimension[2]
float weight
float rate
float plane_offset
float secondary_rgb[3]
int surface_smooth_iterations
float surface_smooth_current_vertex
struct PaintCurve * paint_curve
float tip_roundness
float autosmooth_factor
float cloth_damping
float surface_smooth_shape_preservation
CurveMapPoint * table
short totpoint
CurveMapPoint * curve
CurveMap cm[4]
Definition: DNA_ID.h:368
int tag
Definition: DNA_ID.h:387
struct Library * lib
Definition: DNA_ID.h:372
int us
Definition: DNA_ID.h:388
struct ID * newid
Definition: DNA_ID.h:370
IDProperty * properties
Definition: DNA_ID.h:409
float * rect_float
char brush_map_mode
float rot
struct Tex * tex
Definition: BKE_main.h:121
ListBase brushes
Definition: BKE_main.h:193
ListBase materials
Definition: BKE_main.h:174
struct MaterialGPencilStyle * gp_style
struct Brush * brush
Definition: rand.cc:33
struct ToolSettings * toolsettings
GpWeightPaint * gp_weightpaint
GpPaint * gp_paint
GpSculptPaint * gp_sculptpaint
struct UnifiedPaintSettings unified_paint_settings
GpVertexPaint * gp_vertexpaint
struct ColorSpace * colorspace
bool RE_texture_evaluate(const MTex *mtex, const float vec[3], const int thread, struct ImagePool *pool, const bool skip_load_image, const bool texnode_preview, float *r_intensity, float r_rgba[4])
static int blend(const Tex *tex, const float texvec[3], TexResult *texres)