Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / blendfile.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/blenkernel/intern/blendfile.c
22  *  \ingroup bke
23  *
24  * High level `.blend` file read/write,
25  * and functions for writing *partial* files (only selected data-blocks).
26  */
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_scene_types.h"
34 #include "DNA_screen_types.h"
35 #include "DNA_workspace_types.h"
36
37 #include "BLI_listbase.h"
38 #include "BLI_string.h"
39 #include "BLI_path_util.h"
40 #include "BLI_utildefines.h"
41
42 #include "IMB_colormanagement.h"
43
44 #include "BKE_appdir.h"
45 #include "BKE_blender.h"
46 #include "BKE_blender_version.h"
47 #include "BKE_blendfile.h"
48 #include "BKE_bpath.h"
49 #include "BKE_context.h"
50 #include "BKE_global.h"
51 #include "BKE_ipo.h"
52 #include "BKE_layer.h"
53 #include "BKE_library.h"
54 #include "BKE_main.h"
55 #include "BKE_report.h"
56 #include "BKE_scene.h"
57 #include "BKE_screen.h"
58 #include "BKE_workspace.h"
59
60 #include "BLO_readfile.h"
61 #include "BLO_writefile.h"
62
63 #include "RNA_access.h"
64
65 #include "RE_pipeline.h"
66
67 #ifdef WITH_PYTHON
68 #  include "BPY_extern.h"
69 #endif
70
71 /* -------------------------------------------------------------------- */
72
73 /** \name High Level `.blend` file read/write.
74  * \{ */
75
76 static bool clean_paths_visit_cb(void *UNUSED(userdata), char *path_dst, const char *path_src)
77 {
78         strcpy(path_dst, path_src);
79         BLI_path_native_slash(path_dst);
80         return !STREQ(path_dst, path_src);
81 }
82
83 /* make sure path names are correct for OS */
84 static void clean_paths(Main *main)
85 {
86         Scene *scene;
87
88         BKE_bpath_traverse_main(main, clean_paths_visit_cb, BKE_BPATH_TRAVERSE_SKIP_MULTIFILE, NULL);
89
90         for (scene = main->scene.first; scene; scene = scene->id.next) {
91                 BLI_path_native_slash(scene->r.pic);
92         }
93 }
94
95 static bool wm_scene_is_visible(wmWindowManager *wm, Scene *scene)
96 {
97         wmWindow *win;
98         for (win = wm->windows.first; win; win = win->next) {
99                 if (win->scene == scene) {
100                         return true;
101                 }
102         }
103         return false;
104 }
105
106 /**
107  * Context matching, handle no-ui case
108  *
109  * \note this is called on Undo so any slow conversion functions here
110  * should be avoided or check (mode != LOAD_UNDO).
111  *
112  * \param bfd: Blend file data, freed by this function on exit.
113  * \param filepath: File path or identifier.
114  */
115 static void setup_app_data(
116         bContext *C, BlendFileData *bfd,
117         const char *filepath, ReportList *reports)
118 {
119         Scene *curscene = NULL;
120         const bool recover = (G.fileflags & G_FILE_RECOVER) != 0;
121         enum {
122                 LOAD_UI = 1,
123                 LOAD_UI_OFF,
124                 LOAD_UNDO,
125         } mode;
126
127         /* may happen with library files - UNDO file should never have NULL cursccene... */
128         if (ELEM(NULL, bfd->curscreen, bfd->curscene)) {
129                 BKE_report(reports, RPT_WARNING, "Library file, loading empty scene");
130                 mode = LOAD_UI_OFF;
131         }
132         else if (BLI_listbase_is_empty(&bfd->main->screen)) {
133                 mode = LOAD_UNDO;
134         }
135         else if (G.fileflags & G_FILE_NO_UI) {
136                 mode = LOAD_UI_OFF;
137         }
138         else {
139                 mode = LOAD_UI;
140         }
141
142         /* Free all render results, without this stale data gets displayed after loading files */
143         if (mode != LOAD_UNDO) {
144                 RE_FreeAllRenderResults();
145         }
146
147         /* Only make filepaths compatible when loading for real (not undo) */
148         if (mode != LOAD_UNDO) {
149                 clean_paths(bfd->main);
150         }
151
152         /* XXX here the complex windowmanager matching */
153
154         /* no load screens? */
155         if (mode != LOAD_UI) {
156                 /* Logic for 'track_undo_scene' is to keep using the scene which the active screen has,
157                  * as long as the scene associated with the undo operation is visible in one of the open windows.
158                  *
159                  * - 'curscreen->scene' - scene the user is currently looking at.
160                  * - 'bfd->curscene' - scene undo-step was created in.
161                  *
162                  * This means users can have 2+ windows open and undo in both without screens switching.
163                  * But if they close one of the screens,
164                  * undo will ensure that the scene being operated on will be activated
165                  * (otherwise we'd be undoing on an off-screen scene which isn't acceptable).
166                  * see: T43424
167                  */
168                 wmWindow *win;
169                 bScreen *curscreen = NULL;
170                 SceneLayer *cur_render_layer;
171                 bool track_undo_scene;
172
173                 /* comes from readfile.c */
174                 SWAP(ListBase, G.main->wm, bfd->main->wm);
175                 SWAP(ListBase, G.main->workspaces, bfd->main->workspaces);
176                 SWAP(ListBase, G.main->screen, bfd->main->screen);
177
178                 /* we re-use current window and screen */
179                 win = CTX_wm_window(C);
180                 curscreen = CTX_wm_screen(C);
181                 /* but use Scene pointer from new file */
182                 curscene = bfd->curscene;
183                 cur_render_layer = bfd->cur_render_layer;
184
185                 track_undo_scene = (mode == LOAD_UNDO && curscreen && curscene && bfd->main->wm.first);
186
187                 if (curscene == NULL) {
188                         curscene = bfd->main->scene.first;
189                 }
190                 /* empty file, we add a scene to make Blender work */
191                 if (curscene == NULL) {
192                         curscene = BKE_scene_add(bfd->main, "Empty");
193                 }
194                 if (cur_render_layer == NULL) {
195                         /* fallback to scene layer */
196                         cur_render_layer = BKE_scene_layer_render_active(curscene);
197                 }
198
199                 if (track_undo_scene) {
200                         /* keep the old (free'd) scene, let 'blo_lib_link_screen_restore'
201                          * replace it with 'curscene' if its needed */
202                 }
203                 /* and we enforce curscene to be in current screen */
204                 else if (win) { /* can run in bgmode */
205                         win->scene = curscene;
206                 }
207
208                 /* BKE_blender_globals_clear will free G.main, here we can still restore pointers */
209                 blo_lib_link_restore(bfd->main, CTX_wm_manager(C), curscene, cur_render_layer);
210                 if (win) {
211                         curscene = win->scene;
212                 }
213
214                 if (track_undo_scene) {
215                         wmWindowManager *wm = bfd->main->wm.first;
216                         if (wm_scene_is_visible(wm, bfd->curscene) == false) {
217                                 curscene = bfd->curscene;
218                                 BKE_screen_view3d_scene_sync(curscreen, curscene);
219                         }
220                 }
221         }
222
223         /* free G.main Main database */
224 //      CTX_wm_manager_set(C, NULL);
225         BKE_blender_globals_clear();
226
227         /* clear old property update cache, in case some old references are left dangling */
228         RNA_property_update_cache_free();
229
230         G.main = bfd->main;
231
232         CTX_data_main_set(C, G.main);
233
234         if (bfd->user) {
235
236                 /* only here free userdef themes... */
237                 BKE_blender_userdef_free_data(&U);
238
239                 U = *bfd->user;
240
241                 /* Security issue: any blend file could include a USER block.
242                  *
243                  * Currently we load prefs from BLENDER_STARTUP_FILE and later on load BLENDER_USERPREF_FILE,
244                  * to load the preferences defined in the users home dir.
245                  *
246                  * This means we will never accidentally (or maliciously)
247                  * enable scripts auto-execution by loading a '.blend' file.
248                  */
249                 U.flag |= USER_SCRIPT_AUTOEXEC_DISABLE;
250
251                 MEM_freeN(bfd->user);
252         }
253
254         /* case G_FILE_NO_UI or no screens in file */
255         if (mode != LOAD_UI) {
256                 /* leave entire context further unaltered? */
257                 CTX_data_scene_set(C, curscene);
258         }
259         else {
260                 G.fileflags = bfd->fileflags;
261                 CTX_wm_manager_set(C, G.main->wm.first);
262                 CTX_wm_screen_set(C, bfd->curscreen);
263                 CTX_data_scene_set(C, bfd->curscene);
264                 CTX_wm_area_set(C, NULL);
265                 CTX_wm_region_set(C, NULL);
266                 CTX_wm_menu_set(C, NULL);
267                 curscene = bfd->curscene;
268         }
269
270         /* this can happen when active scene was lib-linked, and doesn't exist anymore */
271         if (CTX_data_scene(C) == NULL) {
272                 wmWindow *win = CTX_wm_window(C);
273
274                 /* in case we don't even have a local scene, add one */
275                 if (!G.main->scene.first)
276                         BKE_scene_add(G.main, "Empty");
277
278                 CTX_data_scene_set(C, G.main->scene.first);
279                 win->scene = CTX_data_scene(C);
280                 curscene = CTX_data_scene(C);
281         }
282
283         BLI_assert(curscene == CTX_data_scene(C));
284
285
286         /* special cases, override loaded flags: */
287         if (G.f != bfd->globalf) {
288                 const int flags_keep = (G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF);
289                 bfd->globalf = (bfd->globalf & ~flags_keep) | (G.f & flags_keep);
290         }
291
292
293         G.f = bfd->globalf;
294
295 #ifdef WITH_PYTHON
296         /* let python know about new main */
297         BPY_context_update(C);
298 #endif
299
300         /* FIXME: this version patching should really be part of the file-reading code,
301          * but we still get too many unrelated data-corruption crashes otherwise... */
302         if (G.main->versionfile < 250)
303                 do_versions_ipos_to_animato(G.main);
304
305         G.main->recovered = 0;
306
307         /* startup.blend or recovered startup */
308         if (bfd->filename[0] == 0) {
309                 G.main->name[0] = 0;
310         }
311         else if (recover && G.relbase_valid) {
312                 /* in case of autosave or quit.blend, use original filename instead
313                  * use relbase_valid to make sure the file is saved, else we get <memory2> in the filename */
314                 filepath = bfd->filename;
315                 G.main->recovered = 1;
316
317                 /* these are the same at times, should never copy to the same location */
318                 if (G.main->name != filepath)
319                         BLI_strncpy(G.main->name, filepath, FILE_MAX);
320         }
321
322         /* baseflags, groups, make depsgraph, etc */
323         /* first handle case if other windows have different scenes visible */
324         if (mode == LOAD_UI) {
325                 wmWindowManager *wm = G.main->wm.first;
326
327                 if (wm) {
328                         for (wmWindow *win = wm->windows.first; win; win = win->next) {
329                                 if (win->scene && win->scene != curscene) {
330                                         BKE_scene_set_background(G.main, win->scene);
331                                 }
332                         }
333                 }
334         }
335
336         if (mode == LOAD_UI_OFF && BLI_listbase_is_empty(&G.main->wm)) {
337                 /* XXX prevent crash in pdInitEffectors called through DEG_scene_relations_rebuild (see T51794).
338                  * Can be removed once BKE_scene_layer_context_active_ex gets workspace passed. */
339                 BLI_addhead(&G.main->wm, CTX_wm_manager(C));
340                 BKE_scene_set_background(G.main, curscene);
341                 BLI_listbase_clear(&G.main->wm);
342         }
343         else {
344                 BKE_scene_set_background(G.main, curscene);
345         }
346
347         if (mode != LOAD_UNDO) {
348                 RE_FreeAllPersistentData();
349                 IMB_colormanagement_check_file_config(G.main);
350         }
351
352         MEM_freeN(bfd);
353
354 }
355
356 static int handle_subversion_warning(Main *main, ReportList *reports)
357 {
358         if (main->minversionfile > BLENDER_VERSION ||
359             (main->minversionfile == BLENDER_VERSION &&
360              main->minsubversionfile > BLENDER_SUBVERSION))
361         {
362                 BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary (%d.%d), expect loss of data!",
363                             main->minversionfile, main->minsubversionfile);
364         }
365
366         return 1;
367 }
368
369 int BKE_blendfile_read(
370         bContext *C, const char *filepath,
371         ReportList *reports, int skip_flags)
372 {
373         BlendFileData *bfd;
374         int retval = BKE_BLENDFILE_READ_OK;
375
376         /* don't print user-pref loading */
377         if (strstr(filepath, BLENDER_STARTUP_FILE) == NULL) {
378                 printf("Read blend: %s\n", filepath);
379         }
380
381         bfd = BLO_read_from_file(filepath, reports, skip_flags);
382         if (bfd) {
383                 if (bfd->user) {
384                         retval = BKE_BLENDFILE_READ_OK_USERPREFS;
385                 }
386
387                 if (0 == handle_subversion_warning(bfd->main, reports)) {
388                         BKE_main_free(bfd->main);
389                         MEM_freeN(bfd);
390                         bfd = NULL;
391                         retval = BKE_BLENDFILE_READ_FAIL;
392                 }
393                 else {
394                         setup_app_data(C, bfd, filepath, reports);
395                 }
396         }
397         else
398                 BKE_reports_prependf(reports, "Loading '%s' failed: ", filepath);
399
400         return (bfd ? retval : BKE_BLENDFILE_READ_FAIL);
401 }
402
403 bool BKE_blendfile_read_from_memory(
404         bContext *C, const void *filebuf, int filelength,
405         ReportList *reports, int skip_flags, bool update_defaults)
406 {
407         BlendFileData *bfd;
408
409         bfd = BLO_read_from_memory(filebuf, filelength, reports, skip_flags);
410         if (bfd) {
411                 if (update_defaults)
412                         BLO_update_defaults_startup_blend(bfd->main);
413                 setup_app_data(C, bfd, "<memory2>", reports);
414         }
415         else {
416                 BKE_reports_prepend(reports, "Loading failed: ");
417         }
418
419         return (bfd != NULL);
420 }
421
422 /* memfile is the undo buffer */
423 bool BKE_blendfile_read_from_memfile(
424         bContext *C, struct MemFile *memfile,
425         ReportList *reports, int skip_flags)
426 {
427         BlendFileData *bfd;
428
429         bfd = BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports, skip_flags);
430         if (bfd) {
431                 /* remove the unused screens and wm */
432                 while (bfd->main->wm.first)
433                         BKE_libblock_free(bfd->main, bfd->main->wm.first);
434                 while (bfd->main->screen.first)
435                         BKE_libblock_free(bfd->main, bfd->main->screen.first);
436
437                 setup_app_data(C, bfd, "<memory1>", reports);
438         }
439         else {
440                 BKE_reports_prepend(reports, "Loading failed: ");
441         }
442
443         return (bfd != NULL);
444 }
445
446 /**
447  * Utility to make a file 'empty' used for startup to optionally give an empty file.
448  * Handy for tests.
449  */
450 void BKE_blendfile_read_make_empty(bContext *C)
451 {
452         Main *bmain = CTX_data_main(C);
453
454         ListBase *lbarray[MAX_LIBARRAY];
455         ID *id;
456         int a;
457
458         a = set_listbasepointers(bmain, lbarray);
459         while (a--) {
460                 id = lbarray[a]->first;
461                 if (id != NULL) {
462                         if (ELEM(GS(id->name), ID_SCE, ID_SCR, ID_WM)) {
463                                 continue;
464                         }
465                         while ((id = lbarray[a]->first)) {
466                                 BKE_libblock_delete(bmain, id);
467                         }
468                 }
469         }
470 }
471
472 /* only read the userdef from a .blend */
473 UserDef *BKE_blendfile_userdef_read(const char *filepath, ReportList *reports)
474 {
475         BlendFileData *bfd;
476         UserDef *userdef = NULL;
477
478         bfd = BLO_read_from_file(filepath, reports, BLO_READ_SKIP_ALL & ~BLO_READ_SKIP_USERDEF);
479         if (bfd) {
480                 if (bfd->user) {
481                         userdef = bfd->user;
482                 }
483                 BKE_main_free(bfd->main);
484                 MEM_freeN(bfd);
485         }
486
487         return userdef;
488 }
489
490
491 UserDef *BKE_blendfile_userdef_read_from_memory(
492         const void *filebuf, int filelength,
493         ReportList *reports)
494 {
495         BlendFileData *bfd;
496         UserDef *userdef = NULL;
497
498         bfd = BLO_read_from_memory(filebuf, filelength, reports, BLO_READ_SKIP_ALL & ~BLO_READ_SKIP_USERDEF);
499         if (bfd) {
500                 if (bfd->user) {
501                         userdef = bfd->user;
502                 }
503                 BKE_main_free(bfd->main);
504                 MEM_freeN(bfd);
505         }
506         else {
507                 BKE_reports_prepend(reports, "Loading failed: ");
508         }
509
510         return userdef;
511 }
512
513
514 /* only write the userdef in a .blend */
515 int BKE_blendfile_userdef_write(const char *filepath, ReportList *reports)
516 {
517         Main *mainb = MEM_callocN(sizeof(Main), "empty main");
518         int retval = 0;
519
520         if (BLO_write_file(mainb, filepath, G_FILE_USERPREFS, reports, NULL)) {
521                 retval = 1;
522         }
523
524         MEM_freeN(mainb);
525
526         return retval;
527 }
528
529 WorkspaceConfigFileData *BKE_blendfile_workspace_config_read(const char *filepath, ReportList *reports)
530 {
531         BlendFileData *bfd;
532         WorkspaceConfigFileData *workspace_config = NULL;
533
534         bfd = BLO_read_from_file(filepath, reports, BLO_READ_SKIP_USERDEF);
535         if (bfd) {
536                 workspace_config = MEM_mallocN(sizeof(*workspace_config), __func__);
537                 workspace_config->main = bfd->main;
538                 workspace_config->workspaces = bfd->main->workspaces;
539
540                 MEM_freeN(bfd);
541         }
542
543         return workspace_config;
544 }
545
546 bool BKE_blendfile_workspace_config_write(Main *bmain, const char *filepath, ReportList *reports)
547 {
548         int fileflags = G.fileflags & ~(G_FILE_NO_UI | G_FILE_AUTOPLAY | G_FILE_HISTORY);
549         bool retval = false;
550
551         BKE_blendfile_write_partial_begin(bmain);
552
553         for (WorkSpace *workspace = bmain->workspaces.first; workspace; workspace = workspace->id.next) {
554                 BKE_blendfile_write_partial_tag_ID(&workspace->id, true);
555         }
556
557         if (BKE_blendfile_write_partial(bmain, filepath, fileflags, reports)) {
558                 retval = true;
559         }
560
561         BKE_blendfile_write_partial_end(bmain);
562
563         return retval;
564 }
565
566 void BKE_blendfile_workspace_config_data_free(WorkspaceConfigFileData *workspace_config)
567 {
568         BKE_main_free(workspace_config->main);
569         MEM_freeN(workspace_config);
570 }
571
572 /** \} */
573
574
575 /* -------------------------------------------------------------------- */
576
577 /** \name Partial `.blend` file save.
578  * \{ */
579
580 void BKE_blendfile_write_partial_begin(Main *bmain_src)
581 {
582         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
583 }
584
585 void BKE_blendfile_write_partial_tag_ID(ID *id, bool set)
586 {
587         if (set) {
588                 id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
589         }
590         else {
591                 id->tag &= ~(LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT);
592         }
593 }
594
595 static void blendfile_write_partial_cb(void *UNUSED(handle), Main *UNUSED(bmain), void *vid)
596 {
597         if (vid) {
598                 ID *id = vid;
599                 /* only tag for need-expand if not done, prevents eternal loops */
600                 if ((id->tag & LIB_TAG_DOIT) == 0)
601                         id->tag |= LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT;
602
603                 if (id->lib && (id->lib->id.tag & LIB_TAG_DOIT) == 0)
604                         id->lib->id.tag |= LIB_TAG_DOIT;
605         }
606 }
607
608 /**
609  * \return Success.
610  */
611 bool BKE_blendfile_write_partial(
612         Main *bmain_src, const char *filepath, const int write_flags, ReportList *reports)
613 {
614         Main *bmain_dst = MEM_callocN(sizeof(Main), "copybuffer");
615         ListBase *lbarray_dst[MAX_LIBARRAY], *lbarray_src[MAX_LIBARRAY];
616         int a, retval;
617
618         void     *path_list_backup = NULL;
619         const int path_list_flag = (BKE_BPATH_TRAVERSE_SKIP_LIBRARY | BKE_BPATH_TRAVERSE_SKIP_MULTIFILE);
620
621         /* This is needed to be able to load that file as a real one later
622          * (otherwise main->name will not be set at read time). */
623         BLI_strncpy(bmain_dst->name, bmain_src->name, sizeof(bmain_dst->name));
624
625         if (write_flags & G_FILE_RELATIVE_REMAP) {
626                 path_list_backup = BKE_bpath_list_backup(bmain_src, path_list_flag);
627         }
628
629         BLO_main_expander(blendfile_write_partial_cb);
630         BLO_expand_main(NULL, bmain_src);
631
632         /* move over all tagged blocks */
633         set_listbasepointers(bmain_src, lbarray_src);
634         a = set_listbasepointers(bmain_dst, lbarray_dst);
635         while (a--) {
636                 ID *id, *nextid;
637                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
638
639                 for (id = lb_src->first; id; id = nextid) {
640                         nextid = id->next;
641                         if (id->tag & LIB_TAG_DOIT) {
642                                 BLI_remlink(lb_src, id);
643                                 BLI_addtail(lb_dst, id);
644                         }
645                 }
646         }
647
648
649         /* save the buffer */
650         retval = BLO_write_file(bmain_dst, filepath, write_flags, reports, NULL);
651
652         /* move back the main, now sorted again */
653         set_listbasepointers(bmain_src, lbarray_dst);
654         a = set_listbasepointers(bmain_dst, lbarray_src);
655         while (a--) {
656                 ID *id;
657                 ListBase *lb_dst = lbarray_dst[a], *lb_src = lbarray_src[a];
658
659                 while ((id = BLI_pophead(lb_src))) {
660                         BLI_addtail(lb_dst, id);
661                         id_sort_by_name(lb_dst, id);
662                 }
663         }
664
665         MEM_freeN(bmain_dst);
666
667         if (path_list_backup) {
668                 BKE_bpath_list_restore(bmain_src, path_list_flag, path_list_backup);
669                 BKE_bpath_list_free(path_list_backup);
670         }
671
672         return retval;
673 }
674
675 void BKE_blendfile_write_partial_end(Main *bmain_src)
676 {
677         BKE_main_id_tag_all(bmain_src, LIB_TAG_NEED_EXPAND | LIB_TAG_DOIT, false);
678 }
679
680 /** \} */