Merge branch 'blender2.7'
[blender.git] / source / blender / editors / scene / scene_edit.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/editors/scene/scene_edit.c
22  *  \ingroup edscene
23  */
24
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "BLI_compiler_attrs.h"
29 #include "BLI_listbase.h"
30 #include "BLI_string.h"
31
32 #include "BKE_context.h"
33 #include "BKE_global.h"
34 #include "BKE_layer.h"
35 #include "BKE_library.h"
36 #include "BKE_library_remap.h"
37 #include "BKE_main.h"
38 #include "BKE_node.h"
39 #include "BKE_report.h"
40 #include "BKE_scene.h"
41 #include "BKE_workspace.h"
42
43 #include "DEG_depsgraph.h"
44 #include "DEG_depsgraph_build.h"
45
46 #include "BLT_translation.h"
47
48 #include "DNA_object_types.h"
49 #include "DNA_workspace_types.h"
50
51 #include "ED_object.h"
52 #include "ED_render.h"
53 #include "ED_scene.h"
54 #include "ED_screen.h"
55 #include "ED_util.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59
60 #include "WM_api.h"
61 #include "WM_types.h"
62
63
64 Scene *ED_scene_add(Main *bmain, bContext *C, wmWindow *win, eSceneCopyMethod method)
65 {
66         Scene *scene_new;
67
68         if (method == SCE_COPY_NEW) {
69                 scene_new = BKE_scene_add(bmain, DATA_("Scene"));
70         }
71         else { /* different kinds of copying */
72                 Scene *scene_old = WM_window_get_active_scene(win);
73
74                 scene_new = BKE_scene_copy(bmain, scene_old, method);
75
76                 /* these can't be handled in blenkernel currently, so do them here */
77                 if (method == SCE_COPY_LINK_DATA) {
78                         ED_object_single_users(bmain, scene_new, false, true);
79                 }
80                 else if (method == SCE_COPY_FULL) {
81                         ED_editors_flush_edits(bmain, false);
82                         ED_object_single_users(bmain, scene_new, true, true);
83                 }
84         }
85
86         WM_window_set_active_scene(bmain, C, win, scene_new);
87
88         WM_event_add_notifier(C, NC_SCENE | ND_SCENEBROWSE, scene_new);
89
90         return scene_new;
91 }
92
93 /**
94  * \note Only call outside of area/region loops
95  * \return true if successful
96  */
97 bool ED_scene_delete(bContext *C, Main *bmain, wmWindow *win, Scene *scene)
98 {
99         Scene *scene_new;
100
101         /* kill running jobs */
102         wmWindowManager *wm = bmain->wm.first;
103         WM_jobs_kill_type(wm, scene, WM_JOB_TYPE_ANY);
104
105         if (scene->id.prev)
106                 scene_new = scene->id.prev;
107         else if (scene->id.next)
108                 scene_new = scene->id.next;
109         else
110                 return false;
111
112         WM_window_set_active_scene(bmain, C, win, scene_new);
113
114         BKE_libblock_remap(bmain, scene, scene_new, ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_NEVER_NULL_USAGE);
115
116         id_us_clear_real(&scene->id);
117         if (scene->id.us == 0) {
118                 BKE_id_free(bmain, scene);
119         }
120
121         return true;
122 }
123
124 /* Depsgraph updates after scene becomes active in a window. */
125 void ED_scene_change_update(Main *bmain, Scene *scene, ViewLayer *layer)
126 {
127         Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, layer, true);
128
129         BKE_scene_set_background(bmain, scene);
130         DEG_graph_relations_update(depsgraph, bmain, scene, layer);
131         DEG_on_visible_update(bmain, false);
132
133         ED_render_engine_changed(bmain);
134         ED_update_for_newframe(bmain, depsgraph);
135 }
136
137 static bool view_layer_remove_poll(
138         const Scene *scene, const ViewLayer *layer)
139 {
140         const int act = BLI_findindex(&scene->view_layers, layer);
141
142         if (act == -1) {
143                 return false;
144         }
145         else if ((scene->view_layers.first == scene->view_layers.last) &&
146                  (scene->view_layers.first == layer))
147         {
148                 /* ensure 1 layer is kept */
149                 return false;
150         }
151
152         return true;
153 }
154
155 static void view_layer_remove_unset_nodetrees(const Main *bmain, Scene *scene, ViewLayer *layer)
156 {
157         int act_layer_index = BLI_findindex(&scene->view_layers, layer);
158
159         for (Scene *sce = bmain->scene.first; sce; sce = sce->id.next) {
160                 if (sce->nodetree) {
161                         BKE_nodetree_remove_layer_n(sce->nodetree, scene, act_layer_index);
162                 }
163         }
164 }
165
166 bool ED_scene_view_layer_delete(
167         Main *bmain, Scene *scene, ViewLayer *layer,
168         ReportList *reports)
169 {
170         if (view_layer_remove_poll(scene, layer) == false) {
171                 if (reports) {
172                         BKE_reportf(reports, RPT_ERROR, "View layer '%s' could not be removed from scene '%s'",
173                                     layer->name, scene->id.name + 2);
174                 }
175
176                 return false;
177         }
178
179         /* We need to unset nodetrees before removing the layer, otherwise its index will be -1. */
180         view_layer_remove_unset_nodetrees(bmain, scene, layer);
181
182         BLI_remlink(&scene->view_layers, layer);
183         BLI_assert(BLI_listbase_is_empty(&scene->view_layers) == false);
184
185         /* Remove from windows. */
186         wmWindowManager *wm = bmain->wm.first;
187         for (wmWindow *win = wm->windows.first; win; win = win->next) {
188                 if (win->scene == scene && STREQ(win->view_layer_name, layer->name)) {
189                         ViewLayer *first_layer = BKE_view_layer_default_view(scene);
190                         STRNCPY(win->view_layer_name, first_layer->name);
191                 }
192         }
193
194         BKE_view_layer_free(layer);
195
196         DEG_id_tag_update(&scene->id, 0);
197         DEG_relations_tag_update(bmain);
198         WM_main_add_notifier(NC_SCENE | ND_LAYER | NA_REMOVED, scene);
199
200         return true;
201 }
202
203 static int scene_new_exec(bContext *C, wmOperator *op)
204 {
205         Main *bmain = CTX_data_main(C);
206         wmWindow *win = CTX_wm_window(C);
207         int type = RNA_enum_get(op->ptr, "type");
208
209         ED_scene_add(bmain, C, win, type);
210
211         return OPERATOR_FINISHED;
212 }
213
214 static void SCENE_OT_new(wmOperatorType *ot)
215 {
216         static EnumPropertyItem type_items[] = {
217                 {SCE_COPY_NEW, "NEW", 0, "New", "Add new scene"},
218                 {SCE_COPY_EMPTY, "EMPTY", 0, "Copy Settings", "Make a copy without any objects"},
219                 {SCE_COPY_LINK_OB, "LINK_OBJECTS", 0, "Link Objects", "Link to the objects from the current scene"},
220                 {SCE_COPY_LINK_DATA, "LINK_OBJECT_DATA", 0, "Link Object Data", "Copy objects linked to data from the current scene"},
221                 {SCE_COPY_FULL, "FULL_COPY", 0, "Full Copy", "Make a full copy of the current scene"},
222                 {0, NULL, 0, NULL, NULL}
223         };
224
225         /* identifiers */
226         ot->name = "New Scene";
227         ot->description = "Add new scene by type";
228         ot->idname = "SCENE_OT_new";
229
230         /* api callbacks */
231         ot->exec = scene_new_exec;
232         ot->invoke = WM_menu_invoke;
233
234         /* flags */
235         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
236
237         /* properties */
238         ot->prop = RNA_def_enum(ot->srna, "type", type_items, 0, "Type", "");
239 }
240
241 static bool scene_delete_poll(bContext *C)
242 {
243         Scene *scene = CTX_data_scene(C);
244         return (scene->id.prev || scene->id.next);
245 }
246
247 static int scene_delete_exec(bContext *C, wmOperator *UNUSED(op))
248 {
249         Scene *scene = CTX_data_scene(C);
250
251         if (ED_scene_delete(C, CTX_data_main(C), CTX_wm_window(C), scene) == false) {
252                 return OPERATOR_CANCELLED;
253         }
254
255         if (G.debug & G_DEBUG)
256                 printf("scene delete %p\n", scene);
257
258         WM_event_add_notifier(C, NC_SCENE | NA_REMOVED, scene);
259
260         return OPERATOR_FINISHED;
261 }
262
263 static void SCENE_OT_delete(wmOperatorType *ot)
264 {
265         /* identifiers */
266         ot->name = "Delete Scene";
267         ot->description = "Delete active scene";
268         ot->idname = "SCENE_OT_delete";
269
270         /* api callbacks */
271         ot->exec = scene_delete_exec;
272         ot->poll = scene_delete_poll;
273
274         /* flags */
275         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
276 }
277
278 void ED_operatortypes_scene(void)
279 {
280         WM_operatortype_append(SCENE_OT_new);
281         WM_operatortype_append(SCENE_OT_delete);
282 }