source/blender/makesrna/intern/rna_scene.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 "DNA_brush_types.h"
  24 #include "DNA_collection_types.h"
  25 #include "DNA_modifier_types.h"
  26 #include "DNA_particle_types.h"
  27 #include "DNA_rigidbody_types.h"
  28 #include "DNA_scene_types.h"
  29 #include "DNA_layer_types.h"
  30 #include "DNA_linestyle_types.h"
  31 #include "DNA_userdef_types.h"
  32 #include "DNA_world_types.h"
  33 #include "DNA_gpencil_types.h"
  34 #include "DNA_view3d_types.h"
  35 #include "DNA_screen_types.h" /* TransformOrientation */
  36
  37 #include "IMB_imbuf_types.h"
  38
  39 #include "BLI_math.h"
  40
  41 #include "BLT_translation.h"
  42
  43 #include "BKE_armature.h"
  44 #include "BKE_editmesh.h"
  45 #include "BKE_paint.h"
  46
  47 #include "ED_object.h"
  48 #include "ED_gpencil.h"
  49
  50 #include "GPU_extensions.h"
  51
  52 #include "DRW_engine.h"
  53
  54 #include "RNA_define.h"
  55 #include "RNA_enum_types.h"
  56
  57 #include "rna_internal.h"
  58
  59 /* Include for Bake Options */
  60 #include "RE_engine.h"
  61 #include "RE_pipeline.h"
  62
  63 #ifdef WITH_FFMPEG
  64 #  include "BKE_writeffmpeg.h"
  65 #  include <libavcodec/avcodec.h>
  66 #  include <libavformat/avformat.h>
  67 #  include "ffmpeg_compat.h"
  68 #endif
  69
  70 #include "ED_render.h"
  71 #include "ED_transform.h"
  72
  73 #include "WM_api.h"
  74 #include "WM_types.h"
  75
  76 #include "BLI_threads.h"
  77
  78 #include "DEG_depsgraph.h"
  79
  80 #ifdef WITH_OPENEXR
  81 const EnumPropertyItem rna_enum_exr_codec_items[] = {
  82     {R_IMF_EXR_CODEC_NONE, "NONE", 0, "None", ""},
  83     {R_IMF_EXR_CODEC_PXR24, "PXR24", 0, "Pxr24 (lossy)", ""},
  84     {R_IMF_EXR_CODEC_ZIP, "ZIP", 0, "ZIP (lossless)", ""},
  85     {R_IMF_EXR_CODEC_PIZ, "PIZ", 0, "PIZ (lossless)", ""},
  86     {R_IMF_EXR_CODEC_RLE, "RLE", 0, "RLE (lossless)", ""},
  87     {R_IMF_EXR_CODEC_ZIPS, "ZIPS", 0, "ZIPS (lossless)", ""},
  88     {R_IMF_EXR_CODEC_B44, "B44", 0, "B44 (lossy)", ""},
  89     {R_IMF_EXR_CODEC_B44A, "B44A", 0, "B44A (lossy)", ""},
  90     {R_IMF_EXR_CODEC_DWAA, "DWAA", 0, "DWAA (lossy)", ""},
  91     /* NOTE: Commented out for until new OpenEXR is released, see T50673. */
  92     /* {R_IMF_EXR_CODEC_DWAB, "DWAB", 0, "DWAB (lossy)", ""}, */
  93     {0, NULL, 0, NULL, NULL},
  94 };
  95 #endif
  96
  97 #ifndef RNA_RUNTIME
  98 static const EnumPropertyItem uv_sculpt_relaxation_items[] = {
  99     {UV_SCULPT_TOOL_RELAX_LAPLACIAN,
 100      "LAPLACIAN",
 101      0,
 102      "Laplacian",
 103      "Use Laplacian method for relaxation"},
 104     {UV_SCULPT_TOOL_RELAX_HC, "HC", 0, "HC", "Use HC method for relaxation"},
 105     {0, NULL, 0, NULL, NULL},
 106 };
 107 #endif
 108
 109 const EnumPropertyItem rna_enum_snap_target_items[] = {
 110     {SCE_SNAP_TARGET_CLOSEST, "CLOSEST", 0, "Closest", "Snap closest point onto target"},
 111     {SCE_SNAP_TARGET_CENTER, "CENTER", 0, "Center", "Snap transformation center onto target"},
 112     {SCE_SNAP_TARGET_MEDIAN, "MEDIAN", 0, "Median", "Snap median onto target"},
 113     {SCE_SNAP_TARGET_ACTIVE, "ACTIVE", 0, "Active", "Snap active onto target"},
 114     {0, NULL, 0, NULL, NULL},
 115 };
 116
 117 const EnumPropertyItem rna_enum_proportional_falloff_items[] = {
 118     {PROP_SMOOTH, "SMOOTH", ICON_SMOOTHCURVE, "Smooth", "Smooth falloff"},
 119     {PROP_SPHERE, "SPHERE", ICON_SPHERECURVE, "Sphere", "Spherical falloff"},
 120     {PROP_ROOT, "ROOT", ICON_ROOTCURVE, "Root", "Root falloff"},
 121     {PROP_INVSQUARE,
 122      "INVERSE_SQUARE",
 123      ICON_INVERSESQUARECURVE,
 124      "Inverse Square",
 125      "Inverse Square falloff"},
 126     {PROP_SHARP, "SHARP", ICON_SHARPCURVE, "Sharp", "Sharp falloff"},
 127     {PROP_LIN, "LINEAR", ICON_LINCURVE, "Linear", "Linear falloff"},
 128     {PROP_CONST, "CONSTANT", ICON_NOCURVE, "Constant", "Constant falloff"},
 129     {PROP_RANDOM, "RANDOM", ICON_RNDCURVE, "Random", "Random falloff"},
 130     {0, NULL, 0, NULL, NULL},
 131 };
 132
 133 /* subset of the enum - only curves, missing random and const */
 134 const EnumPropertyItem rna_enum_proportional_falloff_curve_only_items[] = {
 135     {PROP_SMOOTH, "SMOOTH", ICON_SMOOTHCURVE, "Smooth", "Smooth falloff"},
 136     {PROP_SPHERE, "SPHERE", ICON_SPHERECURVE, "Sphere", "Spherical falloff"},
 137     {PROP_ROOT, "ROOT", ICON_ROOTCURVE, "Root", "Root falloff"},
 138     {PROP_INVSQUARE, "INVERSE_SQUARE", ICON_ROOTCURVE, "Inverse Square", "Inverse Square falloff"},
 139     {PROP_SHARP, "SHARP", ICON_SHARPCURVE, "Sharp", "Sharp falloff"},
 140     {PROP_LIN, "LINEAR", ICON_LINCURVE, "Linear", "Linear falloff"},
 141     {0, NULL, 0, NULL, NULL},
 142 };
 143
 144 /* keep for operators, not used here */
 145 const EnumPropertyItem rna_enum_mesh_select_mode_items[] = {
 146     {SCE_SELECT_VERTEX, "VERTEX", ICON_VERTEXSEL, "Vertex", "Vertex selection mode"},
 147     {SCE_SELECT_EDGE, "EDGE", ICON_EDGESEL, "Edge", "Edge selection mode"},
 148     {SCE_SELECT_FACE, "FACE", ICON_FACESEL, "Face", "Face selection mode"},
 149     {0, NULL, 0, NULL, NULL},
 150 };
 151
 152 const EnumPropertyItem rna_enum_mesh_select_mode_uv_items[] = {
 153     {UV_SELECT_VERTEX, "VERTEX", ICON_UV_VERTEXSEL, "Vertex", "Vertex selection mode"},
 154     {UV_SELECT_EDGE, "EDGE", ICON_UV_EDGESEL, "Edge", "Edge selection mode"},
 155     {UV_SELECT_FACE, "FACE", ICON_UV_FACESEL, "Face", "Face selection mode"},
 156     {UV_SELECT_ISLAND, "ISLAND", ICON_UV_ISLANDSEL, "Island", "Island selection mode"},
 157     {0, NULL, 0, NULL, NULL},
 158 };
 159
 160 const EnumPropertyItem rna_enum_snap_element_items[] = {
 161     {SCE_SNAP_MODE_INCREMENT,
 162      "INCREMENT",
 163      ICON_SNAP_INCREMENT,
 164      "Increment",
 165      "Snap to increments of grid"},
 166     {SCE_SNAP_MODE_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"},
 167     {SCE_SNAP_MODE_EDGE, "EDGE", ICON_SNAP_EDGE, "Edge", "Snap to edges"},
 168     {SCE_SNAP_MODE_FACE, "FACE", ICON_SNAP_FACE, "Face", "Snap to faces"},
 169     {SCE_SNAP_MODE_VOLUME, "VOLUME", ICON_SNAP_VOLUME, "Volume", "Snap to volume"},
 170     {SCE_SNAP_MODE_EDGE_MIDPOINT,
 171      "EDGE_MIDPOINT",
 172      ICON_SNAP_MIDPOINT,
 173      "Edge Center",
 174      "Snap to the middle of edges"},
 175     {SCE_SNAP_MODE_EDGE_PERPENDICULAR,
 176      "EDGE_PERPENDICULAR",
 177      ICON_SNAP_PERPENDICULAR,
 178      "Edge Perpendicular",
 179      "Snap to the nearest point on an edge"},
 180     {0, NULL, 0, NULL, NULL},
 181 };
 182
 183 const EnumPropertyItem rna_enum_snap_node_element_items[] = {
 184     {SCE_SNAP_MODE_GRID, "GRID", ICON_SNAP_GRID, "Grid", "Snap to grid"},
 185     {SCE_SNAP_MODE_NODE_X, "NODE_X", ICON_NODE_SIDE, "Node X", "Snap to left/right node border"},
 186     {SCE_SNAP_MODE_NODE_Y, "NODE_Y", ICON_NODE_TOP, "Node Y", "Snap to top/bottom node border"},
 187     {SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y,
 188      "NODE_XY",
 189      ICON_NODE_CORNER,
 190      "Node X / Y",
 191      "Snap to any node border"},
 192     {0, NULL, 0, NULL, NULL},
 193 };
 194
 195 #ifndef RNA_RUNTIME
 196 static const EnumPropertyItem snap_uv_element_items[] = {
 197     {SCE_SNAP_MODE_INCREMENT,
 198      "INCREMENT",
 199      ICON_SNAP_INCREMENT,
 200      "Increment",
 201      "Snap to increments of grid"},
 202     {SCE_SNAP_MODE_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"},
 203     {0, NULL, 0, NULL, NULL},
 204 };
 205
 206 static const EnumPropertyItem rna_enum_scene_display_aa_methods[] = {
 207     {SCE_DISPLAY_AA_OFF,
 208      "OFF",
 209      0,
 210      "No Anti-Aliasing",
 211      "Scene will be rendering without any anti-aliasing"},
 212     {SCE_DISPLAY_AA_FXAA,
 213      "FXAA",
 214      0,
 215      "Single Pass Anti-Aliasing",
 216      "Scene will be rendered using a single pass anti-aliasing method (FXAA)"},
 217     {SCE_DISPLAY_AA_SAMPLES_5,
 218      "5",
 219      0,
 220      "5 Samples",
 221      "Scene will be rendered using 5 anti-aliasing samples"},
 222     {SCE_DISPLAY_AA_SAMPLES_8,
 223      "8",
 224      0,
 225      "8 Samples",
 226      "Scene will be rendered using 8 anti-aliasing samples"},
 227     {SCE_DISPLAY_AA_SAMPLES_11,
 228      "11",
 229      0,
 230      "11 Samples",
 231      "Scene will be rendered using 11 anti-aliasing samples"},
 232     {SCE_DISPLAY_AA_SAMPLES_16,
 233      "16",
 234      0,
 235      "16 Samples",
 236      "Scene will be rendered using 16 anti-aliasing samples"},
 237     {SCE_DISPLAY_AA_SAMPLES_32,
 238      "32",
 239      0,
 240      "32 Samples",
 241      "Scene will be rendered using 32 anti-aliasing samples"},
 242     {0, NULL, 0, NULL, NULL},
 243 };
 244 #endif
 245
 246 const EnumPropertyItem rna_enum_curve_fit_method_items[] = {
 247     {CURVE_PAINT_FIT_METHOD_REFIT,
 248      "REFIT",
 249      0,
 250      "Refit",
 251      "Incrementally re-fit the curve (high quality)"},
 252     {CURVE_PAINT_FIT_METHOD_SPLIT,
 253      "SPLIT",
 254      0,
 255      "Split",
 256      "Split the curve until the tolerance is met (fast)"},
 257     {0, NULL, 0, NULL, NULL},
 258 };
 259
 260 /* workaround for duplicate enums,
 261  * have each enum line as a define then conditionally set it or not
 262  */
 263
 264 #define R_IMF_ENUM_BMP \
 265   {R_IMF_IMTYPE_BMP, "BMP", ICON_FILE_IMAGE, "BMP", "Output image in bitmap format"},
 266 #define R_IMF_ENUM_IRIS \
 267   {R_IMF_IMTYPE_IRIS, "IRIS", ICON_FILE_IMAGE, "Iris", "Output image in (old!) SGI IRIS format"},
 268 #define R_IMF_ENUM_PNG \
 269   {R_IMF_IMTYPE_PNG, "PNG", ICON_FILE_IMAGE, "PNG", "Output image in PNG format"},
 270 #define R_IMF_ENUM_JPEG \
 271   {R_IMF_IMTYPE_JPEG90, "JPEG", ICON_FILE_IMAGE, "JPEG", "Output image in JPEG format"},
 272 #define R_IMF_ENUM_TAGA \
 273   {R_IMF_IMTYPE_TARGA, "TARGA", ICON_FILE_IMAGE, "Targa", "Output image in Targa format"},
 274 #define R_IMF_ENUM_TAGA_RAW \
 275   {R_IMF_IMTYPE_RAWTGA, \
 276    "TARGA_RAW", \
 277    ICON_FILE_IMAGE, \
 278    "Targa Raw", \
 279    "Output image in uncompressed Targa format"},
 280
 281 #if 0 /* UNUSED (so far) */
 282 #  ifdef WITH_DDS
 283 #    define R_IMF_ENUM_DDS \
 284       {R_IMF_IMTYPE_DDS, "DDS", ICON_FILE_IMAGE, "DDS", "Output image in DDS format"},
 285 #  else
 286 #    define R_IMF_ENUM_DDS
 287 #  endif
 288 #endif
 289
 290 #ifdef WITH_OPENJPEG
 291 #  define R_IMF_ENUM_JPEG2K \
 292     {R_IMF_IMTYPE_JP2, \
 293      "JPEG2000", \
 294      ICON_FILE_IMAGE, \
 295      "JPEG 2000", \
 296      "Output image in JPEG 2000 format"},
 297 #else
 298 #  define R_IMF_ENUM_JPEG2K
 299 #endif
 300
 301 #ifdef WITH_CINEON
 302 #  define R_IMF_ENUM_CINEON \
 303     {R_IMF_IMTYPE_CINEON, "CINEON", ICON_FILE_IMAGE, "Cineon", "Output image in Cineon format"},
 304 #  define R_IMF_ENUM_DPX \
 305     {R_IMF_IMTYPE_DPX, "DPX", ICON_FILE_IMAGE, "DPX", "Output image in DPX format"},
 306 #else
 307 #  define R_IMF_ENUM_CINEON
 308 #  define R_IMF_ENUM_DPX
 309 #endif
 310
 311 #ifdef WITH_OPENEXR
 312 #  define R_IMF_ENUM_EXR_MULTILAYER \
 313     {R_IMF_IMTYPE_MULTILAYER, \
 314      "OPEN_EXR_MULTILAYER", \
 315      ICON_FILE_IMAGE, \
 316      "OpenEXR MultiLayer", \
 317      "Output image in multilayer OpenEXR format"},
 318 #  define R_IMF_ENUM_EXR \
 319     {R_IMF_IMTYPE_OPENEXR, \
 320      "OPEN_EXR", \
 321      ICON_FILE_IMAGE, \
 322      "OpenEXR", \
 323      "Output image in OpenEXR format"},
 324 #else
 325 #  define R_IMF_ENUM_EXR_MULTILAYER
 326 #  define R_IMF_ENUM_EXR
 327 #endif
 328
 329 #ifdef WITH_HDR
 330 #  define R_IMF_ENUM_HDR \
 331     {R_IMF_IMTYPE_RADHDR, \
 332      "HDR", \
 333      ICON_FILE_IMAGE, \
 334      "Radiance HDR", \
 335      "Output image in Radiance HDR format"},
 336 #else
 337 #  define R_IMF_ENUM_HDR
 338 #endif
 339
 340 #ifdef WITH_TIFF
 341 #  define R_IMF_ENUM_TIFF \
 342     {R_IMF_IMTYPE_TIFF, "TIFF", ICON_FILE_IMAGE, "TIFF", "Output image in TIFF format"},
 343 #else
 344 #  define R_IMF_ENUM_TIFF
 345 #endif
 346
 347 #define IMAGE_TYPE_ITEMS_IMAGE_ONLY \
 348   R_IMF_ENUM_BMP \
 349   /* DDS save not supported yet R_IMF_ENUM_DDS */ \
 350   R_IMF_ENUM_IRIS \
 351   R_IMF_ENUM_PNG \
 352   R_IMF_ENUM_JPEG \
 353   R_IMF_ENUM_JPEG2K \
 354   R_IMF_ENUM_TAGA \
 355   R_IMF_ENUM_TAGA_RAW{0, "", 0, " ", NULL}, \
 356       R_IMF_ENUM_CINEON R_IMF_ENUM_DPX R_IMF_ENUM_EXR_MULTILAYER R_IMF_ENUM_EXR R_IMF_ENUM_HDR \
 357           R_IMF_ENUM_TIFF
 358
 359 #ifdef RNA_RUNTIME
 360 static const EnumPropertyItem image_only_type_items[] = {
 361
 362     IMAGE_TYPE_ITEMS_IMAGE_ONLY
 363
 364     {0, NULL, 0, NULL, NULL},
 365 };
 366 #endif
 367
 368 const EnumPropertyItem rna_enum_image_type_items[] = {
 369     {0, "", 0, N_("Image"), NULL},
 370
 371     IMAGE_TYPE_ITEMS_IMAGE_ONLY
 372
 373     {0, "", 0, N_("Movie"), NULL},
 374     {R_IMF_IMTYPE_AVIJPEG,
 375      "AVI_JPEG",
 376      ICON_FILE_MOVIE,
 377      "AVI JPEG",
 378      "Output video in AVI JPEG format"},
 379     {R_IMF_IMTYPE_AVIRAW, "AVI_RAW", ICON_FILE_MOVIE, "AVI Raw", "Output video in AVI Raw format"},
 380 #ifdef WITH_FFMPEG
 381     {R_IMF_IMTYPE_FFMPEG,
 382      "FFMPEG",
 383      ICON_FILE_MOVIE,
 384      "FFmpeg video",
 385      "The most versatile way to output video files"},
 386 #endif
 387     {0, NULL, 0, NULL, NULL},
 388 };
 389
 390 const EnumPropertyItem rna_enum_image_color_mode_items[] = {
 391     {R_IMF_PLANES_BW,
 392      "BW",
 393      0,
 394      "BW",
 395      "Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF)"},
 396     {R_IMF_PLANES_RGB, "RGB", 0, "RGB", "Images are saved with RGB (color) data"},
 397     {R_IMF_PLANES_RGBA,
 398      "RGBA",
 399      0,
 400      "RGBA",
 401      "Images are saved with RGB and Alpha data (if supported)"},
 402     {0, NULL, 0, NULL, NULL},
 403 };
 404
 405 #ifdef RNA_RUNTIME
 406 #  define IMAGE_COLOR_MODE_BW rna_enum_image_color_mode_items[0]
 407 #  define IMAGE_COLOR_MODE_RGB rna_enum_image_color_mode_items[1]
 408 #  define IMAGE_COLOR_MODE_RGBA rna_enum_image_color_mode_items[2]
 409 #endif
 410
 411 const EnumPropertyItem rna_enum_image_color_depth_items[] = {
 412     /* 1 (monochrome) not used */
 413     {R_IMF_CHAN_DEPTH_8, "8", 0, "8", "8 bit color channels"},
 414     {R_IMF_CHAN_DEPTH_10, "10", 0, "10", "10 bit color channels"},
 415     {R_IMF_CHAN_DEPTH_12, "12", 0, "12", "12 bit color channels"},
 416     {R_IMF_CHAN_DEPTH_16, "16", 0, "16", "16 bit color channels"},
 417     /* 24 not used */
 418     {R_IMF_CHAN_DEPTH_32, "32", 0, "32", "32 bit color channels"},
 419     {0, NULL, 0, NULL, NULL},
 420 };
 421
 422 const EnumPropertyItem rna_enum_normal_space_items[] = {
 423     {R_BAKE_SPACE_OBJECT, "OBJECT", 0, "Object", "Bake the normals in object space"},
 424     {R_BAKE_SPACE_TANGENT, "TANGENT", 0, "Tangent", "Bake the normals in tangent space"},
 425     {0, NULL, 0, NULL, NULL},
 426 };
 427
 428 const EnumPropertyItem rna_enum_normal_swizzle_items[] = {
 429     {R_BAKE_POSX, "POS_X", 0, "+X", ""},
 430     {R_BAKE_POSY, "POS_Y", 0, "+Y", ""},
 431     {R_BAKE_POSZ, "POS_Z", 0, "+Z", ""},
 432     {R_BAKE_NEGX, "NEG_X", 0, "-X", ""},
 433     {R_BAKE_NEGY, "NEG_Y", 0, "-Y", ""},
 434     {R_BAKE_NEGZ, "NEG_Z", 0, "-Z", ""},
 435     {0, NULL, 0, NULL, NULL},
 436 };
 437
 438 const EnumPropertyItem rna_enum_bake_save_mode_items[] = {
 439     {R_BAKE_SAVE_INTERNAL,
 440      "INTERNAL",
 441      0,
 442      "Internal",
 443      "Save the baking map in an internal image data-block"},
 444     {R_BAKE_SAVE_EXTERNAL, "EXTERNAL", 0, "External", "Save the baking map in an external file"},
 445     {0, NULL, 0, NULL, NULL},
 446 };
 447
 448 #define R_IMF_VIEWS_ENUM_IND \
 449   {R_IMF_VIEWS_INDIVIDUAL, \
 450    "INDIVIDUAL", \
 451    0, \
 452    "Individual", \
 453    "Individual files for each view with the prefix as defined by the scene views"},
 454 #define R_IMF_VIEWS_ENUM_S3D \
 455   {R_IMF_VIEWS_STEREO_3D, "STEREO_3D", 0, "Stereo 3D", "Single file with an encoded stereo pair"},
 456 #define R_IMF_VIEWS_ENUM_MV \
 457   {R_IMF_VIEWS_MULTIVIEW, "MULTIVIEW", 0, "Multi-View", "Single file with all the views"},
 458
 459 const EnumPropertyItem rna_enum_views_format_items[] = {
 460     R_IMF_VIEWS_ENUM_IND R_IMF_VIEWS_ENUM_S3D{0, NULL, 0, NULL, NULL},
 461 };
 462
 463 const EnumPropertyItem rna_enum_views_format_multilayer_items[] = {
 464     R_IMF_VIEWS_ENUM_IND R_IMF_VIEWS_ENUM_MV{0, NULL, 0, NULL, NULL},
 465 };
 466
 467 const EnumPropertyItem rna_enum_views_format_multiview_items[] = {
 468     R_IMF_VIEWS_ENUM_IND R_IMF_VIEWS_ENUM_S3D R_IMF_VIEWS_ENUM_MV{0, NULL, 0, NULL, NULL},
 469 };
 470
 471 #undef R_IMF_VIEWS_ENUM_IND
 472 #undef R_IMF_VIEWS_ENUM_S3D
 473 #undef R_IMF_VIEWS_ENUM_MV
 474
 475 const EnumPropertyItem rna_enum_stereo3d_display_items[] = {
 476     {S3D_DISPLAY_ANAGLYPH,
 477      "ANAGLYPH",
 478      0,
 479      "Anaglyph",
 480      "Render views for left and right eyes as two differently filtered colors in a single image "
 481      "(anaglyph glasses are required)"},
 482     {S3D_DISPLAY_INTERLACE,
 483      "INTERLACE",
 484      0,
 485      "Interlace",
 486      "Render views for left and right eyes interlaced in a single image (3D-ready monitor is "
 487      "required)"},
 488     {S3D_DISPLAY_PAGEFLIP,
 489      "TIMESEQUENTIAL",
 490      0,
 491      "Time Sequential",
 492      "Render alternate eyes (also known as page flip, quad buffer support in the graphic card is "
 493      "required)"},
 494     {S3D_DISPLAY_SIDEBYSIDE,
 495      "SIDEBYSIDE",
 496      0,
 497      "Side-by-Side",
 498      "Render views for left and right eyes side-by-side"},
 499     {S3D_DISPLAY_TOPBOTTOM,
 500      "TOPBOTTOM",
 501      0,
 502      "Top-Bottom",
 503      "Render views for left and right eyes one above another"},
 504     {0, NULL, 0, NULL, NULL},
 505 };
 506
 507 const EnumPropertyItem rna_enum_stereo3d_anaglyph_type_items[] = {
 508     {S3D_ANAGLYPH_REDCYAN, "RED_CYAN", 0, "Red-Cyan", ""},
 509     {S3D_ANAGLYPH_GREENMAGENTA, "GREEN_MAGENTA", 0, "Green-Magenta", ""},
 510     {S3D_ANAGLYPH_YELLOWBLUE, "YELLOW_BLUE", 0, "Yellow-Blue", ""},
 511     {0, NULL, 0, NULL, NULL},
 512 };
 513
 514 const EnumPropertyItem rna_enum_stereo3d_interlace_type_items[] = {
 515     {S3D_INTERLACE_ROW, "ROW_INTERLEAVED", 0, "Row Interleaved", ""},
 516     {S3D_INTERLACE_COLUMN, "COLUMN_INTERLEAVED", 0, "Column Interleaved", ""},
 517     {S3D_INTERLACE_CHECKERBOARD, "CHECKERBOARD_INTERLEAVED", 0, "Checkerboard Interleaved", ""},
 518     {0, NULL, 0, NULL, NULL},
 519 };
 520
 521 const EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
 522     {R_BAKE_PASS_FILTER_NONE, "NONE", 0, "None", ""},
 523     {R_BAKE_PASS_FILTER_AO, "AO", 0, "Ambient Occlusion", ""},
 524     {R_BAKE_PASS_FILTER_EMIT, "EMIT", 0, "Emit", ""},
 525     {R_BAKE_PASS_FILTER_DIRECT, "DIRECT", 0, "Direct", ""},
 526     {R_BAKE_PASS_FILTER_INDIRECT, "INDIRECT", 0, "Indirect", ""},
 527     {R_BAKE_PASS_FILTER_COLOR, "COLOR", 0, "Color", ""},
 528     {R_BAKE_PASS_FILTER_DIFFUSE, "DIFFUSE", 0, "Diffuse", ""},
 529     {R_BAKE_PASS_FILTER_GLOSSY, "GLOSSY", 0, "Glossy", ""},
 530     {R_BAKE_PASS_FILTER_TRANSM, "TRANSMISSION", 0, "Transmission", ""},
 531     {R_BAKE_PASS_FILTER_SUBSURFACE, "SUBSURFACE", 0, "Subsurface", ""},
 532     {0, NULL, 0, NULL, NULL},
 533 };
 534
 535 #ifndef RNA_RUNTIME
 536 static const EnumPropertyItem rna_enum_gpencil_interpolation_mode_items[] = {
 537     /* interpolation */
 538     {0, "", 0, N_("Interpolation"), "Standard transitions between keyframes"},
 539     {GP_IPO_LINEAR,
 540      "LINEAR",
 541      ICON_IPO_LINEAR,
 542      "Linear",
 543      "Straight-line interpolation between A and B (i.e. no ease in/out)"},
 544     {GP_IPO_CURVEMAP,
 545      "CUSTOM",
 546      ICON_IPO_BEZIER,
 547      "Custom",
 548      "Custom interpolation defined using a curve map"},
 549
 550     /* easing */
 551     {0,
 552      "",
 553      0,
 554      N_("Easing (by strength)"),
 555      "Predefined inertial transitions, useful for motion graphics (from least to most "
 556      "''dramatic'')"},
 557     {GP_IPO_SINE,
 558      "SINE",
 559      ICON_IPO_SINE,
 560      "Sinusoidal",
 561      "Sinusoidal easing (weakest, almost linear but with a slight curvature)"},
 562     {GP_IPO_QUAD, "QUAD", ICON_IPO_QUAD, "Quadratic", "Quadratic easing"},
 563     {GP_IPO_CUBIC, "CUBIC", ICON_IPO_CUBIC, "Cubic", "Cubic easing"},
 564     {GP_IPO_QUART, "QUART", ICON_IPO_QUART, "Quartic", "Quartic easing"},
 565     {GP_IPO_QUINT, "QUINT", ICON_IPO_QUINT, "Quintic", "Quintic easing"},
 566     {GP_IPO_EXPO, "EXPO", ICON_IPO_EXPO, "Exponential", "Exponential easing (dramatic)"},
 567     {GP_IPO_CIRC,
 568      "CIRC",
 569      ICON_IPO_CIRC,
 570      "Circular",
 571      "Circular easing (strongest and most dynamic)"},
 572
 573     {0, "", 0, N_("Dynamic Effects"), "Simple physics-inspired easing effects"},
 574     {GP_IPO_BACK, "BACK", ICON_IPO_BACK, "Back", "Cubic easing with overshoot and settle"},
 575     {GP_IPO_BOUNCE,
 576      "BOUNCE",
 577      ICON_IPO_BOUNCE,
 578      "Bounce",
 579      "Exponentially decaying parabolic bounce, like when objects collide"},
 580     {GP_IPO_ELASTIC,
 581      "ELASTIC",
 582      ICON_IPO_ELASTIC,
 583      "Elastic",
 584      "Exponentially decaying sine wave, like an elastic band"},
 585
 586     {0, NULL, 0, NULL, NULL},
 587 };
 588
 589 #endif
 590
 591 const EnumPropertyItem rna_enum_transform_pivot_items_full[] = {
 592     {V3D_AROUND_CENTER_BOUNDS,
 593      "BOUNDING_BOX_CENTER",
 594      ICON_PIVOT_BOUNDBOX,
 595      "Bounding Box Center",
 596      "Pivot around bounding box center of selected object(s)"},
 597     {V3D_AROUND_CURSOR, "CURSOR", ICON_PIVOT_CURSOR, "3D Cursor", "Pivot around the 3D cursor"},
 598     {V3D_AROUND_LOCAL_ORIGINS,
 599      "INDIVIDUAL_ORIGINS",
 600      ICON_PIVOT_INDIVIDUAL,
 601      "Individual Origins",
 602      "Pivot around each object's own origin"},
 603     {V3D_AROUND_CENTER_MEDIAN,
 604      "MEDIAN_POINT",
 605      ICON_PIVOT_MEDIAN,
 606      "Median Point",
 607      "Pivot around the median point of selected objects"},
 608     {V3D_AROUND_ACTIVE,
 609      "ACTIVE_ELEMENT",
 610      ICON_PIVOT_ACTIVE,
 611      "Active Element",
 612      "Pivot around active object"},
 613     {0, NULL, 0, NULL, NULL},
 614 };
 615
 616 /* Icons could be made a consistent set of images. */
 617 const EnumPropertyItem rna_enum_transform_orientation_items[] = {
 618     {V3D_ORIENT_GLOBAL,
 619      "GLOBAL",
 620      ICON_ORIENTATION_GLOBAL,
 621      "Global",
 622      "Align the transformation axes to world space"},
 623     {V3D_ORIENT_LOCAL,
 624      "LOCAL",
 625      ICON_ORIENTATION_LOCAL,
 626      "Local",
 627      "Align the transformation axes to the selected objects' local space"},
 628     {V3D_ORIENT_NORMAL,
 629      "NORMAL",
 630      ICON_ORIENTATION_NORMAL,
 631      "Normal",
 632      "Align the transformation axes to average normal of selected elements "
 633      "(bone Y axis for pose mode)"},
 634     {V3D_ORIENT_GIMBAL,
 635      "GIMBAL",
 636      ICON_ORIENTATION_GIMBAL,
 637      "Gimbal",
 638      "Align each axis to the Euler rotation axis as used for input"},
 639     {V3D_ORIENT_VIEW,
 640      "VIEW",
 641      ICON_ORIENTATION_VIEW,
 642      "View",
 643      "Align the transformation axes to the window"},
 644     {V3D_ORIENT_CURSOR,
 645      "CURSOR",
 646      ICON_ORIENTATION_CURSOR,
 647      "Cursor",
 648      "Align the transformation axes to the 3D cursor"},
 649     // {V3D_ORIENT_CUSTOM, "CUSTOM", 0, "Custom", "Use a custom transform orientation"},
 650     {0, NULL, 0, NULL, NULL},
 651 };
 652
 653 #ifdef RNA_RUNTIME
 654
 655 #  include "BLI_string_utils.h"
 656
 657 #  include "DNA_anim_types.h"
 658 #  include "DNA_color_types.h"
 659 #  include "DNA_node_types.h"
 660 #  include "DNA_object_types.h"
 661 #  include "DNA_mesh_types.h"
 662 #  include "DNA_text_types.h"
 663 #  include "DNA_workspace_types.h"
 664
 665 #  include "RNA_access.h"
 666
 667 #  include "MEM_guardedalloc.h"
 668
 669 #  include "BKE_brush.h"
 670 #  include "BKE_collection.h"
 671 #  include "BKE_colortools.h"
 672 #  include "BKE_context.h"
 673 #  include "BKE_global.h"
 674 #  include "BKE_idprop.h"
 675 #  include "BKE_image.h"
 676 #  include "BKE_layer.h"
 677 #  include "BKE_main.h"
 678 #  include "BKE_node.h"
 679 #  include "BKE_pointcache.h"
 680 #  include "BKE_scene.h"
 681 #  include "BKE_mesh.h"
 682 #  include "BKE_screen.h"
 683 #  include "BKE_sequencer.h"
 684 #  include "BKE_animsys.h"
 685 #  include "BKE_freestyle.h"
 686 #  include "BKE_gpencil.h"
 687 #  include "BKE_unit.h"
 688
 689 #  include "ED_info.h"
 690 #  include "ED_node.h"
 691 #  include "ED_view3d.h"
 692 #  include "ED_mesh.h"
 693 #  include "ED_keyframing.h"
 694 #  include "ED_image.h"
 695 #  include "ED_scene.h"
 696
 697 #  include "DEG_depsgraph_build.h"
 698 #  include "DEG_depsgraph_query.h"
 699
 700 #  ifdef WITH_FREESTYLE
 701 #    include "FRS_freestyle.h"
 702 #  endif
 703
 704 static void rna_ToolSettings_snap_mode_set(struct PointerRNA *ptr, int value)
 705 {
 706   ToolSettings *ts = (ToolSettings *)ptr->data;
 707   if (value != 0) {
 708     ts->snap_mode = value;
 709   }
 710 }
 711
 712 /* Grease Pencil update cache */
 713 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
 714 {
 715   /* mark all grease pencil datablocks of the scene */
 716   FOREACH_SCENE_COLLECTION_BEGIN (scene, collection) {
 717     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (collection, ob) {
 718       if (ob->type == OB_GPENCIL) {
 719         bGPdata *gpd = (bGPdata *)ob->data;
 720         gpd->flag |= GP_DATA_CACHE_IS_DIRTY;
 721         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
 722       }
 723     }
 724     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
 725   }
 726   FOREACH_SCENE_COLLECTION_END;
 727
 728   WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
 729 }
 730
 731 /* Grease Pencil Interpolation settings */
 732 static char *rna_GPencilInterpolateSettings_path(PointerRNA *UNUSED(ptr))
 733 {
 734   return BLI_strdup("tool_settings.gpencil_interpolate");
 735 }
 736
 737 static void rna_GPencilInterpolateSettings_type_set(PointerRNA *ptr, int value)
 738 {
 739   GP_Interpolate_Settings *settings = (GP_Interpolate_Settings *)ptr->data;
 740
 741   /* NOTE: This cast should be fine, as we have a small + finite set of values
 742    * (#eGP_Interpolate_Type) that should fit well within a char.
 743    */
 744   settings->type = (char)value;
 745
 746   /* init custom interpolation curve here now the first time it's used */
 747   if ((settings->type == GP_IPO_CURVEMAP) && (settings->custom_ipo == NULL)) {
 748     settings->custom_ipo = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 749   }
 750 }
 751
 752 static void rna_Gpencil_mask_point_update(Main *UNUSED(bmain),
 753                                           Scene *UNUSED(scene),
 754                                           PointerRNA *ptr)
 755 {
 756   ToolSettings *ts = (ToolSettings *)ptr->data;
 757
 758   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_STROKE;
 759   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_SEGMENT;
 760 }
 761
 762 static void rna_Gpencil_mask_stroke_update(Main *UNUSED(bmain),
 763                                            Scene *UNUSED(scene),
 764                                            PointerRNA *ptr)
 765 {
 766   ToolSettings *ts = (ToolSettings *)ptr->data;
 767
 768   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_POINT;
 769   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_SEGMENT;
 770 }
 771
 772 static void rna_Gpencil_mask_segment_update(Main *UNUSED(bmain),
 773                                             Scene *UNUSED(scene),
 774                                             PointerRNA *ptr)
 775 {
 776   ToolSettings *ts = (ToolSettings *)ptr->data;
 777
 778   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_POINT;
 779   ts->gpencil_selectmode_sculpt &= ~GP_SCULPT_MASK_SELECTMODE_STROKE;
 780 }
 781
 782 /* Read-only Iterator of all the scene objects. */
 783
 784 static void rna_Scene_objects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 785 {
 786   Scene *scene = (Scene *)ptr->data;
 787   iter->internal.custom = MEM_callocN(sizeof(BLI_Iterator), __func__);
 788
 789   ((BLI_Iterator *)iter->internal.custom)->valid = true;
 790   BKE_scene_objects_iterator_begin(iter->internal.custom, (void *)scene);
 791   iter->valid = ((BLI_Iterator *)iter->internal.custom)->valid;
 792 }
 793
 794 static void rna_Scene_objects_next(CollectionPropertyIterator *iter)
 795 {
 796   BKE_scene_objects_iterator_next(iter->internal.custom);
 797   iter->valid = ((BLI_Iterator *)iter->internal.custom)->valid;
 798 }
 799
 800 static void rna_Scene_objects_end(CollectionPropertyIterator *iter)
 801 {
 802   BKE_scene_objects_iterator_end(iter->internal.custom);
 803   MEM_freeN(iter->internal.custom);
 804 }
 805
 806 static PointerRNA rna_Scene_objects_get(CollectionPropertyIterator *iter)
 807 {
 808   Object *ob = ((BLI_Iterator *)iter->internal.custom)->current;
 809   return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ob);
 810 }
 811
 812 /* End of read-only Iterator of all the scene objects. */
 813
 814 static void rna_Scene_set_set(PointerRNA *ptr,
 815                               PointerRNA value,
 816                               struct ReportList *UNUSED(reports))
 817 {
 818   Scene *scene = (Scene *)ptr->data;
 819   Scene *set = (Scene *)value.data;
 820   Scene *nested_set;
 821
 822   for (nested_set = set; nested_set; nested_set = nested_set->set) {
 823     if (nested_set == scene) {
 824       return;
 825     }
 826     /* prevent eternal loops, set can point to next, and next to set, without problems usually */
 827     if (nested_set->set == set) {
 828       return;
 829     }
 830   }
 831
 832   id_lib_extern((ID *)set);
 833   scene->set = set;
 834 }
 835
 836 void rna_Scene_set_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
 837 {
 838   Scene *scene = (Scene *)ptr->id.data;
 839
 840   DEG_relations_tag_update(bmain);
 841   DEG_id_tag_update_ex(bmain, &scene->id, 0);
 842   if (scene->set != NULL) {
 843     /* Objects which are pulled into main scene's depsgraph needs to have
 844      * their base flags updated.
 845      */
 846     DEG_id_tag_update_ex(bmain, &scene->set->id, 0);
 847   }
 848 }
 849
 850 static void rna_Scene_camera_update(Main *bmain, Scene *UNUSED(scene_unused), PointerRNA *ptr)
 851 {
 852   wmWindowManager *wm = bmain->wm.first;
 853   Scene *scene = (Scene *)ptr->data;
 854
 855   WM_windows_scene_data_sync(&wm->windows, scene);
 856   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
 857   DEG_relations_tag_update(bmain);
 858 }
 859
 860 static void rna_Scene_fps_update(Main *bmain, Scene *scene, PointerRNA *UNUSED(ptr))
 861 {
 862   DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO_FPS | ID_RECALC_SEQUENCER_STRIPS);
 863   /* NOTE: Tag via dependency graph will take care of all the updates ion the evaluated domain,
 864    * however, changes in FPS actually modifies an original skip length,
 865    * so this we take care about here. */
 866   BKE_sequencer_refresh_sound_length(bmain, scene);
 867 }
 868
 869 static void rna_Scene_listener_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
 870 {
 871   DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO_LISTENER);
 872 }
 873
 874 static void rna_Scene_volume_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 875 {
 876   Scene *scene = (Scene *)ptr->id.data;
 877   DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO_VOLUME | ID_RECALC_SEQUENCER_STRIPS);
 878 }
 879
 880 static const char *rna_Scene_statistics_string_get(Scene *scene,
 881                                                    Main *bmain,
 882                                                    ViewLayer *view_layer)
 883 {
 884   return ED_info_stats_string(bmain, scene, view_layer);
 885 }
 886
 887 static void rna_Scene_framelen_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
 888 {
 889   scene->r.framelen = (float)scene->r.framapto / (float)scene->r.images;
 890 }
 891
 892 static void rna_Scene_frame_current_set(PointerRNA *ptr, int value)
 893 {
 894   Scene *data = (Scene *)ptr->data;
 895
 896   /* if negative frames aren't allowed, then we can't use them */
 897   FRAMENUMBER_MIN_CLAMP(value);
 898   data->r.cfra = value;
 899 }
 900
 901 static float rna_Scene_frame_float_get(PointerRNA *ptr)
 902 {
 903   Scene *data = (Scene *)ptr->data;
 904   return (float)data->r.cfra + data->r.subframe;
 905 }
 906
 907 static void rna_Scene_frame_float_set(PointerRNA *ptr, float value)
 908 {
 909   Scene *data = (Scene *)ptr->data;
 910   /* if negative frames aren't allowed, then we can't use them */
 911   FRAMENUMBER_MIN_CLAMP(value);
 912   data->r.cfra = (int)value;
 913   data->r.subframe = value - data->r.cfra;
 914 }
 915
 916 static float rna_Scene_frame_current_final_get(PointerRNA *ptr)
 917 {
 918   Scene *scene = (Scene *)ptr->data;
 919
 920   return BKE_scene_frame_to_ctime(scene, (float)scene->r.cfra);
 921 }
 922
 923 static void rna_Scene_start_frame_set(PointerRNA *ptr, int value)
 924 {
 925   Scene *data = (Scene *)ptr->data;
 926   /* MINFRAME not MINAFRAME, since some output formats can't taken negative frames */
 927   CLAMP(value, MINFRAME, MAXFRAME);
 928   data->r.sfra = value;
 929
 930   if (data->r.sfra >= data->r.efra) {
 931     data->r.efra = MIN2(data->r.sfra, MAXFRAME);
 932   }
 933 }
 934
 935 static void rna_Scene_end_frame_set(PointerRNA *ptr, int value)
 936 {
 937   Scene *data = (Scene *)ptr->data;
 938   CLAMP(value, MINFRAME, MAXFRAME);
 939   data->r.efra = value;
 940
 941   if (data->r.sfra >= data->r.efra) {
 942     data->r.sfra = MAX2(data->r.efra, MINFRAME);
 943   }
 944 }
 945
 946 static void rna_Scene_use_preview_range_set(PointerRNA *ptr, bool value)
 947 {
 948   Scene *data = (Scene *)ptr->data;
 949
 950   if (value) {
 951     /* copy range from scene if not set before */
 952     if ((data->r.psfra == data->r.pefra) && (data->r.psfra == 0)) {
 953       data->r.psfra = data->r.sfra;
 954       data->r.pefra = data->r.efra;
 955     }
 956
 957     data->r.flag |= SCER_PRV_RANGE;
 958   }
 959   else {
 960     data->r.flag &= ~SCER_PRV_RANGE;
 961   }
 962 }
 963
 964 static void rna_Scene_preview_range_start_frame_set(PointerRNA *ptr, int value)
 965 {
 966   Scene *data = (Scene *)ptr->data;
 967
 968   /* check if enabled already */
 969   if ((data->r.flag & SCER_PRV_RANGE) == 0) {
 970     /* set end of preview range to end frame, then clamp as per normal */
 971     /* TODO: or just refuse to set instead? */
 972     data->r.pefra = data->r.efra;
 973   }
 974
 975   /* now set normally */
 976   CLAMP(value, MINAFRAME, data->r.pefra);
 977   data->r.psfra = value;
 978 }
 979
 980 static void rna_Scene_preview_range_end_frame_set(PointerRNA *ptr, int value)
 981 {
 982   Scene *data = (Scene *)ptr->data;
 983
 984   /* check if enabled already */
 985   if ((data->r.flag & SCER_PRV_RANGE) == 0) {
 986     /* set start of preview range to start frame, then clamp as per normal */
 987     /* TODO: or just refuse to set instead? */
 988     data->r.psfra = data->r.sfra;
 989   }
 990
 991   /* now set normally */
 992   CLAMP(value, data->r.psfra, MAXFRAME);
 993   data->r.pefra = value;
 994 }
 995
 996 static void rna_Scene_show_subframe_update(Main *UNUSED(bmain),
 997                                            Scene *UNUSED(current_scene),
 998                                            PointerRNA *ptr)
 999 {
1000   Scene *scene = (Scene *)ptr->id.data;
1001   scene->r.subframe = 0.0f;
1002 }
1003
1004 static void rna_Scene_frame_update(Main *UNUSED(bmain),
1005                                    Scene *UNUSED(current_scene),
1006                                    PointerRNA *ptr)
1007 {
1008   Scene *scene = (Scene *)ptr->id.data;
1009   DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO_SEEK);
1010   WM_main_add_notifier(NC_SCENE | ND_FRAME, scene);
1011 }
1012
1013 static PointerRNA rna_Scene_active_keying_set_get(PointerRNA *ptr)
1014 {
1015   Scene *scene = (Scene *)ptr->data;
1016   return rna_pointer_inherit_refine(ptr, &RNA_KeyingSet, ANIM_scene_get_active_keyingset(scene));
1017 }
1018
1019 static void rna_Scene_active_keying_set_set(PointerRNA *ptr,
1020                                             PointerRNA value,
1021                                             struct ReportList *UNUSED(reports))
1022 {
1023   Scene *scene = (Scene *)ptr->data;
1024   KeyingSet *ks = (KeyingSet *)value.data;
1025
1026   scene->active_keyingset = ANIM_scene_get_keyingset_index(scene, ks);
1027 }
1028
1029 /* get KeyingSet index stuff for list of Keying Sets editing UI
1030  * - active_keyingset-1 since 0 is reserved for 'none'
1031  * - don't clamp, otherwise can never set builtins types as active...
1032  */
1033 static int rna_Scene_active_keying_set_index_get(PointerRNA *ptr)
1034 {
1035   Scene *scene = (Scene *)ptr->data;
1036   return scene->active_keyingset - 1;
1037 }
1038
1039 /* get KeyingSet index stuff for list of Keying Sets editing UI
1040  * - value+1 since 0 is reserved for 'none'
1041  */
1042 static void rna_Scene_active_keying_set_index_set(PointerRNA *ptr, int value)
1043 {
1044   Scene *scene = (Scene *)ptr->data;
1045   scene->active_keyingset = value + 1;
1046 }
1047
1048 /* XXX: evil... builtin_keyingsets is defined in keyingsets.c! */
1049 /* TODO: make API function to retrieve this... */
1050 extern ListBase builtin_keyingsets;
1051
1052 static void rna_Scene_all_keyingsets_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1053 {
1054   Scene *scene = (Scene *)ptr->data;
1055
1056   /* start going over the scene KeyingSets first, while we still have pointer to it
1057    * but only if we have any Keying Sets to use...
1058    */
1059   if (scene->keyingsets.first) {
1060     rna_iterator_listbase_begin(iter, &scene->keyingsets, NULL);
1061   }
1062   else {
1063     rna_iterator_listbase_begin(iter, &builtin_keyingsets, NULL);
1064   }
1065 }
1066
1067 static void rna_Scene_all_keyingsets_next(CollectionPropertyIterator *iter)
1068 {
1069   ListBaseIterator *internal = &iter->internal.listbase;
1070   KeyingSet *ks = (KeyingSet *)internal->link;
1071
1072   /* If we've run out of links in Scene list,
1073    * jump over to the builtins list unless we're there already. */
1074   if ((ks->next == NULL) && (ks != builtin_keyingsets.last)) {
1075     internal->link = (Link *)builtin_keyingsets.first;
1076   }
1077   else {
1078     internal->link = (Link *)ks->next;
1079   }
1080
1081   iter->valid = (internal->link != NULL);
1082 }
1083
1084 static char *rna_SceneEEVEE_path(PointerRNA *UNUSED(ptr))
1085 {
1086   return BLI_strdup("eevee");
1087 }
1088
1089 static int rna_RenderSettings_stereoViews_skip(CollectionPropertyIterator *iter,
1090                                                void *UNUSED(data))
1091 {
1092   ListBaseIterator *internal = &iter->internal.listbase;
1093   SceneRenderView *srv = (SceneRenderView *)internal->link;
1094
1095   if ((STREQ(srv->name, STEREO_LEFT_NAME)) || (STREQ(srv->name, STEREO_RIGHT_NAME))) {
1096     return 0;
1097   }
1098
1099   return 1;
1100 };
1101
1102 static void rna_RenderSettings_stereoViews_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1103 {
1104   RenderData *rd = (RenderData *)ptr->data;
1105   rna_iterator_listbase_begin(iter, &rd->views, rna_RenderSettings_stereoViews_skip);
1106 }
1107
1108 static char *rna_RenderSettings_path(PointerRNA *UNUSED(ptr))
1109 {
1110   return BLI_strdup("render");
1111 }
1112
1113 static char *rna_BakeSettings_path(PointerRNA *UNUSED(ptr))
1114 {
1115   return BLI_strdup("render.bake");
1116 }
1117
1118 static char *rna_ImageFormatSettings_path(PointerRNA *ptr)
1119 {
1120   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1121   ID *id = ptr->id.data;
1122
1123   switch (GS(id->name)) {
1124     case ID_SCE: {
1125       Scene *scene = (Scene *)id;
1126
1127       if (&scene->r.im_format == imf) {
1128         return BLI_strdup("render.image_settings");
1129       }
1130       else if (&scene->r.bake.im_format == imf) {
1131         return BLI_strdup("render.bake.image_settings");
1132       }
1133       return BLI_strdup("..");
1134     }
1135     case ID_NT: {
1136       bNodeTree *ntree = (bNodeTree *)id;
1137       bNode *node;
1138
1139       for (node = ntree->nodes.first; node; node = node->next) {
1140         if (node->type == CMP_NODE_OUTPUT_FILE) {
1141           if (&((NodeImageMultiFile *)node->storage)->format == imf) {
1142             return BLI_sprintfN("nodes['%s'].format", node->name);
1143           }
1144           else {
1145             bNodeSocket *sock;
1146
1147             for (sock = node->inputs.first; sock; sock = sock->next) {
1148               NodeImageMultiFileSocket *sockdata = sock->storage;
1149               if (&sockdata->format == imf) {
1150                 return BLI_sprintfN(
1151                     "nodes['%s'].file_slots['%s'].format", node->name, sockdata->path);
1152               }
1153             }
1154           }
1155         }
1156       }
1157       return BLI_strdup("..");
1158     }
1159     default:
1160       return BLI_strdup("..");
1161   }
1162 }
1163
1164 static int rna_RenderSettings_threads_get(PointerRNA *ptr)
1165 {
1166   RenderData *rd = (RenderData *)ptr->data;
1167   return BKE_render_num_threads(rd);
1168 }
1169
1170 static int rna_RenderSettings_threads_mode_get(PointerRNA *ptr)
1171 {
1172   RenderData *rd = (RenderData *)ptr->data;
1173   int override = BLI_system_num_threads_override_get();
1174
1175   if (override > 0) {
1176     return R_FIXED_THREADS;
1177   }
1178   else {
1179     return (rd->mode & R_FIXED_THREADS);
1180   }
1181 }
1182
1183 static bool rna_RenderSettings_is_movie_format_get(PointerRNA *ptr)
1184 {
1185   RenderData *rd = (RenderData *)ptr->data;
1186   return BKE_imtype_is_movie(rd->im_format.imtype);
1187 }
1188
1189 static void rna_ImageFormatSettings_file_format_set(PointerRNA *ptr, int value)
1190 {
1191   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1192   ID *id = ptr->id.data;
1193   imf->imtype = value;
1194
1195   const bool is_render = (id && GS(id->name) == ID_SCE);
1196   /* see note below on why this is */
1197   const char chan_flag = BKE_imtype_valid_channels(imf->imtype, true) |
1198                          (is_render ? IMA_CHAN_FLAG_BW : 0);
1199
1200   /* ensure depth and color settings match */
1201   if (((imf->planes == R_IMF_PLANES_BW) && !(chan_flag & IMA_CHAN_FLAG_BW)) ||
1202       ((imf->planes == R_IMF_PLANES_RGBA) && !(chan_flag & IMA_CHAN_FLAG_ALPHA))) {
1203     imf->planes = R_IMF_PLANES_RGB;
1204   }
1205
1206   /* ensure usable depth */
1207   {
1208     const int depth_ok = BKE_imtype_valid_depths(imf->imtype);
1209     if ((imf->depth & depth_ok) == 0) {
1210       /* set first available depth */
1211       char depth_ls[] = {
1212           R_IMF_CHAN_DEPTH_32,
1213           R_IMF_CHAN_DEPTH_24,
1214           R_IMF_CHAN_DEPTH_16,
1215           R_IMF_CHAN_DEPTH_12,
1216           R_IMF_CHAN_DEPTH_10,
1217           R_IMF_CHAN_DEPTH_8,
1218           R_IMF_CHAN_DEPTH_1,
1219           0,
1220       };
1221       int i;
1222
1223       for (i = 0; depth_ls[i]; i++) {
1224         if (depth_ok & depth_ls[i]) {
1225           imf->depth = depth_ls[i];
1226           break;
1227         }
1228       }
1229     }
1230   }
1231
1232   if (id && GS(id->name) == ID_SCE) {
1233     Scene *scene = ptr->id.data;
1234     RenderData *rd = &scene->r;
1235 #  ifdef WITH_FFMPEG
1236     BKE_ffmpeg_image_type_verify(rd, imf);
1237 #  endif
1238     (void)rd;
1239   }
1240 }
1241
1242 static const EnumPropertyItem *rna_ImageFormatSettings_file_format_itemf(bContext *UNUSED(C),
1243                                                                          PointerRNA *ptr,
1244                                                                          PropertyRNA *UNUSED(prop),
1245                                                                          bool *UNUSED(r_free))
1246 {
1247   ID *id = ptr->id.data;
1248   if (id && GS(id->name) == ID_SCE) {
1249     return rna_enum_image_type_items;
1250   }
1251   else {
1252     return image_only_type_items;
1253   }
1254 }
1255
1256 static const EnumPropertyItem *rna_ImageFormatSettings_color_mode_itemf(bContext *UNUSED(C),
1257                                                                         PointerRNA *ptr,
1258                                                                         PropertyRNA *UNUSED(prop),
1259                                                                         bool *r_free)
1260 {
1261   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1262   ID *id = ptr->id.data;
1263   const bool is_render = (id && GS(id->name) == ID_SCE);
1264
1265   /* note, we need to act differently for render
1266    * where 'BW' will force grayscale even if the output format writes
1267    * as RGBA, this is age old blender convention and not sure how useful
1268    * it really is but keep it for now - campbell */
1269   char chan_flag = BKE_imtype_valid_channels(imf->imtype, true) |
1270                    (is_render ? IMA_CHAN_FLAG_BW : 0);
1271
1272 #  ifdef WITH_FFMPEG
1273   /* a WAY more crappy case than B&W flag: depending on codec, file format MIGHT support
1274    * alpha channel. for example MPEG format with h264 codec can't do alpha channel, but
1275    * the same MPEG format with QTRLE codec can easily handle alpha channel.
1276    * not sure how to deal with such cases in a nicer way (sergey) */
1277   if (is_render) {
1278     Scene *scene = ptr->id.data;
1279     RenderData *rd = &scene->r;
1280
1281     if (BKE_ffmpeg_alpha_channel_is_supported(rd)) {
1282       chan_flag |= IMA_CHAN_FLAG_ALPHA;
1283     }
1284   }
1285 #  endif
1286
1287   if (chan_flag == (IMA_CHAN_FLAG_BW | IMA_CHAN_FLAG_RGB | IMA_CHAN_FLAG_ALPHA)) {
1288     return rna_enum_image_color_mode_items;
1289   }
1290   else {
1291     int totitem = 0;
1292     EnumPropertyItem *item = NULL;
1293
1294     if (chan_flag & IMA_CHAN_FLAG_BW) {
1295       RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_BW);
1296     }
1297     if (chan_flag & IMA_CHAN_FLAG_RGB) {
1298       RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_RGB);
1299     }
1300     if (chan_flag & IMA_CHAN_FLAG_ALPHA) {
1301       RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_RGBA);
1302     }
1303
1304     RNA_enum_item_end(&item, &totitem);
1305     *r_free = true;
1306
1307     return item;
1308   }
1309 }
1310
1311 static const EnumPropertyItem *rna_ImageFormatSettings_color_depth_itemf(bContext *UNUSED(C),
1312                                                                          PointerRNA *ptr,
1313                                                                          PropertyRNA *UNUSED(prop),
1314                                                                          bool *r_free)
1315 {
1316   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1317
1318   if (imf == NULL) {
1319     return rna_enum_image_color_depth_items;
1320   }
1321   else {
1322     const int depth_ok = BKE_imtype_valid_depths(imf->imtype);
1323     const int is_float = ELEM(
1324         imf->imtype, R_IMF_IMTYPE_RADHDR, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER);
1325
1326     const EnumPropertyItem *item_8bit = &rna_enum_image_color_depth_items[0];
1327     const EnumPropertyItem *item_10bit = &rna_enum_image_color_depth_items[1];
1328     const EnumPropertyItem *item_12bit = &rna_enum_image_color_depth_items[2];
1329     const EnumPropertyItem *item_16bit = &rna_enum_image_color_depth_items[3];
1330     const EnumPropertyItem *item_32bit = &rna_enum_image_color_depth_items[4];
1331
1332     int totitem = 0;
1333     EnumPropertyItem *item = NULL;
1334     EnumPropertyItem tmp = {0, "", 0, "", ""};
1335
1336     if (depth_ok & R_IMF_CHAN_DEPTH_8) {
1337       RNA_enum_item_add(&item, &totitem, item_8bit);
1338     }
1339
1340     if (depth_ok & R_IMF_CHAN_DEPTH_10) {
1341       RNA_enum_item_add(&item, &totitem, item_10bit);
1342     }
1343
1344     if (depth_ok & R_IMF_CHAN_DEPTH_12) {
1345       RNA_enum_item_add(&item, &totitem, item_12bit);
1346     }
1347
1348     if (depth_ok & R_IMF_CHAN_DEPTH_16) {
1349       if (is_float) {
1350         tmp = *item_16bit;
1351         tmp.name = "Float (Half)";
1352         RNA_enum_item_add(&item, &totitem, &tmp);
1353       }
1354       else {
1355         RNA_enum_item_add(&item, &totitem, item_16bit);
1356       }
1357     }
1358
1359     if (depth_ok & R_IMF_CHAN_DEPTH_32) {
1360       if (is_float) {
1361         tmp = *item_32bit;
1362         tmp.name = "Float (Full)";
1363         RNA_enum_item_add(&item, &totitem, &tmp);
1364       }
1365       else {
1366         RNA_enum_item_add(&item, &totitem, item_32bit);
1367       }
1368     }
1369
1370     RNA_enum_item_end(&item, &totitem);
1371     *r_free = true;
1372
1373     return item;
1374   }
1375 }
1376
1377 static const EnumPropertyItem *rna_ImageFormatSettings_views_format_itemf(
1378     bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
1379 {
1380   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1381
1382   if (imf == NULL) {
1383     return rna_enum_views_format_items;
1384   }
1385   else if (imf->imtype == R_IMF_IMTYPE_OPENEXR) {
1386     return rna_enum_views_format_multiview_items;
1387   }
1388   else if (imf->imtype == R_IMF_IMTYPE_MULTILAYER) {
1389     return rna_enum_views_format_multilayer_items;
1390   }
1391   else {
1392     return rna_enum_views_format_items;
1393   }
1394 }
1395
1396 #  ifdef WITH_OPENEXR
1397 /* OpenEXR */
1398
1399 static const EnumPropertyItem *rna_ImageFormatSettings_exr_codec_itemf(bContext *UNUSED(C),
1400                                                                        PointerRNA *ptr,
1401                                                                        PropertyRNA *UNUSED(prop),
1402                                                                        bool *r_free)
1403 {
1404   ImageFormatData *imf = (ImageFormatData *)ptr->data;
1405
1406   EnumPropertyItem *item = NULL;
1407   int i = 1, totitem = 0;
1408
1409   if (imf->depth == 16) {
1410     return rna_enum_exr_codec_items; /* All compression types are defined for halfs */
1411   }
1412
1413   for (i = 0; i < R_IMF_EXR_CODEC_MAX; i++) {
1414     if ((i == R_IMF_EXR_CODEC_B44 || i == R_IMF_EXR_CODEC_B44A)) {
1415       continue; /* B44 and B44A are not defined for 32 bit floats */
1416     }
1417
1418     RNA_enum_item_add(&item, &totitem, &rna_enum_exr_codec_items[i]);
1419   }
1420
1421   RNA_enum_item_end(&item, &totitem);
1422   *r_free = true;
1423
1424   return item;
1425 }
1426
1427 #  endif
1428 static int rna_SceneRender_file_ext_length(PointerRNA *ptr)
1429 {
1430   RenderData *rd = (RenderData *)ptr->data;
1431   char ext[8];
1432   ext[0] = '\0';
1433   BKE_image_path_ensure_ext_from_imformat(ext, &rd->im_format);
1434   return strlen(ext);
1435 }
1436
1437 static void rna_SceneRender_file_ext_get(PointerRNA *ptr, char *str)
1438 {
1439   RenderData *rd = (RenderData *)ptr->data;
1440   str[0] = '\0';
1441   BKE_image_path_ensure_ext_from_imformat(str, &rd->im_format);
1442 }
1443
1444 #  ifdef WITH_FFMPEG
1445 static void rna_FFmpegSettings_lossless_output_set(PointerRNA *ptr, bool value)
1446 {
1447   Scene *scene = (Scene *)ptr->id.data;
1448   RenderData *rd = &scene->r;
1449
1450   if (value) {
1451     rd->ffcodecdata.flags |= FFMPEG_LOSSLESS_OUTPUT;
1452   }
1453   else {
1454     rd->ffcodecdata.flags &= ~FFMPEG_LOSSLESS_OUTPUT;
1455   }
1456
1457   BKE_ffmpeg_codec_settings_verify(rd);
1458 }
1459
1460 static void rna_FFmpegSettings_codec_settings_update(Main *UNUSED(bmain),
1461                                                      Scene *UNUSED(scene_unused),
1462                                                      PointerRNA *ptr)
1463 {
1464   Scene *scene = (Scene *)ptr->id.data;
1465   RenderData *rd = &scene->r;
1466
1467   BKE_ffmpeg_codec_settings_verify(rd);
1468 }
1469 #  endif
1470
1471 static int rna_RenderSettings_active_view_index_get(PointerRNA *ptr)
1472 {
1473   RenderData *rd = (RenderData *)ptr->data;
1474   return rd->actview;
1475 }
1476
1477 static void rna_RenderSettings_active_view_index_set(PointerRNA *ptr, int value)
1478 {
1479   RenderData *rd = (RenderData *)ptr->data;
1480   rd->actview = value;
1481 }
1482
1483 static void rna_RenderSettings_active_view_index_range(
1484     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
1485 {
1486   RenderData *rd = (RenderData *)ptr->data;
1487
1488   *min = 0;
1489   *max = max_ii(0, BLI_listbase_count(&rd->views) - 1);
1490 }
1491
1492 static PointerRNA rna_RenderSettings_active_view_get(PointerRNA *ptr)
1493 {
1494   RenderData *rd = (RenderData *)ptr->data;
1495   SceneRenderView *srv = BLI_findlink(&rd->views, rd->actview);
1496
1497   return rna_pointer_inherit_refine(ptr, &RNA_SceneRenderView, srv);
1498 }
1499
1500 static void rna_RenderSettings_active_view_set(PointerRNA *ptr,
1501                                                PointerRNA value,
1502                                                struct ReportList *UNUSED(reports))
1503 {
1504   RenderData *rd = (RenderData *)ptr->data;
1505   SceneRenderView *srv = (SceneRenderView *)value.data;
1506   const int index = BLI_findindex(&rd->views, srv);
1507   if (index != -1) {
1508     rd->actview = index;
1509   }
1510 }
1511
1512 static SceneRenderView *rna_RenderView_new(ID *id, RenderData *UNUSED(rd), const char *name)
1513 {
1514   Scene *scene = (Scene *)id;
1515   SceneRenderView *srv = BKE_scene_add_render_view(scene, name);
1516
1517   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
1518
1519   return srv;
1520 }
1521
1522 static void rna_RenderView_remove(
1523     ID *id, RenderData *UNUSED(rd), Main *UNUSED(bmain), ReportList *reports, PointerRNA *srv_ptr)
1524 {
1525   SceneRenderView *srv = srv_ptr->data;
1526   Scene *scene = (Scene *)id;
1527
1528   if (!BKE_scene_remove_render_view(scene, srv)) {
1529     BKE_reportf(reports,
1530                 RPT_ERROR,
1531                 "Render view '%s' could not be removed from scene '%s'",
1532                 srv->name,
1533                 scene->id.name + 2);
1534     return;
1535   }
1536
1537   RNA_POINTER_INVALIDATE(srv_ptr);
1538
1539   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
1540 }
1541
1542 static void rna_RenderSettings_views_format_set(PointerRNA *ptr, int value)
1543 {
1544   RenderData *rd = (RenderData *)ptr->data;
1545
1546   if (rd->views_format == SCE_VIEWS_FORMAT_MULTIVIEW && value == SCE_VIEWS_FORMAT_STEREO_3D) {
1547     /* make sure the actview is visible */
1548     if (rd->actview > 1) {
1549       rd->actview = 1;
1550     }
1551   }
1552
1553   rd->views_format = value;
1554 }
1555
1556 static void rna_RenderSettings_engine_set(PointerRNA *ptr, int value)
1557 {
1558   RenderData *rd = (RenderData *)ptr->data;
1559   RenderEngineType *type = BLI_findlink(&R_engines, value);
1560
1561   if (type) {
1562     BLI_strncpy_utf8(rd->engine, type->idname, sizeof(rd->engine));
1563     DEG_id_tag_update(ptr->id.data, ID_RECALC_COPY_ON_WRITE);
1564   }
1565 }
1566
1567 static const EnumPropertyItem *rna_RenderSettings_engine_itemf(bContext *UNUSED(C),
1568                                                                PointerRNA *UNUSED(ptr),
1569                                                                PropertyRNA *UNUSED(prop),
1570                                                                bool *r_free)
1571 {
1572   RenderEngineType *type;
1573   EnumPropertyItem *item = NULL;
1574   EnumPropertyItem tmp = {0, "", 0, "", ""};
1575   int a = 0, totitem = 0;
1576
1577   for (type = R_engines.first; type; type = type->next, a++) {
1578     tmp.value = a;
1579     tmp.identifier = type->idname;
1580     tmp.name = type->name;
1581     RNA_enum_item_add(&item, &totitem, &tmp);
1582   }
1583
1584   RNA_enum_item_end(&item, &totitem);
1585   *r_free = true;
1586
1587   return item;
1588 }
1589
1590 static int rna_RenderSettings_engine_get(PointerRNA *ptr)
1591 {
1592   RenderData *rd = (RenderData *)ptr->data;
1593   RenderEngineType *type;
1594   int a = 0;
1595
1596   for (type = R_engines.first; type; type = type->next, a++) {
1597     if (STREQ(type->idname, rd->engine)) {
1598       return a;
1599     }
1600   }
1601
1602   return 0;
1603 }
1604
1605 static void rna_RenderSettings_engine_update(Main *bmain,
1606                                              Scene *UNUSED(unused),
1607                                              PointerRNA *UNUSED(ptr))
1608 {
1609   ED_render_engine_changed(bmain);
1610 }
1611
1612 static bool rna_RenderSettings_multiple_engines_get(PointerRNA *UNUSED(ptr))
1613 {
1614   return (BLI_listbase_count(&R_engines) > 1);
1615 }
1616
1617 static bool rna_RenderSettings_use_spherical_stereo_get(PointerRNA *ptr)
1618 {
1619   Scene *scene = (Scene *)ptr->id.data;
1620   return BKE_scene_use_spherical_stereo(scene);
1621 }
1622
1623 void rna_Scene_glsl_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1624 {
1625   Scene *scene = (Scene *)ptr->id.data;
1626
1627   DEG_id_tag_update(&scene->id, 0);
1628 }
1629
1630 static void rna_Scene_world_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1631 {
1632   Scene *sc = (Scene *)ptr->id.data;
1633
1634   rna_Scene_glsl_update(bmain, scene, ptr);
1635   WM_main_add_notifier(NC_WORLD | ND_WORLD, &sc->id);
1636   DEG_relations_tag_update(bmain);
1637 }
1638
1639 void rna_Scene_freestyle_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1640 {
1641   Scene *scene = (Scene *)ptr->id.data;
1642
1643   DEG_id_tag_update(&scene->id, 0);
1644 }
1645
1646 void rna_Scene_use_view_map_cache_update(Main *UNUSED(bmain),
1647                                          Scene *UNUSED(scene),
1648                                          PointerRNA *UNUSED(ptr))
1649 {
1650 #  ifdef WITH_FREESTYLE
1651   FRS_free_view_map_cache();
1652 #  endif
1653 }
1654
1655 void rna_ViewLayer_name_set(PointerRNA *ptr, const char *value)
1656 {
1657   Scene *scene = (Scene *)ptr->id.data;
1658   ViewLayer *view_layer = (ViewLayer *)ptr->data;
1659   BLI_assert(BKE_id_is_in_global_main(&scene->id));
1660   BKE_view_layer_rename(G_MAIN, scene, view_layer, value);
1661 }
1662
1663 static void rna_SceneRenderView_name_set(PointerRNA *ptr, const char *value)
1664 {
1665   Scene *scene = (Scene *)ptr->id.data;
1666   SceneRenderView *rv = (SceneRenderView *)ptr->data;
1667   BLI_strncpy_utf8(rv->name, value, sizeof(rv->name));
1668   BLI_uniquename(&scene->r.views,
1669                  rv,
1670                  DATA_("RenderView"),
1671                  '.',
1672                  offsetof(SceneRenderView, name),
1673                  sizeof(rv->name));
1674 }
1675
1676 void rna_ViewLayer_material_override_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1677 {
1678   Scene *scene = (Scene *)ptr->id.data;
1679   rna_Scene_glsl_update(bmain, scene, ptr);
1680   DEG_relations_tag_update(bmain);
1681 }
1682
1683 void rna_ViewLayer_pass_update(Main *bmain, Scene *activescene, PointerRNA *ptr)
1684 {
1685   Scene *scene = (Scene *)ptr->id.data;
1686
1687   if (scene->nodetree) {
1688     ntreeCompositUpdateRLayers(scene->nodetree);
1689   }
1690
1691   rna_Scene_glsl_update(bmain, activescene, ptr);
1692 }
1693
1694 static char *rna_SceneRenderView_path(PointerRNA *ptr)
1695 {
1696   SceneRenderView *srv = (SceneRenderView *)ptr->data;
1697   return BLI_sprintfN("render.views[\"%s\"]", srv->name);
1698 }
1699
1700 static void rna_Scene_use_nodes_update(bContext *C, PointerRNA *ptr)
1701 {
1702   Scene *scene = (Scene *)ptr->data;
1703   if (scene->use_nodes && scene->nodetree == NULL) {
1704     ED_node_composit_default(C, scene);
1705   }
1706   DEG_relations_tag_update(CTX_data_main(C));
1707 }
1708
1709 static void rna_Physics_relations_update(Main *bmain,
1710                                          Scene *UNUSED(scene),
1711                                          PointerRNA *UNUSED(ptr))
1712 {
1713   DEG_relations_tag_update(bmain);
1714 }
1715
1716 static void rna_Physics_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1717 {
1718   Scene *scene = (Scene *)ptr->id.data;
1719   FOREACH_SCENE_OBJECT_BEGIN (scene, ob) {
1720     BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH);
1721   }
1722   FOREACH_SCENE_OBJECT_END;
1723
1724   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
1725 }
1726
1727 static void rna_Scene_editmesh_select_mode_set(PointerRNA *ptr, const bool *value)
1728 {
1729   ToolSettings *ts = (ToolSettings *)ptr->data;
1730   int flag = (value[0] ? SCE_SELECT_VERTEX : 0) | (value[1] ? SCE_SELECT_EDGE : 0) |
1731              (value[2] ? SCE_SELECT_FACE : 0);
1732
1733   if (flag) {
1734     ts->selectmode = flag;
1735
1736     /* Update select mode in all the workspaces in mesh edit mode. */
1737     wmWindowManager *wm = G_MAIN->wm.first;
1738     for (wmWindow *win = wm->windows.first; win; win = win->next) {
1739       ViewLayer *view_layer = WM_window_get_active_view_layer(win);
1740
1741       if (view_layer && view_layer->basact) {
1742         Mesh *me = BKE_mesh_from_object(view_layer->basact->object);
1743         if (me && me->edit_mesh && me->edit_mesh->selectmode != flag) {
1744           me->edit_mesh->selectmode = flag;
1745           EDBM_selectmode_set(me->edit_mesh);
1746         }
1747       }
1748     }
1749   }
1750 }
1751
1752 static void rna_Scene_editmesh_select_mode_update(bContext *C, PointerRNA *UNUSED(ptr))
1753 {
1754   ViewLayer *view_layer = CTX_data_view_layer(C);
1755   Mesh *me = NULL;
1756
1757   if (view_layer->basact) {
1758     me = BKE_mesh_from_object(view_layer->basact->object);
1759     if (me && me->edit_mesh == NULL) {
1760       me = NULL;
1761     }
1762   }
1763
1764   if (me) {
1765     DEG_id_tag_update(&me->id, ID_RECALC_SELECT);
1766     WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, NULL);
1767   }
1768 }
1769
1770 static void object_simplify_update(Object *ob)
1771 {
1772   ModifierData *md;
1773   ParticleSystem *psys;
1774
1775   if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
1776     return;
1777   }
1778
1779   ob->id.tag &= ~LIB_TAG_DOIT;
1780
1781   for (md = ob->modifiers.first; md; md = md->next) {
1782     if (ELEM(md->type,
1783              eModifierType_Subsurf,
1784              eModifierType_Multires,
1785              eModifierType_ParticleSystem)) {
1786       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1787     }
1788   }
1789
1790   for (psys = ob->particlesystem.first; psys; psys = psys->next) {
1791     psys->recalc |= ID_RECALC_PSYS_CHILD;
1792   }
1793
1794   if (ob->instance_collection) {
1795     CollectionObject *cob;
1796
1797     for (cob = ob->instance_collection->gobject.first; cob; cob = cob->next) {
1798       object_simplify_update(cob->ob);
1799     }
1800   }
1801 }
1802
1803 static void rna_Scene_use_simplify_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1804 {
1805   Scene *sce = ptr->id.data;
1806   Scene *sce_iter;
1807   Base *base;
1808
1809   BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
1810   FOREACH_SCENE_OBJECT_BEGIN (sce, ob) {
1811     object_simplify_update(ob);
1812   }
1813   FOREACH_SCENE_OBJECT_END;
1814
1815   for (SETLOOPER_SET_ONLY(sce, sce_iter, base)) {
1816     object_simplify_update(base->object);
1817   }
1818
1819   WM_main_add_notifier(NC_GEOM | ND_DATA, NULL);
1820   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
1821   DEG_id_tag_update(&sce->id, 0);
1822 }
1823
1824 static void rna_Scene_simplify_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1825 {
1826   Scene *sce = ptr->id.data;
1827
1828   if (sce->r.mode & R_SIMPLIFY) {
1829     rna_Scene_use_simplify_update(bmain, scene, ptr);
1830   }
1831 }
1832
1833 static void rna_Scene_use_persistent_data_update(Main *UNUSED(bmain),
1834                                                  Scene *UNUSED(scene),
1835                                                  PointerRNA *ptr)
1836 {
1837   Scene *sce = ptr->id.data;
1838
1839   if (!(sce->r.mode & R_PERSISTENT_DATA)) {
1840     RE_FreePersistentData();
1841   }
1842 }
1843
1844 /* Scene.transform_orientation_slots */
1845 static void rna_Scene_transform_orientation_slots_begin(CollectionPropertyIterator *iter,
1846                                                         PointerRNA *ptr)
1847 {
1848   Scene *scene = (Scene *)ptr->id.data;
1849   TransformOrientationSlot *orient_slot = &scene->orientation_slots[0];
1850   rna_iterator_array_begin(
1851       iter, orient_slot, sizeof(*orient_slot), ARRAY_SIZE(scene->orientation_slots), 0, NULL);
1852 }
1853
1854 static int rna_Scene_transform_orientation_slots_length(PointerRNA *ptr)
1855 {
1856   Scene *scene = (Scene *)ptr->id.data;
1857   return ARRAY_SIZE(scene->orientation_slots);
1858 }
1859
1860 static bool rna_Scene_use_audio_get(PointerRNA *ptr)
1861 {
1862   Scene *scene = (Scene *)ptr->data;
1863   return (scene->audio.flag & AUDIO_MUTE) != 0;
1864 }
1865
1866 static void rna_Scene_use_audio_set(PointerRNA *ptr, bool value)
1867 {
1868   Scene *scene = (Scene *)ptr->data;
1869
1870   if (value) {
1871     scene->audio.flag |= AUDIO_MUTE;
1872   }
1873   else {
1874     scene->audio.flag &= ~AUDIO_MUTE;
1875   }
1876 }
1877
1878 static void rna_Scene_use_audio_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
1879 {
1880   DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO_MUTE);
1881 }
1882
1883 static int rna_Scene_sync_mode_get(PointerRNA *ptr)
1884 {
1885   Scene *scene = (Scene *)ptr->data;
1886   if (scene->audio.flag & AUDIO_SYNC) {
1887     return AUDIO_SYNC;
1888   }
1889   return scene->flag & SCE_FRAME_DROP;
1890 }
1891
1892 static void rna_Scene_sync_mode_set(PointerRNA *ptr, int value)
1893 {
1894   Scene *scene = (Scene *)ptr->data;
1895
1896   if (value == AUDIO_SYNC) {
1897     scene->audio.flag |= AUDIO_SYNC;
1898   }
1899   else if (value == SCE_FRAME_DROP) {
1900     scene->audio.flag &= ~AUDIO_SYNC;
1901     scene->flag |= SCE_FRAME_DROP;
1902   }
1903   else {
1904     scene->audio.flag &= ~AUDIO_SYNC;
1905     scene->flag &= ~SCE_FRAME_DROP;
1906   }
1907 }
1908
1909 static void rna_View3DCursor_rotation_mode_set(PointerRNA *ptr, int value)
1910 {
1911   View3DCursor *cursor = ptr->data;
1912
1913   /* use API Method for conversions... */
1914   BKE_rotMode_change_values(cursor->rotation_quaternion,
1915                             cursor->rotation_euler,
1916                             cursor->rotation_axis,
1917                             &cursor->rotation_angle,
1918                             cursor->rotation_mode,
1919                             (short)value);
1920
1921   /* finally, set the new rotation type */
1922   cursor->rotation_mode = value;
1923 }
1924
1925 static void rna_View3DCursor_rotation_axis_angle_get(PointerRNA *ptr, float *value)
1926 {
1927   View3DCursor *cursor = ptr->data;
1928   value[0] = cursor->rotation_angle;
1929   copy_v3_v3(&value[1], cursor->rotation_axis);
1930 }
1931
1932 static void rna_View3DCursor_rotation_axis_angle_set(PointerRNA *ptr, const float *value)
1933 {
1934   View3DCursor *cursor = ptr->data;
1935   cursor->rotation_angle = value[0];
1936   copy_v3_v3(cursor->rotation_axis, &value[1]);
1937 }
1938
1939 static void rna_View3DCursor_matrix_get(PointerRNA *ptr, float *values)
1940 {
1941   const View3DCursor *cursor = ptr->data;
1942   BKE_scene_cursor_to_mat4(cursor, (float(*)[4])values);
1943 }
1944
1945 static void rna_View3DCursor_matrix_set(PointerRNA *ptr, const float *values)
1946 {
1947   View3DCursor *cursor = ptr->data;
1948   float unit_mat[4][4];
1949   normalize_m4_m4(unit_mat, (const float(*)[4])values);
1950   BKE_scene_cursor_from_mat4(cursor, unit_mat, false);
1951 }
1952
1953 static char *rna_View3DCursor_path(PointerRNA *UNUSED(ptr))
1954 {
1955   return BLI_strdup("cursor");
1956 }
1957
1958 static TimeMarker *rna_TimeLine_add(Scene *scene, const char name[], int frame)
1959 {
1960   TimeMarker *marker = MEM_callocN(sizeof(TimeMarker), "TimeMarker");
1961   marker->flag = SELECT;
1962   marker->frame = frame;
1963   BLI_strncpy_utf8(marker->name, name, sizeof(marker->name));
1964   BLI_addtail(&scene->markers, marker);
1965
1966   WM_main_add_notifier(NC_SCENE | ND_MARKERS, NULL);
1967   WM_main_add_notifier(NC_ANIMATION | ND_MARKERS, NULL);
1968
1969   return marker;
1970 }
1971
1972 static void rna_TimeLine_remove(Scene *scene, ReportList *reports, PointerRNA *marker_ptr)
1973 {
1974   TimeMarker *marker = marker_ptr->data;
1975   if (BLI_remlink_safe(&scene->markers, marker) == false) {
1976     BKE_reportf(reports,
1977                 RPT_ERROR,
1978                 "Timeline marker '%s' not found in scene '%s'",
1979                 marker->name,
1980                 scene->id.name + 2);
1981     return;
1982   }
1983
1984   MEM_freeN(marker);
1985   RNA_POINTER_INVALIDATE(marker_ptr);
1986
1987   WM_main_add_notifier(NC_SCENE | ND_MARKERS, NULL);
1988   WM_main_add_notifier(NC_ANIMATION | ND_MARKERS, NULL);
1989 }
1990
1991 static void rna_TimeLine_clear(Scene *scene)
1992 {
1993   BLI_freelistN(&scene->markers);
1994
1995   WM_main_add_notifier(NC_SCENE | ND_MARKERS, NULL);
1996   WM_main_add_notifier(NC_ANIMATION | ND_MARKERS, NULL);
1997 }
1998
1999 static KeyingSet *rna_Scene_keying_set_new(Scene *sce,
2000                                            ReportList *reports,
2001                                            const char idname[],
2002                                            const char name[])
2003 {
2004   KeyingSet *ks = NULL;
2005
2006   /* call the API func, and set the active keyingset index */
2007   ks = BKE_keyingset_add(&sce->keyingsets, idname, name, KEYINGSET_ABSOLUTE, 0);
2008
2009   if (ks) {
2010     sce->active_keyingset = BLI_listbase_count(&sce->keyingsets);
2011     return ks;
2012   }
2013   else {
2014     BKE_report(reports, RPT_ERROR, "Keying set could not be added");
2015     return NULL;
2016   }
2017 }
2018
2019 static void rna_UnifiedPaintSettings_update(bContext *C, PointerRNA *UNUSED(ptr))
2020 {
2021   Scene *scene = CTX_data_scene(C);
2022   ViewLayer *view_layer = CTX_data_view_layer(C);
2023   Brush *br = BKE_paint_brush(BKE_paint_get_active(scene, view_layer));
2024   WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
2025 }
2026
2027 static void rna_UnifiedPaintSettings_size_set(PointerRNA *ptr, int value)
2028 {
2029   UnifiedPaintSettings *ups = ptr->data;
2030
2031   /* scale unprojected radius so it stays consistent with brush size */
2032   BKE_brush_scale_unprojected_radius(&ups->unprojected_radius, value, ups->size);
2033   ups->size = value;
2034 }
2035
2036 static void rna_UnifiedPaintSettings_unprojected_radius_set(PointerRNA *ptr, float value)
2037 {
2038   UnifiedPaintSettings *ups = ptr->data;
2039
2040   /* scale brush size so it stays consistent with unprojected_radius */
2041   BKE_brush_scale_size(&ups->size, value, ups->unprojected_radius);
2042   ups->unprojected_radius = value;
2043 }
2044
2045 static void rna_UnifiedPaintSettings_radius_update(bContext *C, PointerRNA *ptr)
2046 {
2047   /* changing the unified size should invalidate the overlay but also update the brush */
2048   BKE_paint_invalidate_overlay_all();
2049   rna_UnifiedPaintSettings_update(C, ptr);
2050 }
2051
2052 static char *rna_UnifiedPaintSettings_path(PointerRNA *UNUSED(ptr))
2053 {
2054   return BLI_strdup("tool_settings.unified_paint_settings");
2055 }
2056
2057 static char *rna_CurvePaintSettings_path(PointerRNA *UNUSED(ptr))
2058 {
2059   return BLI_strdup("tool_settings.curve_paint_settings");
2060 }
2061
2062 /* generic function to recalc geometry */
2063 static void rna_EditMesh_update(bContext *C, PointerRNA *UNUSED(ptr))
2064 {
2065   ViewLayer *view_layer = CTX_data_view_layer(C);
2066   Mesh *me = NULL;
2067
2068   if (view_layer->basact) {
2069     me = BKE_mesh_from_object(view_layer->basact->object);
2070     if (me && me->edit_mesh == NULL) {
2071       me = NULL;
2072     }
2073   }
2074
2075   if (me) {
2076     DEG_id_tag_update(&me->id, ID_RECALC_GEOMETRY);
2077     WM_main_add_notifier(NC_GEOM | ND_DATA, me);
2078   }
2079 }
2080
2081 static char *rna_MeshStatVis_path(PointerRNA *UNUSED(ptr))
2082 {
2083   return BLI_strdup("tool_settings.statvis");
2084 }
2085
2086 /* note: without this, when Multi-Paint is activated/deactivated, the colors
2087  * will not change right away when multiple bones are selected, this function
2088  * is not for general use and only for the few cases where changing scene
2089  * settings and NOT for general purpose updates, possibly this should be
2090  * given its own notifier. */
2091 static void rna_Scene_update_active_object_data(bContext *C, PointerRNA *UNUSED(ptr))
2092 {
2093   ViewLayer *view_layer = CTX_data_view_layer(C);
2094   Object *ob = OBACT(view_layer);
2095
2096   if (ob) {
2097     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
2098     WM_main_add_notifier(NC_OBJECT | ND_DRAW, &ob->id);
2099   }
2100 }
2101
2102 static void rna_SceneCamera_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2103 {
2104   Scene *scene = (Scene *)ptr->id.data;
2105   Object *camera = scene->camera;
2106
2107   BKE_sequence_invalidate_scene_strips(bmain, scene);
2108
2109   if (camera && (camera->type == OB_CAMERA)) {
2110     DEG_id_tag_update(&camera->id, ID_RECALC_GEOMETRY);
2111   }
2112 }
2113
2114 static void rna_SceneSequencer_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
2115 {
2116   BKE_sequencer_cache_cleanup(scene);
2117 }
2118
2119 static char *rna_ToolSettings_path(PointerRNA *UNUSED(ptr))
2120 {
2121   return BLI_strdup("tool_settings");
2122 }
2123
2124 PointerRNA rna_FreestyleLineSet_linestyle_get(PointerRNA *ptr)
2125 {
2126   FreestyleLineSet *lineset = (FreestyleLineSet *)ptr->data;
2127
2128   return rna_pointer_inherit_refine(ptr, &RNA_FreestyleLineStyle, lineset->linestyle);
2129 }
2130
2131 void rna_FreestyleLineSet_linestyle_set(PointerRNA *ptr,
2132                                         PointerRNA value,
2133                                         struct ReportList *UNUSED(reports))
2134 {
2135   FreestyleLineSet *lineset = (FreestyleLineSet *)ptr->data;
2136
2137   if (lineset->linestyle) {
2138     id_us_min(&lineset->linestyle->id);
2139   }
2140   lineset->linestyle = (FreestyleLineStyle *)value.data;
2141   id_us_plus(&lineset->linestyle->id);
2142 }
2143
2144 FreestyleLineSet *rna_FreestyleSettings_lineset_add(ID *id,
2145                                                     FreestyleSettings *config,
2146                                                     Main *bmain,
2147                                                     const char *name)
2148 {
2149   Scene *scene = (Scene *)id;
2150   FreestyleLineSet *lineset = BKE_freestyle_lineset_add(bmain, (FreestyleConfig *)config, name);
2151
2152   DEG_id_tag_update(&scene->id, 0);
2153   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
2154
2155   return lineset;
2156 }
2157
2158 void rna_FreestyleSettings_lineset_remove(ID *id,
2159                                           FreestyleSettings *config,
2160                                           ReportList *reports,
2161                                           PointerRNA *lineset_ptr)
2162 {
2163   FreestyleLineSet *lineset = lineset_ptr->data;
2164   Scene *scene = (Scene *)id;
2165
2166   if (!BKE_freestyle_lineset_delete((FreestyleConfig *)config, lineset)) {
2167     BKE_reportf(reports, RPT_ERROR, "Line set '%s' could not be removed", lineset->name);
2168     return;
2169   }
2170
2171   RNA_POINTER_INVALIDATE(lineset_ptr);
2172
2173   DEG_id_tag_update(&scene->id, 0);
2174   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
2175 }
2176
2177 PointerRNA rna_FreestyleSettings_active_lineset_get(PointerRNA *ptr)
2178 {
2179   FreestyleConfig *config = (FreestyleConfig *)ptr->data;
2180   FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(config);
2181   return rna_pointer_inherit_refine(ptr, &RNA_FreestyleLineSet, lineset);
2182 }
2183
2184 void rna_FreestyleSettings_active_lineset_index_range(
2185     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
2186 {
2187   FreestyleConfig *config = (FreestyleConfig *)ptr->data;
2188
2189   *min = 0;
2190   *max = max_ii(0, BLI_listbase_count(&config->linesets) - 1);
2191 }
2192
2193 int rna_FreestyleSettings_active_lineset_index_get(PointerRNA *ptr)
2194 {
2195   FreestyleConfig *config = (FreestyleConfig *)ptr->data;
2196   return BKE_freestyle_lineset_get_active_index(config);
2197 }
2198
2199 void rna_FreestyleSettings_active_lineset_index_set(PointerRNA *ptr, int value)
2200 {
2201   FreestyleConfig *config = (FreestyleConfig *)ptr->data;
2202   BKE_freestyle_lineset_set_active_index(config, value);
2203 }
2204
2205 FreestyleModuleConfig *rna_FreestyleSettings_module_add(ID *id, FreestyleSettings *config)
2206 {
2207   Scene *scene = (Scene *)id;
2208   FreestyleModuleConfig *module = BKE_freestyle_module_add((FreestyleConfig *)config);
2209
2210   DEG_id_tag_update(&scene->id, 0);
2211   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
2212
2213   return module;
2214 }
2215
2216 void rna_FreestyleSettings_module_remove(ID *id,
2217                                          FreestyleSettings *config,
2218                                          ReportList *reports,
2219                                          PointerRNA *module_ptr)
2220 {
2221   Scene *scene = (Scene *)id;
2222   FreestyleModuleConfig *module = module_ptr->data;
2223
2224   if (!BKE_freestyle_module_delete((FreestyleConfig *)config, module)) {
2225     if (module->script) {
2226       BKE_reportf(reports,
2227                   RPT_ERROR,
2228                   "Style module '%s' could not be removed",
2229                   module->script->id.name + 2);
2230     }
2231     else {
2232       BKE_report(reports, RPT_ERROR, "Style module could not be removed");
2233     }
2234     return;
2235   }
2236
2237   RNA_POINTER_INVALIDATE(module_ptr);
2238
2239   DEG_id_tag_update(&scene->id, 0);
2240   WM_main_add_notifier(NC_SCENE | ND_RENDER_OPTIONS, NULL);
2241 }
2242
2243 static void rna_Stereo3dFormat_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2244 {
2245   ID *id = ptr->id.data;
2246
2247   if (id && GS(id->name) == ID_IM) {
2248     Image *ima = (Image *)id;
2249     ImBuf *ibuf;
2250     void *lock;
2251
2252     if (!BKE_image_is_stereo(ima)) {
2253       return;
2254     }
2255
2256     ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
2257
2258     if (ibuf) {
2259       BKE_image_signal(bmain, ima, NULL, IMA_SIGNAL_FREE);
2260     }
2261     BKE_image_release_ibuf(ima, ibuf, lock);
2262   }
2263 }
2264
2265 static ViewLayer *rna_ViewLayer_new(ID *id, Scene *UNUSED(sce), Main *bmain, const char *name)
2266 {
2267   Scene *scene = (Scene *)id;
2268   ViewLayer *view_layer = BKE_view_layer_add(scene, name);
2269
2270   DEG_id_tag_update(&scene->id, 0);
2271   DEG_relations_tag_update(bmain);
2272   WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
2273
2274   return view_layer;
2275 }
2276
2277 static void rna_ViewLayer_remove(
2278     ID *id, Scene *UNUSED(sce), Main *bmain, ReportList *reports, PointerRNA *sl_ptr)
2279 {
2280   Scene *scene = (Scene *)id;
2281   ViewLayer *view_layer = sl_ptr->data;
2282
2283   if (ED_scene_view_layer_delete(bmain, scene, view_layer, reports)) {
2284     RNA_POINTER_INVALIDATE(sl_ptr);
2285   }
2286 }
2287
2288 /* Fake value, used internally (not saved to DNA). */
2289 #  define V3D_ORIENT_DEFAULT -1
2290
2291 static int rna_TransformOrientationSlot_type_get(PointerRNA *ptr)
2292 {
2293   Scene *scene = ptr->id.data;
2294   TransformOrientationSlot *orient_slot = ptr->data;
2295   if (orient_slot != &scene->orientation_slots[SCE_ORIENT_DEFAULT]) {
2296     if ((orient_slot->flag & SELECT) == 0) {
2297       return V3D_ORIENT_DEFAULT;
2298     }
2299   }
2300   return BKE_scene_orientation_slot_get_index(orient_slot);
2301 }
2302
2303 void rna_TransformOrientationSlot_type_set(PointerRNA *ptr, int value)
2304 {
2305   Scene *scene = ptr->id.data;
2306   TransformOrientationSlot *orient_slot = ptr->data;
2307
2308   if (orient_slot != &scene->orientation_slots[SCE_ORIENT_DEFAULT]) {
2309     if (value == V3D_ORIENT_DEFAULT) {
2310       orient_slot->flag &= ~SELECT;
2311       return;
2312     }
2313     else {
2314       orient_slot->flag |= SELECT;
2315     }
2316   }
2317
2318   BKE_scene_orientation_slot_set_index(orient_slot, value);
2319 }
2320
2321 static PointerRNA rna_TransformOrientationSlot_get(PointerRNA *ptr)
2322 {
2323   Scene *scene = ptr->id.data;
2324   TransformOrientationSlot *orient_slot = ptr->data;
2325   TransformOrientation *orientation;
2326   if (orient_slot->type < V3D_ORIENT_CUSTOM) {
2327     orientation = NULL;
2328   }
2329   else {
2330     orientation = BKE_scene_transform_orientation_find(scene, orient_slot->index_custom);
2331   }
2332   return rna_pointer_inherit_refine(ptr, &RNA_TransformOrientation, orientation);
2333 }
2334
2335 static const EnumPropertyItem *rna_TransformOrientation_impl_itemf(Scene *scene,
2336                                                                    const bool include_default,
2337                                                                    bool *r_free)
2338 {
2339   EnumPropertyItem tmp = {0, "", 0, "", ""};
2340   EnumPropertyItem *item = NULL;
2341   int i = V3D_ORIENT_CUSTOM, totitem = 0;
2342
2343   if (include_default) {
2344     tmp.identifier = "DEFAULT";
2345     tmp.name = "Default";
2346     tmp.description = "Use the scene orientation";
2347     tmp.value = V3D_ORIENT_DEFAULT;
2348     tmp.icon = ICON_OBJECT_ORIGIN;
2349     RNA_enum_item_add(&item, &totitem, &tmp);
2350     tmp.icon = 0;
2351
2352     RNA_enum_item_add_separator(&item, &totitem);
2353   }
2354
2355   RNA_enum_items_add(&item, &totitem, rna_enum_transform_orientation_items);
2356
2357   const ListBase *transform_orientations = scene ? &scene->transform_spaces : NULL;
2358
2359   if (transform_orientations && (BLI_listbase_is_empty(transform_orientations) == false)) {
2360     RNA_enum_item_add_separator(&item, &totitem);
2361
2362     for (TransformOrientation *ts = transform_orientations->first; ts; ts = ts->next) {
2363       tmp.identifier = ts->name;
2364       tmp.name = ts->name;
2365       tmp.value = i++;
2366       RNA_enum_item_add(&item, &totitem, &tmp);
2367     }
2368   }
2369
2370   RNA_enum_item_end(&item, &totitem);
2371   *r_free = true;
2372
2373   return item;
2374 }
2375 const EnumPropertyItem *rna_TransformOrientation_itemf(bContext *C,
2376                                                        PointerRNA *ptr,
2377                                                        PropertyRNA *UNUSED(prop),
2378                                                        bool *r_free)
2379 {
2380   Scene *scene;
2381   if (ptr->id.data && (GS(((ID *)ptr->id.data)->name) == ID_SCE)) {
2382     scene = ptr->id.data;
2383   }
2384   else {
2385     scene = CTX_data_scene(C);
2386   }
2387   return rna_TransformOrientation_impl_itemf(scene, false, r_free);
2388 }
2389
2390 const EnumPropertyItem *rna_TransformOrientation_with_scene_itemf(bContext *UNUSED(C),
2391                                                                   PointerRNA *ptr,
2392                                                                   PropertyRNA *UNUSED(prop),
2393                                                                   bool *r_free)
2394 {
2395   Scene *scene = ptr->id.data;
2396   TransformOrientationSlot *orient_slot = ptr->data;
2397   bool include_default = (orient_slot != &scene->orientation_slots[SCE_ORIENT_DEFAULT]);
2398   return rna_TransformOrientation_impl_itemf(scene, include_default, r_free);
2399 }
2400
2401 #  undef V3D_ORIENT_DEFAULT
2402
2403 static const EnumPropertyItem *rna_UnitSettings_itemf_wrapper(const int system,
2404                                                               const int type,
2405                                                               bool *r_free)
2406 {
2407   const void *usys;
2408   int len;
2409   bUnit_GetSystem(system, type, &usys, &len);
2410
2411   EnumPropertyItem *items = NULL;
2412   int totitem = 0;
2413
2414   EnumPropertyItem adaptive = {0};
2415   adaptive.identifier = "ADAPTIVE";
2416   adaptive.name = "Adaptive";
2417   adaptive.value = USER_UNIT_ADAPTIVE;
2418   RNA_enum_item_add(&items, &totitem, &adaptive);
2419
2420   for (int i = 0; i < len; i++) {
2421     if (!bUnit_IsSuppressed(usys, i)) {
2422       EnumPropertyItem tmp = {0};
2423       tmp.identifier = bUnit_GetIdentifier(usys, i);
2424       tmp.name = bUnit_GetNameDisplay(usys, i);
2425       tmp.value = i;
2426       RNA_enum_item_add(&items, &totitem, &tmp);
2427     }
2428   }
2429
2430   *r_free = true;
2431   return items;
2432 }
2433
2434 const EnumPropertyItem *rna_UnitSettings_length_unit_itemf(bContext *UNUSED(C),
2435                                                            PointerRNA *ptr,
2436                                                            PropertyRNA *UNUSED(prop),
2437                                                            bool *r_free)
2438 {
2439   UnitSettings *units = ptr->data;
2440   return rna_UnitSettings_itemf_wrapper(units->system, B_UNIT_LENGTH, r_free);
2441 }
2442
2443 const EnumPropertyItem *rna_UnitSettings_mass_unit_itemf(bContext *UNUSED(C),
2444                                                          PointerRNA *ptr,
2445                                                          PropertyRNA *UNUSED(prop),
2446                                                          bool *r_free)
2447 {
2448   UnitSettings *units = ptr->data;
2449   return rna_UnitSettings_itemf_wrapper(units->system, B_UNIT_MASS, r_free);
2450 }
2451
2452 const EnumPropertyItem *rna_UnitSettings_time_unit_itemf(bContext *UNUSED(C),
2453                                                          PointerRNA *ptr,
2454                                                          PropertyRNA *UNUSED(prop),
2455                                                          bool *r_free)
2456 {
2457   UnitSettings *units = ptr->data;
2458   return rna_UnitSettings_itemf_wrapper(units->system, B_UNIT_TIME, r_free);
2459 }
2460
2461 static void rna_UnitSettings_system_update(Main *UNUSED(bmain),
2462                                            Scene *scene,
2463                                            PointerRNA *UNUSED(ptr))
2464 {
2465   UnitSettings *unit = &scene->unit;
2466   if (unit->system == USER_UNIT_NONE) {
2467     unit->length_unit = USER_UNIT_ADAPTIVE;
2468     unit->mass_unit = USER_UNIT_ADAPTIVE;
2469   }
2470   else {
2471     unit->length_unit = bUnit_GetBaseUnitOfType(unit->system, B_UNIT_LENGTH);
2472     unit->mass_unit = bUnit_GetBaseUnitOfType(unit->system, B_UNIT_MASS);
2473   }
2474 }
2475
2476 static char *rna_UnitSettings_path(PointerRNA *UNUSED(ptr))
2477 {
2478   return BLI_strdup("unit_settings");
2479 }
2480
2481 #else
2482
2483 /* Grease Pencil Interpolation tool settings */
2484 static void rna_def_gpencil_interpolate(BlenderRNA *brna)
2485 {
2486   StructRNA *srna;
2487   PropertyRNA *prop;
2488
2489   srna = RNA_def_struct(brna, "GPencilInterpolateSettings", NULL);
2490   RNA_def_struct_sdna(srna, "GP_Interpolate_Settings");
2491   RNA_def_struct_path_func(srna, "rna_GPencilInterpolateSettings_path");
2492   RNA_def_struct_ui_text(srna,
2493                          "Grease Pencil Interpolate Settings",
2494                          "Settings for Grease Pencil interpolation tools");
2495
2496   /* flags */
2497   prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
2498   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS);
2499   RNA_def_property_ui_text(
2500       prop, "Interpolate All Layers", "Interpolate all layers, not only active");
2501   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2502
2503   prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
2504   RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED);
2505   RNA_def_property_ui_text(prop,
2506                            "Interpolate Selected Strokes",
2507                            "Interpolate only selected strokes in the original frame");
2508   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2509
2510   /* interpolation type */
2511   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2512   RNA_def_property_enum_sdna(prop, NULL, "type");
2513   RNA_def_property_enum_items(prop, rna_enum_gpencil_interpolation_mode_items);
2514   RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilInterpolateSettings_type_set", NULL);
2515   RNA_def_property_ui_text(
2516       prop, "Type", "Interpolation method to use the next time 'Interpolate Sequence' is run");
2517   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2518
2519   /* easing */
2520   prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
2521   RNA_def_property_enum_sdna(prop, NULL, "easing");
2522   RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
2523   RNA_def_property_ui_text(
2524       prop,
2525       "Easing",
2526       "Which ends of the segment between the preceding and following grease pencil frames "
2527       "easing interpolation is applied to");
2528   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2529
2530   /* easing options */
2531   prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
2532   RNA_def_property_float_sdna(prop, NULL, "back");
2533   RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
2534   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2535
2536   prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
2537   RNA_def_property_float_sdna(prop, NULL, "amplitude");
2538   RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
2539   RNA_def_property_ui_text(
2540       prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
2541   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2542
2543   prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
2544   RNA_def_property_float_sdna(prop, NULL, "period");
2545   RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
2546   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2547
2548   /* custom curvemap */
2549   prop = RNA_def_property(srna, "interpolation_curve", PROP_POINTER, PROP_NONE);
2550   RNA_def_property_pointer_sdna(prop, NULL, "custom_ipo");
2551   RNA_def_property_struct_type(prop, "CurveMapping");
2552   RNA_def_property_ui_text(
2553       prop,
2554       "Interpolation Curve",
2555       "Custom curve to control 'sequence' interpolation between Grease Pencil frames");
2556   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2557 }
2558
2559 static void rna_def_transform_orientation(BlenderRNA *brna)
2560 {
2561   StructRNA *srna;
2562   PropertyRNA *prop;
2563
2564   srna = RNA_def_struct(brna, "TransformOrientation", NULL);
2565
2566   prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
2567   RNA_def_property_float_sdna(prop, NULL, "mat");
2568   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3);
2569   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
2570
2571   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2572   RNA_def_struct_name_property(srna, prop);
2573   RNA_def_property_ui_text(prop, "Name", "Name of the custom transform orientation");
2574   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
2575 }
2576
2577 static void rna_def_transform_orientation_slot(BlenderRNA *brna)
2578 {
2579   StructRNA *srna;
2580   PropertyRNA *prop;
2581
2582   srna = RNA_def_struct(brna, "TransformOrientationSlot", NULL);
2583   RNA_def_struct_sdna(srna, "TransformOrientationSlot");
2584   RNA_def_struct_ui_text(srna, "Orientation Slot", "");
2585
2586   /* Orientations */
2587   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2588   RNA_def_property_enum_items(prop, rna_enum_transform_orientation_items);
2589   RNA_def_property_enum_funcs(prop,
2590                               "rna_TransformOrientationSlot_type_get",
2591                               "rna_TransformOrientationSlot_type_set",
2592                               "rna_TransformOrientation_with_scene_itemf");
2593   RNA_def_property_ui_text(prop, "Orientation", "Transformation orientation");
2594   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
2595
2596   prop = RNA_def_property(srna, "custom_orientation", PROP_POINTER, PROP_NONE);
2597   RNA_def_property_struct_type(prop, "TransformOrientation");
2598   RNA_def_property_pointer_funcs(prop, "rna_TransformOrientationSlot_get", NULL, NULL, NULL);
2599   RNA_def_property_ui_text(prop, "Current Transform Orientation", "");
2600
2601   /* flag */
2602   prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
2603   RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
2604   RNA_def_property_ui_text(prop, "Use", "Use scene orientation instead of a custom setting");
2605   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2606 }
2607
2608 static void rna_def_view3d_cursor(BlenderRNA *brna)
2609 {
2610   StructRNA *srna;
2611   PropertyRNA *prop;
2612
2613   srna = RNA_def_struct(brna, "View3DCursor", NULL);
2614   RNA_def_struct_sdna(srna, "View3DCursor");
2615   RNA_def_struct_path_func(srna, "rna_View3DCursor_path");
2616   RNA_def_struct_ui_text(srna, "3D Cursor", "");
2617
2618   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ_LENGTH);
2619   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2620   RNA_def_property_float_sdna(prop, NULL, "location");
2621   RNA_def_property_ui_text(prop, "Location", "");
2622   RNA_def_property_ui_range(prop, -10000.0, 10000.0, 10, 4);
2623   RNA_def_property_update(prop, NC_WINDOW, NULL);
2624
2625   prop = RNA_def_property(srna, "rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
2626   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2627   RNA_def_property_float_sdna(prop, NULL, "rotation_quaternion");
2628   RNA_def_property_float_array_default(prop, rna_default_quaternion);
2629   RNA_def_property_ui_text(
2630       prop, "Quaternion Rotation", "Rotation in quaternions (keep normalized)");
2631   RNA_def_property_update(prop, NC_WINDOW, NULL);
2632
2633   prop = RNA_def_property(srna, "rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
2634   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2635   RNA_def_property_array(prop, 4);
2636   RNA_def_property_float_funcs(prop,
2637                                "rna_View3DCursor_rotation_axis_angle_get",
2638                                "rna_View3DCursor_rotation_axis_angle_set",
2639                                NULL);
2640   RNA_def_property_float_array_default(prop, rna_default_axis_angle);
2641   RNA_def_property_ui_text(
2642       prop, "Axis-Angle Rotation", "Angle of Rotation for Axis-Angle rotation representation");
2643   RNA_def_property_update(prop, NC_WINDOW, NULL);
2644
2645   prop = RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
2646   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2647   RNA_def_property_float_sdna(prop, NULL, "rotation_euler");
2648   RNA_def_property_ui_text(prop, "Euler Rotation", "3D rotation");
2649   RNA_def_property_update(prop, NC_WINDOW, NULL);
2650
2651   prop = RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
2652   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2653   RNA_def_property_enum_sdna(prop, NULL, "rotation_mode");
2654   RNA_def_property_enum_items(prop, rna_enum_object_rotation_mode_items);
2655   RNA_def_property_enum_funcs(prop, NULL, "rna_View3DCursor_rotation_mode_set", NULL);
2656   RNA_def_property_ui_text(prop, "Rotation Mode", "");
2657   RNA_def_property_update(prop, NC_WINDOW, NULL);
2658
2659   /* Matrix access to avoid having to check current rotation mode. */
2660   prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
2661   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2662   RNA_def_property_flag(prop, PROP_THICK_WRAP); /* no reference to original data */
2663   RNA_def_property_ui_text(prop, "Transform Matrix", "Matrix combining loc/rot of the cursor");
2664   RNA_def_property_float_funcs(
2665       prop, "rna_View3DCursor_matrix_get", "rna_View3DCursor_matrix_set", NULL);
2666 }
2667
2668 static void rna_def_tool_settings(BlenderRNA *brna)
2669 {
2670   StructRNA *srna;
2671   PropertyRNA *prop;
2672
2673   /* the construction of this enum is quite special - everything is stored as bitflags,
2674    * with 1st position only for for on/off (and exposed as boolean), while others are mutually
2675    * exclusive options but which will only have any effect when autokey is enabled
2676    */
2677   static const EnumPropertyItem auto_key_items[] = {
2678       {AUTOKEY_MODE_NORMAL & ~AUTOKEY_ON, "ADD_REPLACE_KEYS", 0, "Add & Replace", ""},
2679       {AUTOKEY_MODE_EDITKEYS & ~AUTOKEY_ON, "REPLACE_KEYS", 0, "Replace", ""},
2680       {0, NULL, 0, NULL, NULL},
2681   };
2682
2683   static const EnumPropertyItem draw_groupuser_items[] = {
2684       {OB_DRAW_GROUPUSER_NONE, "NONE", 0, "None", ""},
2685       {OB_DRAW_GROUPUSER_ACTIVE,
2686        "ACTIVE",
2687        0,
2688        "Active",
2689        "Show vertices with no weights in the active group"},
2690       {OB_DRAW_GROUPUSER_ALL, "ALL", 0, "All", "Show vertices with no weights in any group"},
2691       {0, NULL, 0, NULL, NULL},
2692   };
2693
2694   static const EnumPropertyItem vertex_group_select_items[] = {
2695       {WT_VGROUP_ALL, "ALL", 0, "All", "All Vertex Groups"},
2696       {WT_VGROUP_BONE_DEFORM,
2697        "BONE_DEFORM",
2698        0,
2699        "Deform",
2700        "Vertex Groups assigned to Deform Bones"},
2701       {WT_VGROUP_BONE_DEFORM_OFF,
2702        "OTHER_DEFORM",
2703        0,
2704        "Other",
2705        "Vertex Groups assigned to non Deform Bones"},
2706       {0, NULL, 0, NULL, NULL},
2707   };
2708
2709   static const EnumPropertyItem gpencil_stroke_placement_items[] = {
2710       {GP_PROJECT_VIEWSPACE,
2711        "ORIGIN",
2712        ICON_OBJECT_ORIGIN,
2713        "Origin",
2714        "Draw stroke at Object origin"},
2715       {GP_PROJECT_VIEWSPACE | GP_PROJECT_CURSOR,
2716        "CURSOR",
2717        ICON_PIVOT_CURSOR,
2718        "3D Cursor",
2719        "Draw stroke at 3D cursor location"},
2720       {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_VIEW,
2721        "SURFACE",
2722        ICON_SNAP_FACE,
2723        "Surface",
2724        "Stick stroke to surfaces"},
2725       {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_STROKE,
2726        "STROKE",
2727        ICON_STROKE,
2728        "Stroke",
2729        "Stick stroke to other strokes"},
2730       {0, NULL, 0, NULL, NULL},
2731   };
2732
2733   static const EnumPropertyItem gpencil_stroke_snap_items[] = {
2734       {0, "NONE", 0, "All points", "Snap to all points"},
2735       {GP_PROJECT_DEPTH_STROKE_ENDPOINTS,
2736        "ENDS",
2737        0,
2738        "End points",
2739        "Snap to first and last points and interpolate"},
2740       {GP_PROJECT_DEPTH_STROKE_FIRST, "FIRST", 0, "First point", "Snap to first point"},
2741       {0, NULL, 0, NULL, NULL},
2742   };
2743
2744   static const EnumPropertyItem gpencil_selectmode_items[] = {
2745       {GP_SELECTMODE_POINT, "POINT", ICON_GP_SELECT_POINTS, "Point", "Select only points"},
2746       {GP_SELECTMODE_STROKE,
2747        "STROKE",
2748        ICON_GP_SELECT_STROKES,
2749        "Stroke",
2750        "Select all stroke points"},
2751       {GP_SELECTMODE_SEGMENT,
2752        "SEGMENT",
2753        ICON_GP_SELECT_BETWEEN_STROKES,
2754        "Segment",
2755        "Select all stroke points between other strokes"},
2756       {0, NULL, 0, NULL, NULL},
2757   };
2758
2759   static const EnumPropertyItem annotation_stroke_placement_items[] = {
2760       {GP_PROJECT_VIEWSPACE | GP_PROJECT_CURSOR,
2761        "CURSOR",
2762        ICON_PIVOT_CURSOR,
2763        "3D Cursor",
2764        "Draw stroke at 3D cursor location"},
2765       /* Weird, GP_PROJECT_VIEWALIGN is inverted. */
2766       {0, "VIEW", ICON_RESTRICT_VIEW_ON, "View", "Stick stroke to the view "},
2767       {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_VIEW,
2768        "SURFACE",
2769        ICON_FACESEL,
2770        "Surface",
2771        "Stick stroke to surfaces"},
2772       {0, NULL, 0, NULL, NULL},
2773   };
2774
2775   srna = RNA_def_struct(brna, "ToolSettings", NULL);
2776   RNA_def_struct_path_func(srna, "rna_ToolSettings_path");
2777   RNA_def_struct_ui_text(srna, "Tool Settings", "");
2778
2779   prop = RNA_def_property(srna, "sculpt", PROP_POINTER, PROP_NONE);
2780   RNA_def_property_struct_type(prop, "Sculpt");
2781   RNA_def_property_ui_text(prop, "Sculpt", "");
2782
2783   prop = RNA_def_property(srna, "use_auto_normalize", PROP_BOOLEAN, PROP_NONE);
2784   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2785   RNA_def_property_boolean_sdna(prop, NULL, "auto_normalize", 1);
2786   RNA_def_property_ui_text(prop,
2787                            "WPaint Auto-Normalize",
2788                            "Ensure all bone-deforming vertex groups add up "
2789                            "to 1.0 while weight painting");
2790   RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
2791
2792   prop = RNA_def_property(srna, "use_multipaint", PROP_BOOLEAN, PROP_NONE);
2793   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2794   RNA_def_property_boolean_sdna(prop, NULL, "multipaint", 1);
2795   RNA_def_property_ui_text(prop,
2796                            "WPaint Multi-Paint",
2797                            "Paint across the weights of all selected bones, "
2798                            "maintaining their relative influence");
2799   RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
2800
2801   prop = RNA_def_property(srna, "vertex_group_user", PROP_ENUM, PROP_NONE);
2802   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2803   RNA_def_property_enum_sdna(prop, NULL, "weightuser");
2804   RNA_def_property_enum_items(prop, draw_groupuser_items);
2805   RNA_def_property_ui_text(prop, "Mask Non-Group Vertices", "Display unweighted vertices");
2806   RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
2807
2808   prop = RNA_def_property(srna, "vertex_group_subset", PROP_ENUM, PROP_NONE);
2809   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2810   RNA_def_property_enum_sdna(prop, NULL, "vgroupsubset");
2811   RNA_def_property_enum_items(prop, vertex_group_select_items);
2812   RNA_def_property_ui_text(prop, "Subset", "Filter Vertex groups for Display");
2813   RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
2814
2815   prop = RNA_def_property(srna, "vertex_paint", PROP_POINTER, PROP_NONE);
2816   RNA_def_property_pointer_sdna(prop, NULL, "vpaint");
2817   RNA_def_property_ui_text(prop, "Vertex Paint", "");
2818
2819   prop = RNA_def_property(srna, "weight_paint", PROP_POINTER, PROP_NONE);
2820   RNA_def_property_pointer_sdna(prop, NULL, "wpaint");
2821   RNA_def_property_ui_text(prop, "Weight Paint", "");
2822
2823   prop = RNA_def_property(srna, "image_paint", PROP_POINTER, PROP_NONE);
2824   RNA_def_property_pointer_sdna(prop, NULL, "imapaint");
2825   RNA_def_property_ui_text(prop, "Image Paint", "");
2826
2827   prop = RNA_def_property(srna, "uv_sculpt", PROP_POINTER, PROP_NONE);
2828   RNA_def_property_pointer_sdna(prop, NULL, "uvsculpt");
2829   RNA_def_property_ui_text(prop, "UV Sculpt", "");
2830
2831   prop = RNA_def_property(srna, "gpencil_paint", PROP_POINTER, PROP_NONE);
2832   RNA_def_property_pointer_sdna(prop, NULL, "gp_paint");
2833   RNA_def_property_ui_text(prop, "Grease Pencil Paint", "");
2834
2835   prop = RNA_def_property(srna, "particle_edit", PROP_POINTER, PROP_NONE);
2836   RNA_def_property_pointer_sdna(prop, NULL, "particle");
2837   RNA_def_property_ui_text(prop, "Particle Edit", "");
2838
2839   prop = RNA_def_property(srna, "uv_sculpt_lock_borders", PROP_BOOLEAN, PROP_NONE);
2840   RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_LOCK_BORDERS);
2841   RNA_def_property_ui_text(prop, "Lock Borders", "Disable editing of boundary edges");
2842
2843   prop = RNA_def_property(srna, "uv_sculpt_all_islands", PROP_BOOLEAN, PROP_NONE);
2844   RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_ALL_ISLANDS);
2845   RNA_def_property_ui_text(prop, "Sculpt All Islands", "Brush operates on all islands");
2846
2847   prop = RNA_def_property(srna, "uv_relax_method", PROP_ENUM, PROP_NONE);
2848   RNA_def_property_enum_sdna(prop, NULL, "uv_relax_method");
2849   RNA_def_property_enum_items(prop, uv_sculpt_relaxation_items);
2850   RNA_def_property_ui_text(prop, "Relaxation Method", "Algorithm used for UV relaxation");
2851
2852   prop = RNA_def_property(srna, "lock_object_mode", PROP_BOOLEAN, PROP_NONE);
2853   RNA_def_property_boolean_sdna(prop, NULL, "object_flag", SCE_OBJECT_MODE_LOCK);
2854   RNA_def_property_ui_text(prop, "Lock Object Modes", "Restrict select to the current mode");
2855   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2856
2857   /* Transform */
2858   prop = RNA_def_property(srna, "use_proportional_edit", PROP_BOOLEAN, PROP_NONE);
2859   RNA_def_property_boolean_sdna(prop, NULL, "proportional_edit", PROP_EDIT_USE);
2860   RNA_def_property_ui_text(prop, "Proportional Editing", "Proportional edit mode");
2861   RNA_def_property_ui_icon(prop, ICON_PROP_ON, 0);
2862   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2863
2864   prop = RNA_def_property(srna, "use_proportional_edit_objects", PROP_BOOLEAN, PROP_NONE);
2865   RNA_def_property_boolean_sdna(prop, NULL, "proportional_objects", 0);
2866   RNA_def_property_ui_text(
2867       prop, "Proportional Editing Objects", "Proportional editing object mode");
2868   RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
2869   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2870
2871   prop = RNA_def_property(srna, "use_proportional_projected", PROP_BOOLEAN, PROP_NONE);
2872   RNA_def_property_boolean_sdna(prop, NULL, "proportional_edit", PROP_EDIT_PROJECTED);
2873   RNA_def_property_ui_text(
2874       prop, "Projected from View", "Proportional Editing using screen space locations");
2875   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2876
2877   prop = RNA_def_property(srna, "use_proportional_connected", PROP_BOOLEAN, PROP_NONE);
2878   RNA_def_property_boolean_sdna(prop, NULL, "proportional_edit", PROP_EDIT_CONNECTED);
2879   RNA_def_property_ui_text(
2880       prop, "Connected Only", "Proportional Editing using connected geometry only");
2881   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2882
2883   prop = RNA_def_property(srna, "use_proportional_edit_mask", PROP_BOOLEAN, PROP_NONE);
2884   RNA_def_property_boolean_sdna(prop, NULL, "proportional_mask", 0);
2885   RNA_def_property_ui_text(prop, "Proportional Editing Objects", "Proportional editing mask mode");
2886   RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
2887   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2888
2889   prop = RNA_def_property(srna, "use_proportional_action", PROP_BOOLEAN, PROP_NONE);
2890   RNA_def_property_boolean_sdna(prop, NULL, "proportional_action", 0);
2891   RNA_def_property_ui_text(
2892       prop, "Proportional Editing Actions", "Proportional editing in action editor");
2893   RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
2894   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2895
2896   prop = RNA_def_property(srna, "use_proportional_fcurve", PROP_BOOLEAN, PROP_NONE);
2897   RNA_def_property_boolean_sdna(prop, NULL, "proportional_fcurve", 0);
2898   RNA_def_property_ui_text(
2899       prop, "Proportional Editing FCurves", "Proportional editing in FCurve editor");
2900   RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
2901   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2902
2903   prop = RNA_def_property(srna, "lock_markers", PROP_BOOLEAN, PROP_NONE);
2904   RNA_def_property_boolean_sdna(prop, NULL, "lock_markers", 0);
2905   RNA_def_property_ui_text(prop, "Lock Markers", "Prevent marker editing");
2906
2907   prop = RNA_def_property(srna, "proportional_edit_falloff", PROP_ENUM, PROP_NONE);
2908   RNA_def_property_enum_sdna(prop, NULL, "prop_mode");
2909   RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_items);
2910   RNA_def_property_ui_text(
2911       prop, "Proportional Editing Falloff", "Falloff type for proportional editing mode");
2912   /* Abusing id_curve :/ */
2913   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE);
2914   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2915
2916   prop = RNA_def_property(srna, "proportional_size", PROP_FLOAT, PROP_DISTANCE);
2917   RNA_def_property_float_sdna(prop, NULL, "proportional_size");
2918   RNA_def_property_ui_text(
2919       prop, "Proportional Size", "Display size for proportional editing circle");
2920   RNA_def_property_range(prop, 0.00001, 5000.0);
2921
2922   prop = RNA_def_property(srna, "double_threshold", PROP_FLOAT, PROP_DISTANCE);
2923   RNA_def_property_float_sdna(prop, NULL, "doublimit");
2924   RNA_def_property_ui_text(prop, "Merge Threshold", "Threshold distance for Auto Merge");
2925   RNA_def_property_range(prop, 0.0, 1.0);
2926   RNA_def_property_ui_range(prop, 0.0, 0.1, 0.01, 6);
2927
2928   /* Pivot Point */
2929   prop = RNA_def_property(srna, "transform_pivot_point", PROP_ENUM, PROP_NONE);
2930   RNA_def_property_enum_sdna(prop, NULL, "transform_pivot_point");
2931   RNA_def_property_enum_items(prop, rna_enum_transform_pivot_items_full);
2932   RNA_def_property_ui_text(prop, "Pivot Point", "Pivot center for rotation/scaling");
2933   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
2934
2935   prop = RNA_def_property(srna, "use_transform_pivot_point_align", PROP_BOOLEAN, PROP_NONE);
2936   RNA_def_property_boolean_sdna(prop, NULL, "transform_flag", SCE_XFORM_AXIS_ALIGN);
2937   RNA_def_property_ui_text(
2938       prop, "Only Origins", "Manipulate origins (object, pose and weight paint mode only)");
2939   RNA_def_property_ui_icon(prop, ICON_CENTER_ONLY, 0);
2940   RNA_def_property_update(prop, NC_SCENE, NULL);
2941
2942   prop = RNA_def_property(srna, "use_mesh_automerge", PROP_BOOLEAN, PROP_NONE);
2943   RNA_def_property_boolean_sdna(prop, NULL, "automerge", 0);
2944   RNA_def_property_ui_text(
2945       prop, "Auto Merge", "Automatically merge vertices moved to the same location");
2946   RNA_def_property_ui_icon(prop, ICON_AUTOMERGE_OFF, 1);
2947   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2948
2949   prop = RNA_def_property(srna, "use_snap", PROP_BOOLEAN, PROP_NONE);
2950   RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP);
2951   RNA_def_property_ui_text(prop, "Snap", "Snap during transform");
2952   RNA_def_property_ui_icon(prop, ICON_SNAP_OFF, 1);
2953   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2954
2955   prop = RNA_def_property(srna, "use_snap_align_rotation", PROP_BOOLEAN, PROP_NONE);
2956   RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ROTATE);
2957   RNA_def_property_ui_text(
2958       prop, "Align Rotation to Target", "Align rotation with the snapping target");
2959   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2960
2961   prop = RNA_def_property(srna, "use_snap_grid_absolute", PROP_BOOLEAN, PROP_NONE);
2962   RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ABS_GRID);
2963   RNA_def_property_ui_text(
2964       prop,
2965       "Absolute Grid Snap",
2966       "Absolute grid alignment while translating (based on the pivot center)");
2967   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2968
2969   prop = RNA_def_property(srna, "snap_elements", PROP_ENUM, PROP_NONE);
2970   RNA_def_property_enum_bitflag_sdna(prop, NULL, "snap_mode");
2971   RNA_def_property_enum_items(prop, rna_enum_snap_element_items);
2972   RNA_def_property_enum_funcs(prop, NULL, "rna_ToolSettings_snap_mode_set", NULL);
2973   RNA_def_property_flag(prop, PROP_ENUM_FLAG);
2974   RNA_def_property_ui_text(prop, "Snap Element", "Type of element to snap to");
2975   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2976
2977   /* node editor uses own set of snap modes */
2978   prop = RNA_def_property(srna, "snap_node_element", PROP_ENUM, PROP_NONE);
2979   RNA_def_property_enum_bitflag_sdna(prop, NULL, "snap_node_mode");
2980   RNA_def_property_enum_items(prop, rna_enum_snap_node_element_items);
2981   RNA_def_property_ui_text(prop, "Snap Node Element", "Type of element to snap to");
2982   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2983
2984   /* image editor uses own set of snap modes */
2985   prop = RNA_def_property(srna, "snap_uv_element", PROP_ENUM, PROP_NONE);
2986   RNA_def_property_enum_bitflag_sdna(prop, NULL, "snap_uv_mode");
2987   RNA_def_property_enum_items(prop, snap_uv_element_items);
2988   RNA_def_property_ui_text(prop, "Snap UV Element", "Type of element to snap to");
2989   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2990
2991   prop = RNA_def_property(srna, "snap_target", PROP_ENUM, PROP_NONE);
2992   RNA_def_property_enum_sdna(prop, NULL, "snap_target");
2993   RNA_def_property_enum_items(prop, rna_enum_snap_target_items);
2994   RNA_def_property_ui_text(prop, "Snap Target", "Which part to snap onto the target");
2995   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
2996
2997   prop = RNA_def_property(srna, "use_snap_peel_object", PROP_BOOLEAN, PROP_NONE);
2998   RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_PEEL_OBJECT);
2999   RNA_def_property_ui_text(
3000       prop, "Snap Peel Object", "Consider objects as whole when finding volume center");
3001   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3002
3003   prop = RNA_def_property(srna, "use_snap_project", PROP_BOOLEAN, PROP_NONE);
3004   RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_PROJECT);
3005   RNA_def_property_ui_text(prop,
3006                            "Project Individual Elements",
3007                            "Project individual elements on the surface of other objects");
3008   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3009
3010   prop = RNA_def_property(srna, "use_snap_self", PROP_BOOLEAN, PROP_NONE);
3011   RNA_def_property_boolean_negative_sdna(prop, NULL, "snap_flag", SCE_SNAP_NO_SELF);
3012   RNA_def_property_ui_text(prop, "Project onto Self", "Snap onto itself (Edit Mode Only)");
3013   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3014
3015   prop = RNA_def_property(srna, "use_snap_translate", PROP_BOOLEAN, PROP_NONE);
3016   RNA_def_property_boolean_sdna(
3017       prop, NULL, "snap_transform_mode_flag", SCE_SNAP_TRANSFORM_MODE_TRANSLATE);
3018   RNA_def_property_ui_text(
3019       prop, "Use Snap for Translation", "Move is affected by snapping settings");
3020   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3021
3022   prop = RNA_def_property(srna, "use_snap_rotate", PROP_BOOLEAN, PROP_NONE);
3023   RNA_def_property_boolean_sdna(
3024       prop, NULL, "snap_transform_mode_flag", SCE_SNAP_TRANSFORM_MODE_ROTATE);
3025   RNA_def_property_boolean_default(prop, false);
3026   RNA_def_property_ui_text(
3027       prop, "Use Snap for Rotation", "Rotate is affected by the snapping settings");
3028   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3029
3030   prop = RNA_def_property(srna, "use_snap_scale", PROP_BOOLEAN, PROP_NONE);
3031   RNA_def_property_boolean_sdna(
3032       prop, NULL, "snap_transform_mode_flag", SCE_SNAP_TRANSFORM_MODE_SCALE);
3033   RNA_def_property_boolean_default(prop, false);
3034   RNA_def_property_ui_text(prop, "Use Snap for Scale", "Scale is affected by snapping settings");
3035   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
3036
3037   /* Grease Pencil */
3038   prop = RNA_def_property(srna, "use_gpencil_draw_additive", PROP_BOOLEAN, PROP_NONE);
3039   RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_RETAIN_LAST);
3040   RNA_def_property_ui_text(prop,
3041                            "Use Additive Drawing",
3042                            "When creating new frames, the strokes from the previous/active frame "
3043                            "are included as the basis for the new one");
3044   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
3045
3046   prop = RNA_def_property(srna, "use_gpencil_draw_onback", PROP_BOOLEAN, PROP_NONE);
3047   RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_PAINT_ONBACK);
3048   RNA_def_property_ui_text(
3049       prop,
3050       "Draw Strokes on Back",
3051       "When draw new strokes, the new stroke is drawn below of all strokes in the layer");
3052   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
3053
3054   prop = RNA_def_property(srna, "use_gpencil_thumbnail_list", PROP_BOOLEAN, PROP_NONE);
3055   RNA_def_property_boolean_negative_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_THUMBNAIL_LIST);
3056   RNA_def_property_ui_text(
3057       prop, "Compact List", "Show compact list of color instead of thumbnails");
3058   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
3059
3060   prop = RNA_def_property(srna, "use_gpencil_weight_data_add", PROP_BOOLEAN, PROP_NONE);
3061   RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_CREATE_WEIGHTS);
3062   RNA_def_property_ui_text(prop,
3063                            "Add weight data for new strokes",
3064                            "When creating new strokes, the weight data is added according to the "
3065                            "current vertex group and weight, "
3066                            "if no vertex group selected, weight is not added");
3067   RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
3068
3069   prop = RNA_def_property(srna, "gpencil_sculpt", PROP_POINTER, PROP_NONE);
3070   RNA_def_property_pointer_sdna(prop, NULL, "gp_sculpt");
3071   RNA_def_property_struct_type(prop, "GPencilSculptSettings");
3072   RNA_def_property_ui_text(
3073       prop, "Grease Pencil Sculpt", "Settings for stroke sculpting tools and brushes");
3074
3075   prop = RNA_def_property(srna, "gpencil_interpolate", PROP_POINTER, PROP_NONE);
3076   RNA_def_property_pointer_sdna(prop, NULL, "gp_interpolate");
3077   RNA_def_property_struct_type(prop, "GPencilInterpolateSettings");
3078   RNA_def_property_ui_text(
3079       prop, "Grease Pencil Interpolate", "Settings for Grease Pencil Interpolation tools");
3080
3081   /* Grease Pencil - 3D View Stroke Placement */
3082   prop = RNA_def_property(srna, "gpencil_stroke_placement_view3d", PROP_ENUM, PROP_NONE);
3083   RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v3d_align");
3084   RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
3085   RNA_def_property_ui_text(prop, "Stroke Placement (3D View)", "");
3086   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3087
3088   prop = RNA_def_property(srna, "gpencil_stroke_snap_mode", PROP_ENUM, PROP_NONE);
3089   RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v3d_align");
3090   RNA_def_property_enum_items(prop, gpencil_stroke_snap_items);
3091   RNA_def_property_ui_text(prop, "Stroke Snap", "");
3092   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3093
3094   prop = RNA_def_property(srna, "use_gpencil_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
3095   RNA_def_property_boolean_sdna(
3096       prop, NULL, "gpencil_v3d_align", GP_PROJECT_DEPTH_STROKE_ENDPOINTS);
3097   RNA_def_property_ui_text(
3098       prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
3099   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3100
3101   /* Grease Pencil - Select mode Edit */
3102   prop = RNA_def_property(srna, "gpencil_selectmode_edit", PROP_ENUM, PROP_NONE);
3103   RNA_def_property_enum_sdna(prop, NULL, "gpencil_selectmode_edit");
3104   RNA_def_property_enum_items(prop, gpencil_selectmode_items);
3105   RNA_def_property_ui_text(prop, "Select Mode", "");
3106   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3107
3108   /* Grease Pencil - Select mode Sculpt */
3109   prop = RNA_def_property(srna, "use_gpencil_select_mask_point", PROP_BOOLEAN, PROP_NONE);
3110   RNA_def_property_boolean_sdna(
3111       prop, NULL, "gpencil_selectmode_sculpt", GP_SCULPT_MASK_SELECTMODE_POINT);
3112   RNA_def_property_ui_text(prop, "Selection Mask", "Only sculpt selected stroke points");
3113   RNA_def_property_ui_icon(prop, ICON_GP_SELECT_POINTS, 0);
3114   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3115   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Gpencil_mask_point_update");
3116
3117   prop = RNA_def_property(srna, "use_gpencil_select_mask_stroke", PROP_BOOLEAN, PROP_NONE);
3118   RNA_def_property_boolean_sdna(
3119       prop, NULL, "gpencil_selectmode_sculpt", GP_SCULPT_MASK_SELECTMODE_STROKE);
3120   RNA_def_property_ui_text(prop, "Selection Mask", "Only sculpt selected stroke");
3121   RNA_def_property_ui_icon(prop, ICON_GP_SELECT_STROKES, 0);
3122   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3123   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Gpencil_mask_stroke_update");
3124
3125   prop = RNA_def_property(srna, "use_gpencil_select_mask_segment", PROP_BOOLEAN, PROP_NONE);
3126   RNA_def_property_boolean_sdna(
3127       prop, NULL, "gpencil_selectmode_sculpt", GP_SCULPT_MASK_SELECTMODE_SEGMENT);
3128   RNA_def_property_ui_text(
3129       prop, "Selection Mask", "Only sculpt selected stroke points between other strokes");
3130   RNA_def_property_ui_icon(prop, ICON_GP_SELECT_BETWEEN_STROKES, 0);
3131   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3132   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_Gpencil_mask_segment_update");
3133
3134   /* Annotations - 2D Views Stroke Placement */
3135   prop = RNA_def_property(srna, "annotation_stroke_placement_view2d", PROP_ENUM, PROP_NONE);
3136   RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v2d_align");
3137   RNA_def_property_enum_items(prop, annotation_stroke_placement_items);
3138   RNA_def_property_ui_text(prop, "Stroke Placement (2D View)", "");
3139   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3140
3141   /* Annotations - Sequencer Preview Stroke Placement */
3142   prop = RNA_def_property(
3143       srna, "annotation_stroke_placement_sequencer_preview", PROP_ENUM, PROP_NONE);
3144   RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_seq_align");
3145   RNA_def_property_enum_items(prop, annotation_stroke_placement_items);
3146   RNA_def_property_ui_text(prop, "Stroke Placement (Sequencer Preview)", "");
3147   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3148
3149   /* Annotations - Image Editor Stroke Placement */
3150   prop = RNA_def_property(srna, "annotation_stroke_placement_image_editor", PROP_ENUM, PROP_NONE);
3151   RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_ima_align");
3152   RNA_def_property_enum_items(prop, annotation_stroke_placement_items);
3153   RNA_def_property_ui_text(prop, "Stroke Placement (Image Editor)", "");
3154   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3155
3156   /* Annotations - 3D View Stroke Placement */
3157   /* XXX: Do we need to decouple the stroke_endpoints setting too?  */
3158   prop = RNA_def_property(srna, "annotation_stroke_placement_view3d", PROP_ENUM, PROP_NONE);
3159   RNA_def_property_enum_bitflag_sdna(prop, NULL, "annotate_v3d_align");
3160   RNA_def_property_enum_items(prop, annotation_stroke_placement_items);
3161   RNA_def_property_enum_default(prop, GP_PROJECT_VIEWSPACE | GP_PROJECT_CURSOR);
3162   RNA_def_property_ui_text(prop,
3163                            "Annotation Stroke Placement (3D View)",
3164                            "How annotation strokes are orientated in 3D space");
3165   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
3166
3167   /* Annotations - Stroke Thickness */
3168   prop = RNA_def_property(srna, "annotation_thickness", PROP_INT, PROP_PIXEL);
3169   RNA_def_property_int_sdna(prop, NULL, "annotate_thickness");
3170   RNA_def_property_range(prop, 1, 10);
3171   RNA_def_property_ui_text(prop, "Annotation Stroke Thickness", "Thickness of annotation strokes");
3172   RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
3173
3174   /* Auto Keying */
3175   prop = RNA_def_property(srna, "use_keyframe_insert_auto", PROP_BOOLEAN, PROP_NONE);
3176   RNA_def_property_boolean_sdna(prop, NULL, "autokey_mode", AUTOKEY_ON);
3177   RNA_def_property_ui_text(
3178       prop, "Auto Keying", "Automatic keyframe insertion for Objects and Bones");
3179   RNA_def_property_ui_icon(prop, ICON_REC, 0);
3180
3181   prop = RNA_def_property(srna, "auto_keying_mode", PROP_ENUM, PROP_NONE);
3182   RNA_def_property_enum_bitflag_sdna(prop, NULL, "autokey_mode");
3183   RNA_def_property_enum_items(prop, auto_key_items);
3184   RNA_def_property_ui_text(
3185       prop, "Auto-Keying Mode", "Mode of automatic keyframe insertion for Objects and Bones");
3186
3187   prop = RNA_def_property(srna, "use_record_with_nla", PROP_BOOLEAN, PROP_NONE);
3188   RNA_def_property_boolean_sdna(prop, NULL, "autokey_flag", ANIMRECORD_FLAG_WITHNLA);
3189   RNA_def_property_ui_text(
3190       prop,
3191       "Layered",
3192       "Add a new NLA Track + Strip for every loop/pass made over the animation "
3193       "to allow non-destructive tweaking");
3194
3195   prop = RNA_def_property(srna, "use_keyframe_insert_keyingset", PROP_BOOLEAN, PROP_NONE);
3196   RNA_def_property_boolean_sdna(prop, NULL, "autokey_flag", AUTOKEY_FLAG_ONLYKEYINGSET);
3197   RNA_def_property_ui_text(prop,
3198                            "Auto Keyframe Insert Keying Set",
3199                            "Automatic keyframe insertion using active Keying Set only");
3200   RNA_def_property_ui_icon(prop, ICON_KEYINGSET, 0);
3201
3202   prop = RNA_def_property(srna, "use_keyframe_cycle_aware", PROP_BOOLEAN, PROP_NONE);
3203   RNA_def_property_boolean_sdna(prop, NULL, "autokey_flag", AUTOKEY_FLAG_CYCLEAWARE);
3204   RNA_def_property_ui_text(
3205       prop,
3206       "Cycle-Aware Keying",
3207       "For channels with cyclic extrapolation, keyframe insertion is automatically "
3208       "remapped inside the cycle time range, and keeps ends in sync");
3209
3210   /* Keyframing */
3211   prop = RNA_def_property(srna, "keyframe_type", PROP_ENUM, PROP_NONE);
3212   RNA_def_property_enum_sdna(prop, NULL, "keyframe_type");
3213   RNA_def_property_enum_items(prop, rna_enum_beztriple_keyframe_type_items);
3214   RNA_def_property_ui_text(
3215       prop, "New Keyframe Type", "Type of keyframes to create when inserting keyframes");
3216
3217   /* UV */
3218   prop = RNA_def_property(srna, "uv_select_mode", PROP_ENUM, PROP_NONE);
3219   RNA_def_property_enum_sdna(prop, NULL, "uv_selectmode");
3220   RNA_def_property_enum_items(prop, rna_enum_mesh_select_mode_uv_items);
3221   RNA_def_property_ui_text(prop, "UV Selection Mode", "UV selection and display mode");
3222   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
3223
3224   prop = RNA_def_property(srna, "use_uv_select_sync", PROP_BOOLEAN, PROP_NONE);
3225   RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SYNC_SELECTION);
3226   RNA_def_property_ui_text(
3227       prop, "UV Sync Selection", "Keep UV and edit mode mesh selection in sync");
3228   RNA_def_property_ui_icon(prop, ICON_UV_SYNC_SELECT, 0);
3229   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
3230
3231   prop = RNA_def_property(srna, "show_uv_local_view", PROP_BOOLEAN, PROP_NONE);
3232   RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SHOW_SAME_IMAGE);
3233   RNA_def_property_ui_text(
3234       prop, "UV Local View", "Display only faces with the currently displayed image assigned");
3235   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
3236
3237   /* Mesh */
3238   prop = RNA_def_property(srna, "mesh_select_mode", PROP_BOOLEAN, PROP_NONE);
3239   RNA_def_property_boolean_sdna(prop, NULL, "selectmode", 1);
3240   RNA_def_property_array(prop, 3);
3241   RNA_def_property_boolean_funcs(prop, NULL, "rna_Scene_editmesh_select_mode_set");
3242   RNA_def_property_ui_text(prop, "Mesh Selection Mode", "Which mesh elements selection works on");
3243   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3244   RNA_def_property_update(prop, 0, "rna_Scene_editmesh_select_mode_update");
3245
3246   prop = RNA_def_property(srna, "vertex_group_weight", PROP_FLOAT, PROP_FACTOR);
3247   RNA_def_property_float_sdna(prop, NULL, "vgroup_weight");
3248   RNA_def_property_ui_text(prop, "Vertex Group Weight", "Weight to assign in vertex groups");
3249
3250   prop = RNA_def_property(srna, "use_edge_path_live_unwrap", PROP_BOOLEAN, PROP_NONE);
3251   RNA_def_property_boolean_sdna(prop, NULL, "edge_mode_live_unwrap", 1);
3252   RNA_def_property_ui_text(prop, "Live Unwrap", "Changing edges seam re-calculates UV unwrap");
3253
3254   prop = RNA_def_property(srna, "normal_vector", PROP_FLOAT, PROP_XYZ);
3255   RNA_def_property_ui_text(prop, "Normal Vector", "Normal Vector used to copy, add or multiply");
3256   RNA_def_property_ui_range(prop, -10000.0, 10000.0, 1, 3);
3257
3258   /* Unified Paint Settings */
3259   prop = RNA_def_property(srna, "unified_paint_settings", PROP_POINTER, PROP_NONE);
3260   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3261   RNA_def_property_struct_type(prop, "UnifiedPaintSettings");
3262   RNA_def_property_ui_text(prop, "Unified Paint Settings", NULL);
3263
3264   /* Curve Paint Settings */
3265   prop = RNA_def_property(srna, "curve_paint_settings", PROP_POINTER, PROP_NONE);
3266   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3267   RNA_def_property_struct_type(prop, "CurvePaintSettings");
3268   RNA_def_property_ui_text(prop, "Curve Paint Settings", NULL);
3269
3270   /* Mesh Statistics */
3271   prop = RNA_def_property(srna, "statvis", PROP_POINTER, PROP_NONE);
3272   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3273   RNA_def_property_struct_type(prop, "MeshStatVis");
3274   RNA_def_property_ui_text(prop, "Mesh Statistics Visualization", NULL);
3275 }
3276
3277 static void rna_def_unified_paint_settings(BlenderRNA *brna)
3278 {
3279   StructRNA *srna;
3280   PropertyRNA *prop;
3281
3282   static const EnumPropertyItem brush_size_unit_items[] = {
3283       {0, "VIEW", 0, "View", "Measure brush size relative to the view"},
3284       {UNIFIED_PAINT_BRUSH_LOCK_SIZE,
3285        "SCENE",
3286        0,
3287        "Scene",
3288        "Measure brush size relative to the scene"},
3289       {0, NULL, 0, NULL, NULL},
3290   };
3291
3292   srna = RNA_def_struct(brna, "UnifiedPaintSettings", NULL);
3293   RNA_def_struct_path_func(srna, "rna_UnifiedPaintSettings_path");
3294   RNA_def_struct_ui_text(
3295       srna, "Unified Paint Settings", "Overrides for some of the active brush's settings");
3296
3297   /* high-level flags to enable or disable unified paint settings */
3298   prop = RNA_def_property(srna, "use_unified_size", PROP_BOOLEAN, PROP_NONE);
3299   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_SIZE);
3300   RNA_def_property_ui_text(prop,
3301                            "Use Unified Radius",
3302                            "Instead of per-brush radius, the radius is shared across brushes");
3303
3304   prop = RNA_def_property(srna, "use_unified_strength", PROP_BOOLEAN, PROP_NONE);
3305   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_ALPHA);
3306   RNA_def_property_ui_text(prop,
3307                            "Use Unified Strength",
3308                            "Instead of per-brush strength, the strength is shared across brushes");
3309
3310   prop = RNA_def_property(srna, "use_unified_weight", PROP_BOOLEAN, PROP_NONE);
3311   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_WEIGHT);
3312   RNA_def_property_ui_text(prop,
3313                            "Use Unified Weight",
3314                            "Instead of per-brush weight, the weight is shared across brushes");
3315
3316   prop = RNA_def_property(srna, "use_unified_color", PROP_BOOLEAN, PROP_NONE);
3317   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_COLOR);
3318   RNA_def_property_ui_text(
3319       prop, "Use Unified Color", "Instead of per-brush color, the color is shared across brushes");
3320
3321   /* unified paint settings that override the equivalent settings
3322    * from the active brush */
3323   prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
3324   RNA_def_property_int_funcs(prop, NULL, "rna_UnifiedPaintSettings_size_set", NULL);
3325   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3326   RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
3327   RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
3328   RNA_def_property_ui_text(prop, "Radius", "Radius of the brush");
3329   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
3330
3331   prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
3332   RNA_def_property_float_funcs(
3333       prop, NULL, "rna_UnifiedPaintSettings_unprojected_radius_set", NULL);
3334   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3335   RNA_def_property_range(prop, 0.001, FLT_MAX);
3336   RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
3337   RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
3338   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
3339
3340   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
3341   RNA_def_property_float_sdna(prop, NULL, "alpha");
3342   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3343   RNA_def_property_float_default(prop, 0.5f);
3344   RNA_def_property_range(prop, 0.0f, 10.0f);
3345   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
3346   RNA_def_property_ui_text(
3347       prop, "Strength", "How powerful the effect of the brush is when applied");
3348   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
3349
3350   prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
3351   RNA_def_property_float_sdna(prop, NULL, "weight");
3352   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3353   RNA_def_property_float_default(prop, 0.5f);
3354   RNA_def_property_range(prop, 0.0f, 1.0f);
3355   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
3356   RNA_def_property_ui_text(prop, "Weight", "Weight to assign in vertex groups");
3357   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
3358
3359   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
3360   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3361   RNA_def_property_range(prop, 0.0, 1.0);
3362   RNA_def_property_float_sdna(prop, NULL, "rgb");
3363   RNA_def_property_ui_text(prop, "Color", "");
3364   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
3365
3366   prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
3367   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3368   RNA_def_property_range(prop, 0.0, 1.0);
3369   RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
3370   RNA_def_property_ui_text(prop, "Secondary Color", "");
3371   RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
3372
3373   prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
3374   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_SIZE_PRESSURE);
3375   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
3376   RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
3377
3378   prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
3379   RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_ALPHA_PRESSURE);
3380   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
3381   RNA_def_property_ui_text(
3382       prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
3383
3384   prop = RNA_def_property(srna, "use_locked_size", PROP_ENUM, PROP_NONE); /* as an enum */
3385   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
3386   RNA_def_property_enum_items(prop, brush_size_unit_items);
3387   RNA_def_property_ui_text(
3388       prop, "Radius Unit", "Measure brush size relative to the view or the scene ");
3389 }
3390
3391 static void rna_def_curve_paint_settings(BlenderRNA *brna)
3392 {
3393   StructRNA *srna;
3394   PropertyRNA *prop;
3395
3396   srna = RNA_def_struct(brna, "CurvePaintSettings", NULL);
3397   RNA_def_struct_path_func(srna, "rna_CurvePaintSettings_path");
3398   RNA_def_struct_ui_text(srna, "Curve Paint Settings", "");
3399
3400   static const EnumPropertyItem curve_type_items[] = {
3401       {CU_POLY, "POLY", 0, "Poly", ""},
3402       {CU_BEZIER, "BEZIER", 0, "Bezier", ""},
3403       {0, NULL, 0, NULL, NULL},
3404   };
3405
3406   prop = RNA_def_property(srna, "curve_type", PROP_ENUM, PROP_NONE);
3407   RNA_def_property_enum_sdna(prop, NULL, "curve_type");
3408   RNA_def_property_enum_items(prop, curve_type_items);
3409   RNA_def_property_ui_text(prop, "Type", "Type of curve to use for new strokes");
3410
3411   prop = RNA_def_property(srna, "use_corners_detect", PROP_BOOLEAN, PROP_NONE);
3412   RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_CORNERS_DETECT);
3413   RNA_def_property_ui_text(prop, "Detect Corners", "Detect corners and use non-aligned handles");
3414
3415   prop = RNA_def_property(srna, "use_pressure_radius", PROP_BOOLEAN, PROP_NONE);
3416   RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_PRESSURE_RADIUS);
3417   RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
3418   RNA_def_property_ui_text(prop, "Use Pressure", "Map tablet pressure to curve radius");
3419
3420   prop = RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
3421   RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_ENDPOINTS);
3422   RNA_def_property_ui_text(prop, "Only First", "Use the start of the stroke for the depth");
3423
3424   prop = RNA_def_property(srna, "use_offset_absolute", PROP_BOOLEAN, PROP_NONE);
3425   RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_OFFSET_ABS);
3426   RNA_def_property_ui_text(
3427       prop, "Absolute Offset", "Apply a fixed offset (don't scale by the radius)");
3428
3429   prop = RNA_def_property(srna, "error_threshold", PROP_INT, PROP_PIXEL);
3430   RNA_def_property_range(prop, 1, 100);
3431   RNA_def_property_ui_text(prop, "Tolerance", "Allow deviation for a smoother, less precise line");
3432
3433   prop = RNA_def_property(srna, "fit_method", PROP_ENUM, PROP_PIXEL);
3434   RNA_def_property_enum_sdna(prop, NULL, "fit_method");
3435   RNA_def_property_enum_items(prop, rna_enum_curve_fit_method_items);
3436   RNA_def_property_ui_text(prop, "Method", "Curve fitting method");
3437
3438   prop = RNA_def_property(srna, "corner_angle", PROP_FLOAT, PROP_ANGLE);
3439   RNA_def_property_range(prop, 0, M_PI);
3440   RNA_def_property_ui_text(prop, "Corner Angle", "Angles above this are considered corners");
3441
3442   prop = RNA_def_property(srna, "radius_min", PROP_FLOAT, PROP_NONE);
3443   RNA_def_property_range(prop, 0.0, 100.0);
3444   RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
3445   RNA_def_property_ui_text(
3446       prop,
3447       "Radius Min",
3448       "Minimum radius when the minimum pressure is applied (also the minimum when tapering)");
3449
3450   prop = RNA_def_property(srna, "radius_max", PROP_FLOAT, PROP_NONE);
3451   RNA_def_property_range(prop, 0.0, 100.0);
3452   RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
3453   RNA_def_property_ui_text(
3454       prop,
3455       "Radius Max",
3456       "Radius to use when the maximum pressure is applied (or when a tablet isn't used)");
3457
3458   prop = RNA_def_property(srna, "radius_taper_start", PROP_FLOAT, PROP_NONE);
3459   RNA_def_property_range(prop, 0.0, 1.0);
3460   RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
3461   RNA_def_property_ui_text(
3462       prop, "Radius Min", "Taper factor for the radius of each point along the curve");
3463
3464   prop = RNA_def_property(srna, "radius_taper_end", PROP_FLOAT, PROP_NONE);
3465   RNA_def_property_range(prop, 0.0, 10.0);
3466   RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
3467   RNA_def_property_ui_text(
3468       prop, "Radius Max", "Taper factor for the radius of each point along the curve");
3469
3470   prop = RNA_def_property(srna, "surface_offset", PROP_FLOAT, PROP_NONE);
3471   RNA_def_property_range(prop, -10.0, 10.0);
3472   RNA_def_property_ui_range(prop, -1.0f, 1.0, 1, 2);
3473   RNA_def_property_ui_text(prop, "Offset", "Offset the stroke from the surface");
3474
3475   static const EnumPropertyItem depth_mode_items[] = {
3476       {CURVE_PAINT_PROJECT_CURSOR, "CURSOR", 0, "Cursor", ""},
3477       {CURVE_PAINT_PROJECT_SURFACE, "SURFACE", 0, "Surface", ""},
3478       {0, NULL, 0, NULL, NULL},
3479   };
3480
3481   prop = RNA_def_property(srna, "depth_mode", PROP_ENUM, PROP_NONE);
3482   RNA_def_property_enum_sdna(prop, NULL, "depth_mode");
3483   RNA_def_property_enum_items(prop, depth_mode_items);
3484   RNA_def_property_ui_text(prop, "Depth", "Method of projecting depth");
3485
3486   static const EnumPropertyItem surface_plane_items[] = {
3487       {CURVE_PAINT_SURFACE_PLANE_NORMAL_VIEW,
3488        "NORMAL_VIEW",
3489        0,
3490        "Normal/View",
3491        "Display perpendicular to the surface"},
3492       {CURVE_PAINT_SURFACE_PLANE_NORMAL_SURFACE,
3493        "NORMAL_SURFACE",
3494        0,
3495        "Normal/Surface",
3496        "Display aligned to the surface"},
3497       {CURVE_PAINT_SURFACE_PLANE_VIEW, "VIEW", 0, "View", "Display aligned to the viewport"},
3498       {0, NULL, 0, NULL, NULL},
3499   };
3500
3501   prop = RNA_def_property(srna, "surface_plane", PROP_ENUM, PROP_NONE);
3502   RNA_def_property_enum_sdna(prop, NULL, "surface_plane");
3503   RNA_def_property_enum_items(prop, surface_plane_items);
3504   RNA_def_property_ui_text(prop, "Plane", "Plane for projected stroke");
3505 }
3506
3507 static void rna_def_statvis(BlenderRNA *brna)
3508 {
3509   StructRNA *srna;
3510   PropertyRNA *prop;
3511
3512   static const EnumPropertyItem stat_type[] = {
3513       {SCE_STATVIS_OVERHANG, "OVERHANG", 0, "Overhang", ""},
3514       {SCE_STATVIS_THICKNESS, "THICKNESS", 0, "Thickness", ""},
3515       {SCE_STATVIS_INTERSECT, "INTERSECT", 0, "Intersect", ""},
3516       {SCE_STATVIS_DISTORT, "DISTORT", 0, "Distortion", ""},
3517       {SCE_STATVIS_SHARP, "SHARP", 0, "Sharp", ""},
3518       {0, NULL, 0, NULL, NULL},
3519   };
3520
3521   srna = RNA_def_struct(brna, "MeshStatVis", NULL);
3522   RNA_def_struct_path_func(srna, "rna_MeshStatVis_path");
3523   RNA_def_struct_ui_text(srna, "Mesh Visualize Statistics", "");
3524
3525   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
3526   RNA_def_property_enum_items(prop, stat_type);
3527   RNA_def_property_ui_text(prop, "Type", "Type of data to visualize/check");
3528   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3529   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3530
3531   /* overhang */
3532   prop = RNA_def_property(srna, "overhang_min", PROP_FLOAT, PROP_ANGLE);
3533   RNA_def_property_float_sdna(prop, NULL, "overhang_min");
3534   RNA_def_property_float_default(prop, 0.5f);
3535   RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
3536   RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
3537   RNA_def_property_ui_text(prop, "Overhang Min", "Minimum angle to display");
3538   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3539   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3540
3541   prop = RNA_def_property(srna, "overhang_max", PROP_FLOAT, PROP_ANGLE);
3542   RNA_def_property_float_sdna(prop, NULL, "overhang_max");
3543   RNA_def_property_float_default(prop, 0.5f);
3544   RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
3545   RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
3546   RNA_def_property_ui_text(prop, "Overhang Max", "Maximum angle to display");
3547   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3548   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3549
3550   prop = RNA_def_property(srna, "overhang_axis", PROP_ENUM, PROP_NONE);
3551   RNA_def_property_enum_sdna(prop, NULL, "overhang_axis");
3552   RNA_def_property_enum_items(prop, rna_enum_object_axis_items);
3553   RNA_def_property_ui_text(prop, "Axis", "");
3554   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3555   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3556
3557   /* thickness */
3558   prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_DISTANCE);
3559   RNA_def_property_float_sdna(prop, NULL, "thickness_min");
3560   RNA_def_property_float_default(prop, 0.5f);
3561   RNA_def_property_range(prop, 0.0f, 1000.0);
3562   RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
3563   RNA_def_property_ui_text(prop, "Thickness Min", "Minimum for measuring thickness");
3564   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3565   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3566
3567   prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_DISTANCE);
3568   RNA_def_property_float_sdna(prop, NULL, "thickness_max");
3569   RNA_def_property_float_default(prop, 0.5f);
3570   RNA_def_property_range(prop, 0.0f, 1000.0);
3571   RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
3572   RNA_def_property_ui_text(prop, "Thickness Max", "Maximum for measuring thickness");
3573   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3574   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3575
3576   prop = RNA_def_property(srna, "thickness_samples", PROP_INT, PROP_UNSIGNED);
3577   RNA_def_property_int_sdna(prop, NULL, "thickness_samples");
3578   RNA_def_property_range(prop, 1, 32);
3579   RNA_def_property_ui_text(prop, "Samples", "Number of samples to test per face");
3580   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3581   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3582
3583   /* distort */
3584   prop = RNA_def_property(srna, "distort_min", PROP_FLOAT, PROP_ANGLE);
3585   RNA_def_property_float_sdna(prop, NULL, "distort_min");
3586   RNA_def_property_float_default(prop, 0.5f);
3587   RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
3588   RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
3589   RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
3590   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3591   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3592
3593   prop = RNA_def_property(srna, "distort_max", PROP_FLOAT, PROP_ANGLE);
3594   RNA_def_property_float_sdna(prop, NULL, "distort_max");
3595   RNA_def_property_float_default(prop, 0.5f);
3596   RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
3597   RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
3598   RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
3599   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3600   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3601
3602   /* sharp */
3603   prop = RNA_def_property(srna, "sharp_min", PROP_FLOAT, PROP_ANGLE);
3604   RNA_def_property_float_sdna(prop, NULL, "sharp_min");
3605   RNA_def_property_float_default(prop, 0.5f);
3606   RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
3607   RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
3608   RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
3609   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3610   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3611
3612   prop = RNA_def_property(srna, "sharp_max", PROP_FLOAT, PROP_ANGLE);
3613   RNA_def_property_float_sdna(prop, NULL, "sharp_max");
3614   RNA_def_property_float_default(prop, 0.5f);
3615   RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
3616   RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
3617   RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
3618   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3619   RNA_def_property_update(prop, 0, "rna_EditMesh_update");
3620 }
3621
3622 static void rna_def_unit_settings(BlenderRNA *brna)
3623 {
3624   StructRNA *srna;
3625   PropertyRNA *prop;
3626
3627   static const EnumPropertyItem unit_systems[] = {
3628       {USER_UNIT_NONE, "NONE", 0, "None", ""},
3629       {USER_UNIT_METRIC, "METRIC", 0, "Metric", ""},
3630       {USER_UNIT_IMPERIAL, "IMPERIAL", 0, "Imperial", ""},
3631       {0, NULL, 0, NULL, NULL},
3632   };
3633
3634   static const EnumPropertyItem rotation_units[] = {
3635       {0, "DEGREES", 0, "Degrees", "Use degrees for measuring angles and rotations"},
3636       {USER_UNIT_ROT_RADIANS, "RADIANS", 0, "Radians", ""},
3637       {0, NULL, 0, NULL, NULL},
3638   };
3639
3640   srna = RNA_def_struct(brna, "UnitSettings", NULL);
3641   RNA_def_struct_ui_text(srna, "Unit Settings", "");
3642   RNA_def_struct_nested(brna, srna, "Scene");
3643   RNA_def_struct_path_func(srna, "rna_UnitSettings_path");
3644
3645   /* Units */
3646   prop = RNA_def_property(srna, "system", PROP_ENUM, PROP_NONE);
3647   RNA_def_property_enum_items(prop, unit_systems);
3648   RNA_def_property_ui_text(
3649       prop, "Unit System", "The unit system to use for user interface controls");
3650   RNA_def_property_update(prop, NC_WINDOW, "rna_UnitSettings_system_update");
3651
3652   prop = RNA_def_property(srna, "system_rotation", PROP_ENUM, PROP_NONE);
3653   RNA_def_property_enum_items(prop, rotation_units);
3654   RNA_def_property_ui_text(
3655       prop, "Rotation Units", "Unit to use for displaying/editing rotation values");
3656   RNA_def_property_update(prop, NC_WINDOW, NULL);
3657
3658   prop = RNA_def_property(srna, "scale_length", PROP_FLOAT, PROP_UNSIGNED);
3659   RNA_def_property_ui_text(
3660       prop,
3661       "Unit Scale",
3662       "Scale to use when converting between blender units and dimensions."
3663       " When working at microscopic or astronomical scale, a small or large unit scale"
3664       " respectively can be used to avoid numerical precision problems");
3665   RNA_def_property_range(prop, 0.00001, 100000.0);
3666   RNA_def_property_ui_range(prop, 0.001, 100.0, 0.1, 6);
3667   RNA_def_property_update(prop, NC_WINDOW, NULL);
3668
3669   prop = RNA_def_property(srna, "use_separate", PROP_BOOLEAN, PROP_NONE);
3670   RNA_def_property_boolean_sdna(prop, NULL, "flag", USER_UNIT_OPT_SPLIT);
3671   RNA_def_property_ui_text(prop, "Separate Units", "Display units in pairs (e.g. 1m 0cm)");
3672   RNA_def_property_update(prop, NC_WINDOW, NULL);
3673
3674   prop = RNA_def_property(srna, "length_unit", PROP_ENUM, PROP_NONE);
3675   RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items);
3676   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_UnitSettings_length_unit_itemf");
3677   RNA_def_property_ui_text(prop, "Length Unit", "Unit that will be used to display length values");
3678   RNA_def_property_update(prop, NC_WINDOW, NULL);
3679
3680   prop = RNA_def_property(srna, "mass_unit", PROP_ENUM, PROP_NONE);
3681   RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items);
3682   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_UnitSettings_mass_unit_itemf");
3683   RNA_def_property_ui_text(prop, "Mass Unit", "Unit that will be used to display mass values");
3684   RNA_def_property_update(prop, NC_WINDOW, NULL);
3685
3686   prop = RNA_def_property(srna, "time_unit", PROP_ENUM, PROP_NONE);
3687   RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items);
3688   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_UnitSettings_time_unit_itemf");
3689   RNA_def_property_ui_text(prop, "Time Unit", "Unit that will be used to display time values");
3690   RNA_def_property_update(prop, NC_WINDOW, NULL);
3691 }
3692
3693 void rna_def_view_layer_common(StructRNA *srna, const bool scene)
3694 {
3695   PropertyRNA *prop;
3696
3697   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
3698   if (scene) {
3699     RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ViewLayer_name_set");
3700   }
3701   else {
3702     RNA_def_property_string_sdna(prop, NULL, "name");
3703   }
3704   RNA_def_property_ui_text(prop, "Name", "View layer name");
3705   RNA_def_struct_name_property(srna, prop);
3706   if (scene) {
3707     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3708   }
3709   else {
3710     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3711   }
3712
3713   if (scene) {
3714     prop = RNA_def_property(srna, "material_override", PROP_POINTER, PROP_NONE);
3715     RNA_def_property_pointer_sdna(prop, NULL, "mat_override");
3716     RNA_def_property_struct_type(prop, "Material");
3717     RNA_def_property_flag(prop, PROP_EDITABLE);
3718     RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
3719     RNA_def_property_ui_text(
3720         prop, "Material Override", "Material to override all other materials in this view layer");
3721     RNA_def_property_update(
3722         prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_material_override_update");
3723
3724     prop = RNA_def_property(srna, "samples", PROP_INT, PROP_UNSIGNED);
3725     RNA_def_property_ui_text(prop,
3726                              "Samples",
3727                              "Override number of render samples for this view layer, "
3728                              "0 will use the scene setting");
3729     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3730
3731     prop = RNA_def_property(srna, "pass_alpha_threshold", PROP_FLOAT, PROP_FACTOR);
3732     RNA_def_property_ui_text(
3733         prop,
3734         "Alpha Threshold",
3735         "Z, Index, normal, UV and vector passes are only affected by surfaces with "
3736         "alpha transparency equal to or higher than this threshold");
3737     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3738   }
3739
3740   /* layer options */
3741   prop = RNA_def_property(srna, "use_zmask", PROP_BOOLEAN, PROP_NONE);
3742   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZMASK);
3743   RNA_def_property_ui_text(prop, "Zmask", "Only render what's in front of the solid z values");
3744   if (scene) {
3745     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
3746   }
3747   else {
3748     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3749   }
3750
3751   prop = RNA_def_property(srna, "invert_zmask", PROP_BOOLEAN, PROP_NONE);
3752   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_NEG_ZMASK);
3753   RNA_def_property_ui_text(
3754       prop,
3755       "Zmask Negate",
3756       "For Zmask, only render what is behind solid z values instead of in front");
3757   if (scene) {
3758     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
3759   }
3760   else {
3761     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3762   }
3763
3764   prop = RNA_def_property(srna, "use_all_z", PROP_BOOLEAN, PROP_NONE);
3765   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ALL_Z);
3766   RNA_def_property_ui_text(
3767       prop, "All Z", "Fill in Z values for solid faces in invisible layers, for masking");
3768   if (scene) {
3769     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3770   }
3771   else {
3772     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3773   }
3774
3775   prop = RNA_def_property(srna, "use_solid", PROP_BOOLEAN, PROP_NONE);
3776   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
3777   RNA_def_property_ui_text(prop, "Solid", "Render Solid faces in this Layer");
3778   if (scene) {
3779     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3780   }
3781   else {
3782     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3783   }
3784
3785   prop = RNA_def_property(srna, "use_halo", PROP_BOOLEAN, PROP_NONE);
3786   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_HALO);
3787   RNA_def_property_ui_text(prop, "Halo", "Render Halos in this Layer (on top of Solid)");
3788   if (scene) {
3789     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3790   }
3791   else {
3792     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3793   }
3794
3795   prop = RNA_def_property(srna, "use_ztransp", PROP_BOOLEAN, PROP_NONE);
3796   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZTRA);
3797   RNA_def_property_ui_text(
3798       prop, "ZTransp", "Render Z-Transparent faces in this Layer (on top of Solid and Halos)");
3799   if (scene) {
3800     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3801   }
3802   else {
3803     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3804   }
3805
3806   prop = RNA_def_property(srna, "use_sky", PROP_BOOLEAN, PROP_NONE);
3807   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SKY);
3808   RNA_def_property_ui_text(prop, "Sky", "Render Sky in this Layer");
3809   if (scene) {
3810     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
3811   }
3812   else {
3813     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3814   }
3815
3816   prop = RNA_def_property(srna, "use_ao", PROP_BOOLEAN, PROP_NONE);
3817   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_AO);
3818   RNA_def_property_ui_text(prop, "Ambient Occlusion", "Render Ambient Occlusion in this Layer");
3819   if (scene) {
3820     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
3821   }
3822   else {
3823     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3824   }
3825
3826   prop = RNA_def_property(srna, "use_edge_enhance", PROP_BOOLEAN, PROP_NONE);
3827   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_EDGE);
3828   RNA_def_property_ui_text(
3829       prop, "Edge", "Render Edge-enhance in this Layer (only works for Solid faces)");
3830   if (scene) {
3831     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3832   }
3833   else {
3834     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3835   }
3836
3837   prop = RNA_def_property(srna, "use_strand", PROP_BOOLEAN, PROP_NONE);
3838   RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_STRAND);
3839   RNA_def_property_ui_text(prop, "Strand", "Render Strands in this Layer");
3840   if (scene) {
3841     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
3842   }
3843   else {
3844     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3845   }
3846
3847   /* passes */
3848   prop = RNA_def_property(srna, "use_pass_combined", PROP_BOOLEAN, PROP_NONE);
3849   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_COMBINED);
3850   RNA_def_property_ui_text(prop, "Combined", "Deliver full combined RGBA buffer");
3851   if (scene) {
3852     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3853   }
3854   else {
3855     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3856   }
3857
3858   prop = RNA_def_property(srna, "use_pass_z", PROP_BOOLEAN, PROP_NONE);
3859   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_Z);
3860   RNA_def_property_ui_text(prop, "Z", "Deliver Z values pass");
3861   if (scene) {
3862     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3863   }
3864   else {
3865     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3866   }
3867
3868   prop = RNA_def_property(srna, "use_pass_vector", PROP_BOOLEAN, PROP_NONE);
3869   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_VECTOR);
3870   RNA_def_property_ui_text(prop, "Vector", "Deliver speed vector pass");
3871   if (scene) {
3872     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3873   }
3874   else {
3875     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3876   }
3877
3878   prop = RNA_def_property(srna, "use_pass_normal", PROP_BOOLEAN, PROP_NONE);
3879   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_NORMAL);
3880   RNA_def_property_ui_text(prop, "Normal", "Deliver normal pass");
3881   if (scene) {
3882     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3883   }
3884   else {
3885     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3886   }
3887
3888   prop = RNA_def_property(srna, "use_pass_uv", PROP_BOOLEAN, PROP_NONE);
3889   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_UV);
3890   RNA_def_property_ui_text(prop, "UV", "Deliver texture UV pass");
3891   if (scene) {
3892     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3893   }
3894   else {
3895     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3896   }
3897
3898   prop = RNA_def_property(srna, "use_pass_mist", PROP_BOOLEAN, PROP_NONE);
3899   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_MIST);
3900   RNA_def_property_ui_text(prop, "Mist", "Deliver mist factor pass (0.0-1.0)");
3901   if (scene) {
3902     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3903   }
3904   else {
3905     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3906   }
3907
3908   prop = RNA_def_property(srna, "use_pass_object_index", PROP_BOOLEAN, PROP_NONE);
3909   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXOB);
3910   RNA_def_property_ui_text(prop, "Object Index", "Deliver object index pass");
3911   if (scene) {
3912     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3913   }
3914   else {
3915     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3916   }
3917
3918   prop = RNA_def_property(srna, "use_pass_material_index", PROP_BOOLEAN, PROP_NONE);
3919   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXMA);
3920   RNA_def_property_ui_text(prop, "Material Index", "Deliver material index pass");
3921   if (scene) {
3922     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3923   }
3924   else {
3925     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3926   }
3927
3928   prop = RNA_def_property(srna, "use_pass_shadow", PROP_BOOLEAN, PROP_NONE);
3929   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SHADOW);
3930   RNA_def_property_ui_text(prop, "Shadow", "Deliver shadow pass");
3931   if (scene) {
3932     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3933   }
3934   else {
3935     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3936   }
3937
3938   prop = RNA_def_property(srna, "use_pass_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
3939   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_AO);
3940   RNA_def_property_ui_text(prop, "Ambient Occlusion", "Deliver Ambient Occlusion pass");
3941   if (scene) {
3942     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3943   }
3944   else {
3945     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3946   }
3947
3948   prop = RNA_def_property(srna, "use_pass_emit", PROP_BOOLEAN, PROP_NONE);
3949   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_EMIT);
3950   RNA_def_property_ui_text(prop, "Emit", "Deliver emission pass");
3951   if (scene) {
3952     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3953   }
3954   else {
3955     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3956   }
3957
3958   prop = RNA_def_property(srna, "use_pass_environment", PROP_BOOLEAN, PROP_NONE);
3959   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_ENVIRONMENT);
3960   RNA_def_property_ui_text(prop, "Environment", "Deliver environment lighting pass");
3961   if (scene) {
3962     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3963   }
3964   else {
3965     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3966   }
3967
3968   prop = RNA_def_property(srna, "use_pass_diffuse_direct", PROP_BOOLEAN, PROP_NONE);
3969   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_DIRECT);
3970   RNA_def_property_ui_text(prop, "Diffuse Direct", "Deliver diffuse direct pass");
3971   if (scene) {
3972     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3973   }
3974   else {
3975     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3976   }
3977
3978   prop = RNA_def_property(srna, "use_pass_diffuse_indirect", PROP_BOOLEAN, PROP_NONE);
3979   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_INDIRECT);
3980   RNA_def_property_ui_text(prop, "Diffuse Indirect", "Deliver diffuse indirect pass");
3981   if (scene) {
3982     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3983   }
3984   else {
3985     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3986   }
3987
3988   prop = RNA_def_property(srna, "use_pass_diffuse_color", PROP_BOOLEAN, PROP_NONE);
3989   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_COLOR);
3990   RNA_def_property_ui_text(prop, "Diffuse Color", "Deliver diffuse color pass");
3991   if (scene) {
3992     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
3993   }
3994   else {
3995     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3996   }
3997
3998   prop = RNA_def_property(srna, "use_pass_glossy_direct", PROP_BOOLEAN, PROP_NONE);
3999   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_DIRECT);
4000   RNA_def_property_ui_text(prop, "Glossy Direct", "Deliver glossy direct pass");
4001   if (scene) {
4002     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4003   }
4004   else {
4005     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4006   }
4007
4008   prop = RNA_def_property(srna, "use_pass_glossy_indirect", PROP_BOOLEAN, PROP_NONE);
4009   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_INDIRECT);
4010   RNA_def_property_ui_text(prop, "Glossy Indirect", "Deliver glossy indirect pass");
4011   if (scene) {
4012     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4013   }
4014   else {
4015     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4016   }
4017
4018   prop = RNA_def_property(srna, "use_pass_glossy_color", PROP_BOOLEAN, PROP_NONE);
4019   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_COLOR);
4020   RNA_def_property_ui_text(prop, "Glossy Color", "Deliver glossy color pass");
4021   if (scene) {
4022     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4023   }
4024   else {
4025     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4026   }
4027
4028   prop = RNA_def_property(srna, "use_pass_transmission_direct", PROP_BOOLEAN, PROP_NONE);
4029   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_DIRECT);
4030   RNA_def_property_ui_text(prop, "Transmission Direct", "Deliver transmission direct pass");
4031   if (scene) {
4032     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4033   }
4034   else {
4035     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4036   }
4037
4038   prop = RNA_def_property(srna, "use_pass_transmission_indirect", PROP_BOOLEAN, PROP_NONE);
4039   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_INDIRECT);
4040   RNA_def_property_ui_text(prop, "Transmission Indirect", "Deliver transmission indirect pass");
4041   if (scene) {
4042     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4043   }
4044   else {
4045     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4046   }
4047
4048   prop = RNA_def_property(srna, "use_pass_transmission_color", PROP_BOOLEAN, PROP_NONE);
4049   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_COLOR);
4050   RNA_def_property_ui_text(prop, "Transmission Color", "Deliver transmission color pass");
4051   if (scene) {
4052     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4053   }
4054   else {
4055     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4056   }
4057
4058   prop = RNA_def_property(srna, "use_pass_subsurface_direct", PROP_BOOLEAN, PROP_NONE);
4059   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_DIRECT);
4060   RNA_def_property_ui_text(prop, "Subsurface Direct", "Deliver subsurface direct pass");
4061   if (scene) {
4062     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4063   }
4064   else {
4065     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4066   }
4067
4068   prop = RNA_def_property(srna, "use_pass_subsurface_indirect", PROP_BOOLEAN, PROP_NONE);
4069   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_INDIRECT);
4070   RNA_def_property_ui_text(prop, "Subsurface Indirect", "Deliver subsurface indirect pass");
4071   if (scene) {
4072     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4073   }
4074   else {
4075     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4076   }
4077
4078   prop = RNA_def_property(srna, "use_pass_subsurface_color", PROP_BOOLEAN, PROP_NONE);
4079   RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_COLOR);
4080   RNA_def_property_ui_text(prop, "Subsurface Color", "Deliver subsurface color pass");
4081   if (scene) {
4082     RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_ViewLayer_pass_update");
4083   }
4084   else {
4085     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
4086   }
4087 }
4088
4089 static void rna_def_freestyle_modules(BlenderRNA *brna, PropertyRNA *cprop)
4090 {
4091   StructRNA *srna;
4092   FunctionRNA *func;
4093   PropertyRNA *parm;
4094
4095   RNA_def_property_srna(cprop, "FreestyleModules");
4096   srna = RNA_def_struct(brna, "FreestyleModules", NULL);
4097   RNA_def_struct_sdna(srna, "FreestyleSettings");
4098   RNA_def_struct_ui_text(
4099       srna, "Style Modules", "A list of style modules (to be applied from top to bottom)");
4100
4101   func = RNA_def_function(srna, "new", "rna_FreestyleSettings_module_add");
4102   RNA_def_function_ui_description(func,
4103                                   "Add a style module to scene render layer Freestyle settings");
4104   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
4105   parm = RNA_def_pointer(
4106       func, "module", "FreestyleModuleSettings", "", "Newly created style module");
4107   RNA_def_function_return(func, parm);
4108
4109   func = RNA_def_function(srna, "remove", "rna_FreestyleSettings_module_remove");
4110   RNA_def_function_ui_description(
4111       func, "Remove a style module from scene render layer Freestyle settings");
4112   RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
4113   parm = RNA_def_pointer(func, "module", "FreestyleModuleSettings", "", "Style module to remove");
4114   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
4115   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
4116 }
4117
4118 static void rna_def_freestyle_linesets(BlenderRNA *brna, PropertyRNA *cprop)
4119 {
4120   StructRNA *srna;
4121   PropertyRNA *prop;
4122   FunctionRNA *func;
4123   PropertyRNA *parm;
4124
4125   RNA_def_property_srna(cprop, "Linesets");
4126   srna = RNA_def_struct(brna, "Linesets", NULL);
4127   RNA_def_struct_sdna(srna, "FreestyleSettings");
4128   RNA_def_struct_ui_text(
4129       srna, "Line Sets", "Line sets for associating lines and style parameters");
4130
4131   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
4132   RNA_def_property_struct_type(prop, "FreestyleLineSet");
4133   RNA_def_property_pointer_funcs(
4134       prop, "rna_FreestyleSettings_active_lineset_get", NULL, NULL, NULL);
4135   RNA_def_property_ui_text(prop, "Active Line Set", "Active line set being displayed");
4136