source/blender/makesrna/intern/rna_sculpt_paint.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  15  */
  16
  17 /** \file
  18  * \ingroup RNA
  19  */
  20
  21 #include <stdlib.h>
  22
  23 #include "BLI_math.h"
  24 #include "BLI_utildefines.h"
  25
  26 #include "RNA_define.h"
  27 #include "RNA_enum_types.h"
  28
  29 #include "rna_internal.h"
  30
  31 #include "DNA_ID.h"
  32 #include "DNA_gpencil_types.h"
  33 #include "DNA_scene_types.h"
  34 #include "DNA_brush_types.h"
  35 #include "DNA_screen_types.h"
  36 #include "DNA_space_types.h"
  37
  38 #include "BKE_material.h"
  39 #include "BKE_paint.h"
  40 #include "BKE_brush.h"
  41
  42 #include "ED_image.h"
  43
  44 #include "WM_api.h"
  45 #include "WM_types.h"
  46
  47 #include "bmesh.h"
  48
  49 const EnumPropertyItem rna_enum_particle_edit_hair_brush_items[] = {
  50     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb hairs"},
  51     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth hairs"},
  52     {PE_BRUSH_ADD, "ADD", 0, "Add", "Add hairs"},
  53     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make hairs longer or shorter"},
  54     {PE_BRUSH_PUFF, "PUFF", 0, "Puff", "Make hairs stand up"},
  55     {PE_BRUSH_CUT, "CUT", 0, "Cut", "Cut hairs"},
  56     {PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", "Weight hair particles"},
  57     {0, NULL, 0, NULL, NULL},
  58 };
  59
  60 const EnumPropertyItem rna_enum_gpencil_sculpt_brush_items[] = {
  61     {GP_SCULPT_TYPE_SMOOTH, "SMOOTH", ICON_GPBRUSH_SMOOTH, "Smooth", "Smooth stroke points"},
  62     {GP_SCULPT_TYPE_THICKNESS,
  63      "THICKNESS",
  64      ICON_GPBRUSH_THICKNESS,
  65      "Thickness",
  66      "Adjust thickness of strokes"},
  67     {GP_SCULPT_TYPE_STRENGTH,
  68      "STRENGTH",
  69      ICON_GPBRUSH_STRENGTH,
  70      "Strength",
  71      "Adjust color strength of strokes"},
  72     {GP_SCULPT_TYPE_RANDOMIZE,
  73      "RANDOMIZE",
  74      ICON_GPBRUSH_RANDOMIZE,
  75      "Randomize",
  76      "Introduce jitter/randomness into strokes"},
  77     {GP_SCULPT_TYPE_GRAB,
  78      "GRAB",
  79      ICON_GPBRUSH_GRAB,
  80      "Grab",
  81      "Translate the set of points initially within the brush circle"},
  82     {GP_SCULPT_TYPE_PUSH,
  83      "PUSH",
  84      ICON_GPBRUSH_PUSH,
  85      "Push",
  86      "Move points out of the way, as if combing them"},
  87     {GP_SCULPT_TYPE_TWIST,
  88      "TWIST",
  89      ICON_GPBRUSH_TWIST,
  90      "Twist",
  91      "Rotate points around the midpoint of the brush"},
  92     {GP_SCULPT_TYPE_PINCH,
  93      "PINCH",
  94      ICON_GPBRUSH_PINCH,
  95      "Pinch",
  96      "Pull points towards the midpoint of the brush"},
  97     {GP_SCULPT_TYPE_CLONE,
  98      "CLONE",
  99      ICON_GPBRUSH_CLONE,
 100      "Clone",
 101      "Paste copies of the strokes stored on the clipboard"},
 102     {0, NULL, 0, NULL, NULL}};
 103
 104 const EnumPropertyItem rna_enum_gpencil_weight_brush_items[] = {
 105     {GP_SCULPT_TYPE_WEIGHT,
 106      "WEIGHT",
 107      ICON_GPBRUSH_WEIGHT,
 108      "Weight",
 109      "Weight Paint for Vertex Groups"},
 110     {0, NULL, 0, NULL, NULL},
 111 };
 112
 113 #ifndef RNA_RUNTIME
 114 static const EnumPropertyItem rna_enum_gpencil_lock_axis_items[] = {
 115     {GP_LOCKAXIS_VIEW,
 116      "VIEW",
 117      ICON_RESTRICT_VIEW_ON,
 118      "View",
 119      "Align strokes to current view plane"},
 120     {GP_LOCKAXIS_Y,
 121      "AXIS_Y",
 122      ICON_AXIS_FRONT,
 123      "Front (X-Z)",
 124      "Project strokes to plane locked to Y"},
 125     {GP_LOCKAXIS_X,
 126      "AXIS_X",
 127      ICON_AXIS_SIDE,
 128      "Side (Y-Z)",
 129      "Project strokes to plane locked to X"},
 130     {GP_LOCKAXIS_Z, "AXIS_Z", ICON_AXIS_TOP, "Top (X-Y)", "Project strokes to plane locked to Z"},
 131     {GP_LOCKAXIS_CURSOR,
 132      "CURSOR",
 133      ICON_PIVOT_CURSOR,
 134      "Cursor",
 135      "Align strokes to current 3D cursor orientation"},
 136     {0, NULL, 0, NULL, NULL},
 137 };
 138 #endif
 139
 140 const EnumPropertyItem rna_enum_symmetrize_direction_items[] = {
 141     {BMO_SYMMETRIZE_NEGATIVE_X, "NEGATIVE_X", 0, "-X to +X", ""},
 142     {BMO_SYMMETRIZE_POSITIVE_X, "POSITIVE_X", 0, "+X to -X", ""},
 143
 144     {BMO_SYMMETRIZE_NEGATIVE_Y, "NEGATIVE_Y", 0, "-Y to +Y", ""},
 145     {BMO_SYMMETRIZE_POSITIVE_Y, "POSITIVE_Y", 0, "+Y to -Y", ""},
 146
 147     {BMO_SYMMETRIZE_NEGATIVE_Z, "NEGATIVE_Z", 0, "-Z to +Z", ""},
 148     {BMO_SYMMETRIZE_POSITIVE_Z, "POSITIVE_Z", 0, "+Z to -Z", ""},
 149     {0, NULL, 0, NULL, NULL},
 150 };
 151
 152 #ifdef RNA_RUNTIME
 153 #  include "MEM_guardedalloc.h"
 154
 155 #  include "BKE_collection.h"
 156 #  include "BKE_context.h"
 157 #  include "BKE_particle.h"
 158 #  include "BKE_pbvh.h"
 159 #  include "BKE_pointcache.h"
 160 #  include "BKE_object.h"
 161 #  include "BKE_gpencil.h"
 162
 163 #  include "DEG_depsgraph.h"
 164
 165 #  include "ED_particle.h"
 166
 167 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
 168 {
 169   /* mark all grease pencil datablocks of the scene */
 170   FOREACH_SCENE_COLLECTION_BEGIN (scene, collection) {
 171     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (collection, ob) {
 172       if (ob->type == OB_GPENCIL) {
 173         bGPdata *gpd = (bGPdata *)ob->data;
 174         gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
 175         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
 176       }
 177     }
 178     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
 179   }
 180   FOREACH_SCENE_COLLECTION_END;
 181
 182   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
 183 }
 184
 185 const EnumPropertyItem rna_enum_particle_edit_disconnected_hair_brush_items[] = {
 186     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb hairs"},
 187     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth hairs"},
 188     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make hairs longer or shorter"},
 189     {PE_BRUSH_CUT, "CUT", 0, "Cut", "Cut hairs"},
 190     {PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", "Weight hair particles"},
 191     {0, NULL, 0, NULL, NULL},
 192 };
 193
 194 static const EnumPropertyItem particle_edit_cache_brush_items[] = {
 195     {PE_BRUSH_COMB, "COMB", 0, "Comb", "Comb paths"},
 196     {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", "Smooth paths"},
 197     {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", "Make paths longer or shorter"},
 198     {0, NULL, 0, NULL, NULL},
 199 };
 200
 201 static PointerRNA rna_ParticleEdit_brush_get(PointerRNA *ptr)
 202 {
 203   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
 204   ParticleBrushData *brush = NULL;
 205
 206   brush = &pset->brush[pset->brushtype];
 207
 208   return rna_pointer_inherit_refine(ptr, &RNA_ParticleBrush, brush);
 209 }
 210
 211 static PointerRNA rna_ParticleBrush_curve_get(PointerRNA *ptr)
 212 {
 213   return rna_pointer_inherit_refine(ptr, &RNA_CurveMapping, NULL);
 214 }
 215
 216 static void rna_ParticleEdit_redo(bContext *C, PointerRNA *UNUSED(ptr))
 217 {
 218   Scene *scene = CTX_data_scene(C);
 219   ViewLayer *view_layer = CTX_data_view_layer(C);
 220   Object *ob = OBACT(view_layer);
 221   PTCacheEdit *edit = PE_get_current(scene, ob);
 222
 223   if (!edit) {
 224     return;
 225   }
 226
 227   if (ob) {
 228     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
 229   }
 230
 231   BKE_particle_batch_cache_dirty_tag(edit->psys, BKE_PARTICLE_BATCH_DIRTY_ALL);
 232   psys_free_path_cache(edit->psys, edit);
 233   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
 234 }
 235
 236 static void rna_ParticleEdit_update(bContext *C, PointerRNA *UNUSED(ptr))
 237 {
 238   Scene *scene = CTX_data_scene(C);
 239   ViewLayer *view_layer = CTX_data_view_layer(C);
 240   Object *ob = OBACT(view_layer);
 241
 242   if (ob) {
 243     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
 244   }
 245
 246   /* Sync tool setting changes from original to evaluated scenes. */
 247   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
 248 }
 249
 250 static void rna_ParticleEdit_tool_set(PointerRNA *ptr, int value)
 251 {
 252   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
 253
 254   /* redraw hair completely if weight brush is/was used */
 255   if ((pset->brushtype == PE_BRUSH_WEIGHT || value == PE_BRUSH_WEIGHT) && pset->object) {
 256     Object *ob = pset->object;
 257     if (ob) {
 258       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
 259       WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
 260     }
 261   }
 262
 263   pset->brushtype = value;
 264 }
 265 static const EnumPropertyItem *rna_ParticleEdit_tool_itemf(bContext *C,
 266                                                            PointerRNA *UNUSED(ptr),
 267                                                            PropertyRNA *UNUSED(prop),
 268                                                            bool *UNUSED(r_free))
 269 {
 270   ViewLayer *view_layer = CTX_data_view_layer(C);
 271   Object *ob = OBACT(view_layer);
 272 #  if 0
 273   Scene *scene = CTX_data_scene(C);
 274   PTCacheEdit *edit = PE_get_current(scene, ob);
 275   ParticleSystem *psys = edit ? edit->psys : NULL;
 276 #  else
 277   /* use this rather than PE_get_current() - because the editing cache is
 278    * dependent on the cache being updated which can happen after this UI
 279    * draws causing a glitch [#28883] */
 280   ParticleSystem *psys = psys_get_current(ob);
 281 #  endif
 282
 283   if (psys) {
 284     if (psys->flag & PSYS_GLOBAL_HAIR) {
 285       return rna_enum_particle_edit_disconnected_hair_brush_items;
 286     }
 287     else {
 288       return rna_enum_particle_edit_hair_brush_items;
 289     }
 290   }
 291
 292   return particle_edit_cache_brush_items;
 293 }
 294
 295 static bool rna_ParticleEdit_editable_get(PointerRNA *ptr)
 296 {
 297   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
 298
 299   return (pset->object && pset->scene && PE_get_current(pset->scene, pset->object));
 300 }
 301 static bool rna_ParticleEdit_hair_get(PointerRNA *ptr)
 302 {
 303   ParticleEditSettings *pset = (ParticleEditSettings *)ptr->data;
 304
 305   if (pset->scene) {
 306     PTCacheEdit *edit = PE_get_current(pset->scene, pset->object);
 307
 308     return (edit && edit->psys);
 309   }
 310
 311   return 0;
 312 }
 313
 314 static char *rna_ParticleEdit_path(PointerRNA *UNUSED(ptr))
 315 {
 316   return BLI_strdup("tool_settings.particle_edit");
 317 }
 318
 319 static bool rna_Brush_mode_poll(PointerRNA *ptr, PointerRNA value)
 320 {
 321   const Paint *paint = ptr->data;
 322   Brush *brush = value.id.data;
 323   const uint tool_offset = paint->runtime.tool_offset;
 324   const eObjectMode ob_mode = paint->runtime.ob_mode;
 325   UNUSED_VARS_NDEBUG(tool_offset);
 326   BLI_assert(tool_offset && ob_mode);
 327
 328   if (brush->ob_mode & ob_mode) {
 329     if (paint->brush) {
 330       if (BKE_brush_tool_get(paint->brush, paint) == BKE_brush_tool_get(brush, paint)) {
 331         return true;
 332       }
 333     }
 334     else {
 335       return true;
 336     }
 337   }
 338
 339   return false;
 340 }
 341
 342 static bool paint_contains_brush_slot(const Paint *paint, const PaintToolSlot *tslot, int *r_index)
 343 {
 344   if ((tslot >= paint->tool_slots) && (tslot < (paint->tool_slots + paint->tool_slots_len))) {
 345     *r_index = (int)(tslot - paint->tool_slots);
 346     return true;
 347   }
 348   return false;
 349 }
 350
 351 static bool rna_Brush_mode_with_tool_poll(PointerRNA *ptr, PointerRNA value)
 352 {
 353   Scene *scene = (Scene *)ptr->id.data;
 354   const PaintToolSlot *tslot = ptr->data;
 355   ToolSettings *ts = scene->toolsettings;
 356   Brush *brush = value.id.data;
 357   int mode = 0;
 358   int slot_index = 0;
 359
 360   if (paint_contains_brush_slot(&ts->imapaint.paint, tslot, &slot_index)) {
 361     if (slot_index != brush->imagepaint_tool) {
 362       return false;
 363     }
 364     mode = OB_MODE_TEXTURE_PAINT;
 365   }
 366   else if (paint_contains_brush_slot(&ts->sculpt->paint, tslot, &slot_index)) {
 367     if (slot_index != brush->sculpt_tool) {
 368       return false;
 369     }
 370     mode = OB_MODE_SCULPT;
 371   }
 372   else if (paint_contains_brush_slot(&ts->uvsculpt->paint, tslot, &slot_index)) {
 373     if (slot_index != brush->uv_sculpt_tool) {
 374       return false;
 375     }
 376     mode = OB_MODE_EDIT;
 377   }
 378   else if (paint_contains_brush_slot(&ts->vpaint->paint, tslot, &slot_index)) {
 379     if (slot_index != brush->vertexpaint_tool) {
 380       return false;
 381     }
 382     mode = OB_MODE_VERTEX_PAINT;
 383   }
 384   else if (paint_contains_brush_slot(&ts->wpaint->paint, tslot, &slot_index)) {
 385     if (slot_index != brush->weightpaint_tool) {
 386       return false;
 387     }
 388     mode = OB_MODE_WEIGHT_PAINT;
 389   }
 390   else if (paint_contains_brush_slot(&ts->gp_paint->paint, tslot, &slot_index)) {
 391     if (slot_index != brush->gpencil_tool) {
 392       return false;
 393     }
 394     mode = OB_MODE_PAINT_GPENCIL;
 395   }
 396
 397   return brush->ob_mode & mode;
 398 }
 399
 400 static void rna_Sculpt_update(bContext *C, PointerRNA *UNUSED(ptr))
 401 {
 402   Scene *scene = CTX_data_scene(C);
 403   ViewLayer *view_layer = CTX_data_view_layer(C);
 404   Object *ob = OBACT(view_layer);
 405
 406   if (ob) {
 407     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
 408     WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
 409
 410     if (ob->sculpt) {
 411       ob->sculpt->bm_smooth_shading = ((scene->toolsettings->sculpt->flags &
 412                                         SCULPT_DYNTOPO_SMOOTH_SHADING) != 0);
 413     }
 414   }
 415 }
 416
 417 static void rna_Sculpt_ShowDiffuseColor_update(bContext *C, PointerRNA *UNUSED(ptr))
 418 {
 419   ViewLayer *view_layer = CTX_data_view_layer(C);
 420   Object *ob = OBACT(view_layer);
 421
 422   if (ob && ob->sculpt) {
 423     Scene *scene = CTX_data_scene(C);
 424     Sculpt *sd = scene->toolsettings->sculpt;
 425     ob->sculpt->show_diffuse_color = ((sd->flags & SCULPT_SHOW_DIFFUSE) != 0);
 426
 427     if (ob->sculpt->pbvh) {
 428       pbvh_show_diffuse_color_set(ob->sculpt->pbvh, ob->sculpt->show_diffuse_color);
 429     }
 430
 431     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
 432     WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
 433   }
 434 }
 435
 436 static void rna_Sculpt_ShowMask_update(bContext *C, PointerRNA *UNUSED(ptr))
 437 {
 438   ViewLayer *view_layer = CTX_data_view_layer(C);
 439   Object *object = OBACT(view_layer);
 440   if (object == NULL || object->sculpt == NULL) {
 441     return;
 442   }
 443   Scene *scene = CTX_data_scene(C);
 444   Sculpt *sd = scene->toolsettings->sculpt;
 445   object->sculpt->show_mask = ((sd->flags & SCULPT_HIDE_MASK) == 0);
 446   if (object->sculpt->pbvh != NULL) {
 447     pbvh_show_mask_set(object->sculpt->pbvh, object->sculpt->show_mask);
 448   }
 449   DEG_id_tag_update(&object->id, ID_RECALC_GEOMETRY);
 450   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, object);
 451 }
 452
 453 static char *rna_Sculpt_path(PointerRNA *UNUSED(ptr))
 454 {
 455   return BLI_strdup("tool_settings.sculpt");
 456 }
 457
 458 static char *rna_VertexPaint_path(PointerRNA *ptr)
 459 {
 460   Scene *scene = (Scene *)ptr->id.data;
 461   ToolSettings *ts = scene->toolsettings;
 462   if (ptr->data == ts->vpaint) {
 463     return BLI_strdup("tool_settings.vertex_paint");
 464   }
 465   else {
 466     return BLI_strdup("tool_settings.weight_paint");
 467   }
 468 }
 469
 470 static char *rna_ImagePaintSettings_path(PointerRNA *UNUSED(ptr))
 471 {
 472   return BLI_strdup("tool_settings.image_paint");
 473 }
 474
 475 static char *rna_UvSculpt_path(PointerRNA *UNUSED(ptr))
 476 {
 477   return BLI_strdup("tool_settings.uv_sculpt");
 478 }
 479
 480 static char *rna_GpPaint_path(PointerRNA *UNUSED(ptr))
 481 {
 482   return BLI_strdup("tool_settings.gpencil_paint");
 483 }
 484
 485 static char *rna_ParticleBrush_path(PointerRNA *UNUSED(ptr))
 486 {
 487   return BLI_strdup("tool_settings.particle_edit.brush");
 488 }
 489
 490 static void rna_Paint_brush_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 491 {
 492   Paint *paint = ptr->data;
 493   Brush *br = paint->brush;
 494   BKE_paint_invalidate_overlay_all();
 495   /* Needed because we're not calling 'BKE_paint_brush_set' which handles this. */
 496   BKE_paint_toolslots_brush_update(paint);
 497   WM_main_add_notifier(NC_BRUSH | NA_SELECTED, br);
 498 }
 499
 500 static void rna_ImaPaint_viewport_update(Main *UNUSED(bmain),
 501                                          Scene *UNUSED(scene),
 502                                          PointerRNA *UNUSED(ptr))
 503 {
 504   /* not the best solution maybe, but will refresh the 3D viewport */
 505   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
 506 }
 507
 508 static void rna_ImaPaint_mode_update(bContext *C, PointerRNA *UNUSED(ptr))
 509 {
 510   Scene *scene = CTX_data_scene(C);
 511   ViewLayer *view_layer = CTX_data_view_layer(C);
 512   Object *ob = OBACT(view_layer);
 513
 514   if (ob && ob->type == OB_MESH) {
 515     /* of course we need to invalidate here */
 516     BKE_texpaint_slots_refresh_object(scene, ob);
 517
 518     /* We assume that changing the current mode will invalidate the uv layers
 519      * so we need to refresh display. */
 520     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 521     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
 522   }
 523 }
 524
 525 static void rna_ImaPaint_stencil_update(bContext *C, PointerRNA *UNUSED(ptr))
 526 {
 527   Scene *scene = CTX_data_scene(C);
 528   ViewLayer *view_layer = CTX_data_view_layer(C);
 529   Object *ob = OBACT(view_layer);
 530
 531   if (ob && ob->type == OB_MESH) {
 532     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 533     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
 534   }
 535 }
 536
 537 static void rna_ImaPaint_canvas_update(bContext *C, PointerRNA *UNUSED(ptr))
 538 {
 539   Main *bmain = CTX_data_main(C);
 540   Scene *scene = CTX_data_scene(C);
 541   ViewLayer *view_layer = CTX_data_view_layer(C);
 542   Object *ob = OBACT(view_layer);
 543   Object *obedit = OBEDIT_FROM_OBACT(ob);
 544   bScreen *sc;
 545   Image *ima = scene->toolsettings->imapaint.canvas;
 546
 547   for (sc = bmain->screens.first; sc; sc = sc->id.next) {
 548     ScrArea *sa;
 549     for (sa = sc->areabase.first; sa; sa = sa->next) {
 550       SpaceLink *slink;
 551       for (slink = sa->spacedata.first; slink; slink = slink->next) {
 552         if (slink->spacetype == SPACE_IMAGE) {
 553           SpaceImage *sima = (SpaceImage *)slink;
 554
 555           if (!sima->pin) {
 556             ED_space_image_set(bmain, sima, obedit, ima, true);
 557           }
 558         }
 559       }
 560     }
 561   }
 562
 563   if (ob && ob->type == OB_MESH) {
 564     BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 565     WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
 566   }
 567 }
 568
 569 static bool rna_ImaPaint_detect_data(ImagePaintSettings *imapaint)
 570 {
 571   return imapaint->missing_data == 0;
 572 }
 573
 574 static PointerRNA rna_GPencilSculptSettings_brush_get(PointerRNA *ptr)
 575 {
 576   GP_Sculpt_Settings *gset = (GP_Sculpt_Settings *)ptr->data;
 577   GP_Sculpt_Data *brush = NULL;
 578
 579   if ((gset) && (gset->flag & GP_SCULPT_SETT_FLAG_WEIGHT_MODE)) {
 580     if ((gset->weighttype >= GP_SCULPT_TYPE_WEIGHT) && (gset->weighttype < GP_SCULPT_TYPE_MAX)) {
 581       brush = &gset->brush[gset->weighttype];
 582     }
 583   }
 584   else {
 585     if ((gset->brushtype >= 0) && (gset->brushtype < GP_SCULPT_TYPE_WEIGHT)) {
 586       brush = &gset->brush[gset->brushtype];
 587     }
 588   }
 589   return rna_pointer_inherit_refine(ptr, &RNA_GPencilSculptBrush, brush);
 590 }
 591
 592 static char *rna_GPencilSculptSettings_path(PointerRNA *UNUSED(ptr))
 593 {
 594   return BLI_strdup("tool_settings.gpencil_sculpt");
 595 }
 596
 597 static char *rna_GPencilSculptBrush_path(PointerRNA *UNUSED(ptr))
 598 {
 599   return BLI_strdup("tool_settings.gpencil_sculpt.brush");
 600 }
 601
 602 static char *rna_GPencilSculptGuide_path(PointerRNA *UNUSED(ptr))
 603 {
 604   return BLI_strdup("tool_settings.gpencil_sculpt.guide");
 605 }
 606
 607 #else
 608
 609 static void rna_def_paint_curve(BlenderRNA *brna)
 610 {
 611   StructRNA *srna;
 612
 613   srna = RNA_def_struct(brna, "PaintCurve", "ID");
 614   RNA_def_struct_ui_text(srna, "Paint Curve", "");
 615   RNA_def_struct_ui_icon(srna, ICON_CURVE_BEZCURVE);
 616 }
 617
 618 static void rna_def_paint_tool_slot(BlenderRNA *brna)
 619 {
 620   StructRNA *srna;
 621   PropertyRNA *prop;
 622
 623   srna = RNA_def_struct(brna, "PaintToolSlot", NULL);
 624   RNA_def_struct_ui_text(srna, "Paint Tool Slot", "");
 625
 626   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
 627   RNA_def_property_flag(prop, PROP_EDITABLE);
 628   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Brush_mode_with_tool_poll");
 629   RNA_def_property_ui_text(prop, "Brush", "");
 630 }
 631
 632 static void rna_def_paint(BlenderRNA *brna)
 633 {
 634   StructRNA *srna;
 635   PropertyRNA *prop;
 636
 637   srna = RNA_def_struct(brna, "Paint", NULL);
 638   RNA_def_struct_ui_text(srna, "Paint", "");
 639
 640   /* Global Settings */
 641   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
 642   RNA_def_property_flag(prop, PROP_EDITABLE);
 643   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Brush_mode_poll");
 644   RNA_def_property_ui_text(prop, "Brush", "Active Brush");
 645   RNA_def_property_update(prop, 0, "rna_Paint_brush_update");
 646
 647   /* paint_tool_slots */
 648   prop = RNA_def_property(srna, "tool_slots", PROP_COLLECTION, PROP_NONE);
 649   RNA_def_property_collection_sdna(prop, NULL, "tool_slots", "tool_slots_len");
 650   RNA_def_property_struct_type(prop, "PaintToolSlot");
 651   /* don't dereference pointer! */
 652   RNA_def_property_collection_funcs(
 653       prop, NULL, NULL, NULL, "rna_iterator_array_get", NULL, NULL, NULL, NULL);
 654   RNA_def_property_ui_text(prop, "Paint Tool Slots", "");
 655
 656   prop = RNA_def_property(srna, "palette", PROP_POINTER, PROP_NONE);
 657   RNA_def_property_flag(prop, PROP_EDITABLE);
 658   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, NULL);
 659   RNA_def_property_ui_text(prop, "Palette", "Active Palette");
 660
 661   prop = RNA_def_property(srna, "show_brush", PROP_BOOLEAN, PROP_NONE);
 662   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_SHOW_BRUSH);
 663   RNA_def_property_ui_text(prop, "Show Brush", "");
 664   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 665
 666   prop = RNA_def_property(srna, "show_brush_on_surface", PROP_BOOLEAN, PROP_NONE);
 667   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_SHOW_BRUSH_ON_SURFACE);
 668   RNA_def_property_ui_text(prop, "Show Brush On Surface", "");
 669   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 670
 671   prop = RNA_def_property(srna, "show_low_resolution", PROP_BOOLEAN, PROP_NONE);
 672   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_FAST_NAVIGATE);
 673   RNA_def_property_ui_text(
 674       prop, "Fast Navigate", "For multires, show low resolution while navigating the view");
 675   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 676
 677   prop = RNA_def_property(srna, "input_samples", PROP_INT, PROP_UNSIGNED);
 678   RNA_def_property_int_sdna(prop, NULL, "num_input_samples");
 679   RNA_def_property_ui_range(prop, 1, PAINT_MAX_INPUT_SAMPLES, 0, -1);
 680   RNA_def_property_ui_text(
 681       prop, "Input Samples", "Average multiple input samples together to smooth the brush stroke");
 682   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 683
 684   prop = RNA_def_property(srna, "use_symmetry_x", PROP_BOOLEAN, PROP_NONE);
 685   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_X);
 686   RNA_def_property_ui_text(prop, "Symmetry X", "Mirror brush across the X axis");
 687   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 688
 689   prop = RNA_def_property(srna, "use_symmetry_y", PROP_BOOLEAN, PROP_NONE);
 690   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_Y);
 691   RNA_def_property_ui_text(prop, "Symmetry Y", "Mirror brush across the Y axis");
 692   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 693
 694   prop = RNA_def_property(srna, "use_symmetry_z", PROP_BOOLEAN, PROP_NONE);
 695   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMM_Z);
 696   RNA_def_property_ui_text(prop, "Symmetry Z", "Mirror brush across the Z axis");
 697   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 698
 699   prop = RNA_def_property(srna, "use_symmetry_feather", PROP_BOOLEAN, PROP_NONE);
 700   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_SYMMETRY_FEATHER);
 701   RNA_def_property_ui_text(prop,
 702                            "Symmetry Feathering",
 703                            "Reduce the strength of the brush where it overlaps symmetrical daubs");
 704   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 705
 706   prop = RNA_def_property(srna, "cavity_curve", PROP_POINTER, PROP_NONE);
 707   RNA_def_property_flag(prop, PROP_NEVER_NULL);
 708   RNA_def_property_ui_text(prop, "Curve", "Editable cavity curve");
 709   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 710
 711   prop = RNA_def_property(srna, "use_cavity", PROP_BOOLEAN, PROP_NONE);
 712   RNA_def_property_boolean_sdna(prop, NULL, "flags", PAINT_USE_CAVITY_MASK);
 713   RNA_def_property_ui_text(prop, "Cavity Mask", "Mask painting according to mesh geometry cavity");
 714   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 715
 716   prop = RNA_def_property(srna, "tile_offset", PROP_FLOAT, PROP_XYZ);
 717   RNA_def_property_float_sdna(prop, NULL, "tile_offset");
 718   RNA_def_property_array(prop, 3);
 719   RNA_def_property_range(prop, 0.01, FLT_MAX);
 720   RNA_def_property_ui_range(prop, 0.01, 100, 1 * 100, 2);
 721   RNA_def_property_ui_text(
 722       prop, "Tiling offset for the X Axis", "Stride at which tiled strokes are copied");
 723
 724   prop = RNA_def_property(srna, "tile_x", PROP_BOOLEAN, PROP_NONE);
 725   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_X);
 726   RNA_def_property_ui_text(prop, "Tile X", "Tile along X axis");
 727   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 728
 729   prop = RNA_def_property(srna, "tile_y", PROP_BOOLEAN, PROP_NONE);
 730   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_Y);
 731   RNA_def_property_ui_text(prop, "Tile Y", "Tile along Y axis");
 732   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 733
 734   prop = RNA_def_property(srna, "tile_z", PROP_BOOLEAN, PROP_NONE);
 735   RNA_def_property_boolean_sdna(prop, NULL, "symmetry_flags", PAINT_TILE_Z);
 736   RNA_def_property_ui_text(prop, "Tile Z", "Tile along Z axis");
 737   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 738 }
 739
 740 static void rna_def_sculpt(BlenderRNA *brna)
 741 {
 742   static const EnumPropertyItem detail_refine_items[] = {
 743       {SCULPT_DYNTOPO_SUBDIVIDE,
 744        "SUBDIVIDE",
 745        0,
 746        "Subdivide Edges",
 747        "Subdivide long edges to add mesh detail where needed"},
 748       {SCULPT_DYNTOPO_COLLAPSE,
 749        "COLLAPSE",
 750        0,
 751        "Collapse Edges",
 752        "Collapse short edges to remove mesh detail where possible"},
 753       {SCULPT_DYNTOPO_SUBDIVIDE | SCULPT_DYNTOPO_COLLAPSE,
 754        "SUBDIVIDE_COLLAPSE",
 755        0,
 756        "Subdivide Collapse",
 757        "Both subdivide long edges and collapse short edges to refine mesh detail"},
 758       {0, NULL, 0, NULL, NULL},
 759   };
 760
 761   static const EnumPropertyItem detail_type_items[] = {
 762       {0,
 763        "RELATIVE",
 764        0,
 765        "Relative Detail",
 766        "Mesh detail is relative to the brush size and detail size"},
 767       {SCULPT_DYNTOPO_DETAIL_CONSTANT,
 768        "CONSTANT",
 769        0,
 770        "Constant Detail",
 771        "Mesh detail is constant in world space according to detail size"},
 772       {SCULPT_DYNTOPO_DETAIL_BRUSH,
 773        "BRUSH",
 774        0,
 775        "Brush Detail",
 776        "Mesh detail is relative to brush radius"},
 777       {SCULPT_DYNTOPO_DETAIL_MANUAL,
 778        "MANUAL",
 779        0,
 780        "Manual Detail",
 781        "Mesh detail does not change on each stroke, only when using Flood Fill"},
 782       {0, NULL, 0, NULL, NULL},
 783   };
 784
 785   StructRNA *srna;
 786   PropertyRNA *prop;
 787
 788   srna = RNA_def_struct(brna, "Sculpt", "Paint");
 789   RNA_def_struct_path_func(srna, "rna_Sculpt_path");
 790   RNA_def_struct_ui_text(srna, "Sculpt", "");
 791
 792   prop = RNA_def_property(srna, "radial_symmetry", PROP_INT, PROP_XYZ);
 793   RNA_def_property_int_sdna(prop, NULL, "radial_symm");
 794   RNA_def_property_int_default(prop, 1);
 795   RNA_def_property_range(prop, 1, 64);
 796   RNA_def_property_ui_range(prop, 0, 32, 1, 1);
 797   RNA_def_property_ui_text(
 798       prop, "Radial Symmetry Count X Axis", "Number of times to copy strokes across the surface");
 799
 800   prop = RNA_def_property(srna, "lock_x", PROP_BOOLEAN, PROP_NONE);
 801   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_X);
 802   RNA_def_property_ui_text(prop, "Lock X", "Disallow changes to the X axis of vertices");
 803   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 804
 805   prop = RNA_def_property(srna, "lock_y", PROP_BOOLEAN, PROP_NONE);
 806   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_Y);
 807   RNA_def_property_ui_text(prop, "Lock Y", "Disallow changes to the Y axis of vertices");
 808   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 809
 810   prop = RNA_def_property(srna, "lock_z", PROP_BOOLEAN, PROP_NONE);
 811   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_LOCK_Z);
 812   RNA_def_property_ui_text(prop, "Lock Z", "Disallow changes to the Z axis of vertices");
 813   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 814
 815   prop = RNA_def_property(srna, "use_threaded", PROP_BOOLEAN, PROP_NONE);
 816   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_USE_OPENMP);
 817   RNA_def_property_ui_text(
 818       prop, "Use OpenMP", "Take advantage of multiple CPU cores to improve sculpting performance");
 819   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 820
 821   prop = RNA_def_property(srna, "use_deform_only", PROP_BOOLEAN, PROP_NONE);
 822   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_ONLY_DEFORM);
 823   RNA_def_property_ui_text(prop,
 824                            "Use Deform Only",
 825                            "Use only deformation modifiers (temporary disable all "
 826                            "constructive modifiers except multi-resolution)");
 827   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 828   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_update");
 829
 830   prop = RNA_def_property(srna, "show_diffuse_color", PROP_BOOLEAN, PROP_NONE);
 831   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_SHOW_DIFFUSE);
 832   RNA_def_property_ui_text(prop,
 833                            "Show Diffuse Color",
 834                            "Show diffuse color of object and overlay sculpt mask on top of it");
 835   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 836   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_ShowDiffuseColor_update");
 837
 838   prop = RNA_def_property(srna, "show_mask", PROP_BOOLEAN, PROP_NONE);
 839   RNA_def_property_boolean_negative_sdna(prop, NULL, "flags", SCULPT_HIDE_MASK);
 840   RNA_def_property_ui_text(prop, "Show Mask", "Show mask as overlay on object");
 841   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 842   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_ShowMask_update");
 843
 844   prop = RNA_def_property(srna, "detail_size", PROP_FLOAT, PROP_PIXEL);
 845   RNA_def_property_ui_range(prop, 0.5, 40.0, 10, 2);
 846   RNA_def_property_ui_text(
 847       prop, "Detail Size", "Maximum edge length for dynamic topology sculpting (in pixels)");
 848   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 849
 850   prop = RNA_def_property(srna, "detail_percent", PROP_FLOAT, PROP_PERCENTAGE);
 851   RNA_def_property_ui_range(prop, 0.5, 100.0, 10, 2);
 852   RNA_def_property_ui_text(
 853       prop,
 854       "Detail Percentage",
 855       "Maximum edge length for dynamic topology sculpting (in brush percenage)");
 856   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 857
 858   prop = RNA_def_property(srna, "constant_detail_resolution", PROP_FLOAT, PROP_NONE);
 859   RNA_def_property_float_sdna(prop, NULL, "constant_detail");
 860   RNA_def_property_range(prop, 0.0001, FLT_MAX);
 861   RNA_def_property_ui_range(prop, 0.001, 1000.0, 10, 2);
 862   RNA_def_property_ui_text(prop,
 863                            "Resolution",
 864                            "Maximum edge length for dynamic topology sculpting (as divisor "
 865                            "of blender unit - higher value means smaller edge length)");
 866   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 867
 868   prop = RNA_def_property(srna, "use_smooth_shading", PROP_BOOLEAN, PROP_NONE);
 869   RNA_def_property_boolean_sdna(prop, NULL, "flags", SCULPT_DYNTOPO_SMOOTH_SHADING);
 870   RNA_def_property_ui_text(prop,
 871                            "Smooth Shading",
 872                            "Show faces in dynamic-topology mode with smooth "
 873                            "shading rather than flat shaded");
 874   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 875   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Sculpt_update");
 876
 877   prop = RNA_def_property(srna, "symmetrize_direction", PROP_ENUM, PROP_NONE);
 878   RNA_def_property_enum_items(prop, rna_enum_symmetrize_direction_items);
 879   RNA_def_property_ui_text(prop, "Direction", "Source and destination for symmetrize operator");
 880
 881   prop = RNA_def_property(srna, "detail_refine_method", PROP_ENUM, PROP_NONE);
 882   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 883   RNA_def_property_enum_items(prop, detail_refine_items);
 884   RNA_def_property_ui_text(
 885       prop, "Detail Refine Method", "In dynamic-topology mode, how to add or remove mesh detail");
 886   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 887
 888   prop = RNA_def_property(srna, "detail_type_method", PROP_ENUM, PROP_NONE);
 889   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 890   RNA_def_property_enum_items(prop, detail_type_items);
 891   RNA_def_property_ui_text(
 892       prop, "Detail Type Method", "In dynamic-topology mode, how mesh detail size is calculated");
 893   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 894
 895   prop = RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_FACTOR);
 896   RNA_def_property_float_sdna(prop, NULL, "gravity_factor");
 897   RNA_def_property_range(prop, 0.0f, 1.0f);
 898   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
 899   RNA_def_property_ui_text(prop, "Gravity", "Amount of gravity after each dab");
 900   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 901
 902   prop = RNA_def_property(srna, "gravity_object", PROP_POINTER, PROP_NONE);
 903   RNA_def_property_flag(prop, PROP_EDITABLE);
 904   RNA_def_property_ui_text(
 905       prop, "Orientation", "Object whose Z axis defines orientation of gravity");
 906   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 907 }
 908
 909 static void rna_def_uv_sculpt(BlenderRNA *brna)
 910 {
 911   StructRNA *srna;
 912
 913   srna = RNA_def_struct(brna, "UvSculpt", "Paint");
 914   RNA_def_struct_path_func(srna, "rna_UvSculpt_path");
 915   RNA_def_struct_ui_text(srna, "UV Sculpting", "");
 916 }
 917
 918 static void rna_def_gp_paint(BlenderRNA *brna)
 919 {
 920   StructRNA *srna;
 921
 922   srna = RNA_def_struct(brna, "GpPaint", "Paint");
 923   RNA_def_struct_path_func(srna, "rna_GpPaint_path");
 924   RNA_def_struct_ui_text(srna, "Grease Pencil Paint", "");
 925 }
 926
 927 /* use for weight paint too */
 928 static void rna_def_vertex_paint(BlenderRNA *brna)
 929 {
 930   StructRNA *srna;
 931   PropertyRNA *prop;
 932
 933   srna = RNA_def_struct(brna, "VertexPaint", "Paint");
 934   RNA_def_struct_sdna(srna, "VPaint");
 935   RNA_def_struct_path_func(srna, "rna_VertexPaint_path");
 936   RNA_def_struct_ui_text(srna, "Vertex Paint", "Properties of vertex and weight paint mode");
 937
 938   /* weight paint only */
 939   prop = RNA_def_property(srna, "use_group_restrict", PROP_BOOLEAN, PROP_NONE);
 940   RNA_def_property_boolean_sdna(prop, NULL, "flag", VP_FLAG_VGROUP_RESTRICT);
 941   RNA_def_property_ui_text(prop, "Restrict", "Restrict painting to vertices in the group");
 942   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 943
 944   /* Mirroring */
 945   prop = RNA_def_property(srna, "radial_symmetry", PROP_INT, PROP_XYZ);
 946   RNA_def_property_int_sdna(prop, NULL, "radial_symm");
 947   RNA_def_property_int_default(prop, 1);
 948   RNA_def_property_range(prop, 1, 64);
 949   RNA_def_property_ui_range(prop, 1, 32, 1, 1);
 950   RNA_def_property_ui_text(
 951       prop, "Radial Symmetry Count X Axis", "Number of times to copy strokes across the surface");
 952 }
 953
 954 static void rna_def_image_paint(BlenderRNA *brna)
 955 {
 956   StructRNA *srna;
 957   PropertyRNA *prop;
 958   FunctionRNA *func;
 959
 960   static const EnumPropertyItem paint_type_items[] = {
 961       {IMAGEPAINT_MODE_MATERIAL,
 962        "MATERIAL",
 963        0,
 964        "Material",
 965        "Detect image slots from the material"},
 966       {IMAGEPAINT_MODE_IMAGE,
 967        "IMAGE",
 968        0,
 969        "Single Image",
 970        "Set image for texture painting directly"},
 971       {0, NULL, 0, NULL, NULL},
 972   };
 973
 974   static const EnumPropertyItem paint_interp_items[] = {
 975       {IMAGEPAINT_INTERP_LINEAR, "LINEAR", 0, "Linear", "Linear interpolation"},
 976       {IMAGEPAINT_INTERP_CLOSEST,
 977        "CLOSEST",
 978        0,
 979        "Closest",
 980        "No interpolation (sample closest texel)"},
 981       {0, NULL, 0, NULL, NULL},
 982   };
 983
 984   srna = RNA_def_struct(brna, "ImagePaint", "Paint");
 985   RNA_def_struct_sdna(srna, "ImagePaintSettings");
 986   RNA_def_struct_path_func(srna, "rna_ImagePaintSettings_path");
 987   RNA_def_struct_ui_text(srna, "Image Paint", "Properties of image and texture painting mode");
 988
 989   /* functions */
 990   func = RNA_def_function(srna, "detect_data", "rna_ImaPaint_detect_data");
 991   RNA_def_function_ui_description(func, "Check if required texpaint data exist");
 992
 993   /* return type */
 994   RNA_def_function_return(func, RNA_def_boolean(func, "ok", 1, "", ""));
 995
 996   /* booleans */
 997   prop = RNA_def_property(srna, "use_occlude", PROP_BOOLEAN, PROP_NONE);
 998   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_XRAY);
 999   RNA_def_property_ui_text(
1000       prop, "Occlude", "Only paint onto the faces directly under the brush (slower)");
1001   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1002
1003   prop = RNA_def_property(srna, "use_backface_culling", PROP_BOOLEAN, PROP_NONE);
1004   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_BACKFACE);
1005   RNA_def_property_ui_text(prop, "Cull", "Ignore faces pointing away from the view (faster)");
1006   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1007
1008   prop = RNA_def_property(srna, "use_normal_falloff", PROP_BOOLEAN, PROP_NONE);
1009   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_FLAT);
1010   RNA_def_property_ui_text(prop, "Normal", "Paint most on faces pointing towards the view");
1011   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1012
1013   prop = RNA_def_property(srna, "use_stencil_layer", PROP_BOOLEAN, PROP_NONE);
1014   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_STENCIL);
1015   RNA_def_property_ui_text(prop, "Stencil Layer", "Set the mask layer from the UV map buttons");
1016   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1017
1018   prop = RNA_def_property(srna, "invert_stencil", PROP_BOOLEAN, PROP_NONE);
1019   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_STENCIL_INV);
1020   RNA_def_property_ui_text(prop, "Invert", "Invert the stencil layer");
1021   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1022
1023   prop = RNA_def_property(srna, "stencil_image", PROP_POINTER, PROP_NONE);
1024   RNA_def_property_pointer_sdna(prop, NULL, "stencil");
1025   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1026   RNA_def_property_ui_text(prop, "Stencil Image", "Image used as stencil");
1027   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_stencil_update");
1028
1029   prop = RNA_def_property(srna, "canvas", PROP_POINTER, PROP_NONE);
1030   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1031   RNA_def_property_ui_text(prop, "Canvas", "Image used as canvas");
1032   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_canvas_update");
1033
1034   prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE);
1035   RNA_def_property_pointer_sdna(prop, NULL, "clone");
1036   RNA_def_property_flag(prop, PROP_EDITABLE);
1037   RNA_def_property_ui_text(prop, "Clone Image", "Image used as clone source");
1038   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1039
1040   prop = RNA_def_property(srna, "stencil_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1041   RNA_def_property_range(prop, 0.0, 1.0);
1042   RNA_def_property_float_sdna(prop, NULL, "stencil_col");
1043   RNA_def_property_ui_text(prop, "Stencil Color", "Stencil color in the viewport");
1044   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1045
1046   prop = RNA_def_property(srna, "dither", PROP_FLOAT, PROP_NONE);
1047   RNA_def_property_range(prop, 0.0, 2.0);
1048   RNA_def_property_ui_text(prop, "Dither", "Amount of dithering when painting on byte images");
1049   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1050
1051   prop = RNA_def_property(srna, "use_clone_layer", PROP_BOOLEAN, PROP_NONE);
1052   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMAGEPAINT_PROJECT_LAYER_CLONE);
1053   RNA_def_property_ui_text(
1054       prop,
1055       "Clone Map",
1056       "Use another UV map as clone source, otherwise use the 3D cursor as the source");
1057   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1058
1059   /* integers */
1060
1061   prop = RNA_def_property(srna, "seam_bleed", PROP_INT, PROP_PIXEL);
1062   RNA_def_property_ui_range(prop, 0, 8, 0, -1);
1063   RNA_def_property_ui_text(
1064       prop, "Bleed", "Extend paint beyond the faces UVs to reduce seams (in pixels, slower)");
1065
1066   prop = RNA_def_property(srna, "normal_angle", PROP_INT, PROP_UNSIGNED);
1067   RNA_def_property_range(prop, 0, 90);
1068   RNA_def_property_ui_text(
1069       prop, "Angle", "Paint most on faces pointing towards the view according to this angle");
1070
1071   prop = RNA_def_int_array(srna,
1072                            "screen_grab_size",
1073                            2,
1074                            NULL,
1075                            0,
1076                            0,
1077                            "screen_grab_size",
1078                            "Size to capture the image for re-projecting",
1079                            0,
1080                            0);
1081   RNA_def_property_range(prop, 512, 16384);
1082
1083   prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
1084   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1085   RNA_def_property_enum_items(prop, paint_type_items);
1086   RNA_def_property_ui_text(prop, "Mode", "Mode of operation for projection painting");
1087   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_mode_update");
1088
1089   prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1090   RNA_def_property_enum_sdna(prop, NULL, "interp");
1091   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1092   RNA_def_property_enum_items(prop, paint_interp_items);
1093   RNA_def_property_ui_text(prop, "Interpolation", "Texture filtering type");
1094   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_mode_update");
1095
1096   /* Missing data */
1097   prop = RNA_def_property(srna, "missing_uvs", PROP_BOOLEAN, PROP_NONE);
1098   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_UVS);
1099   RNA_def_property_ui_text(prop, "Missing UVs", "A UV layer is missing on the mesh");
1100   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1101
1102   prop = RNA_def_property(srna, "missing_materials", PROP_BOOLEAN, PROP_NONE);
1103   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_MATERIAL);
1104   RNA_def_property_ui_text(prop, "Missing Materials", "The mesh is missing materials");
1105   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1106
1107   prop = RNA_def_property(srna, "missing_stencil", PROP_BOOLEAN, PROP_NONE);
1108   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_STENCIL);
1109   RNA_def_property_ui_text(prop, "Missing Stencil", "Image Painting does not have a stencil");
1110   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1111
1112   prop = RNA_def_property(srna, "missing_texture", PROP_BOOLEAN, PROP_NONE);
1113   RNA_def_property_boolean_sdna(prop, NULL, "missing_data", IMAGEPAINT_MISSING_TEX);
1114   RNA_def_property_ui_text(
1115       prop, "Missing Texture", "Image Painting does not have a texture to paint on");
1116   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1117 }
1118
1119 static void rna_def_particle_edit(BlenderRNA *brna)
1120 {
1121   StructRNA *srna;
1122   PropertyRNA *prop;
1123
1124   static const EnumPropertyItem select_mode_items[] = {
1125       {SCE_SELECT_PATH, "PATH", ICON_PARTICLE_PATH, "Path", "Path edit mode"},
1126       {SCE_SELECT_POINT, "POINT", ICON_PARTICLE_POINT, "Point", "Point select mode"},
1127       {SCE_SELECT_END, "TIP", ICON_PARTICLE_TIP, "Tip", "Tip select mode"},
1128       {0, NULL, 0, NULL, NULL},
1129   };
1130
1131   static const EnumPropertyItem puff_mode[] = {
1132       {0, "ADD", 0, "Add", "Make hairs more puffy"},
1133       {1, "SUB", 0, "Sub", "Make hairs less puffy"},
1134       {0, NULL, 0, NULL, NULL},
1135   };
1136
1137   static const EnumPropertyItem length_mode[] = {
1138       {0, "GROW", 0, "Grow", "Make hairs longer"},
1139       {1, "SHRINK", 0, "Shrink", "Make hairs shorter"},
1140       {0, NULL, 0, NULL, NULL},
1141   };
1142
1143   static const EnumPropertyItem edit_type_items[] = {
1144       {PE_TYPE_PARTICLES, "PARTICLES", 0, "Particles", ""},
1145       {PE_TYPE_SOFTBODY, "SOFT_BODY", 0, "Soft body", ""},
1146       {PE_TYPE_CLOTH, "CLOTH", 0, "Cloth", ""},
1147       {0, NULL, 0, NULL, NULL},
1148   };
1149
1150   /* edit */
1151
1152   srna = RNA_def_struct(brna, "ParticleEdit", NULL);
1153   RNA_def_struct_sdna(srna, "ParticleEditSettings");
1154   RNA_def_struct_path_func(srna, "rna_ParticleEdit_path");
1155   RNA_def_struct_ui_text(srna, "Particle Edit", "Properties of particle editing mode");
1156
1157   prop = RNA_def_property(srna, "tool", PROP_ENUM, PROP_NONE);
1158   RNA_def_property_enum_sdna(prop, NULL, "brushtype");
1159   RNA_def_property_enum_items(prop, rna_enum_particle_edit_hair_brush_items);
1160   RNA_def_property_enum_funcs(
1161       prop, NULL, "rna_ParticleEdit_tool_set", "rna_ParticleEdit_tool_itemf");
1162   RNA_def_property_ui_text(prop, "Tool", "");
1163
1164   prop = RNA_def_property(srna, "select_mode", PROP_ENUM, PROP_NONE);
1165   RNA_def_property_enum_bitflag_sdna(prop, NULL, "selectmode");
1166   RNA_def_property_enum_items(prop, select_mode_items);
1167   RNA_def_property_ui_text(prop, "Selection Mode", "Particle select and display mode");
1168   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1169   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1170
1171   prop = RNA_def_property(srna, "use_preserve_length", PROP_BOOLEAN, PROP_NONE);
1172   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_KEEP_LENGTHS);
1173   RNA_def_property_ui_text(prop, "Keep Lengths", "Keep path lengths constant");
1174
1175   prop = RNA_def_property(srna, "use_preserve_root", PROP_BOOLEAN, PROP_NONE);
1176   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_LOCK_FIRST);
1177   RNA_def_property_ui_text(prop, "Keep Root", "Keep root keys unmodified");
1178
1179   prop = RNA_def_property(srna, "use_emitter_deflect", PROP_BOOLEAN, PROP_NONE);
1180   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_DEFLECT_EMITTER);
1181   RNA_def_property_ui_text(prop, "Deflect Emitter", "Keep paths from intersecting the emitter");
1182
1183   prop = RNA_def_property(srna, "emitter_distance", PROP_FLOAT, PROP_DISTANCE);
1184   RNA_def_property_float_sdna(prop, NULL, "emitterdist");
1185   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 10, 3);
1186   RNA_def_property_ui_text(
1187       prop, "Emitter Distance", "Distance to keep particles away from the emitter");
1188
1189   prop = RNA_def_property(srna, "use_fade_time", PROP_BOOLEAN, PROP_NONE);
1190   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_FADE_TIME);
1191   RNA_def_property_ui_text(
1192       prop, "Fade Time", "Fade paths and keys further away from current frame");
1193   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1194   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1195
1196   prop = RNA_def_property(srna, "use_auto_velocity", PROP_BOOLEAN, PROP_NONE);
1197   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_AUTO_VELOCITY);
1198   RNA_def_property_ui_text(prop, "Auto Velocity", "Calculate point velocities automatically");
1199
1200   prop = RNA_def_property(srna, "show_particles", PROP_BOOLEAN, PROP_NONE);
1201   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1202   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_DRAW_PART);
1203   RNA_def_property_ui_text(prop, "Display Particles", "Display actual particles");
1204   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1205
1206   prop = RNA_def_property(srna, "use_default_interpolate", PROP_BOOLEAN, PROP_NONE);
1207   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_INTERPOLATE_ADDED);
1208   RNA_def_property_ui_text(
1209       prop, "Interpolate", "Interpolate new particles from the existing ones");
1210
1211   prop = RNA_def_property(srna, "default_key_count", PROP_INT, PROP_NONE);
1212   RNA_def_property_int_sdna(prop, NULL, "totaddkey");
1213   RNA_def_property_range(prop, 2, SHRT_MAX);
1214   RNA_def_property_ui_range(prop, 2, 20, 10, 3);
1215   RNA_def_property_ui_text(prop, "Keys", "How many keys to make new particles with");
1216
1217   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
1218   RNA_def_property_struct_type(prop, "ParticleBrush");
1219   RNA_def_property_pointer_funcs(prop, "rna_ParticleEdit_brush_get", NULL, NULL, NULL);
1220   RNA_def_property_ui_text(prop, "Brush", "");
1221
1222   prop = RNA_def_property(srna, "display_step", PROP_INT, PROP_NONE);
1223   RNA_def_property_int_sdna(prop, NULL, "draw_step");
1224   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1225   RNA_def_property_range(prop, 1, 10);
1226   RNA_def_property_ui_text(prop, "Steps", "How many steps to display the path with");
1227   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1228
1229   prop = RNA_def_property(srna, "fade_frames", PROP_INT, PROP_NONE);
1230   RNA_def_property_range(prop, 1, 100);
1231   RNA_def_property_ui_text(prop, "Frames", "How many frames to fade");
1232   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1233   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_update");
1234
1235   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1236   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1237   RNA_def_property_enum_sdna(prop, NULL, "edittype");
1238   RNA_def_property_enum_items(prop, edit_type_items);
1239   RNA_def_property_ui_text(prop, "Type", "");
1240   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1241
1242   prop = RNA_def_property(srna, "is_editable", PROP_BOOLEAN, PROP_NONE);
1243   RNA_def_property_boolean_funcs(prop, "rna_ParticleEdit_editable_get", NULL);
1244   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1245   RNA_def_property_ui_text(prop, "Editable", "A valid edit mode exists");
1246
1247   prop = RNA_def_property(srna, "is_hair", PROP_BOOLEAN, PROP_NONE);
1248   RNA_def_property_boolean_funcs(prop, "rna_ParticleEdit_hair_get", NULL);
1249   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1250   RNA_def_property_ui_text(prop, "Hair", "Editing hair");
1251
1252   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1253   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1254   RNA_def_property_ui_text(prop, "Object", "The edited object");
1255
1256   prop = RNA_def_property(srna, "shape_object", PROP_POINTER, PROP_NONE);
1257   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1258   RNA_def_property_ui_text(prop, "Shape Object", "Outer shape to use for tools");
1259   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Mesh_object_poll");
1260   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ParticleEdit_redo");
1261
1262   /* brush */
1263
1264   srna = RNA_def_struct(brna, "ParticleBrush", NULL);
1265   RNA_def_struct_sdna(srna, "ParticleBrushData");
1266   RNA_def_struct_path_func(srna, "rna_ParticleBrush_path");
1267   RNA_def_struct_ui_text(srna, "Particle Brush", "Particle editing brush");
1268
1269   prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1270   RNA_def_property_range(prop, 1, SHRT_MAX);
1271   RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 10, 3);
1272   RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1273
1274   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1275   RNA_def_property_range(prop, 0.001, 1.0);
1276   RNA_def_property_ui_text(prop, "Strength", "Brush strength");
1277
1278   prop = RNA_def_property(srna, "count", PROP_INT, PROP_NONE);
1279   RNA_def_property_range(prop, 1, 1000);
1280   RNA_def_property_ui_range(prop, 1, 100, 10, 3);
1281   RNA_def_property_ui_text(prop, "Count", "Particle count");
1282
1283   prop = RNA_def_property(srna, "steps", PROP_INT, PROP_NONE);
1284   RNA_def_property_int_sdna(prop, NULL, "step");
1285   RNA_def_property_range(prop, 1, SHRT_MAX);
1286   RNA_def_property_ui_range(prop, 1, 50, 10, 3);
1287   RNA_def_property_ui_text(prop, "Steps", "Brush steps");
1288
1289   prop = RNA_def_property(srna, "puff_mode", PROP_ENUM, PROP_NONE);
1290   RNA_def_property_enum_sdna(prop, NULL, "invert");
1291   RNA_def_property_enum_items(prop, puff_mode);
1292   RNA_def_property_ui_text(prop, "Puff Mode", "");
1293
1294   prop = RNA_def_property(srna, "use_puff_volume", PROP_BOOLEAN, PROP_NONE);
1295   RNA_def_property_boolean_sdna(prop, NULL, "flag", PE_BRUSH_DATA_PUFF_VOLUME);
1296   RNA_def_property_ui_text(
1297       prop,
1298       "Puff Volume",
1299       "Apply puff to unselected end-points (helps maintain hair volume when puffing root)");
1300
1301   prop = RNA_def_property(srna, "length_mode", PROP_ENUM, PROP_NONE);
1302   RNA_def_property_enum_sdna(prop, NULL, "invert");
1303   RNA_def_property_enum_items(prop, length_mode);
1304   RNA_def_property_ui_text(prop, "Length Mode", "");
1305
1306   /* dummy */
1307   prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1308   RNA_def_property_struct_type(prop, "CurveMapping");
1309   RNA_def_property_pointer_funcs(prop, "rna_ParticleBrush_curve_get", NULL, NULL, NULL);
1310   RNA_def_property_ui_text(prop, "Curve", "");
1311 }
1312
1313 /* srna -- gpencil speed guides */
1314 static void rna_def_gpencil_guides(BlenderRNA *brna)
1315 {
1316   StructRNA *srna;
1317   PropertyRNA *prop;
1318
1319   srna = RNA_def_struct(brna, "GPencilSculptGuide", NULL);
1320   RNA_def_struct_sdna(srna, "GP_Sculpt_Guide");
1321   RNA_def_struct_path_func(srna, "rna_GPencilSculptGuide_path");
1322   RNA_def_struct_ui_text(srna, "GPencil Sculpt Guide", "Guides for drawing");
1323
1324   static const EnumPropertyItem prop_gpencil_guidetypes[] = {
1325       {GP_GUIDE_CIRCULAR, "CIRCULAR", 0, "Circular", "Use single point to create rings"},
1326       {GP_GUIDE_RADIAL, "RADIAL", 0, "Radial", "Use single point as direction"},
1327       {GP_GUIDE_PARALLEL, "PARALLEL", 0, "Parallel", "Parallel lines"},
1328       {GP_GUIDE_GRID, "GRID", 0, "Grid", "Grid allows horizontal and vertical lines"},
1329       {0, NULL, 0, NULL, NULL},
1330   };
1331
1332   static const EnumPropertyItem prop_gpencil_guide_references[] = {
1333       {GP_GUIDE_REF_CURSOR, "CURSOR", 0, "Cursor", "Use cursor as reference point"},
1334       {GP_GUIDE_REF_CUSTOM, "CUSTOM", 0, "Custom", "Use custom reference point"},
1335       {GP_GUIDE_REF_OBJECT, "OBJECT", 0, "Object", "Use object as reference point"},
1336       {0, NULL, 0, NULL, NULL},
1337   };
1338
1339   prop = RNA_def_property(srna, "use_guide", PROP_BOOLEAN, PROP_NONE);
1340   RNA_def_property_boolean_sdna(prop, NULL, "use_guide", false);
1341   RNA_def_property_boolean_default(prop, false);
1342   RNA_def_property_ui_text(prop, "Use Guides", "Enable speed guides");
1343   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1344   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1345
1346   prop = RNA_def_property(srna, "use_snapping", PROP_BOOLEAN, PROP_NONE);
1347   RNA_def_property_boolean_sdna(prop, NULL, "use_snapping", false);
1348   RNA_def_property_boolean_default(prop, false);
1349   RNA_def_property_ui_text(
1350       prop, "Use Snapping", "Enable snapping to guides angle or spacing options");
1351   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1352   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1353
1354   prop = RNA_def_property(srna, "reference_object", PROP_POINTER, PROP_NONE);
1355   RNA_def_property_pointer_sdna(prop, NULL, "reference_object");
1356   RNA_def_property_ui_text(prop, "Object", "Object used for reference point");
1357   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1358   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1359
1360   prop = RNA_def_property(srna, "reference_point", PROP_ENUM, PROP_NONE);
1361   RNA_def_property_enum_sdna(prop, NULL, "reference_point");
1362   RNA_def_property_enum_items(prop, prop_gpencil_guide_references);
1363   RNA_def_property_ui_text(prop, "Type", "Type of speed guide");
1364   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1365   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1366
1367   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1368   RNA_def_property_enum_sdna(prop, NULL, "type");
1369   RNA_def_property_enum_items(prop, prop_gpencil_guidetypes);
1370   RNA_def_property_ui_text(prop, "Type", "Type of speed guide");
1371   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1372   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1373
1374   prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1375   RNA_def_property_float_sdna(prop, NULL, "angle");
1376   RNA_def_property_range(prop, -(M_PI * 2.0f), (M_PI * 2.0f));
1377   RNA_def_property_ui_text(prop, "Angle", "Direction of lines");
1378   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1379   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1380
1381   prop = RNA_def_property(srna, "angle_snap", PROP_FLOAT, PROP_ANGLE);
1382   RNA_def_property_float_sdna(prop, NULL, "angle_snap");
1383   RNA_def_property_range(prop, -(M_PI * 2.0f), (M_PI * 2.0f));
1384   RNA_def_property_ui_text(prop, "Angle Snap", "Angle snapping");
1385   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1386   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1387
1388   prop = RNA_def_property(srna, "spacing", PROP_FLOAT, PROP_DISTANCE);
1389   RNA_def_property_float_sdna(prop, NULL, "spacing");
1390   RNA_def_property_float_default(prop, 0.01f);
1391   RNA_def_property_range(prop, 0.0f, FLT_MAX);
1392   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
1393   RNA_def_property_ui_text(prop, "Spacing", "Guide spacing");
1394   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1395   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1396
1397   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_DISTANCE);
1398   RNA_def_property_float_sdna(prop, NULL, "location");
1399   RNA_def_property_array(prop, 3);
1400   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1401   RNA_def_property_ui_text(prop, "Location", "Custom reference point for guides");
1402   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1403   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
1404   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_ImaPaint_viewport_update");
1405 }
1406
1407 static void rna_def_gpencil_sculpt(BlenderRNA *brna)
1408 {
1409   static const EnumPropertyItem prop_direction_items[] = {
1410       {0, "ADD", ICON_ADD, "Add", "Add effect of brush"},
1411       {GP_SCULPT_FLAG_INVERT, "SUBTRACT", ICON_REMOVE, "Subtract", "Subtract effect of brush"},
1412       {0, NULL, 0, NULL, NULL},
1413   };
1414
1415   StructRNA *srna;
1416   PropertyRNA *prop;
1417
1418   /* == Settings == */
1419   srna = RNA_def_struct(brna, "GPencilSculptSettings", NULL);
1420   RNA_def_struct_sdna(srna, "GP_Sculpt_Settings");
1421   RNA_def_struct_path_func(srna, "rna_GPencilSculptSettings_path");
1422   RNA_def_struct_ui_text(
1423       srna, "GPencil Sculpt Settings", "Properties for Grease Pencil stroke sculpting tool");
1424
1425   prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE);
1426   RNA_def_property_enum_sdna(prop, NULL, "brushtype");
1427   RNA_def_property_enum_items(prop, rna_enum_gpencil_sculpt_brush_items);
1428   RNA_def_property_ui_text(prop, "Tool", "");
1429   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1430   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_GPencil_update");
1431
1432   prop = RNA_def_property(srna, "weight_tool", PROP_ENUM, PROP_NONE);
1433   RNA_def_property_enum_sdna(prop, NULL, "weighttype");
1434   RNA_def_property_enum_items(prop, rna_enum_gpencil_weight_brush_items);
1435   RNA_def_property_ui_text(prop, "Tool", "Tool for weight painting");
1436   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1437   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, "rna_GPencil_update");
1438
1439   prop = RNA_def_property(srna, "brush", PROP_POINTER, PROP_NONE);
1440   RNA_def_property_struct_type(prop, "GPencilSculptBrush");
1441   RNA_def_property_pointer_funcs(prop, "rna_GPencilSculptSettings_brush_get", NULL, NULL, NULL);
1442   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1443   RNA_def_property_ui_text(prop, "Brush", "");
1444
1445   prop = RNA_def_property(srna, "guide", PROP_POINTER, PROP_NONE);
1446   RNA_def_property_struct_type(prop, "GPencilSculptGuide");
1447   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1448   RNA_def_property_ui_text(prop, "Guide", "");
1449
1450   prop = RNA_def_property(srna, "use_select_mask", PROP_BOOLEAN, PROP_NONE);
1451   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_SELECT_MASK);
1452   RNA_def_property_ui_text(prop, "Selection Mask", "Only sculpt selected stroke points");
1453   RNA_def_property_ui_icon(prop, ICON_GP_ONLY_SELECTED, 0);
1454   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1455   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1456
1457   prop = RNA_def_property(srna, "use_edit_position", PROP_BOOLEAN, PROP_NONE);
1458   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_POSITION);
1459   RNA_def_property_ui_text(prop, "Affect Position", "The brush affects the position of the point");
1460   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1461   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1462
1463   prop = RNA_def_property(srna, "use_edit_strength", PROP_BOOLEAN, PROP_NONE);
1464   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_STRENGTH);
1465   RNA_def_property_ui_text(
1466       prop, "Affect Strength", "The brush affects the color strength of the point");
1467   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1468   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1469
1470   prop = RNA_def_property(srna, "use_edit_thickness", PROP_BOOLEAN, PROP_NONE);
1471   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_THICKNESS);
1472   RNA_def_property_ui_text(
1473       prop, "Affect Thickness", "The brush affects the thickness of the point");
1474   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1475   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1476
1477   prop = RNA_def_property(srna, "use_edit_uv", PROP_BOOLEAN, PROP_NONE);
1478   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_APPLY_UV);
1479   RNA_def_property_ui_text(prop, "Affect UV", "The brush affects the UV rotation of the point");
1480   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1481   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1482
1483   prop = RNA_def_property(srna, "use_multiframe_falloff", PROP_BOOLEAN, PROP_NONE);
1484   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_FRAME_FALLOFF);
1485   RNA_def_property_ui_text(
1486       prop,
1487       "Use Falloff",
1488       "Use falloff effect when edit in multiframe mode to compute brush effect by frame");
1489   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1490   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1491
1492   prop = RNA_def_property(srna, "use_thickness_curve", PROP_BOOLEAN, PROP_NONE);
1493   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_SETT_FLAG_PRIMITIVE_CURVE);
1494   RNA_def_property_ui_text(prop, "Use Curve", "Use curve to define primitive stroke thickness");
1495   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1496   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1497
1498   /* custom falloff curve */
1499   prop = RNA_def_property(srna, "multiframe_falloff_curve", PROP_POINTER, PROP_NONE);
1500   RNA_def_property_pointer_sdna(prop, NULL, "cur_falloff");
1501   RNA_def_property_struct_type(prop, "CurveMapping");
1502   RNA_def_property_ui_text(
1503       prop, "Curve", "Custom curve to control falloff of brush effect by Grease Pencil frames");
1504   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1505   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1506
1507   /* custom primitive curve */
1508   prop = RNA_def_property(srna, "thickness_primitive_curve", PROP_POINTER, PROP_NONE);
1509   RNA_def_property_pointer_sdna(prop, NULL, "cur_primitive");
1510   RNA_def_property_struct_type(prop, "CurveMapping");
1511   RNA_def_property_ui_text(prop, "Curve", "Custom curve to control primitive thickness");
1512   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1513   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1514
1515   /* lock axis */
1516   prop = RNA_def_property(srna, "lock_axis", PROP_ENUM, PROP_NONE);
1517   RNA_def_property_enum_sdna(prop, NULL, "lock_axis");
1518   RNA_def_property_enum_items(prop, rna_enum_gpencil_lock_axis_items);
1519   RNA_def_property_ui_text(prop, "Lock Axis", "");
1520   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1521   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1522
1523   /* threshold for cutter */
1524   prop = RNA_def_property(srna, "intersection_threshold", PROP_FLOAT, PROP_NONE);
1525   RNA_def_property_float_sdna(prop, NULL, "isect_threshold");
1526   RNA_def_property_range(prop, 0.0f, 10.0f);
1527   RNA_def_property_float_default(prop, 0.1f);
1528   RNA_def_property_ui_text(prop, "Threshold", "Threshold for stroke intersections");
1529   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1530
1531   /* brush */
1532   srna = RNA_def_struct(brna, "GPencilSculptBrush", NULL);
1533   RNA_def_struct_sdna(srna, "GP_Sculpt_Data");
1534   RNA_def_struct_path_func(srna, "rna_GPencilSculptBrush_path");
1535   RNA_def_struct_ui_text(srna, "GPencil Sculpt Brush", "Stroke editing brush");
1536
1537   prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1538   RNA_def_property_range(prop, 1, GP_MAX_BRUSH_PIXEL_RADIUS);
1539   RNA_def_property_ui_range(prop, 1, 500, 10, 3);
1540   RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1541   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1542   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1543
1544   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1545   RNA_def_property_range(prop, 0.001, 1.0);
1546   RNA_def_property_ui_text(prop, "Strength", "Brush strength");
1547   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1548   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1549
1550   prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1551   RNA_def_property_range(prop, 0.0, 1.0);
1552   RNA_def_property_ui_text(prop,
1553                            "Weight",
1554                            "Target weight (define a maximum range limit for the weight. Any value "
1555                            "above will be clamped)");
1556   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1557   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1558
1559   prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
1560   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_USE_PRESSURE);
1561   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1562   RNA_def_property_ui_text(
1563       prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
1564   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1565   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1566
1567   prop = RNA_def_property(srna, "use_pressure_radius", PROP_BOOLEAN, PROP_NONE);
1568   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_PRESSURE_RADIUS);
1569   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1570   RNA_def_property_ui_text(
1571       prop, "Radius Pressure", "Enable tablet pressure sensitivity for radius");
1572   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1573   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1574
1575   prop = RNA_def_property(srna, "use_falloff", PROP_BOOLEAN, PROP_NONE);
1576   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_USE_FALLOFF);
1577   RNA_def_property_ui_text(
1578       prop, "Use Falloff", "Strength of brush decays with distance from cursor");
1579   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1580   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1581
1582   prop = RNA_def_property(srna, "use_edit_pressure", PROP_BOOLEAN, PROP_NONE);
1583   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_SMOOTH_PRESSURE);
1584   RNA_def_property_ui_text(
1585       prop, "Affect Pressure", "Affect pressure values as well when smoothing strokes");
1586   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1587   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1588
1589   prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1590   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1591   RNA_def_property_enum_items(prop, prop_direction_items);
1592   RNA_def_property_ui_text(prop, "Direction", "");
1593   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1594   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
1595
1596   /* Cursor Color */
1597   static float default_1[3] = {1.0f, 0.6f, 0.6f};
1598   static float default_2[3] = {0.6f, 0.6f, 1.0f};
1599
1600   prop = RNA_def_property(srna, "cursor_color_add", PROP_FLOAT, PROP_COLOR_GAMMA);
1601   RNA_def_property_float_sdna(prop, NULL, "curcolor_add");
1602   RNA_def_property_array(prop, 3);
1603   RNA_def_property_range(prop, 0.0f, 1.0f);
1604   RNA_def_property_float_array_default(prop, default_1);
1605   RNA_def_property_ui_text(prop, "Cursor Add", "Color for the cursor for addition");
1606   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1607
1608   prop = RNA_def_property(srna, "cursor_color_sub", PROP_FLOAT, PROP_COLOR_GAMMA);
1609   RNA_def_property_float_sdna(prop, NULL, "curcolor_sub");
1610   RNA_def_property_array(prop, 3);
1611   RNA_def_property_range(prop, 0.0f, 1.0f);
1612   RNA_def_property_float_array_default(prop, default_2);
1613   RNA_def_property_ui_text(prop, "Cursor Sub", "Color for the cursor for subtraction");
1614   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1615
1616   prop = RNA_def_property(srna, "use_cursor", PROP_BOOLEAN, PROP_NONE);
1617   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SCULPT_FLAG_ENABLE_CURSOR);
1618   RNA_def_property_boolean_default(prop, true);
1619   RNA_def_property_ui_text(prop, "Enable Cursor", "Enable cursor on screen");
1620   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1621 }
1622
1623 void RNA_def_sculpt_paint(BlenderRNA *brna)
1624 {
1625   /* *** Non-Animated *** */
1626   RNA_define_animate_sdna(false);
1627   rna_def_paint_curve(brna);
1628   rna_def_paint_tool_slot(brna);
1629   rna_def_paint(brna);
1630   rna_def_sculpt(brna);
1631   rna_def_uv_sculpt(brna);
1632   rna_def_gp_paint(brna);
1633   rna_def_vertex_paint(brna);
1634   rna_def_image_paint(brna);
1635   rna_def_particle_edit(brna);
1636   rna_def_gpencil_guides(brna);
1637   rna_def_gpencil_sculpt(brna);
1638   RNA_define_animate_sdna(true);
1639 }
1640
1641 #endif