Blender  V3.3
versioning_280.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 /* allow readfile to use deprecated functionality */
8 #define DNA_DEPRECATED_ALLOW
9 
10 #include <float.h>
11 #include <string.h>
12 
13 #include "BLI_listbase.h"
14 #include "BLI_math.h"
15 #include "BLI_mempool.h"
16 #include "BLI_string.h"
17 #include "BLI_utildefines.h"
18 
19 #include "DNA_defaults.h"
20 
21 #include "DNA_anim_types.h"
22 #include "DNA_armature_types.h"
23 #include "DNA_camera_types.h"
24 #include "DNA_cloth_types.h"
25 #include "DNA_collection_types.h"
26 #include "DNA_constraint_types.h"
27 #include "DNA_curve_types.h"
28 #include "DNA_curveprofile_types.h"
29 #include "DNA_fluid_types.h"
30 #include "DNA_freestyle_types.h"
31 #include "DNA_genfile.h"
33 #include "DNA_gpencil_types.h"
34 #include "DNA_gpu_types.h"
35 #include "DNA_key_types.h"
36 #include "DNA_layer_types.h"
37 #include "DNA_light_types.h"
38 #include "DNA_lightprobe_types.h"
39 #include "DNA_linestyle_types.h"
40 #include "DNA_material_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_modifier_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_particle_types.h"
45 #include "DNA_rigidbody_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_screen_types.h"
48 #include "DNA_shader_fx_types.h"
49 #include "DNA_text_types.h"
50 #include "DNA_texture_types.h"
51 #include "DNA_view3d_types.h"
52 #include "DNA_workspace_types.h"
53 #include "DNA_world_types.h"
54 
55 #include "BKE_animsys.h"
56 #include "BKE_brush.h"
57 #include "BKE_cloth.h"
58 #include "BKE_collection.h"
59 #include "BKE_colortools.h"
60 #include "BKE_constraint.h"
61 #include "BKE_curveprofile.h"
62 #include "BKE_customdata.h"
63 #include "BKE_fcurve.h"
64 #include "BKE_fcurve_driver.h"
65 #include "BKE_freestyle.h"
66 #include "BKE_global.h"
67 #include "BKE_gpencil.h"
68 #include "BKE_gpencil_geom.h"
69 #include "BKE_gpencil_modifier.h"
70 #include "BKE_idprop.h"
71 #include "BKE_key.h"
72 #include "BKE_layer.h"
73 #include "BKE_lib_id.h"
74 #include "BKE_main.h"
75 #include "BKE_mesh.h"
77 #include "BKE_node.h"
78 #include "BKE_node_tree_update.h"
79 #include "BKE_paint.h"
80 #include "BKE_pointcache.h"
81 #include "BKE_report.h"
82 #include "BKE_rigidbody.h"
83 #include "BKE_screen.h"
84 #include "BKE_studiolight.h"
85 #include "BKE_unit.h"
86 #include "BKE_workspace.h"
87 
88 #include "SEQ_iterator.h"
89 #include "SEQ_modifier.h"
90 #include "SEQ_utils.h"
91 
92 /* Only for IMB_BlendMode */
93 #include "IMB_imbuf.h"
94 
95 #include "DEG_depsgraph.h"
96 
97 #include "BLT_translation.h"
98 
99 #include "BLO_readfile.h"
100 #include "readfile.h"
101 
102 #include "versioning_common.h"
103 
104 #include "MEM_guardedalloc.h"
105 
106 /* Make preferences read-only, use versioning_userdef.c. */
107 #define U (*((const UserDef *)&U))
108 
109 static bScreen *screen_parent_find(const bScreen *screen)
110 {
111  /* Can avoid lookup if screen state isn't maximized/full
112  * (parent and child store the same state). */
113  if (ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL)) {
114  LISTBASE_FOREACH (const ScrArea *, area, &screen->areabase) {
115  if (area->full && area->full != screen) {
116  BLI_assert(area->full->state == screen->state);
117  return area->full;
118  }
119  }
120  }
121 
122  return NULL;
123 }
124 
126 {
127  bmain->is_locked_for_linking = false;
128 
129  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
130  const bScreen *screen_parent = screen_parent_find(screen);
131  WorkSpace *workspace;
132  if (screen->temp) {
133  continue;
134  }
135 
136  if (screen_parent) {
137  /* Full-screen with "Back to Previous" option, don't create
138  * a new workspace, add layout workspace containing parent. */
139  workspace = BLI_findstring(
140  &bmain->workspaces, screen_parent->id.name + 2, offsetof(ID, name) + 2);
141  }
142  else {
143  workspace = BKE_workspace_add(bmain, screen->id.name + 2);
144  }
145  if (workspace == NULL) {
146  continue; /* Not much we can do. */
147  }
148  BKE_workspace_layout_add(bmain, workspace, screen, screen->id.name + 2);
149  }
150 
151  bmain->is_locked_for_linking = true;
152 }
153 
155 {
157  SpaceAction *saction = (SpaceAction *)stype->create(area, scene);
158  ARegion *region_channels;
159 
160  /* Properly free current regions */
161  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
162  BKE_area_region_free(area->type, region);
163  }
164  BLI_freelistN(&area->regionbase);
165 
166  area->type = stype;
167  area->spacetype = stype->spaceid;
168 
169  BLI_addhead(&area->spacedata, saction);
170  area->regionbase = saction->regionbase;
171  BLI_listbase_clear(&saction->regionbase);
172 
173  /* Different defaults for timeline */
175  region_channels->flag |= RGN_FLAG_HIDDEN;
176 
177  saction->mode = SACTCONT_TIMELINE;
178  saction->ads.flag |= ADS_FLAG_SUMMARY_COLLAPSED;
179  saction->ads.filterflag |= ADS_FILTER_SUMMARY;
180 }
181 
195 {
197 
199 
200  for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
201  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
202  bScreen *screen_parent = screen_parent_find(win->screen);
203  bScreen *screen = screen_parent ? screen_parent : win->screen;
204 
205  if (screen->temp) {
206  /* We do not generate a new workspace for those screens...
207  * still need to set some data in win. */
208  win->workspace_hook = BKE_workspace_instance_hook_create(bmain, win->winid);
209  win->scene = screen->scene;
210  /* Deprecated from now on! */
211  win->screen = NULL;
212  continue;
213  }
214 
215  WorkSpace *workspace = BLI_findstring(
216  &bmain->workspaces, screen->id.name + 2, offsetof(ID, name) + 2);
217  BLI_assert(workspace != NULL);
218  WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, win->screen);
219  BLI_assert(layout != NULL);
220 
221  win->workspace_hook = BKE_workspace_instance_hook_create(bmain, win->winid);
222 
223  BKE_workspace_active_set(win->workspace_hook, workspace);
224  BKE_workspace_active_layout_set(win->workspace_hook, win->winid, workspace, layout);
225 
226  /* Move scene and view layer to window. */
227  Scene *scene = screen->scene;
228  ViewLayer *layer = BLI_findlink(&scene->view_layers, scene->r.actlay);
229  if (!layer) {
231  }
232 
233  win->scene = scene;
234  STRNCPY(win->view_layer_name, layer->name);
235 
236  /* Deprecated from now on! */
237  win->screen = NULL;
238  }
239  }
240 
241  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
242  /* Deprecated from now on! */
243  BLI_freelistN(&screen->scene->transform_spaces);
244  screen->scene = NULL;
245  }
246 }
247 
248 #ifdef USE_COLLECTION_COMPAT_28
249 enum {
250  COLLECTION_DEPRECATED_VISIBLE = (1 << 0),
251  COLLECTION_DEPRECATED_VIEWPORT = (1 << 0),
252  COLLECTION_DEPRECATED_SELECTABLE = (1 << 1),
253  COLLECTION_DEPRECATED_DISABLED = (1 << 2),
254  COLLECTION_DEPRECATED_RENDER = (1 << 3),
255 };
256 
257 static void do_version_view_layer_visibility(ViewLayer *view_layer)
258 {
259  /* Convert from deprecated VISIBLE flag to DISABLED */
260  LayerCollection *lc;
261  for (lc = view_layer->layer_collections.first; lc; lc = lc->next) {
262  if (lc->flag & COLLECTION_DEPRECATED_DISABLED) {
263  lc->flag &= ~COLLECTION_DEPRECATED_DISABLED;
264  }
265 
266  if ((lc->flag & COLLECTION_DEPRECATED_VISIBLE) == 0) {
267  lc->flag |= COLLECTION_DEPRECATED_DISABLED;
268  }
269 
270  lc->flag |= COLLECTION_DEPRECATED_VIEWPORT | COLLECTION_DEPRECATED_RENDER;
271  }
272 }
273 
274 static void do_version_layer_collection_pre(ViewLayer *view_layer,
275  ListBase *lb,
276  GSet *enabled_set,
277  GSet *selectable_set)
278 {
279  /* Convert from deprecated DISABLED to new layer collection and collection flags */
280  LISTBASE_FOREACH (LayerCollection *, lc, lb) {
281  if (lc->scene_collection) {
282  if (!(lc->flag & COLLECTION_DEPRECATED_DISABLED)) {
283  BLI_gset_insert(enabled_set, lc->scene_collection);
284  }
285  if (lc->flag & COLLECTION_DEPRECATED_SELECTABLE) {
286  BLI_gset_insert(selectable_set, lc->scene_collection);
287  }
288  }
289 
290  do_version_layer_collection_pre(
291  view_layer, &lc->layer_collections, enabled_set, selectable_set);
292  }
293 }
294 
295 static void do_version_layer_collection_post(ViewLayer *view_layer,
296  ListBase *lb,
297  GSet *enabled_set,
298  GSet *selectable_set,
299  GHash *collection_map)
300 {
301  /* Apply layer collection exclude flags. */
302  LISTBASE_FOREACH (LayerCollection *, lc, lb) {
303  if (!(lc->collection->flag & COLLECTION_IS_MASTER)) {
304  SceneCollection *sc = BLI_ghash_lookup(collection_map, lc->collection);
305  const bool enabled = (sc && BLI_gset_haskey(enabled_set, sc));
306  const bool selectable = (sc && BLI_gset_haskey(selectable_set, sc));
307 
308  if (!enabled) {
310  }
311  if (enabled && !selectable) {
313  }
314  }
315 
316  do_version_layer_collection_post(
317  view_layer, &lc->layer_collections, enabled_set, selectable_set, collection_map);
318  }
319 }
320 
321 static void do_version_scene_collection_convert(
322  Main *bmain, ID *id, SceneCollection *sc, Collection *collection, GHash *collection_map)
323 {
324  if (collection_map) {
325  BLI_ghash_insert(collection_map, collection, sc);
326  }
327 
328  for (SceneCollection *nsc = sc->scene_collections.first; nsc;) {
329  SceneCollection *nsc_next = nsc->next;
330  Collection *ncollection = BKE_collection_add(bmain, collection, nsc->name);
331  ncollection->id.lib = id->lib;
332  do_version_scene_collection_convert(bmain, id, nsc, ncollection, collection_map);
333  nsc = nsc_next;
334  }
335 
336  LISTBASE_FOREACH (LinkData *, link, &sc->objects) {
337  Object *ob = link->data;
338  if (ob) {
339  BKE_collection_object_add_notest(bmain, collection, ob);
340  id_us_min(&ob->id);
341  }
342  }
343 
344  BLI_freelistN(&sc->objects);
345  MEM_freeN(sc);
346 }
347 
348 static void do_version_group_collection_to_collection(Main *bmain, Collection *group)
349 {
350  /* Convert old 2.8 group collections to new unified collections. */
351  if (group->collection) {
352  do_version_scene_collection_convert(bmain, &group->id, group->collection, group, NULL);
353  }
354 
355  group->collection = NULL;
356  group->view_layer = NULL;
357  id_fake_user_set(&group->id);
358 }
359 
360 static void do_version_scene_collection_to_collection(Main *bmain, Scene *scene)
361 {
362  /* Convert old 2.8 scene collections to new unified collections. */
363 
364  /* Temporarily clear view layers so we don't do any layer collection syncing
365  * and destroy old flags that we want to restore. */
366  ListBase view_layers = scene->view_layers;
368 
369  if (!scene->master_collection) {
371  }
372 
373  /* Convert scene collections. */
374  GHash *collection_map = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
375  if (scene->collection) {
376  do_version_scene_collection_convert(
377  bmain, &scene->id, scene->collection, scene->master_collection, collection_map);
378  scene->collection = NULL;
379  }
380 
381  scene->view_layers = view_layers;
382 
383  /* Convert layer collections. */
384  ViewLayer *view_layer;
385  for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
386  GSet *enabled_set = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
387  GSet *selectable_set = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
388 
389  do_version_layer_collection_pre(
390  view_layer, &view_layer->layer_collections, enabled_set, selectable_set);
391 
393 
394  BKE_layer_collection_sync(scene, view_layer);
395 
396  do_version_layer_collection_post(
397  view_layer, &view_layer->layer_collections, enabled_set, selectable_set, collection_map);
398 
399  BLI_gset_free(enabled_set, NULL);
400  BLI_gset_free(selectable_set, NULL);
401 
402  BKE_layer_collection_sync(scene, view_layer);
403  }
404 
405  BLI_ghash_free(collection_map, NULL, NULL);
406 }
407 #endif
408 
410 {
411  /* Since we don't have access to FileData we check the (always valid) first
412  * render layer instead. */
413  if (!scene->master_collection) {
415  }
416 
417  if (scene->view_layers.first) {
418  return;
419  }
420 
421  /* Create collections from layers. */
422  Collection *collection_master = scene->master_collection;
423  Collection *collections[20] = {NULL};
424 
425  for (int layer = 0; layer < 20; layer++) {
426  LISTBASE_FOREACH (Base *, base, &scene->base) {
427  if (base->lay & (1 << layer)) {
428  /* Create collections when needed only. */
429  if (collections[layer] == NULL) {
430  char name[MAX_NAME];
431 
432  BLI_snprintf(
433  name, sizeof(collection_master->id.name), DATA_("Collection %d"), layer + 1);
434 
435  Collection *collection = BKE_collection_add(bmain, collection_master, name);
436  collection->id.lib = scene->id.lib;
437  if (ID_IS_LINKED(collection)) {
438  collection->id.tag |= LIB_TAG_INDIRECT;
439  }
440  collections[layer] = collection;
441 
442  if (!(scene->lay & (1 << layer))) {
444  }
445  }
446 
447  /* Note usually this would do slow collection syncing for view layers,
448  * but since no view layers exists yet at this point it's fast. */
449  BKE_collection_object_add_notest(bmain, collections[layer], base->object);
450  }
451 
452  if (base->flag & SELECT) {
453  base->object->flag |= SELECT;
454  }
455  else {
456  base->object->flag &= ~SELECT;
457  }
458  }
459  }
460 
461  /* Handle legacy render layers. */
462  bool have_override = false;
463  const bool need_default_renderlayer = scene->r.layers.first == NULL;
464 
465  LISTBASE_FOREACH (SceneRenderLayer *, srl, &scene->r.layers) {
467 
468  if (srl->layflag & SCE_LAY_DISABLE) {
469  view_layer->flag &= ~VIEW_LAYER_RENDER;
470  }
471 
472  if ((srl->layflag & SCE_LAY_FRS) == 0) {
473  view_layer->flag &= ~VIEW_LAYER_FREESTYLE;
474  }
475 
476  view_layer->layflag = srl->layflag;
477  view_layer->passflag = srl->passflag;
478  view_layer->pass_alpha_threshold = srl->pass_alpha_threshold;
479  view_layer->samples = srl->samples;
480  view_layer->mat_override = srl->mat_override;
481 
482  BKE_freestyle_config_free(&view_layer->freestyle_config, true);
483  view_layer->freestyle_config = srl->freestyleConfig;
484  view_layer->id_properties = srl->prop;
485 
486  /* Set exclusion and overrides. */
487  for (int layer = 0; layer < 20; layer++) {
488  Collection *collection = collections[layer];
489  if (collection) {
491  collection);
492 
493  if (srl->lay_exclude & (1 << layer)) {
494  /* Disable excluded layer. */
495  have_override = true;
498  nlc->flag |= LAYER_COLLECTION_EXCLUDE;
499  }
500  }
501  else {
502  if (srl->lay_zmask & (1 << layer)) {
503  have_override = true;
505  }
506 
507  if ((srl->lay & (1 << layer)) == 0) {
508  have_override = true;
510  }
511  }
512  }
513  }
514 
515  /* for convenience set the same active object in all the layers */
516  if (scene->basact) {
517  view_layer->basact = BKE_view_layer_base_find(view_layer, scene->basact->object);
518  }
519 
520  LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
521  if ((base->flag & BASE_SELECTABLE) && (base->object->flag & SELECT)) {
522  base->flag |= BASE_SELECTED;
523  }
524  }
525  }
526 
527  BLI_freelistN(&scene->r.layers);
528 
529  /* If render layers included overrides, or there are no render layers,
530  * we also create a vanilla viewport layer. */
531  if (have_override || need_default_renderlayer) {
532  ViewLayer *view_layer = BKE_view_layer_add(scene, "Viewport", NULL, VIEWLAYER_ADD_NEW);
533 
534  /* If we ported all the original render layers,
535  * we don't need to make the viewport layer renderable. */
537  view_layer->flag &= ~VIEW_LAYER_RENDER;
538  }
539 
540  /* convert active base */
541  if (scene->basact) {
542  view_layer->basact = BKE_view_layer_base_find(view_layer, scene->basact->object);
543  }
544 
545  /* convert selected bases */
546  LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
547  if ((base->flag & BASE_SELECTABLE) && (base->object->flag & SELECT)) {
548  base->flag |= BASE_SELECTED;
549  }
550 
551  /* keep lay around for forward compatibility (open those files in 2.79) */
552  base->lay = base->object->lay;
553  }
554  }
555 
556  /* remove bases once and for all */
557  LISTBASE_FOREACH (Base *, base, &scene->base) {
558  id_us_min(&base->object->id);
559  }
560 
561  BLI_freelistN(&scene->base);
562  scene->basact = NULL;
563 }
564 
566 {
567  if (ID_IS_LINKED(collection)) {
568  for (CollectionChild *collection_child = collection->children.first; collection_child != NULL;
569  collection_child = collection_child->next) {
570  if (!ID_IS_LINKED(collection_child->collection)) {
571  collection_child->collection->id.lib = collection->id.lib;
572  }
573  do_version_collection_propagate_lib_to_children(collection_child->collection);
574  }
575  }
576 }
577 
580 {
581  LISTBASE_FOREACH (const bGPDpalette *, palette, &gpd->palettes) {
582  LISTBASE_FOREACH (bGPDpalettecolor *, palcolor, &palette->colors) {
583  /* fix layers */
584  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
585  /* unlock/unhide layer */
586  gpl->flag &= ~GP_LAYER_LOCKED;
587  gpl->flag &= ~GP_LAYER_HIDE;
588  /* set opacity to 1 */
589  gpl->opacity = 1.0f;
590  /* disable tint */
591  gpl->tintcolor[3] = 0.0f;
592 
593  LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
594  LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
595  if ((gps->colorname[0] != '\0') && (STREQ(gps->colorname, palcolor->info))) {
596  /* copy color settings */
597  copy_v4_v4(gpl->color, palcolor->color);
598  }
599  }
600  }
601  }
602  }
603  }
604 }
605 
606 static void do_versions_remove_region(ListBase *regionbase, ARegion *region)
607 {
608  BLI_freelinkN(regionbase, region);
609 }
610 
611 static void do_versions_remove_regions_by_type(ListBase *regionbase, int regiontype)
612 {
613  ARegion *region, *region_next;
614  for (region = regionbase->first; region; region = region_next) {
615  region_next = region->next;
616  if (region->regiontype == regiontype) {
617  do_versions_remove_region(regionbase, region);
618  }
619  }
620 }
621 
622 static ARegion *do_versions_find_region_or_null(ListBase *regionbase, int regiontype)
623 {
624  LISTBASE_FOREACH (ARegion *, region, regionbase) {
625  if (region->regiontype == regiontype) {
626  return region;
627  }
628  }
629  return NULL;
630 }
631 
632 static ARegion *do_versions_find_region(ListBase *regionbase, int regiontype)
633 {
634  ARegion *region = do_versions_find_region_or_null(regionbase, regiontype);
635  if (region == NULL) {
636  BLI_assert_msg(0, "Did not find expected region in versioning");
637  }
638  return region;
639 }
640 
642  const short space_type,
643  const short region_flag)
644 {
645  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
646  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
647  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
648  if (sl->spacetype == space_type) {
649  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
650  &sl->regionbase;
652  if (!region) {
654  region = do_versions_add_region(RGN_TYPE_TOOLS, "tools region");
655  BLI_insertlinkafter(regionbase, header, region);
656  region->alignment = RGN_ALIGN_LEFT;
657  region->flag = region_flag;
658  }
659  }
660  }
661  }
662  }
663 }
664 
666 {
667  LISTBASE_FOREACH (Bone *, bone, lb) {
668  bone->scale_in_z = bone->scale_in_x;
669  bone->scale_out_z = bone->scale_out_x;
670 
671  do_version_bones_split_bbone_scale(&bone->childbase);
672  }
673 }
674 
676 {
677  LISTBASE_FOREACH (Bone *, bone, lb) {
678  if (bone->flag & BONE_NO_SCALE) {
679  bone->inherit_scale_mode = BONE_INHERIT_SCALE_NONE_LEGACY;
680  bone->flag &= ~BONE_NO_SCALE;
681  }
682 
683  do_version_bones_inherit_scale(&bone->childbase);
684  }
685 }
686 
687 static bool replace_bbone_scale_rnapath(char **p_old_path)
688 {
689  char *old_path = *p_old_path;
690 
691  if (old_path == NULL) {
692  return false;
693  }
694 
695  if (BLI_str_endswith(old_path, "bbone_scalein") ||
696  BLI_str_endswith(old_path, "bbone_scaleout")) {
697  *p_old_path = BLI_strdupcat(old_path, "x");
698 
699  MEM_freeN(old_path);
700  return true;
701  }
702 
703  return false;
704 }
705 
707 {
708  /* Update driver variable paths. */
709  if (fcu->driver) {
710  LISTBASE_FOREACH (DriverVar *, dvar, &fcu->driver->variables) {
712  replace_bbone_scale_rnapath(&dtar->rna_path);
713  }
715  }
716  }
717 
718  /* Update F-Curve's path. */
720  /* If matched, duplicate the curve and tweak name. */
721  FCurve *second = BKE_fcurve_copy(fcu);
722 
723  second->rna_path[strlen(second->rna_path) - 1] = 'y';
724 
725  BLI_insertlinkafter(curves, fcu, second);
726 
727  /* Add to the curve group. */
728  second->grp = fcu->grp;
729 
730  if (fcu->grp != NULL && fcu->grp->channels.last == fcu) {
731  fcu->grp->channels.last = second;
732  }
733  }
734 }
735 
737  AnimData *adt,
738  void *UNUSED(wrapper_data))
739 {
740  LISTBASE_FOREACH_MUTABLE (FCurve *, fcu, &adt->drivers) {
742  }
743 }
744 
746 {
747  LISTBASE_FOREACH (bConstraint *, con, lb) {
748  if (con->type == CONSTRAINT_TYPE_SAMEVOL) {
750  data->mode = SAMEVOL_UNIFORM;
751  }
752  }
753 }
754 
756 {
757  LISTBASE_FOREACH (bConstraint *, con, lb) {
758  if (con->type == CONSTRAINT_TYPE_SIZELIKE) {
760  data->power = 1.0f;
761  }
762  }
763 }
764 
766 {
767  LISTBASE_FOREACH (bConstraint *, con, lb) {
768  if (con->type == CONSTRAINT_TYPE_ROTLIKE) {
770  data->mix_mode = (data->flag & ROTLIKE_OFFSET) ? ROTLIKE_MIX_OFFSET : ROTLIKE_MIX_REPLACE;
771  data->flag &= ~ROTLIKE_OFFSET;
772  }
773  }
774 }
775 
777 {
778  for (Sequence *seq = seqbase->first; seq != NULL; seq = seq->next) {
779  if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) == 0) {
780  if (seq->strip->transform == NULL) {
781  seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
782  }
783 
784  if (seq->strip->crop == NULL) {
785  seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
786  }
787 
788  if (seq->seqbase.first != NULL) {
790  }
791  }
792  }
793 }
794 
795 /* Return true if there is something to convert. */
797 {
798  bool need_update = false;
799 
800  /* Iterate backwards from end so we don't encounter newly added links. */
801  bNodeLink *prevlink;
802  for (bNodeLink *link = ntree->links.last; link; link = prevlink) {
803  prevlink = link->prev;
804 
805  /* Detect link to replace. */
806  bNode *fromnode = link->fromnode;
807  bNodeSocket *fromsock = link->fromsock;
808  bNode *tonode = link->tonode;
809  bNodeSocket *tosock = link->tosock;
810 
811  if (!(tonode->type == SH_NODE_OUTPUT_MATERIAL && STREQ(tosock->identifier, "Surface"))) {
812  continue;
813  }
814 
815  /* Only do outputs that are enabled for EEVEE */
816  if (!ELEM(tonode->custom1, SHD_OUTPUT_ALL, SHD_OUTPUT_EEVEE)) {
817  continue;
818  }
819 
820  if (blend_method == 1 /* MA_BM_ADD */) {
821  nodeRemLink(ntree, link);
822 
824  add_node->locx = 0.5f * (fromnode->locx + tonode->locx);
825  add_node->locy = 0.5f * (fromnode->locy + tonode->locy);
826 
827  bNodeSocket *shader1_socket = add_node->inputs.first;
828  bNodeSocket *shader2_socket = add_node->inputs.last;
829  bNodeSocket *add_socket = nodeFindSocket(add_node, SOCK_OUT, "Shader");
830 
832  transp_node->locx = add_node->locx;
833  transp_node->locy = add_node->locy - 110.0f;
834 
835  bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
836 
837  /* Link to input and material output node. */
838  nodeAddLink(ntree, fromnode, fromsock, add_node, shader1_socket);
839  nodeAddLink(ntree, transp_node, transp_socket, add_node, shader2_socket);
840  nodeAddLink(ntree, add_node, add_socket, tonode, tosock);
841 
842  need_update = true;
843  }
844  else if (blend_method == 2 /* MA_BM_MULTIPLY */) {
845  nodeRemLink(ntree, link);
846 
848 
849  bNodeSocket *color_socket = nodeFindSocket(transp_node, SOCK_IN, "Color");
850  bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
851 
852  /* If incoming link is from a closure socket, we need to convert it. */
853  if (fromsock->type == SOCK_SHADER) {
854  transp_node->locx = 0.33f * fromnode->locx + 0.66f * tonode->locx;
855  transp_node->locy = 0.33f * fromnode->locy + 0.66f * tonode->locy;
856 
858  shtorgb_node->locx = 0.66f * fromnode->locx + 0.33f * tonode->locx;
859  shtorgb_node->locy = 0.66f * fromnode->locy + 0.33f * tonode->locy;
860 
861  bNodeSocket *shader_socket = nodeFindSocket(shtorgb_node, SOCK_IN, "Shader");
862  bNodeSocket *rgba_socket = nodeFindSocket(shtorgb_node, SOCK_OUT, "Color");
863 
864  nodeAddLink(ntree, fromnode, fromsock, shtorgb_node, shader_socket);
865  nodeAddLink(ntree, shtorgb_node, rgba_socket, transp_node, color_socket);
866  }
867  else {
868  transp_node->locx = 0.5f * (fromnode->locx + tonode->locx);
869  transp_node->locy = 0.5f * (fromnode->locy + tonode->locy);
870 
871  nodeAddLink(ntree, fromnode, fromsock, transp_node, color_socket);
872  }
873 
874  /* Link to input and material output node. */
875  nodeAddLink(ntree, transp_node, transp_socket, tonode, tosock);
876 
877  need_update = true;
878  }
879  }
880 
881  if (need_update) {
883  }
884 }
885 
887 {
888  layer_collection->local_collections_bits = ~(0);
889  LISTBASE_FOREACH (LayerCollection *, child, &layer_collection->layer_collections) {
891  }
892 }
893 
895 {
896  if (cumap == NULL) {
897  return;
898  }
899 
900 #define CUMA_EXTEND_EXTRAPOLATE_OLD 1
901  for (int curve_map_index = 0; curve_map_index < 4; curve_map_index++) {
902  CurveMap *cuma = &cumap->cm[curve_map_index];
903  if (cuma->flag & CUMA_EXTEND_EXTRAPOLATE_OLD) {
904  cumap->flag |= CUMA_EXTEND_EXTRAPOLATE;
905  return;
906  }
907  }
908 #undef CUMA_EXTEND_EXTRAPOLATE_OLD
909 }
910 
911 /* Util version to walk over all CurveMappings in the given `bmain` */
912 static void do_version_curvemapping_walker(Main *bmain, void (*callback)(CurveMapping *cumap))
913 {
914  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
916 
919  }
920 
921  if (scene->ed != NULL) {
922  LISTBASE_FOREACH (Sequence *, seq, &scene->ed->seqbase) {
923  LISTBASE_FOREACH (SequenceModifierData *, smd, &seq->modifiers) {
924  const SequenceModifierTypeInfo *smti = SEQ_modifier_type_info_get(smd->type);
925 
926  if (smti) {
927  if (smd->type == seqModifierType_Curves) {
929  callback(&cmd->curve_mapping);
930  }
931  else if (smd->type == seqModifierType_HueCorrect) {
933  callback(&hcmd->curve_mapping);
934  }
935  }
936  }
937  }
938  }
939 
940  /* toolsettings */
942  if (ts->vpaint) {
944  }
945  if (ts->wpaint) {
947  }
948  if (ts->sculpt) {
950  }
951  if (ts->uvsculpt) {
953  }
954  if (ts->gp_paint) {
956  }
957  if (ts->gp_interpolate.custom_ipo) {
959  }
960  if (ts->gp_sculpt.cur_falloff) {
962  }
963  if (ts->gp_sculpt.cur_primitive) {
965  }
967  }
968 
969  FOREACH_NODETREE_BEGIN (bmain, node_tree, id) {
970  LISTBASE_FOREACH (bNode *, node, &node_tree->nodes) {
971  if (ELEM(node->type,
980  callback((CurveMapping *)node->storage);
981  }
982  }
983  }
985 
986  LISTBASE_FOREACH (Light *, light, &bmain->lights) {
987  if (light->curfalloff) {
988  callback(light->curfalloff);
989  }
990  }
991 
992  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
993  if (brush->curve) {
994  callback(brush->curve);
995  }
996  if (brush->gpencil_settings) {
997  if (brush->gpencil_settings->curve_sensitivity) {
998  callback(brush->gpencil_settings->curve_sensitivity);
999  }
1000  if (brush->gpencil_settings->curve_strength) {
1001  callback(brush->gpencil_settings->curve_strength);
1002  }
1003  if (brush->gpencil_settings->curve_jitter) {
1004  callback(brush->gpencil_settings->curve_jitter);
1005  }
1006  }
1007  }
1008 
1009  LISTBASE_FOREACH (ParticleSettings *, part, &bmain->particles) {
1010  if (part->clumpcurve) {
1011  callback(part->clumpcurve);
1012  }
1013  if (part->roughcurve) {
1014  callback(part->roughcurve);
1015  }
1016  if (part->twistcurve) {
1017  callback(part->twistcurve);
1018  }
1019  }
1020 
1021  /* Object */
1022  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1023  /* Object modifiers */
1024  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
1025  if (md->type == eModifierType_Hook) {
1026  HookModifierData *hmd = (HookModifierData *)md;
1027 
1028  if (hmd->curfalloff) {
1029  callback(hmd->curfalloff);
1030  }
1031  }
1032  else if (md->type == eModifierType_Warp) {
1033  WarpModifierData *tmd = (WarpModifierData *)md;
1034  if (tmd->curfalloff) {
1035  callback(tmd->curfalloff);
1036  }
1037  }
1038  else if (md->type == eModifierType_WeightVGEdit) {
1040 
1041  if (wmd->cmap_curve) {
1042  callback(wmd->cmap_curve);
1043  }
1044  }
1045  }
1046  /* Grease pencil modifiers */
1047  LISTBASE_FOREACH (ModifierData *, md, &ob->greasepencil_modifiers) {
1048  if (md->type == eGpencilModifierType_Thick) {
1050 
1051  if (gpmd->curve_thickness) {
1052  callback(gpmd->curve_thickness);
1053  }
1054  }
1055  else if (md->type == eGpencilModifierType_Hook) {
1057 
1058  if (gpmd->curfalloff) {
1059  callback(gpmd->curfalloff);
1060  }
1061  }
1062  else if (md->type == eGpencilModifierType_Noise) {
1064 
1065  if (gpmd->curve_intensity) {
1066  callback(gpmd->curve_intensity);
1067  }
1068  }
1069  else if (md->type == eGpencilModifierType_Tint) {
1071 
1072  if (gpmd->curve_intensity) {
1073  callback(gpmd->curve_intensity);
1074  }
1075  }
1076  else if (md->type == eGpencilModifierType_Smooth) {
1078 
1079  if (gpmd->curve_intensity) {
1080  callback(gpmd->curve_intensity);
1081  }
1082  }
1083  else if (md->type == eGpencilModifierType_Color) {
1085 
1086  if (gpmd->curve_intensity) {
1087  callback(gpmd->curve_intensity);
1088  }
1089  }
1090  else if (md->type == eGpencilModifierType_Opacity) {
1092 
1093  if (gpmd->curve_intensity) {
1094  callback(gpmd->curve_intensity);
1095  }
1096  }
1097  }
1098  }
1099 
1100  /* Free Style */
1103  switch (m->type) {
1106  break;
1109  break;
1112  break;
1113  case LS_MODIFIER_MATERIAL:
1115  break;
1116  case LS_MODIFIER_TANGENT:
1118  break;
1119  case LS_MODIFIER_NOISE:
1121  break;
1124  break;
1127  break;
1128  }
1129  }
1130 
1132  switch (m->type) {
1135  break;
1138  break;
1141  break;
1142  case LS_MODIFIER_MATERIAL:
1144  break;
1145  case LS_MODIFIER_TANGENT:
1147  break;
1150  break;
1153  break;
1154  }
1155  }
1156  }
1157 }
1158 
1160  struct FCurve *fcu,
1161  void *UNUSED(user_data))
1162 {
1163  if (fcu->rna_path == NULL || !STREQ(fcu->rna_path, "hide")) {
1164  return;
1165  }
1166 
1167  MEM_freeN(fcu->rna_path);
1168  fcu->rna_path = BLI_strdupn("hide_viewport", 13);
1169 }
1170 
1172 {
1173  bool use_collection_compat_28 = true;
1174 
1175  if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1176  use_collection_compat_28 = false;
1177 
1178  /* Convert group layer visibility flags to hidden nested collection. */
1179  for (Collection *collection = bmain->collections.first; collection;
1180  collection = collection->id.next) {
1181  /* Add fake user for all existing groups. */
1182  id_fake_user_set(&collection->id);
1183 
1184  if (collection->flag & (COLLECTION_HIDE_VIEWPORT | COLLECTION_HIDE_RENDER)) {
1185  continue;
1186  }
1187 
1188  Collection *hidden_collection_array[20] = {NULL};
1189  for (CollectionObject *cob = collection->gobject.first, *cob_next = NULL; cob;
1190  cob = cob_next) {
1191  cob_next = cob->next;
1192  Object *ob = cob->ob;
1193 
1194  if (!(ob->lay & collection->layer)) {
1195  /* Find or create hidden collection matching object's first layer. */
1196  Collection **collection_hidden = NULL;
1197  int coll_idx = 0;
1198  for (; coll_idx < 20; coll_idx++) {
1199  if (ob->lay & (1 << coll_idx)) {
1200  collection_hidden = &hidden_collection_array[coll_idx];
1201  break;
1202  }
1203  }
1204  if (collection_hidden == NULL) {
1205  /* This should never happen (objects are always supposed to be instantiated in a
1206  * scene), but it does sometimes, see e.g. T81168.
1207  * Just put them in first hidden collection in those cases. */
1208  collection_hidden = &hidden_collection_array[0];
1209  }
1210 
1211  if (*collection_hidden == NULL) {
1212  char name[MAX_ID_NAME];
1213  BLI_snprintf(name, sizeof(name), DATA_("Hidden %d"), coll_idx + 1);
1214  *collection_hidden = BKE_collection_add(bmain, collection, name);
1215  (*collection_hidden)->flag |= COLLECTION_HIDE_VIEWPORT | COLLECTION_HIDE_RENDER;
1216  }
1217 
1218  BKE_collection_object_add_notest(bmain, *collection_hidden, ob);
1219  BKE_collection_object_remove(bmain, collection, ob, true);
1220  }
1221  }
1222  }
1223 
1224  /* We need to assign lib pointer to generated hidden collections *after* all have been
1225  * created, otherwise we'll end up with several data-blocks sharing same name/library,
1226  * which is FORBIDDEN! NOTE: we need this to be recursive, since a child collection may be
1227  * sorted before its parent in bmain. */
1228  for (Collection *collection = bmain->collections.first; collection != NULL;
1229  collection = collection->id.next) {
1231  }
1232 
1233  /* Convert layers to collections. */
1234  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1236  }
1237  }
1238 
1239  if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1240  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1241  BLO_read_assert_message(screen->scene == NULL,
1242  ,
1243  (BlendHandle *)fd,
1244  bmain,
1245  "No Screen data-block should ever have a NULL `scene` pointer");
1246 
1247  /* same render-layer as do_version_workspaces_after_lib_link will activate,
1248  * so same layer as BKE_view_layer_default_view would return */
1249  ViewLayer *layer = screen->scene->view_layers.first;
1250 
1251  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1252  LISTBASE_FOREACH (SpaceLink *, space, &area->spacedata) {
1253  if (space->spacetype == SPACE_OUTLINER) {
1254  SpaceOutliner *space_outliner = (SpaceOutliner *)space;
1255 
1256  space_outliner->outlinevis = SO_VIEW_LAYER;
1257 
1258  if (BLI_listbase_count_at_most(&layer->layer_collections, 2) == 1) {
1259  if (space_outliner->treestore == NULL) {
1260  space_outliner->treestore = BLI_mempool_create(
1261  sizeof(TreeStoreElem), 1, 512, BLI_MEMPOOL_ALLOW_ITER);
1262  }
1263 
1264  /* Create a tree store element for the collection. This is normally
1265  * done in check_persistent (outliner_tree.c), but we need to access
1266  * it here :/ (expand element if it's the only one) */
1267  TreeStoreElem *tselem = BLI_mempool_calloc(space_outliner->treestore);
1268  tselem->type = TSE_LAYER_COLLECTION;
1269  tselem->id = layer->layer_collections.first;
1270  tselem->nr = tselem->used = 0;
1271  tselem->flag &= ~TSE_CLOSED;
1272  }
1273  }
1274  }
1275  }
1276  }
1277  }
1278 
1279  if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1280  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1281  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1282  LISTBASE_FOREACH (SpaceLink *, space, &area->spacedata) {
1283  if (space->spacetype == SPACE_IMAGE) {
1284  SpaceImage *sima = (SpaceImage *)space;
1285  if ((sima) && (sima->gpd)) {
1286  sima->gpd->flag |= GP_DATA_ANNOTATIONS;
1288  }
1289  }
1290  if (space->spacetype == SPACE_CLIP) {
1291  SpaceClip *spclip = (SpaceClip *)space;
1292  MovieClip *clip = spclip->clip;
1293  if ((clip) && (clip->gpd)) {
1294  clip->gpd->flag |= GP_DATA_ANNOTATIONS;
1296  }
1297  }
1298  }
1299  }
1300  }
1301  }
1302 
1303  /* New workspace design */
1304  if (!MAIN_VERSION_ATLEAST(bmain, 280, 1)) {
1306  }
1307 
1308  if (!MAIN_VERSION_ATLEAST(bmain, 280, 2)) {
1309  /* Cleanup any remaining SceneRenderLayer data for files that were created
1310  * with Blender 2.8 before the SceneRenderLayer > RenderLayer refactor. */
1311  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1312  LISTBASE_FOREACH (SceneRenderLayer *, srl, &scene->r.layers) {
1313  if (srl->prop) {
1314  IDP_FreeProperty(srl->prop);
1315  }
1316  BKE_freestyle_config_free(&srl->freestyleConfig, true);
1317  }
1318  BLI_freelistN(&scene->r.layers);
1319  }
1320  }
1321 
1322  if (!MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1323  /* Due to several changes to particle RNA and draw code particles from older files may
1324  * no longer be visible.
1325  * Here we correct this by setting a default draw size for those files. */
1326  for (Object *object = bmain->objects.first; object; object = object->id.next) {
1327  LISTBASE_FOREACH (ParticleSystem *, psys, &object->particlesystem) {
1328  if (psys->part->draw_size == 0.0f) {
1329  psys->part->draw_size = 0.1f;
1330  }
1331  }
1332  }
1333  }
1334 
1335  if (!MAIN_VERSION_ATLEAST(bmain, 280, 4)) {
1336  for (Object *object = bmain->objects.first; object; object = object->id.next) {
1337  if (object->particlesystem.first) {
1338  object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT;
1339  LISTBASE_FOREACH (ParticleSystem *, psys, &object->particlesystem) {
1340  if (psys->part->draw & PART_DRAW_EMITTER) {
1341  object->duplicator_visibility_flag |= OB_DUPLI_FLAG_RENDER;
1342  break;
1343  }
1344  }
1345  }
1346  else if (object->transflag & OB_DUPLI) {
1347  object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT;
1348  }
1349  else {
1350  object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT | OB_DUPLI_FLAG_RENDER;
1351  }
1352  }
1353 
1354  /* Cleanup deprecated flag from particle-settings data-blocks. */
1355  for (ParticleSettings *part = bmain->particles.first; part; part = part->id.next) {
1356  part->draw &= ~PART_DRAW_EMITTER;
1357  }
1358  }
1359 
1360  /* SpaceTime & SpaceLogic removal/replacing */
1361  if (!MAIN_VERSION_ATLEAST(bmain, 280, 9)) {
1362  const wmWindowManager *wm = bmain->wm.first;
1363  const Scene *scene = bmain->scenes.first;
1364 
1365  if (wm != NULL) {
1366  /* Action editors need a scene for creation. First, update active
1367  * screens using the active scene of the window they're displayed in.
1368  * Next, update remaining screens using first scene in main listbase. */
1369 
1370  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
1371  const bScreen *screen = BKE_workspace_active_screen_get(win->workspace_hook);
1372  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1373  if (ELEM(area->butspacetype, SPACE_TIME, SPACE_LOGIC)) {
1375 
1376  /* Don't forget to unset! */
1377  area->butspacetype = SPACE_EMPTY;
1378  }
1379  }
1380  }
1381  }
1382  if (scene != NULL) {
1383  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1384  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1385  if (ELEM(area->butspacetype, SPACE_TIME, SPACE_LOGIC)) {
1386  /* Areas that were already handled won't be handled again */
1388 
1389  /* Don't forget to unset! */
1390  area->butspacetype = SPACE_EMPTY;
1391  }
1392  }
1393  }
1394  }
1395  }
1396 
1397 #ifdef USE_COLLECTION_COMPAT_28
1398  if (use_collection_compat_28 && !MAIN_VERSION_ATLEAST(bmain, 280, 14)) {
1399  for (Collection *group = bmain->collections.first; group; group = group->id.next) {
1400  do_version_group_collection_to_collection(bmain, group);
1401  }
1402 
1403  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1404  do_version_scene_collection_to_collection(bmain, scene);
1405  }
1406  }
1407 #endif
1408 
1409  /* Update Curve object Shape Key data layout to include the Radius property */
1410  if (!MAIN_VERSION_ATLEAST(bmain, 280, 23)) {
1411  for (Curve *cu = bmain->curves.first; cu; cu = cu->id.next) {
1412  if (!cu->key || cu->key->elemsize != sizeof(float[4])) {
1413  continue;
1414  }
1415 
1416  cu->key->elemstr[0] = 3; /*KEYELEM_ELEM_SIZE_CURVE*/
1417  cu->key->elemsize = sizeof(float[3]);
1418 
1419  int new_count = BKE_keyblock_curve_element_count(&cu->nurb);
1420 
1421  LISTBASE_FOREACH (KeyBlock *, block, &cu->key->block) {
1422  int old_count = block->totelem;
1423  void *old_data = block->data;
1424 
1425  if (!old_data || old_count <= 0) {
1426  continue;
1427  }
1428 
1429  block->totelem = new_count;
1430  block->data = MEM_callocN(sizeof(float[3]) * new_count, __func__);
1431 
1432  float *oldptr = old_data;
1433  float(*newptr)[3] = block->data;
1434 
1435  LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
1436  if (nu->bezt) {
1437  BezTriple *bezt = nu->bezt;
1438 
1439  for (int a = 0; a < nu->pntsu; a++, bezt++) {
1440  if ((old_count -= 3) < 0) {
1441  memcpy(newptr, bezt->vec, sizeof(float[3][3]));
1442  newptr[3][0] = bezt->tilt;
1443  }
1444  else {
1445  memcpy(newptr, oldptr, sizeof(float[3][4]));
1446  }
1447 
1448  newptr[3][1] = bezt->radius;
1449 
1450  oldptr += 3 * 4;
1451  newptr += 4; /*KEYELEM_ELEM_LEN_BEZTRIPLE*/
1452  }
1453  }
1454  else if (nu->bp) {
1455  BPoint *bp = nu->bp;
1456 
1457  for (int a = 0; a < nu->pntsu * nu->pntsv; a++, bp++) {
1458  if (--old_count < 0) {
1459  copy_v3_v3(newptr[0], bp->vec);
1460  newptr[1][0] = bp->tilt;
1461  }
1462  else {
1463  memcpy(newptr, oldptr, sizeof(float[4]));
1464  }
1465 
1466  newptr[1][1] = bp->radius;
1467 
1468  oldptr += 4;
1469  newptr += 2; /*KEYELEM_ELEM_LEN_BPOINT*/
1470  }
1471  }
1472  }
1473 
1474  MEM_freeN(old_data);
1475  }
1476  }
1477  }
1478 
1479  /* Move B-Bone custom handle settings from bPoseChannel to Bone. */
1480  if (!MAIN_VERSION_ATLEAST(bmain, 280, 25)) {
1481  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1482  bArmature *arm = ob->data;
1483 
1484  /* If it is an armature from the same file. */
1485  if (ob->pose && arm && arm->id.lib == ob->id.lib) {
1486  bool rebuild = false;
1487 
1488  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
1489  /* If the 2.7 flag is enabled, processing is needed. */
1490  if (pchan->bone && (pchan->bboneflag & PCHAN_BBONE_CUSTOM_HANDLES)) {
1491  /* If the settings in the Bone are not set, copy. */
1492  if (pchan->bone->bbone_prev_type == BBONE_HANDLE_AUTO &&
1493  pchan->bone->bbone_next_type == BBONE_HANDLE_AUTO &&
1494  pchan->bone->bbone_prev == NULL && pchan->bone->bbone_next == NULL) {
1495  pchan->bone->bbone_prev_type = (pchan->bboneflag & PCHAN_BBONE_CUSTOM_START_REL) ?
1498  pchan->bone->bbone_next_type = (pchan->bboneflag & PCHAN_BBONE_CUSTOM_END_REL) ?
1501 
1502  if (pchan->bbone_prev) {
1503  pchan->bone->bbone_prev = pchan->bbone_prev->bone;
1504  }
1505  if (pchan->bbone_next) {
1506  pchan->bone->bbone_next = pchan->bbone_next->bone;
1507  }
1508  }
1509 
1510  rebuild = true;
1511  pchan->bboneflag = 0;
1512  }
1513  }
1514 
1515  /* Tag pose rebuild for all objects that use this armature. */
1516  if (rebuild) {
1517  for (Object *ob2 = bmain->objects.first; ob2; ob2 = ob2->id.next) {
1518  if (ob2->pose && ob2->data == arm) {
1519  ob2->pose->flag |= POSE_RECALC;
1520  }
1521  }
1522  }
1523  }
1524  }
1525  }
1526 
1527  if (!MAIN_VERSION_ATLEAST(bmain, 280, 30)) {
1528  for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
1529  if (brush->gpencil_settings != NULL) {
1530  brush->gpencil_tool = brush->gpencil_settings->brush_type;
1531  }
1532  }
1534  }
1535 
1536  if (!MAIN_VERSION_ATLEAST(bmain, 280, 38)) {
1537  /* Ensure we get valid rigidbody object/constraint data in relevant collections' objects.
1538  */
1539  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1541 
1542  if (rbw == NULL) {
1543  continue;
1544  }
1545 
1548  }
1549  }
1550 
1551  if (!MAIN_VERSION_ATLEAST(bmain, 280, 69)) {
1552  /* Unify DOF settings (EEVEE part only) */
1553  enum { SCE_EEVEE_DOF_ENABLED = (1 << 7) };
1554  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1556  if (scene->eevee.flag & SCE_EEVEE_DOF_ENABLED) {
1557  Object *cam_ob = scene->camera;
1558  if (cam_ob && cam_ob->type == OB_CAMERA) {
1559  Camera *cam = cam_ob->data;
1560  cam->dof.flag |= CAM_DOF_ENABLED;
1561  }
1562  }
1563  }
1564  }
1565 
1566  LISTBASE_FOREACH (Camera *, camera, &bmain->cameras) {
1567  camera->dof.focus_object = camera->dof_ob;
1568  camera->dof.focus_distance = camera->dof_distance;
1569  camera->dof.aperture_fstop = camera->gpu_dof.fstop;
1570  camera->dof.aperture_rotation = camera->gpu_dof.rotation;
1571  camera->dof.aperture_ratio = camera->gpu_dof.ratio;
1572  camera->dof.aperture_blades = camera->gpu_dof.num_blades;
1573  camera->dof_ob = NULL;
1574  }
1575  }
1576 
1577  if (!MAIN_VERSION_ATLEAST(bmain, 281, 2)) {
1578  /* Replace Multiply and Additive blend mode by Alpha Blend
1579  * now that we use dual-source blending. */
1580  /* We take care of doing only node-trees that are always part of materials
1581  * with old blending modes. */
1582  for (Material *ma = bmain->materials.first; ma; ma = ma->id.next) {
1583  bNodeTree *ntree = ma->nodetree;
1584  if (ma->blend_method == 1 /* MA_BM_ADD */) {
1585  if (ma->use_nodes) {
1587  }
1588  ma->blend_method = MA_BM_BLEND;
1589  }
1590  else if (ma->blend_method == 2 /* MA_BM_MULTIPLY */) {
1591  if (ma->use_nodes) {
1592  do_versions_material_convert_legacy_blend_mode(ntree, 2 /* MA_BM_MULTIPLY */);
1593  }
1594  ma->blend_method = MA_BM_BLEND;
1595  }
1596  }
1597 
1598  /* Update all ruler layers to set new flag. */
1599  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1600  bGPdata *gpd = scene->gpd;
1601  if (gpd == NULL) {
1602  continue;
1603  }
1604  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1605  if (STREQ(gpl->info, "RulerData3D")) {
1606  gpl->flag |= GP_LAYER_IS_RULER;
1607  break;
1608  }
1609  }
1610  }
1611 
1612  /* This versioning could probably be done only on earlier versions, not sure however
1613  * which exact version fully deprecated tessfaces, so think we can keep that one here, no
1614  * harm to be expected anyway for being over-conservative. */
1615  for (Mesh *me = bmain->meshes.first; me != NULL; me = me->id.next) {
1616  /* Check if we need to convert mfaces to mpolys. */
1617  if (me->totface && !me->totpoly) {
1618  /* temporarily switch main so that reading from
1619  * external CustomData works */
1620  Main *gmain = G_MAIN;
1621  G_MAIN = bmain;
1622 
1624 
1625  G_MAIN = gmain;
1626  }
1627 
1628  /* Deprecated, only kept for conversion. */
1630  }
1631  }
1632 
1633  if (!MAIN_VERSION_ATLEAST(bmain, 282, 2)) {
1634  /* Init all Vertex/Sculpt and Weight Paint brushes. */
1635  Brush *brush;
1636  Material *ma;
1637  /* Pen Soft brush. */
1638  brush = (Brush *)do_versions_rename_id(bmain, ID_BR, "Draw Soft", "Pencil Soft");
1639  if (brush) {
1641  }
1642  do_versions_rename_id(bmain, ID_BR, "Draw Pencil", "Pencil");
1643  do_versions_rename_id(bmain, ID_BR, "Draw Pen", "Pen");
1644  do_versions_rename_id(bmain, ID_BR, "Draw Ink", "Ink Pen");
1645  do_versions_rename_id(bmain, ID_BR, "Draw Noise", "Ink Pen Rough");
1646  do_versions_rename_id(bmain, ID_BR, "Draw Marker", "Marker Bold");
1647  do_versions_rename_id(bmain, ID_BR, "Draw Block", "Marker Chisel");
1648 
1649  ma = BLI_findstring(&bmain->materials, "Black", offsetof(ID, name) + 2);
1650  if (ma && ma->gp_style) {
1651  do_versions_rename_id(bmain, ID_MA, "Black", "Solid Stroke");
1652  }
1653  ma = BLI_findstring(&bmain->materials, "Red", offsetof(ID, name) + 2);
1654  if (ma && ma->gp_style) {
1655  do_versions_rename_id(bmain, ID_MA, "Red", "Squares Stroke");
1656  }
1657  ma = BLI_findstring(&bmain->materials, "Grey", offsetof(ID, name) + 2);
1658  if (ma && ma->gp_style) {
1659  do_versions_rename_id(bmain, ID_MA, "Grey", "Solid Fill");
1660  }
1661  ma = BLI_findstring(&bmain->materials, "Black Dots", offsetof(ID, name) + 2);
1662  if (ma && ma->gp_style) {
1663  do_versions_rename_id(bmain, ID_MA, "Black Dots", "Dots Stroke");
1664  }
1665 
1666  brush = BLI_findstring(&bmain->brushes, "Pencil", offsetof(ID, name) + 2);
1667 
1668  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1670 
1671  /* Ensure new Paint modes. */
1676 
1677  /* Set default Draw brush. */
1678  if (brush != NULL) {
1679  Paint *paint = &ts->gp_paint->paint;
1680  BKE_paint_brush_set(paint, brush);
1681  /* Enable cursor by default. */
1682  paint->flags |= PAINT_SHOW_BRUSH;
1683  }
1684  }
1685  }
1686 
1687  if (!MAIN_VERSION_ATLEAST(bmain, 283, 8)) {
1688 
1689  /* During development of Blender 2.80 the "Object.hide" property was
1690  * removed, and reintroduced in 5e968a996a53 as "Object.hide_viewport". */
1691  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1693  }
1694 
1695  /* Reset all grease pencil brushes. */
1696  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1697  /* Ensure new Paint modes. */
1701  }
1702  }
1703 
1704  /* Old forgotten versioning code. */
1705  if (!MAIN_VERSION_ATLEAST(bmain, 300, 39)) {
1706  /* Paint Brush. This ensure that the brush paints by default. Used during the development and
1707  * patch review of the initial Sculpt Vertex Colors implementation (D5975) */
1708  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
1709  if (brush->ob_mode & OB_MODE_SCULPT && brush->sculpt_tool == SCULPT_TOOL_PAINT) {
1710  brush->tip_roundness = 1.0f;
1711  brush->flow = 1.0f;
1712  brush->density = 1.0f;
1713  brush->tip_scale_x = 1.0f;
1714  }
1715  }
1716 
1717  /* Pose Brush with support for loose parts. */
1718  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
1719  if (brush->sculpt_tool == SCULPT_TOOL_POSE && brush->disconnected_distance_max == 0.0f) {
1720  brush->flag2 |= BRUSH_USE_CONNECTED_ONLY;
1721  brush->disconnected_distance_max = 0.1f;
1722  }
1723  }
1724  }
1725 
1736  {
1737  /* Keep this block, even when empty. */
1738  }
1739 }
1740 
1741 /* NOTE: This version patch is intended for versions < 2.52.2,
1742  * but was initially introduced in 2.27 already.
1743  * But in 2.79 another case generating non-unique names was discovered
1744  * (see T55668, involving Meta strips). */
1746 {
1747  for (Sequence *seq = seqbasep->first; seq != NULL; seq = seq->next) {
1749  if (seq->seqbase.first != NULL) {
1750  do_versions_seq_unique_name_all_strips(sce, &seq->seqbase);
1751  }
1752  }
1753 }
1754 
1756 {
1760  ed->recycle_max_cost = 10.0f;
1761 }
1762 
1764 {
1765  seq->flag &= ~((1 << 6) | (1 << 18) | (1 << 19) | (1 << 21));
1766  if (seq->type == SEQ_TYPE_SPEED) {
1768  s->flags &= ~(SEQ_SPEED_UNUSED_1);
1769  }
1770  return true;
1771 }
1772 
1773 /* NOLINTNEXTLINE: readability-function-size */
1775 {
1776  bool use_collection_compat_28 = true;
1777 
1778  if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1779  use_collection_compat_28 = false;
1780 
1781  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1782  scene->r.gauss = 1.5f;
1783  }
1784  }
1785 
1786  if (!MAIN_VERSION_ATLEAST(bmain, 280, 1)) {
1787  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "bleedexp")) {
1788  for (Light *la = bmain->lights.first; la; la = la->id.next) {
1789  la->bleedexp = 2.5f;
1790  }
1791  }
1792 
1793  if (!DNA_struct_elem_find(fd->filesdna, "GPUDOFSettings", "float", "ratio")) {
1794  for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
1795  ca->gpu_dof.ratio = 1.0f;
1796  }
1797  }
1798 
1799  /* MTexPoly now removed. */
1800  if (DNA_struct_find(fd->filesdna, "MTexPoly")) {
1801  for (Mesh *me = bmain->meshes.first; me; me = me->id.next) {
1802  /* If we have UV's, so this file will have MTexPoly layers too! */
1803  if (me->mloopuv != NULL) {
1804  CustomData_update_typemap(&me->pdata);
1805  CustomData_free_layers(&me->pdata, CD_MTEXPOLY, me->totpoly);
1807  }
1808  }
1809  }
1810  }
1811 
1812  if (!MAIN_VERSION_ATLEAST(bmain, 280, 2)) {
1813  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "cascade_max_dist")) {
1814  for (Light *la = bmain->lights.first; la; la = la->id.next) {
1815  la->cascade_max_dist = 1000.0f;
1816  la->cascade_count = 4;
1817  la->cascade_exponent = 0.8f;
1818  la->cascade_fade = 0.1f;
1819  }
1820  }
1821 
1822  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "contact_dist")) {
1823  for (Light *la = bmain->lights.first; la; la = la->id.next) {
1824  la->contact_dist = 0.2f;
1825  la->contact_bias = 0.03f;
1826  la->contact_spread = 0.2f;
1827  la->contact_thickness = 0.2f;
1828  }
1829  }
1830 
1831  if (!DNA_struct_elem_find(fd->filesdna, "LightProbe", "float", "vis_bias")) {
1832  for (LightProbe *probe = bmain->lightprobes.first; probe; probe = probe->id.next) {
1833  probe->vis_bias = 1.0f;
1834  probe->vis_blur = 0.2f;
1835  }
1836  }
1837 
1838  typedef enum eNTreeDoVersionErrors {
1839  NTREE_DOVERSION_NO_ERROR = 0,
1840  NTREE_DOVERSION_NEED_OUTPUT = (1 << 0),
1841  NTREE_DOVERSION_TRANSPARENCY_EMISSION = (1 << 1),
1842  } eNTreeDoVersionErrors;
1843 
1844  /* Eevee shader nodes renamed because of the output node system.
1845  * Note that a new output node is not being added here, because it would be overkill
1846  * to handle this case in lib_verify_nodetree.
1847  *
1848  * Also, metallic node is now unified into the principled node. */
1849  eNTreeDoVersionErrors error = NTREE_DOVERSION_NO_ERROR;
1850 
1851  FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1852  if (ntree->type == NTREE_SHADER) {
1854  if (node->type == 194 /* SH_NODE_EEVEE_METALLIC */ &&
1855  STREQ(node->idname, "ShaderNodeOutputMetallic")) {
1856  BLI_strncpy(node->idname, "ShaderNodeEeveeMetallic", sizeof(node->idname));
1857  error |= NTREE_DOVERSION_NEED_OUTPUT;
1858  }
1859 
1860  else if (node->type == SH_NODE_EEVEE_SPECULAR &&
1861  STREQ(node->idname, "ShaderNodeOutputSpecular")) {
1862  BLI_strncpy(node->idname, "ShaderNodeEeveeSpecular", sizeof(node->idname));
1863  error |= NTREE_DOVERSION_NEED_OUTPUT;
1864  }
1865 
1866  else if (node->type == 196 /* SH_NODE_OUTPUT_EEVEE_MATERIAL */ &&
1867  STREQ(node->idname, "ShaderNodeOutputEeveeMaterial")) {
1868  node->type = SH_NODE_OUTPUT_MATERIAL;
1869  BLI_strncpy(node->idname, "ShaderNodeOutputMaterial", sizeof(node->idname));
1870  }
1871 
1872  else if (node->type == 194 /* SH_NODE_EEVEE_METALLIC */ &&
1873  STREQ(node->idname, "ShaderNodeEeveeMetallic")) {
1874  node->type = SH_NODE_BSDF_PRINCIPLED;
1875  BLI_strncpy(node->idname, "ShaderNodeBsdfPrincipled", sizeof(node->idname));
1876  node->custom1 = SHD_GLOSSY_MULTI_GGX;
1877  error |= NTREE_DOVERSION_TRANSPARENCY_EMISSION;
1878  }
1879  }
1880  }
1881  }
1883 
1884  if (error & NTREE_DOVERSION_NEED_OUTPUT) {
1885  BKE_report(fd->reports != NULL ? fd->reports->reports : NULL,
1886  RPT_ERROR,
1887  "Eevee material conversion problem. Error in console");
1888  printf(
1889  "You need to connect Principled and Eevee Specular shader nodes to new material "
1890  "output "
1891  "nodes.\n");
1892  }
1893 
1894  if (error & NTREE_DOVERSION_TRANSPARENCY_EMISSION) {
1895  BKE_report(fd->reports != NULL ? fd->reports->reports : NULL,
1896  RPT_ERROR,
1897  "Eevee material conversion problem. Error in console");
1898  printf(
1899  "You need to combine transparency and emission shaders to the converted Principled "
1900  "shader nodes.\n");
1901  }
1902 
1903 #ifdef USE_COLLECTION_COMPAT_28
1904  if (use_collection_compat_28 &&
1905  (DNA_struct_elem_find(fd->filesdna, "ViewLayer", "FreestyleConfig", "freestyle_config") ==
1906  false) &&
1907  DNA_struct_elem_find(fd->filesdna, "Scene", "ListBase", "view_layers")) {
1908  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1909  ViewLayer *view_layer;
1910  for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
1911  view_layer->flag |= VIEW_LAYER_FREESTYLE;
1912  view_layer->layflag = 0x7FFF; /* solid Z-transparency halo edge strand. */
1913  view_layer->passflag = SCE_PASS_COMBINED | SCE_PASS_Z;
1914  view_layer->pass_alpha_threshold = 0.5f;
1916  }
1917  }
1918  }
1919 #endif
1920 
1921  {
1922  /* Init grease pencil edit line color */
1923  if (!DNA_struct_elem_find(fd->filesdna, "bGPdata", "float", "line_color[4]")) {
1924  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1925  ARRAY_SET_ITEMS(gpd->line_color, 0.6f, 0.6f, 0.6f, 0.5f);
1926  }
1927  }
1928 
1929  /* Init grease pencil pixel size factor */
1930  if (!DNA_struct_elem_find(fd->filesdna, "bGPdata", "float", "pixfactor")) {
1931  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1932  gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
1933  }
1934  }
1935 
1936  /* Grease pencil multi-frame falloff curve. */
1937  if (!DNA_struct_elem_find(
1938  fd->filesdna, "GP_Sculpt_Settings", "CurveMapping", "cur_falloff")) {
1939  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1940  /* sculpt brushes */
1942  if ((gset) && (gset->cur_falloff == NULL)) {
1943  gset->cur_falloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1946  &gset->cur_falloff->clipr,
1949  }
1950  }
1951  }
1952  }
1953 
1954  /* 2.79 style Maintain Volume mode. */
1955  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1957  if (ob->pose) {
1958  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
1960  }
1961  }
1962  }
1963  }
1964 
1965 #ifdef USE_COLLECTION_COMPAT_28
1966  if (use_collection_compat_28 && !MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1967  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1968  ViewLayer *view_layer;
1969  for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
1970  do_version_view_layer_visibility(view_layer);
1971  }
1972  }
1973 
1974  for (Collection *group = bmain->collections.first; group; group = group->id.next) {
1975  if (group->view_layer != NULL) {
1976  do_version_view_layer_visibility(group->view_layer);
1977  }
1978  }
1979  }
1980 #endif
1981 
1982  if (!MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1983  /* init grease pencil grids and paper */
1984  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_paper_color[3]")) {
1985  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1986  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1987  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1988  if (sl->spacetype == SPACE_VIEW3D) {
1989  View3D *v3d = (View3D *)sl;
1990  v3d->overlay.gpencil_paper_opacity = 0.5f;
1991  v3d->overlay.gpencil_grid_opacity = 0.9f;
1992  }
1993  }
1994  }
1995  }
1996  }
1997  }
1998 
1999  if (!MAIN_VERSION_ATLEAST(bmain, 280, 6)) {
2000  if (DNA_struct_elem_find(fd->filesdna, "SpaceOutliner", "int", "filter") == false) {
2001  bScreen *screen;
2002  ScrArea *area;
2003  SpaceLink *sl;
2004 
2005  /* Update files using invalid (outdated) outlinevis Outliner values. */
2006  for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2007  for (area = screen->areabase.first; area; area = area->next) {
2008  for (sl = area->spacedata.first; sl; sl = sl->next) {
2009  if (sl->spacetype == SPACE_OUTLINER) {
2010  SpaceOutliner *space_outliner = (SpaceOutliner *)sl;
2011 
2012  if (!ELEM(space_outliner->outlinevis,
2013  SO_SCENES,
2014  SO_LIBRARIES,
2015  SO_SEQUENCE,
2016  SO_DATA_API,
2017  SO_ID_ORPHANS)) {
2018  space_outliner->outlinevis = SO_VIEW_LAYER;
2019  }
2020  }
2021  }
2022  }
2023  }
2024  }
2025 
2026  if (!DNA_struct_elem_find(fd->filesdna, "LightProbe", "float", "intensity")) {
2027  for (LightProbe *probe = bmain->lightprobes.first; probe; probe = probe->id.next) {
2028  probe->intensity = 1.0f;
2029  }
2030  }
2031 
2032  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2033  bConstraint *con, *con_next;
2034  con = ob->constraints.first;
2035  while (con) {
2036  con_next = con->next;
2037  if (con->type == 17) { /* CONSTRAINT_TYPE_RIGIDBODYJOINT */
2038  BLI_remlink(&ob->constraints, con);
2040  MEM_freeN(con);
2041  }
2042  con = con_next;
2043  }
2044  }
2045 
2046  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2047  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2048  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2049  if (sl->spacetype == SPACE_VIEW3D) {
2050  View3D *v3d = (View3D *)sl;
2053 
2054  /* Assume (demo) files written with 2.8 want to show
2055  * Eevee renders in the viewport. */
2056  if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2057  v3d->drawtype = OB_MATERIAL;
2058  }
2059  }
2060  }
2061  }
2062  }
2063  }
2064 
2065  if (!MAIN_VERSION_ATLEAST(bmain, 280, 7)) {
2066  /* Render engine storage moved elsewhere and back during 2.8
2067  * development, we assume any files saved in 2.8 had Eevee set
2068  * as scene render engine. */
2069  if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2070  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2072  }
2073  }
2074  }
2075 
2076  if (!MAIN_VERSION_ATLEAST(bmain, 280, 8)) {
2077  /* Blender Internal removal */
2078  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2079  if (STR_ELEM(scene->r.engine, "BLENDER_RENDER", "BLENDER_GAME")) {
2081  }
2082 
2083  scene->r.bake_mode = 0;
2084  }
2085 
2086  for (Tex *tex = bmain->textures.first; tex; tex = tex->id.next) {
2087  /* Removed environment map, point-density, voxel-data, ocean textures. */
2088  if (ELEM(tex->type, 10, 14, 15, 16)) {
2089  tex->type = 0;
2090  }
2091  }
2092  }
2093 
2094  if (!MAIN_VERSION_ATLEAST(bmain, 280, 11)) {
2095 
2096  /* Remove info editor, but only if at the top of the window. */
2097  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2098  /* Calculate window width/height from screen vertices */
2099  int win_width = 0, win_height = 0;
2100  LISTBASE_FOREACH (ScrVert *, vert, &screen->vertbase) {
2101  win_width = MAX2(win_width, vert->vec.x);
2102  win_height = MAX2(win_height, vert->vec.y);
2103  }
2104 
2105  for (ScrArea *area = screen->areabase.first, *area_next; area; area = area_next) {
2106  area_next = area->next;
2107 
2108  if (area->spacetype == SPACE_INFO) {
2109  if ((area->v2->vec.y == win_height) && (area->v1->vec.x == 0) &&
2110  (area->v4->vec.x == win_width)) {
2112 
2113  BLI_remlink(&screen->areabase, area);
2114 
2118 
2119  MEM_freeN(area);
2120  }
2121  }
2122  /* AREA_TEMP_INFO is deprecated from now on, it should only be set for info areas
2123  * which are deleted above, so don't need to unset it. Its slot/bit can be reused */
2124  }
2125  }
2126  }
2127 
2128  if (!MAIN_VERSION_ATLEAST(bmain, 280, 11)) {
2129  for (Light *la = bmain->lights.first; la; la = la->id.next) {
2130  if (la->mode & (1 << 13)) { /* LA_SHAD_RAY */
2131  la->mode |= LA_SHADOW;
2132  la->mode &= ~(1 << 13);
2133  }
2134  }
2135  }
2136 
2137  if (!MAIN_VERSION_ATLEAST(bmain, 280, 12)) {
2138  /* Remove tool property regions. */
2139  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2140  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2141  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2142  if (ELEM(sl->spacetype, SPACE_VIEW3D, SPACE_CLIP)) {
2143  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
2144  &sl->regionbase;
2145 
2146  for (ARegion *region = regionbase->first, *region_next; region; region = region_next) {
2147  region_next = region->next;
2148 
2149  if (region->regiontype == RGN_TYPE_TOOL_PROPS) {
2150  BKE_area_region_free(NULL, region);
2151  BLI_freelinkN(regionbase, region);
2152  }
2153  }
2154  }
2155  }
2156  }
2157  }
2158  }
2159 
2160  if (!MAIN_VERSION_ATLEAST(bmain, 280, 13)) {
2161  /* Initialize specular factor. */
2162  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "spec_fac")) {
2163  for (Light *la = bmain->lights.first; la; la = la->id.next) {
2164  la->spec_fac = 1.0f;
2165  }
2166  }
2167 
2168  /* Initialize new view3D options. */
2169  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2170  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2171  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2172  if (sl->spacetype == SPACE_VIEW3D) {
2173  View3D *v3d = (View3D *)sl;
2176  copy_v3_fl(v3d->shading.single_color, 0.8f);
2177  v3d->shading.shadow_intensity = 0.5;
2178 
2179  v3d->overlay.backwire_opacity = 0.5f;
2180  v3d->overlay.normals_length = 0.1f;
2181  v3d->overlay.flag = 0;
2182  }
2183  }
2184  }
2185  }
2186  }
2187 
2188  if (!MAIN_VERSION_ATLEAST(bmain, 280, 14)) {
2189  if (!DNA_struct_elem_find(fd->filesdna, "Scene", "SceneDisplay", "display")) {
2190  /* Initialize new scene.SceneDisplay */
2191  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2192  copy_v3_v3(scene->display.light_direction, (float[3]){-M_SQRT1_3, -M_SQRT1_3, M_SQRT1_3});
2193  }
2194  }
2195  if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "float", "shadow_shift")) {
2196  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2197  scene->display.shadow_shift = 0.1;
2198  }
2199  }
2200 
2201  if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "transform_pivot_point")) {
2202  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2204  }
2205  }
2206 
2207  if (!DNA_struct_find(fd->filesdna, "SceneEEVEE")) {
2208  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2209  /* First set the default for all the properties. */
2210 
2214 
2215  scene->eevee.taa_samples = 16;
2217 
2218  scene->eevee.sss_samples = 7;
2220 
2221  scene->eevee.ssr_quality = 0.25f;
2222  scene->eevee.ssr_max_roughness = 0.5f;
2223  scene->eevee.ssr_thickness = 0.2f;
2224  scene->eevee.ssr_border_fade = 0.075f;
2225  scene->eevee.ssr_firefly_fac = 10.0f;
2226 
2227  scene->eevee.volumetric_start = 0.1f;
2228  scene->eevee.volumetric_end = 100.0f;
2234 
2235  scene->eevee.gtao_distance = 0.2f;
2236  scene->eevee.gtao_factor = 1.0f;
2237  scene->eevee.gtao_quality = 0.25f;
2238 
2239  scene->eevee.bokeh_max_size = 100.0f;
2240  scene->eevee.bokeh_threshold = 1.0f;
2241 
2243  scene->eevee.bloom_threshold = 0.8f;
2244  scene->eevee.bloom_knee = 0.5f;
2245  scene->eevee.bloom_intensity = 0.05f;
2246  scene->eevee.bloom_radius = 6.5f;
2247  scene->eevee.bloom_clamp = 0.0f;
2248 
2249  scene->eevee.motion_blur_samples = 8;
2251 
2252  scene->eevee.shadow_method = SHADOW_ESM;
2253  scene->eevee.shadow_cube_size = 512;
2255 
2259 
2260  /* If the file is pre-2.80 move on. */
2261  if (scene->layer_properties == NULL) {
2262  continue;
2263  }
2264 
2265  /* Now we handle eventual properties that may be set in the file. */
2266 #define EEVEE_GET_BOOL(_props, _name, _flag) \
2267  { \
2268  IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2269  if (_idprop != NULL) { \
2270  const int _value = IDP_Int(_idprop); \
2271  if (_value) { \
2272  scene->eevee.flag |= _flag; \
2273  } \
2274  else { \
2275  scene->eevee.flag &= ~_flag; \
2276  } \
2277  } \
2278  } \
2279  ((void)0)
2280 
2281 #define EEVEE_GET_INT(_props, _name) \
2282  { \
2283  IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2284  if (_idprop != NULL) { \
2285  scene->eevee._name = IDP_Int(_idprop); \
2286  } \
2287  } \
2288  ((void)0)
2289 
2290 #define EEVEE_GET_FLOAT(_props, _name) \
2291  { \
2292  IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2293  if (_idprop != NULL) { \
2294  scene->eevee._name = IDP_Float(_idprop); \
2295  } \
2296  } \
2297  ((void)0)
2298 
2299 #define EEVEE_GET_FLOAT_ARRAY(_props, _name, _length) \
2300  { \
2301  IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2302  if (_idprop != NULL) { \
2303  const float *_values = IDP_Array(_idprop); \
2304  for (int _i = 0; _i < _length; _i++) { \
2305  scene->eevee._name[_i] = _values[_i]; \
2306  } \
2307  } \
2308  } \
2309  ((void)0)
2310  enum { SCE_EEVEE_DOF_ENABLED = (1 << 7) };
2313  // EEVEE_GET_BOOL(props, volumetric_enable, SCE_EEVEE_VOLUMETRIC_ENABLED);
2314  EEVEE_GET_BOOL(props, volumetric_lights, SCE_EEVEE_VOLUMETRIC_LIGHTS);
2315  EEVEE_GET_BOOL(props, volumetric_shadows, SCE_EEVEE_VOLUMETRIC_SHADOWS);
2316  EEVEE_GET_BOOL(props, gtao_enable, SCE_EEVEE_GTAO_ENABLED);
2317  EEVEE_GET_BOOL(props, gtao_use_bent_normals, SCE_EEVEE_GTAO_BENT_NORMALS);
2318  EEVEE_GET_BOOL(props, gtao_bounce, SCE_EEVEE_GTAO_BOUNCE);
2319  EEVEE_GET_BOOL(props, dof_enable, SCE_EEVEE_DOF_ENABLED);
2320  EEVEE_GET_BOOL(props, bloom_enable, SCE_EEVEE_BLOOM_ENABLED);
2321  EEVEE_GET_BOOL(props, motion_blur_enable, SCE_EEVEE_MOTION_BLUR_ENABLED);
2322  EEVEE_GET_BOOL(props, shadow_high_bitdepth, SCE_EEVEE_SHADOW_HIGH_BITDEPTH);
2323  EEVEE_GET_BOOL(props, taa_reprojection, SCE_EEVEE_TAA_REPROJECTION);
2324  // EEVEE_GET_BOOL(props, sss_enable, SCE_EEVEE_SSS_ENABLED);
2325  // EEVEE_GET_BOOL(props, sss_separate_albedo, SCE_EEVEE_SSS_SEPARATE_ALBEDO);
2326  EEVEE_GET_BOOL(props, ssr_enable, SCE_EEVEE_SSR_ENABLED);
2327  EEVEE_GET_BOOL(props, ssr_refraction, SCE_EEVEE_SSR_REFRACTION);
2328  EEVEE_GET_BOOL(props, ssr_halfres, SCE_EEVEE_SSR_HALF_RESOLUTION);
2329 
2330  EEVEE_GET_INT(props, gi_diffuse_bounces);
2331  EEVEE_GET_INT(props, gi_diffuse_bounces);
2332  EEVEE_GET_INT(props, gi_cubemap_resolution);
2333  EEVEE_GET_INT(props, gi_visibility_resolution);
2334 
2335  EEVEE_GET_INT(props, taa_samples);
2336  EEVEE_GET_INT(props, taa_render_samples);
2337 
2338  EEVEE_GET_INT(props, sss_samples);
2339  EEVEE_GET_FLOAT(props, sss_jitter_threshold);
2340 
2341  EEVEE_GET_FLOAT(props, ssr_quality);
2342  EEVEE_GET_FLOAT(props, ssr_max_roughness);
2343  EEVEE_GET_FLOAT(props, ssr_thickness);
2344  EEVEE_GET_FLOAT(props, ssr_border_fade);
2345  EEVEE_GET_FLOAT(props, ssr_firefly_fac);
2346 
2347  EEVEE_GET_FLOAT(props, volumetric_start);
2348  EEVEE_GET_FLOAT(props, volumetric_end);
2349  EEVEE_GET_INT(props, volumetric_tile_size);
2350  EEVEE_GET_INT(props, volumetric_samples);
2351  EEVEE_GET_FLOAT(props, volumetric_sample_distribution);
2352  EEVEE_GET_FLOAT(props, volumetric_light_clamp);
2353  EEVEE_GET_INT(props, volumetric_shadow_samples);
2354 
2355  EEVEE_GET_FLOAT(props, gtao_distance);
2356  EEVEE_GET_FLOAT(props, gtao_factor);
2357  EEVEE_GET_FLOAT(props, gtao_quality);
2358 
2359  EEVEE_GET_FLOAT(props, bokeh_max_size);
2360  EEVEE_GET_FLOAT(props, bokeh_threshold);
2361 
2362  EEVEE_GET_FLOAT_ARRAY(props, bloom_color, 3);
2363  EEVEE_GET_FLOAT(props, bloom_threshold);
2364  EEVEE_GET_FLOAT(props, bloom_knee);
2365  EEVEE_GET_FLOAT(props, bloom_intensity);
2366  EEVEE_GET_FLOAT(props, bloom_radius);
2367  EEVEE_GET_FLOAT(props, bloom_clamp);
2368 
2369  EEVEE_GET_INT(props, motion_blur_samples);
2370  EEVEE_GET_FLOAT(props, motion_blur_shutter);
2371 
2372  EEVEE_GET_INT(props, shadow_method);
2373  EEVEE_GET_INT(props, shadow_cube_size);
2374  EEVEE_GET_INT(props, shadow_cascade_size);
2375 
2376  /* Cleanup. */
2379 
2380 #undef EEVEE_GET_FLOAT_ARRAY
2381 #undef EEVEE_GET_FLOAT
2382 #undef EEVEE_GET_INT
2383 #undef EEVEE_GET_BOOL
2384  }
2385  }
2386 
2387  if (!MAIN_VERSION_ATLEAST(bmain, 280, 15)) {
2388  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2392  }
2393 
2394  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2395  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2396  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2397  if (sl->spacetype == SPACE_OUTLINER) {
2398  SpaceOutliner *space_outliner = (SpaceOutliner *)sl;
2399  space_outliner->filter_id_type = ID_GR;
2400  space_outliner->outlinevis = SO_VIEW_LAYER;
2401  }
2402  }
2403  }
2404  }
2405 
2406  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2407  switch (scene->toolsettings->snap_mode) {
2408  case 0:
2409  scene->toolsettings->snap_mode = (1 << 4); /* SCE_SNAP_MODE_INCREMENT */
2410  break;
2411  case 1:
2412  scene->toolsettings->snap_mode = (1 << 0); /* SCE_SNAP_MODE_VERTEX */
2413  break;
2414  case 2:
2415  scene->toolsettings->snap_mode = (1 << 1); /* SCE_SNAP_MODE_EDGE */
2416  break;
2417  case 3:
2418  scene->toolsettings->snap_mode = (1 << 2); /* SCE_SNAP_MODE_FACE_RAYCAST */
2419  break;
2420  case 4:
2421  scene->toolsettings->snap_mode = (1 << 3); /* SCE_SNAP_MODE_VOLUME */
2422  break;
2423  }
2424  switch (scene->toolsettings->snap_node_mode) {
2425  case 5:
2426  scene->toolsettings->snap_node_mode = (1 << 5); /* SCE_SNAP_MODE_NODE_X */
2427  break;
2428  case 6:
2429  scene->toolsettings->snap_node_mode = (1 << 6); /* SCE_SNAP_MODE_NODE_Y */
2430  break;
2431  case 7:
2433  (1 << 5) | (1 << 6); /* SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y */
2434  break;
2435  case 8:
2436  scene->toolsettings->snap_node_mode = (1 << 7); /* SCE_SNAP_MODE_GRID */
2437  break;
2438  }
2439  switch (scene->toolsettings->snap_uv_mode) {
2440  case 0:
2441  scene->toolsettings->snap_uv_mode = (1 << 4); /* SCE_SNAP_MODE_INCREMENT */
2442  break;
2443  case 1:
2444  scene->toolsettings->snap_uv_mode = (1 << 0); /* SCE_SNAP_MODE_VERTEX */
2445  break;
2446  }
2447  }
2448 
2449  ParticleSettings *part;
2450  for (part = bmain->particles.first; part; part = part->id.next) {
2452  part->shape = 0.0f;
2453  part->rad_root = 1.0f;
2454  part->rad_tip = 0.0f;
2455  part->rad_scale = 0.01f;
2456  }
2457  }
2458  }
2459 
2460  if (!MAIN_VERSION_ATLEAST(bmain, 280, 18)) {
2461  if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "roughness")) {
2462  for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
2463  if (mat->use_nodes) {
2464  if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2465  mat->roughness = mat->gloss_mir;
2466  }
2467  else {
2468  mat->roughness = 0.25f;
2469  }
2470  }
2471  else {
2472  mat->roughness = 1.0f - mat->gloss_mir;
2473  }
2474  mat->metallic = mat->ray_mirror;
2475  }
2476 
2477  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2478  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2479  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2480  if (sl->spacetype == SPACE_VIEW3D) {
2481  View3D *v3d = (View3D *)sl;
2483  }
2484  }
2485  }
2486  }
2487  }
2488 
2489  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "xray_alpha")) {
2490  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2491  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2492  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2493  if (sl->spacetype == SPACE_VIEW3D) {
2494  View3D *v3d = (View3D *)sl;
2495  v3d->shading.xray_alpha = 0.5f;
2496  }
2497  }
2498  }
2499  }
2500  }
2501  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "matcap[256]")) {
2503  /* when loading the internal file is loaded before the matcaps */
2504  if (default_matcap) {
2505  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2506  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2507  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2508  if (sl->spacetype == SPACE_VIEW3D) {
2509  View3D *v3d = (View3D *)sl;
2510  BLI_strncpy(v3d->shading.matcap, default_matcap->name, FILE_MAXFILE);
2511  }
2512  }
2513  }
2514  }
2515  }
2516  }
2517  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "wireframe_threshold")) {
2518  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2519  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2520  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2521  if (sl->spacetype == SPACE_VIEW3D) {
2522  View3D *v3d = (View3D *)sl;
2523  v3d->overlay.wireframe_threshold = 0.5f;
2524  }
2525  }
2526  }
2527  }
2528  }
2529  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "cavity_valley_factor")) {
2530  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2531  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2532  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2533  if (sl->spacetype == SPACE_VIEW3D) {
2534  View3D *v3d = (View3D *)sl;
2535  v3d->shading.cavity_valley_factor = 1.0f;
2536  v3d->shading.cavity_ridge_factor = 1.0f;
2537  }
2538  }
2539  }
2540  }
2541  }
2542  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "xray_alpha_bone")) {
2543  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2544  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2545  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2546  if (sl->spacetype == SPACE_VIEW3D) {
2547  View3D *v3d = (View3D *)sl;
2548  v3d->overlay.xray_alpha_bone = 0.5f;
2549  }
2550  }
2551  }
2552  }
2553  }
2554  }
2555 
2556  if (!MAIN_VERSION_ATLEAST(bmain, 280, 19)) {
2557  if (!DNA_struct_elem_find(fd->filesdna, "Image", "ListBase", "renderslot")) {
2558  for (Image *ima = bmain->images.first; ima; ima = ima->id.next) {
2559  if (ima->type == IMA_TYPE_R_RESULT) {
2560  for (int i = 0; i < 8; i++) {
2561  RenderSlot *slot = MEM_callocN(sizeof(RenderSlot), "Image Render Slot Init");
2562  BLI_snprintf(slot->name, sizeof(slot->name), "Slot %d", i + 1);
2563  BLI_addtail(&ima->renderslots, slot);
2564  }
2565  }
2566  }
2567  }
2568  if (!DNA_struct_elem_find(fd->filesdna, "SpaceAction", "char", "mode_prev")) {
2569  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2570  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2571  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2572  if (sl->spacetype == SPACE_ACTION) {
2573  SpaceAction *saction = (SpaceAction *)sl;
2574  /* "Dopesheet" should be default here,
2575  * unless it looks like the Action Editor was active instead. */
2576  if ((saction->mode_prev == 0) && (saction->action == NULL)) {
2577  saction->mode_prev = SACTCONT_DOPESHEET;
2578  }
2579  }
2580  }
2581  }
2582  }
2583  }
2584 
2585  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2586  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2587  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2588  if (sl->spacetype == SPACE_VIEW3D) {
2589  View3D *v3d = (View3D *)sl;
2590  if (v3d->drawtype == OB_TEXTURE) {
2591  v3d->drawtype = OB_SOLID;
2594  }
2595  }
2596  }
2597  }
2598  }
2599  }
2600 
2601  if (!MAIN_VERSION_ATLEAST(bmain, 280, 21)) {
2602  for (Scene *sce = bmain->scenes.first; sce != NULL; sce = sce->id.next) {
2603  if (sce->ed != NULL && sce->ed->seqbase.first != NULL) {
2604  do_versions_seq_unique_name_all_strips(sce, &sce->ed->seqbase);
2605  }
2606  }
2607 
2608  if (!DNA_struct_elem_find(
2609  fd->filesdna, "View3DOverlay", "float", "texture_paint_mode_opacity")) {
2610  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2611  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2612  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2613  if (sl->spacetype == SPACE_VIEW3D) {
2614  enum {
2615  V3D_SHOW_MODE_SHADE_OVERRIDE = (1 << 15),
2616  };
2617  View3D *v3d = (View3D *)sl;
2618  float alpha = (v3d->flag2 & V3D_SHOW_MODE_SHADE_OVERRIDE) ? 0.0f : 1.0f;
2619  v3d->overlay.texture_paint_mode_opacity = alpha;
2620  v3d->overlay.vertex_paint_mode_opacity = alpha;
2621  v3d->overlay.weight_paint_mode_opacity = alpha;
2622  }
2623  }
2624  }
2625  }
2626  }
2627 
2628  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "background_type")) {
2629  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2630  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2631  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2632  if (sl->spacetype == SPACE_VIEW3D) {
2633  View3D *v3d = (View3D *)sl;
2634  copy_v3_fl(v3d->shading.background_color, 0.05f);
2635  }
2636  }
2637  }
2638  }
2639  }
2640 
2641  if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_cubemap_draw_size")) {
2642  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2645  }
2646  }
2647 
2648  if (!DNA_struct_elem_find(
2649  fd->filesdna, "RigidBodyWorld", "RigidBodyWorld_Shared", "*shared")) {
2650  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2652 
2653  if (rbw == NULL) {
2654  continue;
2655  }
2656 
2657  if (rbw->shared == NULL) {
2658  rbw->shared = MEM_callocN(sizeof(*rbw->shared), "RigidBodyWorld_Shared");
2659  }
2660 
2661  /* Move shared pointers from deprecated location to current location */
2662  rbw->shared->pointcache = rbw->pointcache;
2663  rbw->shared->ptcaches = rbw->ptcaches;
2664 
2665  rbw->pointcache = NULL;
2666  BLI_listbase_clear(&rbw->ptcaches);
2667 
2668  if (rbw->shared->pointcache == NULL) {
2669  rbw->shared->pointcache = BKE_ptcache_add(&(rbw->shared->ptcaches));
2670  }
2671  }
2672  }
2673 
2674  if (!DNA_struct_elem_find(fd->filesdna, "SoftBody", "SoftBody_Shared", "*shared")) {
2675  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2676  SoftBody *sb = ob->soft;
2677  if (sb == NULL) {
2678  continue;
2679  }
2680  if (sb->shared == NULL) {
2681  sb->shared = MEM_callocN(sizeof(*sb->shared), "SoftBody_Shared");
2682  }
2683 
2684  /* Move shared pointers from deprecated location to current location */
2685  sb->shared->pointcache = sb->pointcache;
2686  sb->shared->ptcaches = sb->ptcaches;
2687 
2688  sb->pointcache = NULL;
2689  BLI_listbase_clear(&sb->ptcaches);
2690  }
2691  }
2692 
2693  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "short", "type")) {
2694  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2695  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2696  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2697  if (sl->spacetype == SPACE_VIEW3D) {
2698  View3D *v3d = (View3D *)sl;
2699  if (v3d->drawtype == OB_RENDER) {
2700  v3d->drawtype = OB_SOLID;
2701  }
2702  v3d->shading.type = v3d->drawtype;
2703  v3d->shading.prev_type = OB_SOLID;
2704  }
2705  }
2706  }
2707  }
2708  }
2709 
2710  if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "View3DShading", "shading")) {
2711  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2713  }
2714  }
2715  /* initialize grease pencil view data */
2716  if (!DNA_struct_elem_find(fd->filesdna, "SpaceView3D", "float", "vertex_opacity")) {
2717  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2718  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2719  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2720  if (sl->spacetype == SPACE_VIEW3D) {
2721  View3D *v3d = (View3D *)sl;
2722  v3d->vertex_opacity = 1.0f;
2724  }
2725  }
2726  }
2727  }
2728  }
2729  }
2730 
2731  if (!MAIN_VERSION_ATLEAST(bmain, 280, 22)) {
2732  if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "annotate_v3d_align")) {
2733  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2736  }
2737  }
2738  if (!DNA_struct_elem_find(fd->filesdna, "bGPDlayer", "short", "line_change")) {
2739  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
2740  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2741  gpl->line_change = gpl->thickness;
2742  if ((gpl->thickness < 1) || (gpl->thickness > 10)) {
2743  gpl->thickness = 3;
2744  }
2745  }
2746  }
2747  }
2748  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_paper_opacity")) {
2749  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2750  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2751  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2752  if (sl->spacetype == SPACE_VIEW3D) {
2753  View3D *v3d = (View3D *)sl;
2754  v3d->overlay.gpencil_paper_opacity = 0.5f;
2755  }
2756  }
2757  }
2758  }
2759  }
2760  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_grid_opacity")) {
2761  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2762  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2763  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2764  if (sl->spacetype == SPACE_VIEW3D) {
2765  View3D *v3d = (View3D *)sl;
2766  v3d->overlay.gpencil_grid_opacity = 0.5f;
2767  }
2768  }
2769  }
2770  }
2771  }
2772 
2773  /* default loc axis */
2774  if (!DNA_struct_elem_find(fd->filesdna, "GP_Sculpt_Settings", "int", "lock_axis")) {
2775  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2776  /* lock axis */
2778  if (gset) {
2779  gset->lock_axis = GP_LOCKAXIS_Y;
2780  }
2781  }
2782  }
2783 
2784  /* Versioning code for Subsurf modifier. */
2785  if (!DNA_struct_elem_find(fd->filesdna, "SubsurfModifier", "short", "uv_smooth")) {
2786  for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2787  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2788  if (md->type == eModifierType_Subsurf) {
2792  }
2793  else {
2795  }
2796  }
2797  }
2798  }
2799  }
2800 
2801  if (!DNA_struct_elem_find(fd->filesdna, "SubsurfModifier", "short", "quality")) {
2802  for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2803  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2804  if (md->type == eModifierType_Subsurf) {
2806  smd->quality = min_ii(smd->renderLevels, 3);
2807  }
2808  }
2809  }
2810  }
2811  /* Versioning code for Multires modifier. */
2812  if (!DNA_struct_elem_find(fd->filesdna, "MultiresModifier", "short", "quality")) {
2813  for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2814  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2815  if (md->type == eModifierType_Multires) {
2817  mmd->quality = 3;
2820  }
2821  else {
2823  }
2824  }
2825  }
2826  }
2827  }
2828 
2829  if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "short", "bending_model")) {
2830  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2831  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2832  ClothModifierData *clmd = NULL;
2833  if (md->type == eModifierType_Cloth) {
2834  clmd = (ClothModifierData *)md;
2835  }
2836  else if (md->type == eModifierType_ParticleSystem) {
2838  ParticleSystem *psys = psmd->psys;
2839  clmd = psys->clmd;
2840  }
2841  if (clmd != NULL) {
2843  clmd->sim_parms->tension = clmd->sim_parms->structural;
2844  clmd->sim_parms->compression = clmd->sim_parms->structural;
2845  clmd->sim_parms->shear = clmd->sim_parms->structural;
2846  clmd->sim_parms->max_tension = clmd->sim_parms->max_struct;
2847  clmd->sim_parms->max_compression = clmd->sim_parms->max_struct;
2848  clmd->sim_parms->max_shear = clmd->sim_parms->max_struct;
2850  clmd->sim_parms->tension_damp = clmd->sim_parms->Cdis;
2851  clmd->sim_parms->compression_damp = clmd->sim_parms->Cdis;
2852  clmd->sim_parms->shear_damp = clmd->sim_parms->Cdis;
2853  }
2854  }
2855  }
2856  }
2857 
2858  if (!DNA_struct_elem_find(fd->filesdna, "BrushGpencilSettings", "float", "era_strength_f")) {
2859  for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
2860  if (brush->gpencil_settings != NULL) {
2861  BrushGpencilSettings *gp = brush->gpencil_settings;
2862  if (gp->brush_type == GPAINT_TOOL_ERASE) {
2863  gp->era_strength_f = 100.0f;
2864  gp->era_thickness_f = 10.0f;
2865  }
2866  }
2867  }
2868  }
2869 
2870  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2871  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2872  if (md->type == eModifierType_Cloth) {
2873  ClothModifierData *clmd = (ClothModifierData *)md;
2874 
2875  if (!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL)) {
2876  clmd->sim_parms->vgroup_mass = 0;
2877  }
2878 
2880  clmd->sim_parms->vgroup_struct = 0;
2881  clmd->sim_parms->vgroup_shear = 0;
2882  clmd->sim_parms->vgroup_bend = 0;
2883  }
2884 
2885  if (!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SEW)) {
2886  clmd->sim_parms->shrink_min = 0.0f;
2887  clmd->sim_parms->vgroup_shrink = 0;
2888  }
2889 
2892  }
2893  }
2894  }
2895  }
2896  }
2897 
2898  if (!MAIN_VERSION_ATLEAST(bmain, 280, 24)) {
2899  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2900  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2901  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2902  if (sl->spacetype == SPACE_VIEW3D) {
2903  View3D *v3d = (View3D *)sl;
2908  }
2909  }
2910  }
2911  }
2912 
2913  if (!DNA_struct_elem_find(fd->filesdna, "ShrinkwrapModifierData", "char", "shrinkMode")) {
2914  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2915  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2916  if (md->type == eModifierType_Shrinkwrap) {
2918  if (smd->shrinkOpts & MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE) {
2920  smd->shrinkOpts &= ~MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE;
2921  }
2922  }
2923  }
2924  }
2925  }
2926 
2927  if (!DNA_struct_elem_find(fd->filesdna, "PartDeflect", "float", "pdef_cfrict")) {
2928  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2929  if (ob->pd) {
2930  ob->pd->pdef_cfrict = 5.0f;
2931  }
2932 
2933  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2934  if (md->type == eModifierType_Cloth) {
2935  ClothModifierData *clmd = (ClothModifierData *)md;
2936 
2937  clmd->coll_parms->selfepsilon = 0.015f;
2938  }
2939  }
2940  }
2941  }
2942 
2943  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "xray_alpha_wire")) {
2944  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2945  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2946  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2947  if (sl->spacetype == SPACE_VIEW3D) {
2948  View3D *v3d = (View3D *)sl;
2950  }
2951  }
2952  }
2953  }
2954  }
2955  }
2956 
2957  if (!MAIN_VERSION_ATLEAST(bmain, 280, 25)) {
2958  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2959  UnitSettings *unit = &scene->unit;
2960  if (unit->system != USER_UNIT_NONE) {
2963  }
2965  }
2966 
2967  /* gpencil grid settings */
2968  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
2969  ARRAY_SET_ITEMS(gpd->grid.color, 0.5f, 0.5f, 0.5f); /* Color */
2970  ARRAY_SET_ITEMS(gpd->grid.scale, 1.0f, 1.0f); /* Scale */
2971  gpd->grid.lines = GP_DEFAULT_GRID_LINES; /* Number of lines */
2972  }
2973  }
2974 
2975  if (!MAIN_VERSION_ATLEAST(bmain, 280, 28)) {
2976  for (Mesh *mesh = bmain->meshes.first; mesh; mesh = mesh->id.next) {
2978  }
2979  }
2980 
2981  if (!MAIN_VERSION_ATLEAST(bmain, 280, 29)) {
2982  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2983  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2984  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2985  if (sl->spacetype == SPACE_VIEW3D) {
2986  enum { V3D_OCCLUDE_WIRE = (1 << 14) };
2987  View3D *v3d = (View3D *)sl;
2988  if (v3d->flag2 & V3D_OCCLUDE_WIRE) {
2990  v3d->flag2 &= ~V3D_OCCLUDE_WIRE;
2991  }
2992  }
2993  }
2994  }
2995  }
2996 
2997  /* Files stored pre 2.5 (possibly re-saved with newer versions) may have non-visible
2998  * spaces without a header (visible/active ones are properly versioned).
2999  * Multiple version patches below assume there's always a header though. So inserting this
3000  * patch in-between older ones to add a header when needed.
3001  *
3002  * From here on it should be fine to assume there always is a header.
3003  */
3004  if (!MAIN_VERSION_ATLEAST(bmain, 283, 1)) {
3005  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3006  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3007  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3008  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3009  &sl->regionbase;
3010  ARegion *region_header = do_versions_find_region_or_null(regionbase, RGN_TYPE_HEADER);
3011 
3012  if (!region_header) {
3013  /* Headers should always be first in the region list, except if there's also a
3014  * tool-header. These were only introduced in later versions though, so should be
3015  * fine to always insert headers first. */
3017 
3019  "header 2.83.1 versioning");
3020  region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM :
3021  RGN_ALIGN_TOP;
3022  BLI_addhead(regionbase, region);
3023  }
3024  }
3025  }
3026  }
3027  }
3028 
3029  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3030  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3031  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3032  if (sl->spacetype == SPACE_PROPERTIES) {
3033  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3034  &sl->regionbase;
3035  ARegion *region = MEM_callocN(sizeof(ARegion), "navigation bar for properties");
3036  ARegion *region_header = NULL;
3037 
3038  for (region_header = regionbase->first; region_header;
3039  region_header = region_header->next) {
3040  if (region_header->regiontype == RGN_TYPE_HEADER) {
3041  break;
3042  }
3043  }
3044  BLI_assert(region_header);
3045 
3046  BLI_insertlinkafter(regionbase, region_header, region);
3047 
3048  region->regiontype = RGN_TYPE_NAV_BAR;
3049  region->alignment = RGN_ALIGN_LEFT;
3050  }
3051  }
3052  }
3053  }
3054 
3055  /* grease pencil fade layer opacity */
3056  if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_fade_layer")) {
3057  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3058  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3059  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3060  if (sl->spacetype == SPACE_VIEW3D) {
3061  View3D *v3d = (View3D *)sl;
3062  v3d->overlay.gpencil_fade_layer = 0.5f;
3063  }
3064  }
3065  }
3066  }
3067  }
3068  }
3069 
3070  if (!MAIN_VERSION_ATLEAST(bmain, 280, 30)) {
3071  /* grease pencil main material show switches */
3072  for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3073  if (mat->gp_style) {
3074  mat->gp_style->flag |= GP_MATERIAL_STROKE_SHOW;
3075  mat->gp_style->flag |= GP_MATERIAL_FILL_SHOW;
3076  }
3077  }
3078  }
3079 
3080  if (!MAIN_VERSION_ATLEAST(bmain, 280, 33)) {
3081 
3082  if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "overscan")) {
3083  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3084  scene->eevee.overscan = 3.0f;
3085  }
3086  }
3087 
3088  for (Light *la = bmain->lights.first; la; la = la->id.next) {
3089  /* Removed Hemi lights. */
3090  if (!ELEM(la->type, LA_LOCAL, LA_SUN, LA_SPOT, LA_AREA)) {
3091  la->type = LA_SUN;
3092  }
3093  }
3094 
3095  if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "light_threshold")) {
3096  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3097  scene->eevee.light_threshold = 0.01f;
3098  }
3099  }
3100 
3101  if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_irradiance_smoothing")) {
3102  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3104  }
3105  }
3106 
3107  if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_filter_quality")) {
3108  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3109  scene->eevee.gi_filter_quality = 1.0f;
3110  }
3111  }
3112 
3113  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "att_dist")) {
3114  for (Light *la = bmain->lights.first; la; la = la->id.next) {
3115  la->att_dist = la->clipend;
3116  }
3117  }
3118 
3119  if (!DNA_struct_elem_find(fd->filesdna, "Brush", "char", "weightpaint_tool")) {
3120  /* Magic defines from old files (2.7x) */
3121 
3122 #define PAINT_BLEND_MIX 0
3123 #define PAINT_BLEND_ADD 1
3124 #define PAINT_BLEND_SUB 2
3125 #define PAINT_BLEND_MUL 3
3126 #define PAINT_BLEND_BLUR 4
3127 #define PAINT_BLEND_LIGHTEN 5
3128 #define PAINT_BLEND_DARKEN 6
3129 #define PAINT_BLEND_AVERAGE 7
3130 #define PAINT_BLEND_SMEAR 8
3131 #define PAINT_BLEND_COLORDODGE 9
3132 #define PAINT_BLEND_DIFFERENCE 10
3133 #define PAINT_BLEND_SCREEN 11
3134 #define PAINT_BLEND_HARDLIGHT 12
3135 #define PAINT_BLEND_OVERLAY 13
3136 #define PAINT_BLEND_SOFTLIGHT 14
3137 #define PAINT_BLEND_EXCLUSION 15
3138 #define PAINT_BLEND_LUMINOSITY 16
3139 #define PAINT_BLEND_SATURATION 17
3140 #define PAINT_BLEND_HUE 18
3141 #define PAINT_BLEND_ALPHA_SUB 19
3142 #define PAINT_BLEND_ALPHA_ADD 20
3143 
3144  for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
3145  if (brush->ob_mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) {
3146  const char tool_init = brush->vertexpaint_tool;
3147  bool is_blend = false;
3148 
3149  {
3150  char tool;
3151  switch (tool_init) {
3152  case PAINT_BLEND_MIX:
3153  tool = VPAINT_TOOL_DRAW;
3154  break;
3155  case PAINT_BLEND_BLUR:
3156  tool = VPAINT_TOOL_BLUR;
3157  break;
3158  case PAINT_BLEND_AVERAGE:
3159  tool = VPAINT_TOOL_AVERAGE;
3160  break;
3161  case PAINT_BLEND_SMEAR:
3162  tool = VPAINT_TOOL_SMEAR;
3163  break;
3164  default:
3165  tool = VPAINT_TOOL_DRAW;
3166  is_blend = true;
3167  break;
3168  }
3169  brush->vertexpaint_tool = tool;
3170  }
3171 
3172  if (is_blend == false) {
3173  brush->blend = IMB_BLEND_MIX;
3174  }
3175  else {
3176  short blend = IMB_BLEND_MIX;
3177  switch (tool_init) {
3178  case PAINT_BLEND_ADD:
3179  blend = IMB_BLEND_ADD;
3180  break;
3181  case PAINT_BLEND_SUB:
3182  blend = IMB_BLEND_SUB;
3183  break;
3184  case PAINT_BLEND_MUL:
3185  blend = IMB_BLEND_MUL;
3186  break;
3187  case PAINT_BLEND_LIGHTEN:
3189  break;
3190  case PAINT_BLEND_DARKEN:
3192  break;
3195  break;
3198  break;
3199  case PAINT_BLEND_SCREEN:
3201  break;
3202  case PAINT_BLEND_HARDLIGHT:
3204  break;
3205  case PAINT_BLEND_OVERLAY:
3207  break;
3208  case PAINT_BLEND_SOFTLIGHT:
3210  break;
3211  case PAINT_BLEND_EXCLUSION:
3213  break;
3216  break;
3219  break;
3220  case PAINT_BLEND_HUE:
3221  blend = IMB_BLEND_HUE;
3222  break;
3223  case PAINT_BLEND_ALPHA_SUB:
3225  break;
3226  case PAINT_BLEND_ALPHA_ADD:
3228  break;
3229  }
3230  brush->blend = blend;
3231  }
3232  }
3233  /* For now these match, in the future new items may not. */
3234  brush->weightpaint_tool = brush->vertexpaint_tool;
3235  }
3236 
3237 #undef PAINT_BLEND_MIX
3238 #undef PAINT_BLEND_ADD
3239 #undef PAINT_BLEND_SUB
3240 #undef PAINT_BLEND_MUL
3241 #undef PAINT_BLEND_BLUR
3242 #undef PAINT_BLEND_LIGHTEN
3243 #undef PAINT_BLEND_DARKEN
3244 #undef PAINT_BLEND_AVERAGE
3245 #undef PAINT_BLEND_SMEAR
3246 #undef PAINT_BLEND_COLORDODGE
3247 #undef PAINT_BLEND_DIFFERENCE
3248 #undef PAINT_BLEND_SCREEN
3249 #undef PAINT_BLEND_HARDLIGHT
3250 #undef PAINT_BLEND_OVERLAY
3251 #undef PAINT_BLEND_SOFTLIGHT
3252 #undef PAINT_BLEND_EXCLUSION
3253 #undef PAINT_BLEND_LUMINOSITY
3254 #undef PAINT_BLEND_SATURATION
3255 #undef PAINT_BLEND_HUE
3256 #undef PAINT_BLEND_ALPHA_SUB
3257 #undef PAINT_BLEND_ALPHA_ADD
3258  }
3259  }
3260 
3261  if (!MAIN_VERSION_ATLEAST(bmain, 280, 34)) {
3262  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3263  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3264  LISTBASE_FOREACH (SpaceLink *, slink, &area->spacedata) {
3265  if (slink->spacetype == SPACE_USERPREF) {
3266  ARegion *navigation_region = BKE_spacedata_find_region_type(
3267  slink, area, RGN_TYPE_NAV_BAR);
3268 
3269  if (!navigation_region) {
3271  ListBase *regionbase = (slink == area->spacedata.first) ? &area->regionbase :
3272  &slink->regionbase;
3273 
3274  navigation_region = MEM_callocN(sizeof(ARegion),
3275  "userpref navigation-region do_versions");
3276 
3277  /* Order matters, addhead not addtail! */
3278  BLI_insertlinkbefore(regionbase, main_region, navigation_region);
3279 
3280  navigation_region->regiontype = RGN_TYPE_NAV_BAR;
3281  navigation_region->alignment = RGN_ALIGN_LEFT;
3282  }
3283  }
3284  }
3285  }
3286  }
3287  }
3288 
3289  if (!MAIN_VERSION_ATLEAST(bmain, 280, 36)) {
3290  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "curvature_ridge_factor")) {
3291  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3292  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3293  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3294  if (sl->spacetype == SPACE_VIEW3D) {
3295  View3D *v3d = (View3D *)sl;
3296  v3d->shading.curvature_ridge_factor = 1.0f;
3297  v3d->shading.curvature_valley_factor = 1.0f;
3298  }
3299  }
3300  }
3301  }
3302  }
3303 
3304  /* Rename OpenGL to Workbench. */
3305  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3306  if (STREQ(scene->r.engine, "BLENDER_OPENGL")) {
3308  }
3309  }
3310 
3311  /* init Annotations onion skin */
3312  if (!DNA_struct_elem_find(fd->filesdna, "bGPDlayer", "int", "gstep")) {
3313  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
3314  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
3315  ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.302f, 0.851f, 0.302f);
3316  ARRAY_SET_ITEMS(gpl->gcolor_next, 0.250f, 0.1f, 1.0f);
3317  }
3318  }
3319  }
3320 
3321  /* Move studio_light selection to lookdev_light. */
3322  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "lookdev_light[256]")) {
3323  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3324  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3325  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3326  if (sl->spacetype == SPACE_VIEW3D) {
3327  View3D *v3d = (View3D *)sl;
3328  memcpy(v3d->shading.lookdev_light, v3d->shading.studio_light, sizeof(char[256]));
3329  }
3330  }
3331  }
3332  }
3333  }
3334 
3335  /* Change Solid mode shadow orientation. */
3336  if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "float", "shadow_focus")) {
3337  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3338  float *dir = scene->display.light_direction;
3339  SWAP(float, dir[2], dir[1]);
3340  dir[2] = -dir[2];
3341  dir[0] = -dir[0];
3342  }
3343  }
3344  }
3345 
3346  if (!MAIN_VERSION_ATLEAST(bmain, 280, 37)) {
3347  for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
3348  ca->drawsize *= 2.0f;
3349  }
3350 
3351  /* Grease pencil primitive curve */
3352  if (!DNA_struct_elem_find(
3353  fd->filesdna, "GP_Sculpt_Settings", "CurveMapping", "cur_primitive")) {
3354  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3356  if ((gset) && (gset->cur_primitive == NULL)) {
3357  gset->cur_primitive = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
3360  &gset->cur_primitive->clipr,
3363  }
3364  }
3365  }
3366  }
3367 
3368  if (!MAIN_VERSION_ATLEAST(bmain, 280, 38)) {
3369  if (DNA_struct_elem_find(fd->filesdna, "Object", "char", "empty_image_visibility_flag")) {
3370  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3371  ob->empty_image_visibility_flag ^= (OB_EMPTY_IMAGE_HIDE_PERSPECTIVE |
3374  }
3375  }
3376 
3377  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3378  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3379  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3380  switch (sl->spacetype) {
3381  case SPACE_IMAGE: {
3382  SpaceImage *sima = (SpaceImage *)sl;
3387  break;
3388  }
3389  case SPACE_VIEW3D: {
3390  View3D *v3d = (View3D *)sl;
3395  break;
3396  }
3397  case SPACE_OUTLINER: {
3398  SpaceOutliner *space_outliner = (SpaceOutliner *)sl;
3399  space_outliner->filter &= ~(SO_FILTER_CLEARED_1 | SO_FILTER_UNUSED_5 |
3401  space_outliner->storeflag &= ~(SO_TREESTORE_UNUSED_1);
3402  break;
3403  }
3404  case SPACE_FILE: {
3405  SpaceFile *sfile = (SpaceFile *)sl;
3406  if (sfile->params) {
3409  }
3410  break;
3411  }
3412  case SPACE_NODE: {
3413  SpaceNode *snode = (SpaceNode *)sl;
3415  break;
3416  }
3417  case SPACE_PROPERTIES: {
3418  SpaceProperties *sbuts = (SpaceProperties *)sl;
3419  sbuts->flag &= ~(SB_FLAG_UNUSED_2 | SB_FLAG_UNUSED_3);
3420  break;
3421  }
3422  case SPACE_NLA: {
3423  SpaceNla *snla = (SpaceNla *)sl;
3425  break;
3426  }
3427  }
3428  }
3429  }
3430  }
3431 
3432  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3438 
3441 
3442  if (scene->toolsettings->sculpt) {
3445  }
3446 
3447  if (scene->ed) {
3449  }
3450  }
3451 
3452  for (World *world = bmain->worlds.first; world; world = world->id.next) {
3455  }
3456 
3457  for (Image *image = bmain->images.first; image; image = image->id.next) {
3461  }
3462 
3463  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3464  ob->flag &= ~(OB_FLAG_UNUSED_11 | OB_FLAG_UNUSED_12);
3466  ob->shapeflag &= ~OB_SHAPE_FLAG_UNUSED_1;
3467  }
3468 
3469  for (Mesh *me = bmain->meshes.first; me; me = me->id.next) {
3472  }
3473 
3474  for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3475  mat->blend_flag &= ~(1 << 2); /* UNUSED */
3476  }
3477  }
3478 
3479  if (!MAIN_VERSION_ATLEAST(bmain, 280, 40)) {
3480  if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "snap_transform_mode_flag")) {
3481  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3483  }
3484  }
3485 
3486  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3487  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3488  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3489  switch (sl->spacetype) {
3490  case SPACE_VIEW3D: {
3491  enum { V3D_BACKFACE_CULLING = (1 << 10) };
3492  View3D *v3d = (View3D *)sl;
3493  if (v3d->flag2 & V3D_BACKFACE_CULLING) {
3494  v3d->flag2 &= ~V3D_BACKFACE_CULLING;
3496  }
3497  break;
3498  }
3499  }
3500  }
3501  }
3502  }
3503 
3504  if (!DNA_struct_find(fd->filesdna, "TransformOrientationSlot")) {
3505  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3506  for (int i = 0; i < ARRAY_SIZE(scene->orientation_slots); i++) {
3508  }
3509  }
3510  }
3511 
3512  /* Grease pencil cutter/select segment intersection threshold. */
3513  if (!DNA_struct_elem_find(fd->filesdna, "GP_Sculpt_Settings", "float", "isect_threshold")) {
3514  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3516  if (gset) {
3517  gset->isect_threshold = 0.1f;
3518  }
3519  }
3520  }
3521 
3522  /* Fix anamorphic bokeh eevee rna limits. */
3523  for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
3524  if (ca->gpu_dof.ratio < 0.01f) {
3525  ca->gpu_dof.ratio = 0.01f;
3526  }
3527  }
3528 
3529  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3530  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3531  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3532  if (sl->spacetype == SPACE_USERPREF) {
3534 
3535  if (!execute_region) {
3536  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3537  &sl->regionbase;
3539 
3540  execute_region = MEM_callocN(sizeof(ARegion), "execute region for properties");
3541 
3542  BLI_assert(region_navbar);
3543 
3544  BLI_insertlinkafter(regionbase, region_navbar, execute_region);
3545 
3546  execute_region->regiontype = RGN_TYPE_EXECUTE;
3547  execute_region->alignment = RGN_ALIGN_BOTTOM | RGN_SPLIT_PREV;
3548  execute_region->flag |= RGN_FLAG_DYNAMIC_SIZE;
3549  }
3550  }
3551  }
3552  }
3553  }
3554  }
3555 
3556  if (!MAIN_VERSION_ATLEAST(bmain, 280, 43)) {
3557  ListBase *lb = which_libbase(bmain, ID_BR);
3559  }
3560 
3561  if (!MAIN_VERSION_ATLEAST(bmain, 280, 44)) {
3562  if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "a")) {
3563  for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3564  mat->a = 1.0f;
3565  }
3566  }
3567 
3568  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3569  enum {
3570  R_ALPHAKEY = 2,
3571  };
3574  if (scene->r.alphamode == R_ALPHAKEY) {
3576  }
3578  ts->particle.flag &= ~PE_UNUSED_6;
3579  if (ts->sculpt != NULL) {
3581  }
3582  }
3583  }
3584 
3585  if (!MAIN_VERSION_ATLEAST(bmain, 280, 46)) {
3586  /* Add wireframe color. */
3587  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "wire_color_type")) {
3588  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3589  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3590  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3591  if (sl->spacetype == SPACE_VIEW3D) {
3592  View3D *v3d = (View3D *)sl;
3594  }
3595  }
3596  }
3597  }
3598  }
3599 
3600  if (!DNA_struct_elem_find(fd->filesdna, "View3DCursor", "short", "rotation_mode")) {
3601  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3604  scene->cursor.rotation_quaternion[0] = 1.0f;
3605  scene->cursor.rotation_axis[1] = 1.0f;
3606  }
3607  }
3608  }
3609  }
3610 
3611  if (!MAIN_VERSION_ATLEAST(bmain, 280, 47)) {
3612  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
3614  if (pset->brushtype < 0) {
3615  pset->brushtype = PE_BRUSH_COMB;
3616  }
3617  }
3618 
3619  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
3620  {
3621  enum { PARCURVE = 1, PARKEY = 2, PAR_DEPRECATED = 16 };
3622  if (ELEM(ob->partype, PARCURVE, PARKEY, PAR_DEPRECATED)) {
3623  ob->partype = PAROBJECT;
3624  }
3625  }
3626 
3627  {
3628  enum { OB_WAVE = 21, OB_LIFE = 23, OB_SECTOR = 24 };
3629  if (ELEM(ob->type, OB_WAVE, OB_LIFE, OB_SECTOR)) {
3630  ob->type = OB_EMPTY;
3631  }
3632  }
3633 
3636 
3637  ob->nlaflag &= ~(OB_ADS_UNUSED_1 | OB_ADS_UNUSED_2);
3638  }
3639 
3640  LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
3643  }
3644 
3645  LISTBASE_FOREACH (Text *, text, &bmain->texts) {
3646  text->flags &= ~(TXT_FLAG_UNUSED_8 | TXT_FLAG_UNUSED_9);
3647  }
3648  }
3649 
3650  if (!MAIN_VERSION_ATLEAST(bmain, 280, 48)) {
3651  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3652  /* Those are not currently used, but are accessible through RNA API and were not
3653  * properly initialized previously. This is mere copy of #scene_init_data code. */
3654  if (scene->r.im_format.view_settings.look[0] == '\0') {
3658  }
3659 
3660  if (scene->r.bake.im_format.view_settings.look[0] == '\0') {
3664  "Filmic");
3665  }
3666  }
3667  }
3668 
3669  if (!MAIN_VERSION_ATLEAST(bmain, 280, 49)) {
3670  /* All tool names changed, reset to defaults. */
3671  for (WorkSpace *workspace = bmain->workspaces.first; workspace;
3672  workspace = workspace->id.next) {
3673  while (!BLI_listbase_is_empty(&workspace->tools)) {
3674  BKE_workspace_tool_remove(workspace, workspace->tools.first);
3675  }
3676  }
3677  }
3678 
3679  if (!MAIN_VERSION_ATLEAST(bmain, 280, 52)) {
3680  LISTBASE_FOREACH (ParticleSettings *, part, &bmain->particles) {
3681  /* Replace deprecated PART_DRAW_BB by PART_DRAW_NOT */
3682  if (part->ren_as == PART_DRAW_BB) {
3683  part->ren_as = PART_DRAW_NOT;
3684  }
3685  if (part->draw_as == PART_DRAW_BB) {
3686  part->draw_as = PART_DRAW_NOT;
3687  }
3688  }
3689 
3690  if (!DNA_struct_elem_find(fd->filesdna, "TriangulateModifierData", "int", "min_vertices")) {
3691  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3692  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
3693  if (md->type == eModifierType_Triangulate) {
3695  smd->min_vertices = 4;
3696  }
3697  }
3698  }
3699  }
3700 
3701  FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
3702  if (ntree->type == NTREE_SHADER) {
3704  /* Fix missing version patching from earlier changes. */
3705  if (STREQ(node->idname, "ShaderNodeOutputLamp")) {
3706  STRNCPY(node->idname, "ShaderNodeOutputLight");
3707  }
3708  if (node->type == SH_NODE_BSDF_PRINCIPLED && node->custom2 == 0) {
3709  node->custom2 = SHD_SUBSURFACE_BURLEY;
3710  }
3711  }
3712  }
3713  }
3715  }
3716 
3717  if (!MAIN_VERSION_ATLEAST(bmain, 280, 53)) {
3718  for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3719  /* Eevee: Keep material appearance consistent with previous behavior. */
3720  if (!mat->use_nodes || !mat->nodetree || mat->blend_method == MA_BM_SOLID) {
3721  mat->blend_shadow = MA_BS_SOLID;
3722  }
3723  }
3724 
3725  /* grease pencil default animation channel color */
3726  {
3727  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
3728  if (gpd->flag & GP_DATA_ANNOTATIONS) {
3729  continue;
3730  }
3731  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
3732  /* default channel color */
3733  ARRAY_SET_ITEMS(gpl->color, 0.2f, 0.2f, 0.2f);
3734  }
3735  }
3736  }
3737  }
3738 
3739  if (!MAIN_VERSION_ATLEAST(bmain, 280, 54)) {
3740  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3741  bool is_first_subdiv = true;
3742  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
3743  if (md->type == eModifierType_Subsurf) {
3745  if (is_first_subdiv) {
3747  }
3748  else {
3750  }
3751  is_first_subdiv = false;
3752  }
3753  else if (md->type == eModifierType_Multires) {
3755  if (is_first_subdiv) {
3757  }
3758  else {
3760  }
3761  is_first_subdiv = false;
3762  }
3763  }
3764  }
3765  }
3766 
3767  if (!MAIN_VERSION_ATLEAST(bmain, 280, 55)) {
3768  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3769  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3770  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3771  if (sl->spacetype == SPACE_TEXT) {
3772  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3773  &sl->regionbase;
3774 
3775  /* Remove multiple footers that were added by mistake. */
3777 
3778  /* Add footer. */
3779  ARegion *region = do_versions_add_region(RGN_TYPE_FOOTER, "footer for text");
3780  region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_TOP : RGN_ALIGN_BOTTOM;
3781 
3782  ARegion *region_header = do_versions_find_region(regionbase, RGN_TYPE_HEADER);
3783  BLI_insertlinkafter(regionbase, region_header, region);
3784  }
3785  }
3786  }
3787  }
3788  }
3789 
3790  if (!MAIN_VERSION_ATLEAST(bmain, 280, 56)) {
3791  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3792  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3793  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3794  if (sl->spacetype == SPACE_VIEW3D) {
3795  View3D *v3d = (View3D *)sl;
3801  }
3802  }
3803  }
3804  }
3805  }
3806 
3807  if (!MAIN_VERSION_ATLEAST(bmain, 280, 57)) {
3808  /* Enable Show Interpolation in dopesheet by default. */
3809  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3810  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3811  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3812  if (sl->spacetype == SPACE_ACTION) {
3813  SpaceAction *saction = (SpaceAction *)sl;
3814  if ((saction->flag & SACTION_SHOW_EXTREMES) == 0) {
3815  saction->flag |= SACTION_SHOW_INTERPOLATION;
3816  }
3817  }
3818  }
3819  }
3820  }
3821 
3822  /* init grease pencil brush gradients */
3823  if (!DNA_struct_elem_find(fd->filesdna, "BrushGpencilSettings", "float", "hardeness")) {
3824  for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
3825  if (brush->gpencil_settings != NULL) {
3826  BrushGpencilSettings *gp = brush->gpencil_settings;
3827  gp->hardeness = 1.0f;
3828  copy_v2_fl(gp->aspect_ratio, 1.0f);
3829  }
3830  }
3831  }
3832 
3833  /* init grease pencil stroke gradients */
3834  if (!DNA_struct_elem_find(fd->filesdna, "bGPDstroke", "float", "hardeness")) {
3835  for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
3836  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
3837  LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
3838  LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
3839  gps->hardeness = 1.0f;
3840  copy_v2_fl(gps->aspect_ratio, 1.0f);
3841  }
3842  }
3843  }
3844  }
3845  }
3846 
3847  /* enable the axis aligned ortho grid by default */
3848  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3849  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3850  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3851  if (sl->spacetype == SPACE_VIEW3D) {
3852  View3D *v3d = (View3D *)sl;
3853  v3d->gridflag |= V3D_SHOW_ORTHO_GRID;
3854  }
3855  }
3856  }
3857  }
3858  }
3859 
3860  /* Keep un-versioned until we're finished adding space types. */
3861  {
3862  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3863  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3864  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3865  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3866  &sl->regionbase;
3867  /* All spaces that use tools must be eventually added. */
3868  ARegion *region = NULL;
3869  if (ELEM(sl->spacetype, SPACE_VIEW3D, SPACE_IMAGE, SPACE_SEQ) &&
3870  ((region = do_versions_find_region_or_null(regionbase, RGN_TYPE_TOOL_HEADER)) ==
3871  NULL)) {
3872  /* Add tool header. */
3873  region = do_versions_add_region(RGN_TYPE_TOOL_HEADER, "tool header");
3874  region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
3875 
3876  ARegion *region_header = do_versions_find_region(regionbase, RGN_TYPE_HEADER);
3877  BLI_insertlinkbefore(regionbase, region_header, region);
3878  /* Hide by default, enable for painting workspaces (startup only). */
3879  region->flag |= RGN_FLAG_HIDDEN | RGN_FLAG_HIDDEN_BY_USER;
3880  }
3881  if (region != NULL) {
3883  region->flag, region->flag & RGN_FLAG_HIDDEN_BY_USER, RGN_FLAG_HIDDEN);
3884  }
3885  }
3886  }
3887  }
3888  }
3889 
3890  if (!MAIN_VERSION_ATLEAST(bmain, 280, 60)) {
3891  if (!DNA_struct_elem_find(fd->filesdna, "bSplineIKConstraint", "short", "yScaleMode")) {
3892  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3893  if (ob->pose) {
3894  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
3895  LISTBASE_FOREACH (bConstraint *, con, &pchan->constraints) {
3896  if (con->type == CONSTRAINT_TYPE_SPLINEIK) {
3898  if ((data->flag & CONSTRAINT_SPLINEIK_SCALE_LIMITED) == 0) {
3899  data->yScaleMode = CONSTRAINT_SPLINEIK_YS_FIT_CURVE;
3900  }
3901  }
3902  }
3903  }
3904  }
3905  }
3906  }
3907 
3908  if (!DNA_struct_elem_find(
3909  fd->filesdna, "View3DOverlay", "float", "sculpt_mode_mask_opacity")) {
3910  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3911  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3912  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3913  if (sl->spacetype == SPACE_VIEW3D) {
3914  View3D *v3d = (View3D *)sl;
3915  v3d->overlay.sculpt_mode_mask_opacity = 0.75f;
3916  }
3917  }
3918  }
3919  }
3920  }
3921  if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "char", "render_aa")) {
3922  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
3925  }
3926  }
3927 
3928  /* Split bbone_scalein/bbone_scaleout into x and y fields. */
3929  if (!DNA_struct_elem_find(fd->filesdna, "bPoseChannel", "float", "scale_out_y")) {
3930  /* Update armature data and pose channels. */
3931  LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
3932  do_version_bones_split_bbone_scale(&arm->bonebase);
3933  }
3934 
3935  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
3936  if (ob->pose) {
3937  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
3938  pchan->scale_in_z = pchan->scale_in_x;
3939  pchan->scale_out_z = pchan->scale_out_x;
3940  }
3941  }
3942  }
3943 
3944  /* Update action curves and drivers. */
3945  LISTBASE_FOREACH (bAction *, act, &bmain->actions) {
3946  LISTBASE_FOREACH_MUTABLE (FCurve *, fcu, &act->curves) {
3947  do_version_bbone_scale_fcurve_fix(&act->curves, fcu);
3948  }
3949  }
3950 
3952  }
3953 
3954  for (Scene *sce = bmain->scenes.first; sce != NULL; sce = sce->id.next) {
3955  if (sce->ed != NULL) {
3957  }
3958  }
3959  }
3960 
3961  if (!MAIN_VERSION_ATLEAST(bmain, 280, 61)) {
3962  /* Added a power option to Copy Scale. */
3963  if (!DNA_struct_elem_find(fd->filesdna, "bSizeLikeConstraint", "float", "power")) {
3964  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
3965  do_version_constraints_copy_scale_power(&ob->constraints);
3966  if (ob->pose) {
3967  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
3968  do_version_constraints_copy_scale_power(&pchan->constraints);
3969  }
3970  }
3971  }
3972  }
3973 
3974  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3975  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3976  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3977  if (ELEM(sl->spacetype, SPACE_CLIP, SPACE_GRAPH, SPACE_SEQ)) {
3978  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3979  &sl->regionbase;
3980 
3981  ARegion *region = NULL;
3982  if (sl->spacetype == SPACE_CLIP) {
3983  if (((SpaceClip *)sl)->view == SC_VIEW_GRAPH) {
3984  region = do_versions_find_region_or_null(regionbase, RGN_TYPE_PREVIEW);
3985  }
3986  }
3987  else {
3988  region = do_versions_find_region_or_null(regionbase, RGN_TYPE_WINDOW);
3989  }
3990 
3991  if (region != NULL) {
3992  region->v2d.scroll &= ~V2D_SCROLL_LEFT;
3993  region->v2d.scroll |= V2D_SCROLL_RIGHT;
3994  }
3995  }
3996  }
3997  }
3998  }
3999 
4000  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4001  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4002  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4003  if (sl->spacetype != SPACE_OUTLINER) {
4004  continue;
4005  }
4006  SpaceOutliner *space_outliner = (SpaceOutliner *)sl;
4007  space_outliner->filter &= ~SO_FLAG_UNUSED_1;
4009  }
4010  }
4011  }
4012  }
4013 
4014  if (!MAIN_VERSION_ATLEAST(bmain, 280, 69)) {
4015  LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
4016  arm->flag &= ~(ARM_FLAG_UNUSED_7 | ARM_FLAG_UNUSED_9);
4017  }
4018 
4019  /* Initializes sun lights with the new angular diameter property */
4020  if (!DNA_struct_elem_find(fd->filesdna, "Lamp", "float", "sun_angle")) {
4021  LISTBASE_FOREACH (Light *, light, &bmain->lights) {
4022  light->sun_angle = 2.0f * atanf(light->area_size);
4023  }
4024  }
4025  }
4026 
4027  if (!MAIN_VERSION_ATLEAST(bmain, 280, 70)) {
4028  /* New image alpha modes. */
4029  LISTBASE_FOREACH (Image *, image, &bmain->images) {
4030  enum { IMA_IGNORE_ALPHA = (1 << 12) };
4031  if (image->flag & IMA_IGNORE_ALPHA) {
4032  image->alpha_mode = IMA_ALPHA_IGNORE;
4033  image->flag &= ~IMA_IGNORE_ALPHA;
4034  }
4035  }
4036  }
4037 
4038  if (!MAIN_VERSION_ATLEAST(bmain, 280, 71)) {
4039  /* This assumes the Blender builtin config. Depending on the OCIO
4040  * environment variable for versioning is weak, and these deprecated view
4041  * transforms and look names don't seem to exist in other commonly used
4042  * OCIO configs so .blend files created for those would be unaffected. */
4043  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4044  ColorManagedViewSettings *view_settings;
4045  view_settings = &scene->view_settings;
4046 
4047  if (STREQ(view_settings->view_transform, "Default")) {
4048  STRNCPY(view_settings->view_transform, "Standard");
4049  }
4050  else if (STR_ELEM(view_settings->view_transform, "RRT", "Film")) {
4051  STRNCPY(view_settings->view_transform, "Filmic");
4052  }
4053  else if (STREQ(view_settings->view_transform, "Log")) {
4054  STRNCPY(view_settings->view_transform, "Filmic Log");
4055  }
4056 
4057  if (STREQ(view_settings->look, "Filmic - Base Contrast")) {
4058  STRNCPY(view_settings->look, "None");
4059  }
4060  }
4061  }
4062 
4063  if (!MAIN_VERSION_ATLEAST(bmain, 280, 74)) {
4064  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4065  if (scene->ed != NULL) {
4067  }
4068  }
4069  }
4070 
4071  if (!MAIN_VERSION_ATLEAST(bmain, 280, 75)) {
4072  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4073  if (scene->master_collection != NULL) {
4076  }
4077 
4078  UnitSettings *unit = &scene->unit;
4079  if (unit->system == USER_UNIT_NONE) {
4080  unit->length_unit = (char)USER_UNIT_ADAPTIVE;
4081  unit->mass_unit = (char)USER_UNIT_ADAPTIVE;
4082  }
4083 
4084  RenderData *render_data = &scene->r;
4085  switch (render_data->ffcodecdata.ffmpeg_preset) {
4086  case FFM_PRESET_ULTRAFAST:
4087  case FFM_PRESET_SUPERFAST:
4089  break;
4090  case FFM_PRESET_VERYFAST:
4091  case FFM_PRESET_FASTER:
4092  case FFM_PRESET_FAST:
4093  case FFM_PRESET_MEDIUM:
4094  render_data->ffcodecdata.ffmpeg_preset = FFM_PRESET_GOOD;
4095  break;
4096  case FFM_PRESET_SLOW:
4097  case FFM_PRESET_SLOWER:
4098  case FFM_PRESET_VERYSLOW:
4099  render_data->ffcodecdata.ffmpeg_preset = FFM_PRESET_BEST;
4100  }
4101  }
4102 
4103  LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
4104  arm->flag &= ~(ARM_FLAG_UNUSED_6);
4105  }
4106  }
4107 
4108  if (!MAIN_VERSION_ATLEAST(bmain, 281, 1)) {
4109  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
4110  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4111  if (md->type == eModifierType_DataTransfer) {
4112  /* Now data-transfer's mix factor is multiplied with weights when any,
4113  * instead of being ignored,
4114  * we need to take care of that to keep 'old' files compatible. */
4116  if (dtmd->defgrp_name[0] != '\0') {
4117  dtmd->mix_factor = 1.0f;
4118  }
4119  }
4120  }
4121  }
4122  }
4123 
4124  if (!MAIN_VERSION_ATLEAST(bmain, 281, 3)) {
4125  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4126  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4127  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4128  if (sl->spacetype == SPACE_TEXT) {
4129  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
4130  &sl->regionbase;
4131  ARegion *region = do_versions_find_region_or_null(regionbase, RGN_TYPE_UI);
4132  if (region) {
4133  region->alignment = RGN_ALIGN_RIGHT;
4134  }
4135  }
4136  /* Mark outliners as dirty for syncing and enable synced selection */
4137  if (sl->spacetype == SPACE_OUTLINER) {
4138  SpaceOutliner *space_outliner = (SpaceOutliner *)sl;
4140  space_outliner->flag |= SO_SYNC_SELECT;
4141  }
4142  }
4143  }
4144  }
4145  for (Mesh *mesh = bmain->meshes.first; mesh; mesh = mesh->id.next) {
4146  if (mesh->remesh_voxel_size == 0.0f) {
4147  mesh->remesh_voxel_size = 0.1f;
4148  }
4149  }
4150  }
4151 
4152  if (!MAIN_VERSION_ATLEAST(bmain, 281, 4)) {
4153  ID *id;
4154  FOREACH_MAIN_ID_BEGIN (bmain, id) {
4155  bNodeTree *ntree = ntreeFromID(id);
4156  if (ntree) {
4158  }
4159  }
4161  }
4162 
4163  if (!MAIN_VERSION_ATLEAST(bmain, 281, 5)) {
4164  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4165  if (br->ob_mode & OB_MODE_SCULPT && br->normal_radius_factor == 0.0f) {
4166  br->normal_radius_factor = 0.5f;
4167  }
4168  }
4169 
4170  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
4171  /* Older files do not have a master collection, which is then added through
4172  * `BKE_collection_master_add()`, so everything is fine. */
4173  if (scene->master_collection != NULL) {
4175  }
4176  }
4177  }
4178 
4179  if (!MAIN_VERSION_ATLEAST(bmain, 281, 6)) {
4180  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4181  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4182  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4183  if (sl->spacetype == SPACE_VIEW3D) {
4184  View3D *v3d = (View3D *)sl;
4186 
4187  /* files by default don't have studio lights selected unless interacted
4188  * with the shading popover. When no studio-light could be read, we will
4189  * select the default world one. */
4192  if (studio_light != NULL) {
4193  STRNCPY(v3d->shading.lookdev_light, studio_light->name);
4194  }
4195  }
4196  }
4197  }
4198  }
4199  }
4200 
4201  if (!MAIN_VERSION_ATLEAST(bmain, 281, 9)) {
4202  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4203  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4204  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4205  if (sl->spacetype == SPACE_FILE) {
4206  SpaceFile *sfile = (SpaceFile *)sl;
4207  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
4208  &sl->regionbase;
4209  ARegion *region_ui = do_versions_find_region(regionbase, RGN_TYPE_UI);
4210  ARegion *region_header = do_versions_find_region(regionbase, RGN_TYPE_HEADER);
4211  ARegion *region_toolprops = do_versions_find_region_or_null(regionbase,
4213 
4214  /* Reinsert UI region so that it spawns entire area width */
4215  BLI_remlink(regionbase, region_ui);
4216  BLI_insertlinkafter(regionbase, region_header, region_ui);
4217 
4218  region_ui->flag |= RGN_FLAG_DYNAMIC_SIZE;
4219 
4220  if (region_toolprops &&
4221  (region_toolprops->alignment == (RGN_ALIGN_BOTTOM | RGN_SPLIT_PREV))) {
4222  SpaceType *stype = BKE_spacetype_from_id(sl->spacetype);
4223 
4224  /* Remove empty region at old location. */
4225  BLI_assert(sfile->op == NULL);
4226  BKE_area_region_free(stype, region_toolprops);
4227  BLI_freelinkN(regionbase, region_toolprops);
4228  }
4229 
4230  if (sfile->params) {
4232  }
4233  }
4234  }
4235  }
4236  }
4237 
4238  /* Convert the BONE_NO_SCALE flag to inherit_scale_mode enum. */
4239  if (!DNA_struct_elem_find(fd->filesdna, "Bone", "char", "inherit_scale_mode")) {
4240  LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
4241  do_version_bones_inherit_scale(&arm->bonebase);
4242  }
4243  }
4244 
4245  /* Convert the Offset flag to the mix mode enum. */
4246  if (!DNA_struct_elem_find(fd->filesdna, "bRotateLikeConstraint", "char", "mix_mode")) {
4247  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
4249  if (ob->pose) {
4250  LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
4251  do_version_constraints_copy_rotation_mix_mode(&pchan->constraints);
4252  }
4253  }
4254  }
4255  }
4256 
4257  /* Added studio-light intensity. */
4258  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "studiolight_intensity")) {
4259  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4260  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4261  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4262  if (sl->spacetype == SPACE_VIEW3D) {
4263  View3D *v3d = (View3D *)sl;
4264  v3d->shading.studiolight_intensity = 1.0f;
4265  }
4266  }
4267  }
4268  }
4269  }
4270 
4271  /* Elastic deform brush */
4272  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4273  if (br->ob_mode & OB_MODE_SCULPT && br->elastic_deform_volume_preservation == 0.0f) {
4274  br->elastic_deform_volume_preservation = 0.5f;
4275  }
4276  }
4277  }
4278 
4279  if (!MAIN_VERSION_ATLEAST(bmain, 281, 15)) {
4280  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
4283  }
4284  }
4285 
4286  if (!DNA_struct_elem_find(
4287  fd->filesdna, "LayerCollection", "short", "local_collections_bits")) {
4288  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
4289  LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
4290  LISTBASE_FOREACH (LayerCollection *, layer_collection, &view_layer->layer_collections) {
4291  do_versions_local_collection_bits_set(layer_collection);
4292  }
4293  }
4294  }
4295  }
4296 
4297  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4298  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4299  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4300  if (sl->spacetype == SPACE_VIEW3D) {
4301  View3D *v3d = (View3D *)sl;
4302 
4303  LISTBASE_FOREACH (ScrArea *, area_other, &screen->areabase) {
4304  LISTBASE_FOREACH (SpaceLink *, sl_other, &area_other->spacedata) {
4305  if (sl != sl_other && sl_other->spacetype == SPACE_VIEW3D) {
4306  View3D *v3d_other = (View3D *)sl_other;
4307 
4308  if (v3d->shading.prop == v3d_other->shading.prop) {
4309  v3d_other->shading.prop = NULL;
4310  }
4311  }
4312  }
4313  }
4314  }
4315  else if (sl->spacetype == SPACE_FILE) {
4316  ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
4317  &sl->regionbase;
4318  ARegion *region_tools = do_versions_find_region_or_null(regionbase, RGN_TYPE_TOOLS);
4319  ARegion *region_header = do_versions_find_region(regionbase, RGN_TYPE_HEADER);
4320 
4321  if (region_tools) {
4322  ARegion *region_next = region_tools->next;
4323 
4324  /* We temporarily had two tools regions, get rid of the second one. */
4325  if (region_next && region_next->regiontype == RGN_TYPE_TOOLS) {
4326  do_versions_remove_region(regionbase, region_next);
4327  }
4328 
4329  BLI_remlink(regionbase, region_tools);
4330  BLI_insertlinkafter(regionbase, region_header, region_tools);
4331  }
4332  else {
4333  region_tools = do_versions_add_region(RGN_TYPE_TOOLS,
4334  "versioning file tools region");
4335  BLI_insertlinkafter(regionbase, region_header, region_tools);
4336  region_tools->alignment = RGN_ALIGN_LEFT;
4337  }
4338  }
4339  }
4340  }
4341  }
4342 
4343  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4344  if (br->ob_mode & OB_MODE_SCULPT && br->area_radius_factor == 0.0f) {
4345  br->area_radius_factor = 0.5f;
4346  }
4347  }
4348  }
4349 
4350  if (!MAIN_VERSION_ATLEAST(bmain, 282, 2)) {
4352 
4353  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4354  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4355  area->flag &= ~AREA_FLAG_UNUSED_6;
4356  }
4357  }
4358 
4359  /* Add custom curve profile to toolsettings for bevel tool */
4360  if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "CurveProfile", "custom_profile")) {
4361  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4363  if ((ts) && (ts->custom_bevel_profile_preset == NULL)) {
4365  }
4366  }
4367  }
4368 
4369  /* Add custom curve profile to bevel modifier */
4370  if (!DNA_struct_elem_find(fd->filesdna, "BevelModifier", "CurveProfile", "custom_profile")) {
4371  for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
4372  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
4373  if (md->type == eModifierType_Bevel) {
4374  BevelModifierData *bmd = (BevelModifierData *)md;
4375  if (!bmd->custom_profile) {
4377  }
4378  }
4379  }
4380  }
4381  }
4382 
4383  /* Dash Ratio and Dash Samples */
4384  if (!DNA_struct_elem_find(fd->filesdna, "Brush", "float", "dash_ratio")) {
4385  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4386  br->dash_ratio = 1.0f;
4387  br->dash_samples = 20;
4388  }
4389  }
4390 
4391  /* Pose brush smooth iterations */
4392  if (!DNA_struct_elem_find(fd->filesdna, "Brush", "float", "pose_smooth_iterations")) {
4393  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4394  br->pose_smooth_iterations = 4;
4395  }
4396  }
4397 
4398  /* Cloth pressure */
4399  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4400  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4401  if (md->type == eModifierType_Cloth) {
4402  ClothModifierData *clmd = (ClothModifierData *)md;
4403 
4404  clmd->sim_parms->pressure_factor = 1;
4405  }
4406  }
4407  }
4408  }
4409 
4410  if (!MAIN_VERSION_ATLEAST(bmain, 282, 3)) {
4411  /* Remove Unified pressure/size and pressure/alpha */
4412  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4416  }
4417 
4418  /* Set the default render pass in the viewport to Combined. */
4419  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "int", "render_pass")) {
4420  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4422  }
4423 
4424  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4425  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4426  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4427  if (sl->spacetype == SPACE_VIEW3D) {
4428  View3D *v3d = (View3D *)sl;
4430  }
4431  }
4432  }
4433  }
4434  }
4435 
4436  /* Make markers region visible by default. */
4437  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4438  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4439  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4440  switch (sl->spacetype) {
4441  case SPACE_SEQ: {
4442  SpaceSeq *sseq = (SpaceSeq *)sl;
4443  sseq->flag |= SEQ_SHOW_MARKERS;
4444  break;
4445  }
4446  case SPACE_ACTION: {
4447  SpaceAction *saction = (SpaceAction *)sl;
4448  saction->flag |= SACTION_SHOW_MARKERS;
4449  break;
4450  }
4451  case SPACE_GRAPH: {
4452  SpaceGraph *sipo = (SpaceGraph *)sl;
4453  sipo->flag |= SIPO_SHOW_MARKERS;
4454  break;
4455  }
4456  case SPACE_NLA: {
4457  SpaceNla *snla = (SpaceNla *)sl;
4458  snla->flag |= SNLA_SHOW_MARKERS;
4459  break;
4460  }
4461  }
4462  }
4463  }
4464  }
4465  }
4466 
4467  if (!MAIN_VERSION_ATLEAST(bmain, 283, 3)) {
4468  /* Color Management Look. */
4469  for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
4470  ColorManagedViewSettings *view_settings;
4471  view_settings = &scene->view_settings;
4472  if (BLI_str_startswith(view_settings->look, "Filmic - ")) {
4473  char *src = view_settings->look + strlen("Filmic - ");
4474  memmove(view_settings->look, src, strlen(src) + 1);
4475  }
4476  else if (BLI_str_startswith(view_settings->look, "Standard - ")) {
4477  char *src = view_settings->look + strlen("Standard - ");
4478  memmove(view_settings->look, src, strlen(src) + 1);
4479  }
4480  }
4481 
4482  /* Sequencer Tool region */
4484 
4485  /* Cloth internal springs */
4486  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4487  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4488  if (md->type == eModifierType_Cloth) {
4489  ClothModifierData *clmd = (ClothModifierData *)md;
4490 
4491  clmd->sim_parms->internal_tension = 15.0f;
4492  clmd->sim_parms->max_internal_tension = 15.0f;
4493  clmd->sim_parms->internal_compression = 15.0f;
4494  clmd->sim_parms->max_internal_compression = 15.0f;
4496  }
4497  }
4498  }
4499 
4500  /* Add primary tile to images. */
4501  if (!DNA_struct_elem_find(fd->filesdna, "Image", "ListBase", "tiles")) {
4502  for (Image *ima = bmain->images.first; ima; ima = ima->id.next) {
4503  ImageTile *tile = MEM_callocN(sizeof(ImageTile), "Image Tile");
4504  tile->tile_number = 1001;
4505  BLI_addtail(&ima->tiles, tile);
4506  }
4507  }
4508 
4509  /* UDIM Image Editor change. */
4510  if (!DNA_struct_elem_find(fd->filesdna, "SpaceImage", "int", "tile_grid_shape[2]")) {
4511  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4512  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4513  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4514  if (sl->spacetype == SPACE_IMAGE) {
4515  SpaceImage *sima = (SpaceImage *)sl;
4516  sima->tile_grid_shape[0] = 1;
4517  sima->tile_grid_shape[1] = 1;
4518  }
4519  }
4520  }
4521  }
4522  }
4523 
4524  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4525  br->add_col[3] = 0.9f;
4526  br->sub_col[3] = 0.9f;
4527  }
4528 
4529  /* Pose brush IK segments. */
4530  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4531  if (br->pose_ik_segments == 0) {
4532  br->pose_ik_segments = 1;
4533  }
4534  }
4535 
4536  /* Pose brush keep anchor point. */
4537  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4538  if (br->sculpt_tool == SCULPT_TOOL_POSE) {
4539  br->flag2 |= BRUSH_POSE_IK_ANCHORED;
4540  }
4541  }
4542 
4543  /* Tip Roundness. */
4544  if (!DNA_struct_elem_find(fd->filesdna, "Brush", "float", "tip_roundness")) {
4545  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4546  if (br->ob_mode & OB_MODE_SCULPT && br->sculpt_tool == SCULPT_TOOL_CLAY_STRIPS) {
4547  br->tip_roundness = 0.18f;
4548  }
4549  }
4550  }
4551 
4552  /* EEVEE: Cascade shadow bias fix */
4553  LISTBASE_FOREACH (Light *, light, &bmain->lights) {
4554  if (light->type == LA_SUN) {
4555  /* Should be 0.0004 but for practical reason we make it bigger.
4556  * Correct factor is scene dependent. */
4557  light->bias *= 0.002f;
4558  }
4559  }
4560  }
4561 
4562  if (!MAIN_VERSION_ATLEAST(bmain, 283, 5)) {
4563  /* Alembic Transform Cache changed from world to local space. */
4564  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
4565  LISTBASE_FOREACH (bConstraint *, con, &ob->constraints) {
4566  if (con->type == CONSTRAINT_TYPE_TRANSFORM_CACHE) {
4567  con->ownspace = CONSTRAINT_SPACE_LOCAL;
4568  }
4569  }
4570  }
4571 
4572  /* Add 2D transform to UV Warp modifier. */
4573  if (!DNA_struct_elem_find(fd->filesdna, "UVWarpModifierData", "float", "scale[2]")) {
4574  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4575  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4576  if (md->type == eModifierType_UVWarp) {
4578  copy_v2_fl(umd->scale, 1.0f);
4579  }
4580  }
4581  }
4582  }
4583 
4584  /* Add Lookdev blur property. */
4585  if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "studiolight_blur")) {
4586  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4587  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4588  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4589  if (sl->spacetype == SPACE_VIEW3D) {
4590  View3D *v3d = (View3D *)sl;
4591  v3d->shading.studiolight_blur = 0.5f;
4592  }
4593  }
4594  }
4595  }
4596  }
4597  }
4598 
4599  if (!MAIN_VERSION_ATLEAST(bmain, 283, 7)) {
4600  /* Init default Grease Pencil Vertex paint mix factor for Viewport. */
4601  if (!DNA_struct_elem_find(
4602  fd->filesdna, "View3DOverlay", "float", "gpencil_vertex_paint_opacity")) {
4603  LISTBASE_FOREACH (bScreen *, screen, &bmain->screens) {
4604  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4605  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4606  if (sl->spacetype == SPACE_VIEW3D) {
4607  View3D *v3d = (View3D *)sl;
4609  }
4610  }
4611  }
4612  }
4613  }
4614 
4615  /* Update Grease Pencil after drawing engine and code refactor.
4616  * It uses the seed variable of Array modifier to avoid double patching for
4617  * files created with a development version. */
4618  if (!DNA_struct_elem_find(fd->filesdna, "ArrayGpencilModifierData", "int", "seed")) {
4619  /* Init new Grease Pencil Paint tools. */
4620  {
4621  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
4622  if (brush->gpencil_settings != NULL) {
4623  brush->gpencil_vertex_tool = brush->gpencil_settings->brush_type;
4624  brush->gpencil_sculpt_tool = brush->gpencil_settings->brush_type;
4625  brush->gpencil_weight_tool = brush->gpencil_settings->brush_type;
4626  }
4627  }
4628  }
4629 
4630  LISTBASE_FOREACH (Material *, mat, &bmain->materials) {
4631  MaterialGPencilStyle *gp_style = mat->gp_style;
4632  if (gp_style == NULL) {
4633  continue;
4634  }
4635  /* Fix Grease Pencil Material colors to Linear. */
4636  srgb_to_linearrgb_v4(gp_style->stroke_rgba, gp_style->stroke_rgba);
4637  srgb_to_linearrgb_v4(gp_style->fill_rgba, gp_style->fill_rgba);
4638 
4639  /* Move old gradient variables to texture. */
4640  if (gp_style->fill_style == GP_MATERIAL_FILL_STYLE_GRADIENT) {
4641  gp_style->texture_angle = gp_style->gradient_angle;
4642  copy_v2_v2(gp_style->texture_scale, gp_style->gradient_scale);
4643  copy_v2_v2(gp_style->texture_offset, gp_style->gradient_shift);
4644  }
4645  /* Set Checker material as Solid. This fill mode has been removed and replaced
4646  * by textures. */
4647  if (gp_style->fill_style == GP_MATERIAL_FILL_STYLE_CHECKER) {
4649  }
4650  /* Update Alpha channel for texture opacity. */
4651  if (gp_style->fill_style == GP_MATERIAL_FILL_STYLE_TEXTURE) {
4652  gp_style->fill_rgba[3] *= gp_style->texture_opacity;
4653  }
4654  /* Stroke stencil mask to mix = 1. */
4655  if (gp_style->flag & GP_MATERIAL_STROKE_PATTERN) {
4656  gp_style->mix_stroke_factor = 1.0f;
4657  gp_style->flag &= ~GP_MATERIAL_STROKE_PATTERN;
4658  }
4659  /* Mix disabled, set mix factor to 0. */
4660  else if ((gp_style->flag & GP_MATERIAL_STROKE_TEX_MIX) == 0) {
4661  gp_style->mix_stroke_factor = 0.0f;
4662  }
4663  }
4664 
4665  /* Fix Grease Pencil VFX and modifiers. */
4666  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
4667  if (ob->type != OB_GPENCIL) {
4668  continue;
4669  }
4670 
4671  /* VFX. */
4672  LISTBASE_FOREACH (ShaderFxData *, fx, &ob->shader_fx) {
4673  switch (fx->type) {
4674  case eShaderFxType_Colorize: {
4677  vfx->factor = 1.0f;
4678  }
4681  break;
4682  }
4683  case eShaderFxType_Pixel: {
4684  PixelShaderFxData *vfx = (PixelShaderFxData *)fx;
4685  srgb_to_linearrgb_v4(vfx->rgba, vfx->rgba);
4686  break;
4687  }
4688  case eShaderFxType_Rim: {
4689  RimShaderFxData *vfx = (RimShaderFxData *)fx;
4692  break;
4693  }
4694  case eShaderFxType_Shadow: {
4697  break;
4698  }
4699  case eShaderFxType_Glow: {
4700  GlowShaderFxData *vfx = (GlowShaderFxData *)fx;
4702  vfx->glow_color[3] = 1.0f;
4704  vfx->blur[1] = vfx->blur[0];
4705  break;
4706  }
4707  default:
4708  break;
4709  }
4710  }
4711 
4712  /* Modifiers. */
4713  LISTBASE_FOREACH (GpencilModifierData *, md, &ob->greasepencil_modifiers) {
4714  switch ((GpencilModifierType)md->type) {
4717  mmd->seed = 1;
4718  if ((mmd->offset[0] != 0.0f) || (mmd->offset[1] != 0.0f) ||
4719  (mmd->offset[2] != 0.0f)) {
4720  mmd->flag |= GP_ARRAY_USE_OFFSET;
4721  }
4722  if ((mmd->shift[0] != 0.0f) || (mmd->shift[1] != 0.0f) || (mmd->shift[2] != 0.0f)) {
4723  mmd->flag |= GP_ARRAY_USE_OFFSET;
4724  }
4725  if (mmd->object != NULL) {
4726  mmd->flag |= GP_ARRAY_USE_OB_OFFSET;
4727  }
4728  break;
4729  }
4732  float factor = mmd->factor / 25.0f;
4733  mmd->factor = (mmd->flag & GP_NOISE_MOD_LOCATION) ? factor : 0.0f;
4734  mmd->factor_thickness = (mmd->flag & GP_NOISE_MOD_STRENGTH) ? factor : 0.0f;
4735  mmd->factor_strength = (mmd->flag & GP_NOISE_MOD_THICKNESS) ? factor : 0.0f;
4736  mmd->factor_uvs = (mmd->flag & GP_NOISE_MOD_UV) ? factor : 0.0f;
4737 
4738  mmd->noise_scale = (mmd->flag & GP_NOISE_FULL_STROKE) ? 0.0f : 1.0f;
4739 
4740  if (mmd->curve_intensity == NULL) {
4741  mmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
4742  if (mmd->curve_intensity) {
4744  }
4745  }
4746  break;
4747  }
4750  srgb_to_linearrgb_v3_v3(mmd->rgb, mmd->rgb);
4751  if (mmd->curve_intensity == NULL) {
4752  mmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
4753  if (mmd->curve_intensity) {
4755  }
4756  }
4757  break;
4758  }
4761  if (mmd->curve_intensity == NULL) {
4762  mmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
4763  if (mmd->curve_intensity) {
4765  }
4766  }
4767  break;
4768  }
4771  if (mmd->curve_intensity == NULL) {
4772  mmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
4773  if (mmd->curve_intensity) {
4775  }
4776  }
4777  break;
4778  }
4781  if (mmd->curve_intensity == NULL) {
4782  mmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
4783  if (mmd->curve_intensity) {
4785  }
4786  }
4787  break;
4788  }
4790  if (!DNA_struct_elem_find(
4791  fd->filesdna, "ThickGpencilModifierData", "float", "thickness_fac")) {
4793  mmd->thickness_fac = mmd->thickness;
4794  }
4795  break;
4796  }
4799  mmd->fading_opacity = 1.0 - mmd->fading_opacity;
4800  break;
4801  }
4803  const short simple = (1 << 0);
4805  if (mmd->flag & simple) {
4806  mmd->flag &= ~simple;
4807  mmd->type = GP_SUBDIV_SIMPLE;
4808  }
4809  break;
4810  }
4811  default:
4812  break;
4813  }
4814  }
4815  }
4816 
4817  /* Fix Layers Colors and Vertex Colors to Linear.
4818  * Also set lights to on for layers. */
4819  LISTBASE_FOREACH (bGPdata *, gpd, &bmain->gpencils) {
4820  if (gpd->flag & GP_DATA_ANNOTATIONS) {
4821  continue;
4822  }
4823  /* Onion colors. */
4824  srgb_to_linearrgb_v3_v3(gpd->gcolor_prev, gpd->gcolor_prev);
4825  srgb_to_linearrgb_v3_v3(gpd->gcolor_next, gpd->gcolor_next);
4826  /* Z-depth Offset. */
4827  gpd->zdepth_offset = 0.150f;
4828 
4829  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
4830  gpl->flag |= GP_LAYER_USE_LIGHTS;
4831  srgb_to_linearrgb_v4(gpl->tintcolor, gpl->tintcolor);
4832  gpl->vertex_paint_opacity = 1.0f;
4833 
4834  LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
4835  LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
4836  /* Set initial opacity for fill color. */
4837  gps->fill_opacity_fac = 1.0f;
4838 
4839  /* Calc geometry data because in old versions this data was not saved. */
4841 
4842  srgb_to_linearrgb_v4(gps->vert_color_fill, gps->vert_color_fill);
4843  int i;
4844  bGPDspoint *pt;
4845  for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
4847  }
4848  }
4849  }
4850  }
4851  }
4852  }
4853  }
4854 
4855  if (!MAIN_VERSION_ATLEAST(bmain, 283, 8)) {
4856  if (!DNA_struct_elem_find(
4857  fd->filesdna, "View3DOverlay", "float", "sculpt_mode_face_sets_opacity")) {
4858  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4859  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
4860  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
4861  if (sl->spacetype == SPACE_VIEW3D) {
4862  View3D *v3d = (View3D *)sl;
4864  }
4865  }
4866  }
4867  }
4868  }
4869 
4870  /* Alembic Transform Cache changed from local to world space. */
4871  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
4872  LISTBASE_FOREACH (bConstraint *, con, &ob->constraints) {
4873  if (con->type == CONSTRAINT_TYPE_TRANSFORM_CACHE) {
4874  con->ownspace = CONSTRAINT_SPACE_WORLD;
4875  }
4876  }
4877  }
4878 
4879  /* Boundary Edges Auto-masking. */
4880  if (!DNA_struct_elem_find(
4881  fd->filesdna, "Brush", "int", "automasking_boundary_edges_propagation_steps")) {
4882  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
4883  br->automasking_boundary_edges_propagation_steps = 1;
4884  }
4885  }
4886 
4887  /* Corrective smooth modifier scale. */
4888  if (!DNA_struct_elem_find(fd->filesdna, "CorrectiveSmoothModifierData", "float", "scale")) {
4889  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4890  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4891  if (md->type == eModifierType_CorrectiveSmooth) {
4893  csmd->scale = 1.0f;
4894  }
4895  }
4896  }
4897  }
4898 
4899  /* Default Face Set Color. */
4900  for (Mesh *me = bmain->meshes.first; me != NULL; me = me->id.next) {
4901  if (me->totpoly > 0) {
4902  const int *face_sets = CustomData_get_layer(&me->pdata, CD_SCULPT_FACE_SETS);
4903  if (face_sets) {
4904  me->face_sets_color_default = abs(face_sets[0]);
4905  }
4906  }
4907  }
4908  }
4909 
4910  if (!MAIN_VERSION_ATLEAST(bmain, 283, 11)) {
4911  if (!DNA_struct_elem_find(fd->filesdna, "OceanModifierData", "float", "fetch_jonswap")) {
4912  for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
4913  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
4914  if (md->type == eModifierType_Ocean) {
4915  OceanModifierData *omd = (OceanModifierData *)md;
4916  omd->fetch_jonswap = 120.0f;
4917  }
4918  }
4919  }
4920  }
4921 
4922  if (!DNA_struct_find(fd->filesdna, "XrSessionSettings")) {
4923  for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
4924  const View3D *v3d_default = DNA_struct_default_get(View3D);
4925 
4926  wm->xr.session_settings.shading = v3d_default->shading;
4927  wm->xr.session_settings.draw_flags = (V3D_OFSDRAW_SHOW_GRIDFLOOR |
4929  wm->xr.session_settings.clip_start = v3d_default->clip_start;
4930  wm->xr.session_settings.clip_end = v3d_default->clip_end;
4931 
4932  wm->xr.session_settings.flag = XR_SESSION_USE_POSITION_TRACKING;
4933  }
4934  }
4935 
4936  /* Surface deform modifier strength. */
4937  if (!DNA_struct_elem_find(fd->filesdna, "SurfaceDeformModifierData", "float", "strength")) {
4938  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4939  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4940  if (md->type == eModifierType_SurfaceDeform) {
4942  sdmd->strength = 1.0f;
4943  }
4944  }
4945  }
4946  }
4947  }
4948 
4949  if (!MAIN_VERSION_ATLEAST(bmain, 283, 12)) {
4950  /* Activate f-curve drawing in the sequencer. */
4951  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
4952  for (ScrArea *area = screen->areabase.first; area; area = area->next) {
4953  for (SpaceLink *sl = area->spacedata.first; sl; sl = sl->next) {
4954  if (sl->spacetype == SPACE_SEQ) {
4955  SpaceSeq *sseq = (SpaceSeq *)sl;
4957  }
4958  }
4959  }
4960  }
4961 
4962  /* Remesh Modifier Voxel Mode. */
4963  if (!DNA_struct_elem_find(fd->filesdna, "RemeshModifierData", "float", "voxel_size")) {
4964  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4965  LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
4966  if (md->type == eModifierType_Remesh) {
4968  rmd->voxel_size = 0.1f;
4969  rmd->adaptivity = 0.0f;
4970  }
4971  }
4972  }
4973  }
4974  }
4975 
4976  if (!MAIN_VERSION_ATLEAST(bmain, 283, 14)) {
4977  /* Solidify modifier merge tolerance. */
4978  if (!DNA_struct_elem_find(fd->filesdna, "SolidifyModifierData", "float", "merge_tolerance")) {
4979  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4980  for (ModifierData *md = ob->modifiers.first; md; md = md->next) {
4981  if (md->type == eModifierType_Solidify) {
4983  /* set to 0.0003 since that is what was used before, default now is 0.0001 */
4984  smd->merge_tolerance = 0.0003f;
4985  }
4986  }
4987  }
4988  }
4989 
4990  /* Enumerator was incorrect for a time in 2.83 development.
4991  * Note that this only corrects values known to be invalid. */
4992  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
4993  RigidBodyCon *rbc = ob->rigidbody_constraint;
4994  if (rbc != NULL) {
4995  enum {
4996  INVALID_RBC_TYPE_SLIDER = 2,
4997  INVALID_RBC_TYPE_6DOF_SPRING = 4,
4998  INVALID_RBC_TYPE_MOTOR = 7,
4999  };
5000  switch (rbc->type) {
5001  case INVALID_RBC_TYPE_SLIDER:
5002  rbc->type = RBC_TYPE_SLIDER;
5003  break;
5004  case INVALID_RBC_TYPE_6DOF_SPRING:
5005  rbc->type = RBC_TYPE_6DOF_SPRING;
5006  break;
5007  case INVALID_RBC_TYPE_MOTOR:
5008  rbc->type = RBC_TYPE_MOTOR;
5009  break;
5010  }
5011  }
5012  }
5013  }
5014 
5015  /* Match scale of fluid modifier gravity with scene gravity. */
5016  if (!MAIN_VERSION_ATLEAST(bmain, 283, 15)) {
5017  for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
5018  for (ModifierData *md = ob->modifiers.first; md; md = md->next) {
5019  if (md->type == eModifierType_Fluid) {
5020  FluidModifierData *fmd = (FluidModifierData *)md;
5021  if (fmd->domain != NULL) {
5022  mul_v3_fl(fmd->domain->gravity, 9.81f);
5023  }
5024  }
5025  }
5026  }
5027  }
5028 
5029  if (!MAIN_VERSION_ATLEAST(bmain, 283, 16)) {
5030  /* Init SMAA threshold for grease pencil render. */
5031  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
5033  }
5034  }
5035 
5036  if (!MAIN_VERSION_ATLEAST(bmain, 283, 17)) {
5037  /* Reset the cloth mass to 1.0 in brushes with an invalid value. */
5038  for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
5039  if (br->sculpt_tool == SCULPT_TOOL_CLOTH) {
5040  if (br->cloth_mass == 0.0f) {
5041  br->cloth_mass = 1.0f;
5042  }
5043  }
5044  }
5045 
5046  /* Set Brush default color for grease pencil. */
5047  LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
5048  if (brush->gpencil_settings) {
5049  brush->rgb[0] = 0.498f;
5050  brush->rgb[1] = 1.0f;
5051  brush->rgb[2] = 0.498f;
5052  }
5053  }
5054  }
5055 
5056  /* Old forgotten versioning code. */
5057  if (!MAIN_VERSION_ATLEAST(bmain, 300, 39)) {
5058  /* Set the cloth wind factor to 1 for old forces. */
5059  if (!DNA_struct_elem_find(fd->filesdna, "PartDeflect", "float", "f_wind_factor")) {
5060  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
5061  if (ob->pd) {
5062  ob->pd->f_wind_factor = 1.0f;
5063  }
5064  }
5065  LISTBASE_FOREACH (ParticleSettings *, part, &bmain->particles) {
5066  if (part->pd) {
5067  part->pd->f_wind_factor = 1.0f;
5068  }
5069  if (part->pd2) {
5070  part->pd2->f_wind_factor = 1.0f;
5071  }
5072  }
5073  }
5074 
5075  for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
5076  /* Don't rotate light with the viewer by default, make it fixed. Shading settings can't be
5077  * edited and this flag should always be set. */
5078  wm->xr.session_settings.shading.flag |= V3D_SHADING_WORLD_ORIENTATION;
5079  }
5080  }
5081 
5092  {
5093  /* Keep this block, even when empty. */
5094  }
5095 }
typedef float(TangentPoint)[2]
void BKE_fcurves_id_cb(struct ID *id, ID_FCurve_Edit_Callback func, void *user_data)
Definition: anim_data.c:1157
void BKE_animdata_main_cb(struct Main *bmain, ID_AnimData_Edit_Callback func, void *user_data)
Definition: anim_data.c:1177
struct Collection * BKE_collection_add(struct Main *bmain, struct Collection *parent, const char *name)
Definition: collection.c:425
bool BKE_collection_object_remove(struct Main *bmain, struct Collection *collection, struct Object *object, bool free_us)
Definition: collection.c:1170
bool BKE_collection_object_add_notest(struct Main *bmain, struct Collection *collection, struct Object *ob)
Definition: collection.c:1099
struct Collection * BKE_collection_master_add(void)
Definition: collection.c:852
void BKE_curvemapping_init(struct CurveMapping *cumap)
Definition: colortools.c:1235
void BKE_curvemap_reset(struct CurveMap *cuma, const struct rctf *clipr, int preset, int slope)
void BKE_color_managed_view_settings_init_render(struct ColorManagedViewSettings *settings, const struct ColorManagedDisplaySettings *display_settings, const char *view_transform)
void BKE_color_managed_display_settings_init(struct ColorManagedDisplaySettings *settings)
Definition: colortools.c:1789
@ CURVEMAP_SLOPE_POSITIVE
struct CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition: colortools.c:72
void BKE_constraint_free_data(struct bConstraint *con)
Definition: constraint.c:5571
struct CurveProfile * BKE_curveprofile_add(eCurveProfilePresets preset)
Definition: curveprofile.cc:31
CustomData interface, see also DNA_customdata_types.h.
void CustomData_free_layers(struct CustomData *data, int type, int totelem)
Definition: customdata.cc:2904
void * CustomData_get_layer(const struct CustomData *data, int type)
void CustomData_update_typemap(struct CustomData *data)
Definition: customdata.cc:2193
struct FCurve * BKE_fcurve_copy(const struct FCurve *fcu)
#define DRIVER_TARGETS_LOOPER_BEGIN(dvar)
#define DRIVER_TARGETS_LOOPER_END
void BKE_freestyle_config_init(struct FreestyleConfig *config)
Definition: freestyle.c:27
void BKE_freestyle_config_free(struct FreestyleConfig *config, bool do_id_user)
Definition: freestyle.c:40
#define G_MAIN
Definition: BKE_global.h:267
void BKE_gpencil_stroke_geometry_update(struct bGPdata *gpd, struct bGPDstroke *gps)
void IDP_FreeProperty(struct IDProperty *prop)
Definition: idprop.c:1093
struct IDProperty * IDP_GetPropertyFromGroup(const struct IDProperty *prop, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BKE_keyblock_curve_element_count(const struct ListBase *nurb)
void BKE_layer_collection_doversion_2_80(const struct Scene *scene, struct ViewLayer *view_layer)
@ VIEWLAYER_ADD_NEW
Definition: BKE_layer.h:37
struct ViewLayer * BKE_view_layer_default_view(const struct Scene *scene)
struct Base * BKE_view_layer_base_find(struct ViewLayer *view_layer, struct Object *ob)
Definition: layer.c:379
struct LayerCollection * BKE_layer_collection_first_from_scene_collection(const struct ViewLayer *view_layer, const struct Collection *collection)
void BKE_layer_collection_sync(const struct Scene *scene, struct ViewLayer *view_layer)
struct ViewLayer * BKE_view_layer_add(struct Scene *scene, const char *name, struct ViewLayer *view_layer_source, int type)
Definition: layer.c:185
void id_us_min(struct ID *id)
Definition: lib_id.c:313
void id_fake_user_set(struct ID *id)
Definition: lib_id.c:343
void BKE_main_id_repair_duplicate_names_listbase(struct Main *bmain, struct ListBase *lb)
Definition: lib_id.c:967
#define FOREACH_MAIN_ID_END
Definition: BKE_main.h:367
#define MAIN_VERSION_ATLEAST(main, ver, subver)
Definition: BKE_main.h:427
#define FOREACH_MAIN_ID_BEGIN(_bmain, _id)
Definition: BKE_main.h:361
struct ListBase * which_libbase(struct Main *bmain, short type)
Definition: main.c:567
void BKE_mesh_tessface_clear(struct Mesh *mesh)
Definition: mesh.cc:1654
void BKE_mesh_calc_edges_loose(struct Mesh *mesh)
void BKE_mesh_update_customdata_pointers(struct Mesh *me, bool do_ensure_tess_cd)
Definition: mesh.cc:874
void BKE_mesh_do_versions_convert_mfaces_to_mpolys(struct Mesh *mesh)
struct bNodeTree * ntreeFromID(struct ID *id)
Definition: node.cc:3231
#define CMP_NODE_TIME
Definition: BKE_node.h:1209
#define SH_NODE_BSDF_PRINCIPLED
Definition: BKE_node.h:1164
#define SH_NODE_ADD_SHADER
Definition: BKE_node.h:1127
#define CMP_NODE_HUECORRECT
Definition: BKE_node.h:1256
void nodeRemLink(struct bNodeTree *ntree, struct bNodeLink *link)
Definition: node.cc:2338
#define SH_NODE_BSDF_TRANSPARENT
Definition: BKE_node.h:1113
#define SH_NODE_SHADERTORGB
Definition: BKE_node.h:1084
#define SH_NODE_OUTPUT_MATERIAL
Definition: BKE_node.h:1101
#define FOREACH_NODETREE_END
Definition: BKE_node.h:1058
struct bNodeLink * nodeAddLink(struct bNodeTree *ntree, struct bNode *fromnode, struct bNodeSocket *fromsock, struct bNode *tonode, struct bNodeSocket *tosock)
Definition: node.cc:2296
#define CMP_NODE_CURVE_RGB
Definition: BKE_node.h:1204
struct bNodeSocket * nodeFindSocket(const struct bNode *node, eNodeSocketInOut in_out, const char *identifier)
#define SH_NODE_CURVE_RGB
Definition: BKE_node.h:1090
#define FOREACH_NODETREE_BEGIN(bmain, _nodetree, _id)
Definition: BKE_node.h:1048
#define TEX_NODE_CURVE_TIME
Definition: BKE_node.h:1359
struct bNode * nodeAddStaticNode(const struct bContext *C, struct bNodeTree *ntree, int type)
Definition: node.cc:2151
#define CMP_NODE_CURVE_VEC
Definition: BKE_node.h:1203
#define TEX_NODE_CURVE_RGB
Definition: BKE_node.h:1356
void BKE_paint_brush_set(struct Paint *paint, struct Brush *br)
Definition: paint.c:617
bool BKE_paint_ensure_from_paintmode(struct Scene *sce, ePaintMode mode)
Definition: paint.c:294
@ PAINT_MODE_GPENCIL
Definition: BKE_paint.h:77
@ PAINT_MODE_VERTEX_GPENCIL
Definition: BKE_paint.h:79
@ PAINT_MODE_WEIGHT_GPENCIL
Definition: BKE_paint.h:81
@ PAINT_MODE_SCULPT_GPENCIL
Definition: BKE_paint.h:80
void BKE_paint_toolslots_init_from_main(struct Main *bmain)
struct PointCache * BKE_ptcache_add(struct ListBase *ptcaches)
Definition: pointcache.c:3014
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition: report.c:83
API for Blender-side Rigid Body stuff.
void BKE_rigidbody_constraints_collection_validate(struct Scene *scene, struct RigidBodyWorld *rbw)
Definition: rigidbody.c:2368
void BKE_rigidbody_objects_collection_validate(struct Main *bmain, struct Scene *scene, struct RigidBodyWorld *rbw)
Definition: rigidbody.c:2365
struct ARegion * BKE_spacedata_find_region_type(const struct SpaceLink *slink, const struct ScrArea *area, int region_type) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BKE_screen_area_free(struct ScrArea *area)
Definition: screen.c:670
struct ARegion * BKE_area_find_region_type(const struct ScrArea *area, int type)
void BKE_screen_remove_double_scredges(struct bScreen *screen)
Definition: screen.c:777
void BKE_screen_view3d_shading_init(struct View3DShading *shading)
Definition: screen.c:1007
void BKE_screen_remove_unused_scrverts(struct bScreen *screen)
Definition: screen.c:838
void BKE_screen_remove_unused_scredges(struct bScreen *screen)
Definition: screen.c:793
void BKE_area_region_free(struct SpaceType *st, struct ARegion *region)
Definition: screen.c:626
struct SpaceType * BKE_spacetype_from_id(int spaceid)
Definition: screen.c:353
@ STUDIOLIGHT_TYPE_MATCAP
@ STUDIOLIGHT_TYPE_WORLD
struct StudioLight * BKE_studiolight_find(const char *name, int flag)
Definition: studiolight.c:1462
struct StudioLight * BKE_studiolight_find_default(int flag)
Definition: studiolight.c:1437
int BKE_unit_base_of_type_get(int system, int type)
Definition: unit.c:1269
@ B_UNIT_LENGTH
Definition: BKE_unit.h:101
@ B_UNIT_MASS
Definition: BKE_unit.h:104
@ B_UNIT_TIME
Definition: BKE_unit.h:106
struct WorkSpaceLayout * BKE_workspace_layout_add(struct Main *bmain, struct WorkSpace *workspace, struct bScreen *screen, const char *name) ATTR_NONNULL()
Definition: workspace.c:364
void BKE_workspace_tool_remove(struct WorkSpace *workspace, struct bToolRef *tref) ATTR_NONNULL(1
struct WorkSpace * BKE_workspace_add(struct Main *bmain, const char *name)
Definition: workspace.c:314
struct bScreen * BKE_workspace_active_screen_get(const struct WorkSpaceInstanceHook *hook) GETTER_ATTRS
void BKE_workspace_active_layout_set(struct WorkSpaceInstanceHook *hook, int winid, struct WorkSpace *workspace, struct WorkSpaceLayout *layout) SETTER_ATTRS
Activate a layout.
Definition: workspace.c:557
struct WorkSpaceInstanceHook * BKE_workspace_instance_hook_create(const struct Main *bmain, int winid)
void BKE_workspace_active_set(struct WorkSpaceInstanceHook *hook, struct WorkSpace *workspace) SETTER_ATTRS
Definition: workspace.c:520
struct WorkSpaceLayout * BKE_workspace_layout_find(const struct WorkSpace *workspace, const struct bScreen *screen) ATTR_NONNULL() ATTR_WARN_UNUSED_RESULT
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define BLI_assert_msg(a, msg)
Definition: BLI_assert.h:53
struct GSet GSet
Definition: BLI_ghash.h:340
bool BLI_gset_haskey(const GSet *gs, const void *key) ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:1007
unsigned int BLI_ghashutil_ptrhash(const void *key)
GHash * BLI_ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:689
GSet * BLI_gset_new(GSetHashFP hashfp, GSetCmpFP cmpfp, const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:947
void BLI_gset_insert(GSet *gs, void *key)
Definition: BLI_ghash.c:962
void * BLI_ghash_lookup(const GHash *gh, const void *key) ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:734
bool BLI_ghashutil_ptrcmp(const void *a, const void *b)
void BLI_ghash_insert(GHash *gh, void *key, void *val)
Definition: BLI_ghash.c:710
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
Definition: BLI_ghash.c:863
void BLI_gset_free(GSet *gs, GSetKeyFreeFP keyfreefp)
Definition: BLI_ghash.c:1037
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
Definition: BLI_listbase.h:269
void BLI_addhead(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:60
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void BLI_freelinkN(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:239
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
Definition: BLI_listbase.h:354
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void BLI_insertlinkafter(struct ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
Definition: listbase.c:301
int BLI_listbase_count_at_most(const struct ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void void BLI_freelistN(struct ListBase *listbase) ATTR_NONNULL(1)
Definition: listbase.c:466
void void BLI_INLINE bool BLI_listbase_is_single(const struct ListBase *lb)
Definition: BLI_listbase.h:265
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
void BLI_insertlinkbefore(struct ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
Definition: listbase.c:340
void * BLI_findlink(const struct ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_findstring(const struct ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
MINLINE int min_ii(int a, int b)
#define M_PI_4
Definition: BLI_math_base.h:26
MINLINE void srgb_to_linearrgb_v3_v3(float linear[3], const float srgb[3])
MINLINE void srgb_to_linearrgb_v4(float linear[4], const float srgb[4])
MINLINE void copy_v4_v4(float r[4], const float a[4])
MINLINE void copy_v2_v2(float r[2], const float a[2])
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE bool is_zero_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void copy_v3_fl(float r[3], float f)
MINLINE void copy_v2_fl(float r[2], float f)
@ BLI_MEMPOOL_ALLOW_ITER
Definition: BLI_mempool.h:107
BLI_mempool * BLI_mempool_create(unsigned int esize, unsigned int elem_num, unsigned int pchunk, unsigned int flag) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
Definition: BLI_mempool.c:253
void * BLI_mempool_calloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
Definition: BLI_mempool.c:347
#define FILE_MAXFILE
bool BLI_str_startswith(const char *__restrict str, const char *__restrict start) ATTR_NONNULL()
Definition: string.c:860
#define STR_ELEM(...)
Definition: BLI_string.h:539
#define STRNCPY(dst, src)
Definition: BLI_string.h:483
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition: string.c:33
char * BLI_strdupcat(const char *__restrict str1, const char *__restrict str2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL() ATTR_MALLOC
Definition: string.c:47
bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) ATTR_NONNULL()
Definition: string.c:887
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define ARRAY_SIZE(arr)
#define ARRAY_SET_ITEMS(...)
#define SWAP(type, a, b)
#define UNUSED(x)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define MAX2(a, b)
#define ELEM(...)
#define STREQ(a, b)
external readfile function prototypes.
struct BlendHandle BlendHandle
Definition: BLO_readfile.h:35
#define BLO_read_assert_message(_check_expr, _ret_value, _bh, _bmain, _message)
Definition: BLO_readfile.h:287
#define DATA_(msgid)
#define ID_IS_LINKED(_id)
Definition: DNA_ID.h:566
#define MAX_ID_NAME
Definition: DNA_ID.h:337
@ LIB_TAG_INDIRECT
Definition: DNA_ID.h:677
@ LIB_EMBEDDED_DATA
Definition: DNA_ID.h:635
@ ID_BR
Definition: DNA_ID_enums.h:69
@ ID_MA
Definition: DNA_ID_enums.h:51
@ ID_GR
Definition: DNA_ID_enums.h:65
@ ADS_FILTER_SUMMARY
@ ROT_MODE_XYZ
@ ADS_FLAG_SUMMARY_COLLAPSED
@ POSE_RECALC
@ SACTCONT_TIMELINE
@ SACTCONT_DOPESHEET
@ SACTION_SHOW_INTERPOLATION
@ SACTION_SHOW_EXTREMES
@ SACTION_SHOW_MARKERS
@ BBONE_HANDLE_AUTO
@ BBONE_HANDLE_ABSOLUTE
@ BBONE_HANDLE_RELATIVE
@ ARM_FLAG_UNUSED_5
@ ARM_FLAG_UNUSED_12
@ ARM_FLAG_UNUSED_6
@ ARM_FLAG_UNUSED_7
@ ARM_FLAG_UNUSED_1
@ ARM_FLAG_UNUSED_9
@ BONE_INHERIT_SCALE_NONE_LEGACY
@ GPAINT_TOOL_ERASE
@ SCULPT_TOOL_CLOTH
@ SCULPT_TOOL_PAINT
@ SCULPT_TOOL_POSE
@ SCULPT_TOOL_CLAY_STRIPS
@ VPAINT_TOOL_BLUR
@ VPAINT_TOOL_DRAW
@ VPAINT_TOOL_SMEAR
@ VPAINT_TOOL_AVERAGE
@ GP_BRUSH_ICON_PEN
@ BRUSH_USE_CONNECTED_ONLY
@ BRUSH_POSE_IK_ANCHORED
@ CAM_DOF_ENABLED
@ CLOTH_BENDING_LINEAR
@ CLOTH_COLLSETTINGS_FLAG_ENABLED
@ CLOTH_COLLSETTINGS_FLAG_SELF
@ CLOTH_SIMSETTINGS_FLAG_GOAL
@ CLOTH_SIMSETTINGS_FLAG_SCALING
@ CLOTH_SIMSETTINGS_FLAG_SEW
Object groups, one object can be in many groups at once.
@ COLLECTION_HIDE_RENDER
@ COLLECTION_HIDE_SELECT
@ COLLECTION_IS_MASTER
@ COLLECTION_HIDE_VIEWPORT
@ CUMA_EXTEND_EXTRAPOLATE
@ CURVE_PRESET_GAUSS
@ CURVE_PRESET_BELL
@ ROTLIKE_MIX_OFFSET
@ ROTLIKE_MIX_REPLACE
@ CONSTRAINT_TYPE_ROTLIKE
@ CONSTRAINT_TYPE_SPLINEIK
@ CONSTRAINT_TYPE_SIZELIKE
@ CONSTRAINT_TYPE_SAMEVOL
@ CONSTRAINT_TYPE_TRANSFORM_CACHE
@ CONSTRAINT_SPLINEIK_YS_FIT_CURVE
@ CONSTRAINT_SPACE_WORLD
@ CONSTRAINT_SPACE_LOCAL
@ SAMEVOL_UNIFORM
@ PROF_PRESET_LINE
@ CD_SCULPT_FACE_SETS
#define DNA_struct_default_get(struct_name)
Definition: DNA_defaults.h:29
#define MAX_NAME
Definition: DNA_defs.h:48
blenloader genfile private function prototypes
bool DNA_struct_find(const struct SDNA *sdna, const char *stype)
bool DNA_struct_elem_find(const struct SDNA *sdna, const char *stype, const char *vartype, const char *name)
@ GP_ARRAY_USE_OB_OFFSET
@ eGpencilModifierType_Array
@ eGpencilModifierType_Noise
@ eGpencilModifierType_Color
@ eGpencilModifierType_Multiply
@ eGpencilModifierType_Subdiv
@ eGpencilModifierType_Opacity
@ eGpencilModifierType_Hook
@ eGpencilModifierType_Smooth
@ eGpencilModifierType_Tint
@ eGpencilModifierType_Thick
@ GP_NOISE_MOD_THICKNESS
#define GP_DEFAULT_PIX_FACTOR
@ GP_LAYER_IS_RULER
@ GP_LAYER_LOCKED
@ GP_LAYER_HIDE
@ GP_LAYER_USE_LIGHTS
#define GP_DEFAULT_GRID_LINES
@ GP_DATA_ANNOTATIONS
@ IMA_FLAG_UNUSED_16
@ IMA_FLAG_UNUSED_8
@ IMA_FLAG_UNUSED_6
@ IMA_FLAG_UNUSED_1
@ IMA_FLAG_UNUSED_15
@ IMA_HIGH_BITDEPTH
@ IMA_FLAG_UNUSED_4
@ IMA_ALPHA_IGNORE
@ IMA_TYPE_R_RESULT
@ LAYER_COLLECTION_EXCLUDE
@ LAYER_COLLECTION_INDIRECT_ONLY
@ LAYER_COLLECTION_HOLDOUT
@ BASE_SELECTABLE
@ BASE_SELECTED
@ VIEW_LAYER_FREESTYLE
@ VIEW_LAYER_RENDER
#define LA_AREA
#define LA_SPOT
#define LA_SUN
#define LA_SHADOW
#define LA_LOCAL
#define LS_MODIFIER_DISTANCE_FROM_CAMERA
#define LS_MODIFIER_TANGENT
#define LS_MODIFIER_CREASE_ANGLE
#define LS_MODIFIER_DISTANCE_FROM_OBJECT
#define LS_MODIFIER_NOISE
#define LS_MODIFIER_ALONG_STROKE
#define LS_MODIFIER_CURVATURE_3D
#define LS_MODIFIER_MATERIAL
@ GP_MATERIAL_FILL_STYLE_GRADIENT
@ GP_MATERIAL_FILL_STYLE_TEXTURE
@ GP_MATERIAL_FILL_STYLE_CHECKER
@ GP_MATERIAL_FILL_STYLE_SOLID
@ MA_BS_SOLID
@ GP_MATERIAL_STROKE_PATTERN
@ GP_MATERIAL_STROKE_TEX_MIX
@ GP_MATERIAL_STROKE_SHOW
@ GP_MATERIAL_FILL_SHOW
@ MA_BM_SOLID
@ MA_BM_BLEND
@ ME_FLAG_UNUSED_6
@ ME_FLAG_UNUSED_4
@ ME_REMESH_REPROJECT_VERTEX_COLORS
@ ME_FLAG_UNUSED_3
@ ME_FLAG_UNUSED_7
@ ME_FLAG_UNUSED_1
@ ME_FLAG_UNUSED_0
@ eMultiresModifierFlag_PlainUv_DEPRECATED
@ eMultiresModifierFlag_UseCrease
@ MOD_SHRINKWRAP_ABOVE_SURFACE
@ eModifierType_ParticleSystem
@ eModifierType_Solidify
@ eModifierType_Subsurf
@ eModifierType_Cloth
@ eModifierType_Fluid
@ eModifierType_Shrinkwrap
@ eModifierType_Hook
@ eModifierType_Ocean
@ eModifierType_DataTransfer
@ eModifierType_UVWarp
@ eModifierType_SurfaceDeform
@ eModifierType_Warp
@ eModifierType_CorrectiveSmooth
@ eModifierType_Bevel
@ eModifierType_Remesh
@ eModifierType_WeightVGEdit
@ eModifierType_Multires
@ eModifierType_Triangulate
@ eSubsurfModifierFlag_SubsurfUv_DEPRECATED
@ eSubsurfModifierFlag_UseCrease
@ SUBSURF_UV_SMOOTH_PRESERVE_CORNERS
@ SUBSURF_UV_SMOOTH_NONE
@ SHD_SUBSURFACE_BURLEY
@ SHD_OUTPUT_ALL
@ SHD_OUTPUT_EEVEE
@ SOCK_OUT
@ SOCK_IN
@ SOCK_SHADER
#define SHD_GLOSSY_MULTI_GGX
#define NTREE_SHADER
@ OB_TEXTURE
@ OB_SOLID
@ OB_RENDER
@ OB_MATERIAL
@ OB_MODE_WEIGHT_PAINT
@ OB_MODE_SCULPT
@ OB_MODE_VERTEX_PAINT
Object is a sort of wrapper for general info.
@ OB_EMPTY
@ OB_CAMERA
@ OB_GPENCIL
@ OB_DUPLI_FLAG_VIEWPORT
@ OB_DUPLI_FLAG_RENDER
@ OB_TRANSFORM_ADJUST_ROOT_PARENT_FOR_VIEW_LOCK
@ OB_DUPLI
@ OB_TRANSFLAG_UNUSED_1
@ OB_TRANSFLAG_UNUSED_12
@ OB_TRANSFLAG_UNUSED_6
@ OB_TRANSFLAG_UNUSED_3
@ OB_EMPTY_IMAGE_HIDE_ORTHOGRAPHIC
@ OB_EMPTY_IMAGE_HIDE_BACK
@ OB_EMPTY_IMAGE_HIDE_PERSPECTIVE
@ OB_ADS_UNUSED_1
@ OB_ADS_UNUSED_2
@ PAROBJECT
@ TSE_LAYER_COLLECTION
@ TSE_CLOSED
@ PART_SHAPE_CLOSE_TIP
#define PART_DRAW_NOT
#define PART_DRAW_BB
Types and defines for representing Rigid Body entities.
@ RBC_TYPE_SLIDER
@ RBC_TYPE_MOTOR
@ RBC_TYPE_6DOF_SPRING
#define R_SCEMODE_UNUSED_19
#define R_MODE_UNUSED_6
@ SCULPT_FLAG_UNUSED_1
@ SCULPT_FLAG_UNUSED_2
@ SCULPT_FLAG_UNUSED_0
@ SCULPT_FLAG_UNUSED_6
#define R_MODE_UNUSED_21
@ UNIFIED_PAINT_FLAG_UNUSED_0
@ UNIFIED_PAINT_FLAG_UNUSED_1
#define R_MODE_UNUSED_27
#define R_SCEMODE_UNUSED_11
#define USER_UNIT_NONE
#define R_MODE_UNUSED_16
@ GP_LOCKAXIS_Y
@ FFM_PRESET_GOOD
@ FFM_PRESET_REALTIME
@ FFM_PRESET_BEST
#define R_MODE_UNUSED_20
#define R_MODE_UNUSED_4
#define R_MODE_UNUSED_10
#define R_MODE_UNUSED_13
#define R_SCEMODE_UNUSED_17
#define R_MODE_UNUSED_5
@ PAINT_SHOW_BRUSH
@ R_SEQ_UNUSED_0
@ R_SEQ_UNUSED_2
@ R_SEQ_UNUSED_1
#define PE_UNUSED_6
#define R_SCEMODE_UNUSED_8
#define R_MODE_UNUSED_8
#define R_SCEMODE_UNUSED_13
#define R_MODE_UNUSED_1
@ R_ADDSKY
#define R_MODE_UNUSED_19
@ SCE_EEVEE_SHADOW_HIGH_BITDEPTH
@ SCE_EEVEE_VOLUMETRIC_SHADOWS
@ SCE_EEVEE_SSR_ENABLED
@ SCE_EEVEE_MOTION_BLUR_ENABLED
@ SCE_EEVEE_SSR_REFRACTION
@ SCE_EEVEE_BLOOM_ENABLED
@ SCE_EEVEE_GTAO_BOUNCE
@ SCE_EEVEE_SSR_HALF_RESOLUTION
@ SCE_EEVEE_TAA_REPROJECTION
@ SCE_EEVEE_GTAO_BENT_NORMALS
@ SCE_EEVEE_GTAO_ENABLED
@ SCE_EEVEE_VOLUMETRIC_LIGHTS
@ GP_PROJECT_VIEWSPACE
@ GP_PROJECT_CURSOR
@ SHADOW_ESM
@ SCE_DISPLAY_AA_SAMPLES_8
@ SCE_DISPLAY_AA_FXAA
#define R_SCEMODE_UNUSED_16
#define R_MODE_UNUSED_3
@ SCE_SNAP_TRANSFORM_MODE_TRANSLATE
#define R_MODE_UNUSED_7
#define USER_UNIT_ADAPTIVE
#define R_MODE_UNUSED_2
#define R_MODE_UNUSED_18
#define PE_BRUSH_COMB
#define SCE_LAY_DISABLE
#define SCE_LAY_FRS
@ R_COLOR_MANAGEMENT_UNUSED_1
@ SCE_PASS_COMBINED
@ SCE_PASS_Z
@ SCE_SNAP_MODE_GRID
@ SCE_SNAP_MODE_NODE_X
#define R_MODE_UNUSED_17
@ AREA_FLAG_UNUSED_6
@ RGN_FLAG_DYNAMIC_SIZE
@ RGN_FLAG_HIDDEN
@ RGN_FLAG_HIDDEN_BY_USER
@ SCREENFULL
@ SCREENMAXIMIZED
@ RGN_TYPE_CHANNELS
@ RGN_TYPE_TOOL_HEADER
@ RGN_TYPE_EXECUTE
@ RGN_TYPE_UI
@ RGN_TYPE_WINDOW
@ RGN_TYPE_PREVIEW
@ RGN_TYPE_NAV_BAR
@ RGN_TYPE_FOOTER
@ RGN_TYPE_HEADER
@ RGN_TYPE_TOOLS
@ RGN_TYPE_TOOL_PROPS
@ RGN_ALIGN_BOTTOM
@ RGN_ALIGN_LEFT
@ RGN_ALIGN_TOP
@ RGN_ALIGN_RIGHT
@ RGN_SPLIT_PREV
@ SEQ_TYPE_SOUND_RAM
@ SEQ_TYPE_SOUND_HD
@ SEQ_TYPE_SPEED
@ seqModifierType_Curves
@ seqModifierType_HueCorrect
#define SEQ_SPEED_UNUSED_1
@ SEQ_CACHE_STORE_FINAL_OUT
@ SEQ_CACHE_VIEW_ENABLE
@ SEQ_CACHE_VIEW_FINAL_OUT
@ eShaderFxColorizeMode_GrayScale
@ eShaderFxColorizeMode_Sepia
@ eShaderFxType_Pixel
@ eShaderFxType_Rim
@ eShaderFxType_Glow
@ eShaderFxType_Shadow
@ eShaderFxType_Colorize
@ SI_CUSTOM_GRID
@ SI_FLAG_UNUSED_8
@ SI_FLAG_UNUSED_0
@ SI_FLAG_UNUSED_7
@ SI_FLAG_UNUSED_17
@ SI_FLAG_UNUSED_23
@ SI_FLAG_UNUSED_3
@ SI_FLAG_UNUSED_24
@ SI_FLAG_UNUSED_1
@ SI_FLAG_UNUSED_6
@ SNODE_FLAG_UNUSED_6
@ SNODE_FLAG_UNUSED_11
@ SNODE_FLAG_UNUSED_10
@ SPACE_TEXT
@ SPACE_CLIP
@ SPACE_ACTION
@ SPACE_OUTLINER
@ SPACE_NODE
@ SPACE_USERPREF
@ SPACE_FILE
@ SPACE_PROPERTIES
@ SPACE_NLA
@ SPACE_SEQ
@ SPACE_EMPTY
@ SPACE_IMAGE
@ SPACE_GRAPH
@ SPACE_VIEW3D
@ SPACE_INFO
@ SEQ_TIMELINE_SHOW_FCURVES
@ SC_VIEW_GRAPH
@ FILE_DETAILS_DATETIME
@ FILE_DETAILS_SIZE
@ SIPO_SHOW_MARKERS
@ SO_RESTRICT_HIDE
@ SO_RESTRICT_ENABLE
@ SO_FILTER_CLEARED_1
@ SO_FILTER_OB_STATE_SELECTABLE
@ SO_FILTER_UNUSED_5
@ SNLA_FLAG_UNUSED_0
@ SNLA_FLAG_UNUSED_1
@ SNLA_FLAG_UNUSED_3
@ SNLA_SHOW_MARKERS
@ SO_SYNC_SELECT
@ SO_FLAG_UNUSED_1
@ SB_FLAG_UNUSED_3
@ SB_FLAG_UNUSED_2
@ SO_TREESTORE_UNUSED_1
@ FILE_PARAMS_FLAG_UNUSED_3
@ FILE_PARAMS_FLAG_UNUSED_1
@ FILE_PARAMS_FLAG_UNUSED_2
@ SEQ_SHOW_MARKERS
@ SO_SEQUENCE
@ SO_DATA_API
@ SO_LIBRARIES
@ SO_VIEW_LAYER
@ SO_SCENES
@ SO_ID_ORPHANS
@ TXT_FLAG_UNUSED_9
@ TXT_FLAG_UNUSED_8
@ USER_HEADER_BOTTOM
@ V2D_SCROLL_LEFT
@ V2D_SCROLL_RIGHT
@ V3D_OFSDRAW_SHOW_GRIDFLOOR
@ V3D_OFSDRAW_SHOW_ANNOTATION
@ V3D_SHADING_TEXTURE_COLOR
@ V3D_SHADING_MATERIAL_COLOR
@ V3D_SHADING_SINGLE_COLOR
@ V3D_LIGHTING_STUDIO
@ V3D_AROUND_CENTER_MEDIAN
#define V3D_FLAG_UNUSED_1
@ V3D_GIZMO_SHOW_EMPTY_FORCE_FIELD
@ V3D_GIZMO_SHOW_EMPTY_IMAGE
@ V3D_GIZMO_SHOW_LIGHT_LOOK_AT
@ V3D_GIZMO_SHOW_LIGHT_SIZE
#define V3D_FLAG_UNUSED_10
#define V3D_SHOW_ORTHO_GRID
#define V3D_FLAG2_UNUSED_13
#define V3D_FLAG2_UNUSED_3
#define V3D_FLAG2_UNUSED_6
@ V3D_GIZMO_SHOW_ARMATURE_BBONE
@ V3D_GIZMO_SHOW_ARMATURE_ROLL
@ V3D_GIZMO_SHOW_CAMERA_DOF_DIST
@ V3D_GIZMO_SHOW_CAMERA_LENS
@ V3D_SHADING_SCENE_WORLD_RENDER
@ V3D_SHADING_SPECULAR_HIGHLIGHT
@ V3D_SHADING_WORLD_ORIENTATION
@ V3D_SHADING_OBJECT_OUTLINE
@ V3D_SHADING_SCENE_LIGHTS_RENDER
@ V3D_SHADING_XRAY_WIREFRAME
@ V3D_SHADING_BACKFACE_CULLING
#define V3D_FLAG2_UNUSED_14
@ V3D_OVERLAY_EDIT_FREESTYLE_FACE
@ V3D_OVERLAY_EDIT_CREASES
@ V3D_OVERLAY_EDIT_FREESTYLE_EDGE
@ V3D_OVERLAY_EDIT_FACES
@ V3D_OVERLAY_EDIT_OCCLUDE_WIRE
@ V3D_OVERLAY_EDIT_SEAMS
@ V3D_OVERLAY_EDIT_BWEIGHTS
@ V3D_OVERLAY_EDIT_SHARP
@ V3D_OVERLAY_EDIT_EDGES
#define V3D_GP_SHOW_EDIT_LINES
#define V3D_FLAG2_UNUSED_15
#define V3D_LOCAL_COLLECTIONS
#define V3D_FLAG2_UNUSED_12
#define V3D_FLAG_UNUSED_12
#define WM_OUTLINER_SYNC_SELECT_FROM_ALL
#define WO_MODE_UNUSED_5
#define WO_MODE_UNUSED_1
#define WO_MODE_UNUSED_2
#define WO_MODE_UNUSED_3
#define WO_MODE_UNUSED_7
#define WO_MODE_UNUSED_4
@ XR_SESSION_USE_POSITION_TRACKING
Definition: DNA_xr_types.h:46
@ IMB_BLEND_EXCLUSION
Definition: IMB_imbuf.h:229
@ IMB_BLEND_DIFFERENCE
Definition: IMB_imbuf.h:228
@ IMB_BLEND_HARDLIGHT
Definition: IMB_imbuf.h:219
@ IMB_BLEND_COLORDODGE
Definition: IMB_imbuf.h:222
@ IMB_BLEND_ERASE_ALPHA
Definition: IMB_imbuf.h:216
@ IMB_BLEND_SCREEN
Definition: IMB_imbuf.h:223
@ IMB_BLEND_HUE
Definition: IMB_imbuf.h:230
@ IMB_BLEND_MUL
Definition: IMB_imbuf.h:213
@ IMB_BLEND_ADD_ALPHA
Definition: IMB_imbuf.h:217
@ IMB_BLEND_DARKEN
Definition: IMB_imbuf.h:215
@ IMB_BLEND_OVERLAY
Definition: IMB_imbuf.h:218
@ IMB_BLEND_SATURATION
Definition: IMB_imbuf.h:231
@ IMB_BLEND_LUMINOSITY
Definition: IMB_imbuf.h:232
@ IMB_BLEND_LIGHTEN
Definition: IMB_imbuf.h:214
@ IMB_BLEND_SOFTLIGHT
Definition: IMB_imbuf.h:224
@ IMB_BLEND_MIX
Definition: IMB_imbuf.h:210
@ IMB_BLEND_ADD
Definition: IMB_imbuf.h:211
@ IMB_BLEND_SUB
Definition: IMB_imbuf.h:212
Read Guarded memory(de)allocation.
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model SH_NODE_EEVEE_SPECULAR
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color SH_NODE_CURVE_VEC
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to curves
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera
__forceinline const avxi srl(const avxi &a, const int32_t b)
Definition: avxi.h:335
unsigned int U
Definition: btGjkEpa3.h:78
#define SELECT
OperationNode * node
Scene scene
Curve curve
FreestyleLineStyle linestyle
World world
void * user_data
DEGForeachIDComponentCallback callback
SyclQueue void void * src
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx in_weight_img image(1, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D_ARRAY, "out_weight_img") .image(3
bNodeTree * ntree
DRWShaderLibrary * lib
bNodeSocketValueRGBA * color_socket
bool enabled
void SEQ_for_each_callback(ListBase *seqbase, SeqForEachFunc callback, void *user_data)
Definition: iterator.c:76
ccl_global const KernelWorkTile * tile
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
static void error(const char *str)
Definition: meshlaplacian.c:51
#define atanf(x)
Definition: metal/compat.h:223
static unsigned a[3]
Definition: RandGen.cpp:78
static void area(int d1, int d2, int e1, int e2, float weights[2])
T abs(const T &a)
const char * RE_engine_id_BLENDER_WORKBENCH
Definition: scene.cc:1696
const char * RE_engine_id_BLENDER_EEVEE
Definition: scene.cc:1695
const SequenceModifierTypeInfo * SEQ_modifier_type_info_get(int type)
struct ARegion * next
short alignment
short regiontype
ListBase drivers
float vec[4]
float radius
float tilt
struct ImageFormatData im_format
struct CurveProfile * custom_profile
float vec[3][3]
struct ReportList * reports
Definition: BLO_readfile.h:80
struct BrushGpencilSettings * gpencil_settings
struct CameraDOFSettings dof
ListBase variables
struct ClothSimSettings * sim_parms
struct ClothCollSettings * coll_parms
float max_internal_compression
float internal_spring_max_diversion
struct CurveMapping * curve_intensity
struct CurveMapping * curve_mapping
CurveMap cm[4]
struct CurveMapping curve_mapping
ListBase seqbase
float recycle_max_cost
bActionGroup * grp
char * rna_path
ChannelDriver * driver
struct BlendFileReadReport * reports
Definition: readfile.h:106
struct SDNA * filesdna
Definition: readfile.h:63
struct FluidDomainSettings * domain
struct CurveMapping * custom_ipo
struct CurveMapping * cur_primitive
struct CurveMapping * cur_falloff
struct CurveMapping * curfalloff
struct CurveMapping curve_mapping
Definition: DNA_ID.h:368
int tag
Definition: DNA_ID.h:387
struct Library * lib
Definition: DNA_ID.h:372
short flag
Definition: DNA_ID.h:383
void * next
Definition: DNA_ID.h:369
char name[66]
Definition: DNA_ID.h:378
ColorManagedDisplaySettings display_settings
ColorManagedViewSettings view_settings
struct LayerCollection * next
ListBase layer_collections
unsigned short local_collections_bits
struct Collection * collection
ID id
Definition: DNA_ID.h:458
void * last
Definition: DNA_listBase.h:31
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
ListBase lightprobes
Definition: BKE_main.h:187
ListBase brushes
Definition: BKE_main.h:193
ListBase scenes
Definition: BKE_main.h:168
char is_locked_for_linking
Definition: BKE_main.h:156
ListBase wm
Definition: BKE_main.h:197
ListBase textures
Definition: BKE_main.h:175
ListBase actions
Definition: BKE_main.h:191
ListBase texts
Definition: BKE_main.h:185
ListBase meshes
Definition: BKE_main.h:171
ListBase lights
Definition: BKE_main.h:178
ListBase particles
Definition: BKE_main.h:194
ListBase materials
Definition: BKE_main.h:174
ListBase linestyles
Definition: BKE_main.h:201
ListBase cameras
Definition: BKE_main.h:179
ListBase armatures
Definition: BKE_main.h:190
ListBase curves
Definition: BKE_main.h:172
ListBase worlds
Definition: BKE_main.h:182
ListBase screens
Definition: BKE_main.h:183
ListBase workspaces
Definition: BKE_main.h:203
ListBase collections
Definition: BKE_main.h:189
ListBase images
Definition: BKE_main.h:176
ListBase gpencils
Definition: BKE_main.h:198
ListBase objects
Definition: BKE_main.h:170
struct MaterialGPencilStyle * gp_style
float remesh_voxel_size
struct ModifierData * next
struct bGPdata * gpd
struct CurveMapping * curve_intensity
void * data
struct CurveMapping * cavity_curve
struct ParticleSystem * psys
struct ClothModifierData * clmd
float4 rotation
Definition: particles.h:26
struct CurveMapping mblur_shutter_curve
struct BakeData bake
char engine[32]
struct ImageFormatData im_format
struct FFMpegCodecData ffcodecdata
char name[64]
struct PointCache * pointcache
struct RigidBodyWorld_Shared * shared
ListBase scene_collections
struct SceneCollection * next
float matcap_ssao_distance
float light_direction[3]
float matcap_ssao_attenuation
View3DShading shading
float volumetric_light_clamp
float volumetric_start
float motion_blur_shutter
float bloom_intensity
float ssr_max_roughness
float gi_irradiance_smoothing
float volumetric_end
float sss_jitter_threshold
float bloom_color[3]
float volumetric_sample_distribution
float ssr_border_fade
float bloom_threshold
float bokeh_threshold
int gi_visibility_resolution
float bokeh_max_size
float gi_filter_quality
float gi_irradiance_draw_size
float gi_cubemap_draw_size
float light_threshold
int volumetric_shadow_samples
float ssr_firefly_fac
int volumetric_tile_size
int gi_cubemap_resolution
struct Collection * master_collection
struct RigidBodyWorld * rigidbody_world
IDProperty * layer_properties
struct SceneDisplay display
struct SceneGpencil grease_pencil_settings
struct ToolSettings * toolsettings
ColorManagedViewSettings view_settings
struct Editing * ed
struct bGPdata * gpd
struct RenderData r
View3DCursor cursor
ListBase view_layers
TransformOrientationSlot orientation_slots[4]
struct UnitSettings unit
struct Object * camera
struct SceneEEVEE eevee
Paint paint
struct PointCache * pointcache
struct ListBase ptcaches
struct SoftBody_Shared * shared
bAction * action
bDopeSheet ads
ListBase regionbase
struct MovieClip * clip
struct wmOperator * op
FileSelectParams * params
int tile_grid_shape[2]
struct bGPdata * gpd
struct BLI_mempool * treestore
struct SpaceLink *(* create)(const struct ScrArea *area, const struct Scene *scene)
Definition: BKE_screen.h:71
int spaceid
Definition: BKE_screen.h:66
char name[FILE_MAXFILE]
short type
struct CurveMapping * curve_thickness
struct CurveMapping * curve_intensity
char transform_pivot_point
struct ImagePaintSettings imapaint
struct CurveProfile * custom_bevel_profile_preset
GpPaint * gp_paint
struct UnifiedPaintSettings unified_paint_settings
short annotate_thickness
struct GP_Interpolate_Settings gp_interpolate
struct ParticleEditSettings particle
char snap_transform_mode_flag
UvSculpt * uvsculpt
struct GP_Sculpt_Settings gp_sculpt
float rotation_axis[3]
float rotation_quaternion[4]
float sculpt_mode_mask_opacity
float gpencil_grid_opacity
float sculpt_mode_face_sets_opacity
float gpencil_paper_opacity
float texture_paint_mode_opacity
float vertex_paint_mode_opacity
float gpencil_vertex_paint_opacity
float weight_paint_mode_opacity
float curvature_ridge_factor
float background_color[3]
float cavity_valley_factor
float curvature_valley_factor
float studiolight_intensity
char studio_light[256]
float single_color[3]
char lookdev_light[256]
struct IDProperty * prop
float vertex_opacity
View3DOverlay overlay
char gizmo_show_armature
char gizmo_show_light
char gizmo_show_camera
float clip_end
char gizmo_show_empty
View3DShading shading
float clip_start
short gp_flag
struct FreestyleConfig freestyle_config
struct IDProperty * id_properties
ListBase layer_collections
struct ViewLayer * next
struct Base * basact
ListBase object_bases
float pass_alpha_threshold
struct Material * mat_override
char name[64]
struct CurveMapping * curfalloff
struct CurveMapping * cmap_curve
Wrapper for bScreen.
short flag
struct bConstraint * next
float vert_color[4]
ListBase layers
char identifier[64]
ListBase nodes
ListBase links
short custom1
float locy
ListBase inputs
float locx
short type
ListBase areabase
static int blend(const Tex *tex, const float texvec[3], TexResult *texres)
static bNode * add_node(const bContext *C, bNodeTree *ntree, const int type, const float locx, const float locy)
void SEQ_sequence_base_unique_name_recursive(struct Scene *scene, ListBase *seqbasep, Sequence *seq)
Definition: utils.c:78
static ARegion * do_versions_find_region(ListBase *regionbase, int regiontype)
static void do_version_collection_propagate_lib_to_children(Collection *collection)
static void do_version_fcurve_hide_viewport_fix(struct ID *UNUSED(id), struct FCurve *fcu, void *UNUSED(user_data))
#define PAINT_BLEND_DIFFERENCE
#define PAINT_BLEND_EXCLUSION
static void do_versions_material_convert_legacy_blend_mode(bNodeTree *ntree, char blend_method)
#define PAINT_BLEND_COLORDODGE
static void do_version_layers_to_collections(Main *bmain, Scene *scene)
static void do_versions_area_ensure_tool_region(Main *bmain, const short space_type, const short region_flag)
#define PAINT_BLEND_SATURATION
#define EEVEE_GET_FLOAT(_props, _name)
#define PAINT_BLEND_SUB
static void do_version_curvemapping_walker(Main *bmain, void(*callback)(CurveMapping *cumap))
static void do_versions_remove_region(ListBase *regionbase, ARegion *region)
static void do_version_bbone_scale_animdata_cb(ID *UNUSED(id), AnimData *adt, void *UNUSED(wrapper_data))
#define PAINT_BLEND_LUMINOSITY
static void do_versions_remove_regions_by_type(ListBase *regionbase, int regiontype)
static bool replace_bbone_scale_rnapath(char **p_old_path)
static bScreen * screen_parent_find(const bScreen *screen)
#define PAINT_BLEND_HARDLIGHT
#define PAINT_BLEND_AVERAGE
#define EEVEE_GET_BOOL(_props, _name, _flag)
static void do_version_bbone_scale_fcurve_fix(ListBase *curves, FCurve *fcu)
#define PAINT_BLEND_BLUR
#define EEVEE_GET_INT(_props, _name)
#define PAINT_BLEND_ALPHA_ADD
static void do_version_curvemapping_flag_extend_extrapolate(CurveMapping *cumap)
static void do_version_constraints_copy_rotation_mix_mode(ListBase *lb)
static void do_version_workspaces_after_lib_link(Main *bmain)
After lib-link versioning for new workspace design.
void do_versions_after_linking_280(FileData *fd, Main *bmain)
#define PAINT_BLEND_OVERLAY
#define PAINT_BLEND_ALPHA_SUB
#define CUMA_EXTEND_EXTRAPOLATE_OLD
#define PAINT_BLEND_SOFTLIGHT
#define PAINT_BLEND_SMEAR
#define PAINT_BLEND_SCREEN
static void do_version_workspaces_create_from_screens(Main *bmain)
#define PAINT_BLEND_LIGHTEN
void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
static void do_version_area_change_space_to_space_action(ScrArea *area, const Scene *scene)
static void do_versions_seq_set_cache_defaults(Editing *ed)
static ARegion * do_versions_find_region_or_null(ListBase *regionbase, int regiontype)
#define EEVEE_GET_FLOAT_ARRAY(_props, _name, _length)
static void do_version_constraints_maintain_volume_mode_uniform(ListBase *lb)
static void do_versions_seq_alloc_transform_and_crop(ListBase *seqbase)
#define PAINT_BLEND_MIX
#define PAINT_BLEND_DARKEN
static void do_versions_seq_unique_name_all_strips(Scene *sce, ListBase *seqbasep)
static void do_versions_local_collection_bits_set(LayerCollection *layer_collection)
static void do_version_bones_inherit_scale(ListBase *lb)
#define PAINT_BLEND_MUL
#define PAINT_BLEND_ADD
#define PAINT_BLEND_HUE
static bool seq_update_flags_cb(Sequence *seq, void *UNUSED(user_data))
static void do_version_constraints_copy_scale_power(ListBase *lb)
static void do_versions_fix_annotations(bGPdata *gpd)
static void do_version_bones_split_bbone_scale(ListBase *lb)
ID * do_versions_rename_id(Main *bmain, const short id_type, const char *name_src, const char *name_dst)
ARegion * do_versions_add_region(int regiontype, const char *name)
void version_socket_update_is_used(bNodeTree *ntree)