Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / render / render_update.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program; if not, write to the Free Software Foundation,
13  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
14  *
15  * The Original Code is Copyright (C) 2009 Blender Foundation.
16  * All rights reserved.
17  */
18
19 /** \file
20  * \ingroup edrend
21  */
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "DNA_light_types.h"
27 #include "DNA_material_types.h"
28 #include "DNA_meshdata_types.h"
29 #include "DNA_node_types.h"
30 #include "DNA_object_types.h"
31 #include "DNA_scene_types.h"
32 #include "DNA_screen_types.h"
33 #include "DNA_space_types.h"
34 #include "DNA_view3d_types.h"
35 #include "DNA_workspace_types.h"
36 #include "DNA_world_types.h"
37 #include "DNA_windowmanager_types.h"
38
39 #include "DRW_engine.h"
40
41 #include "BLI_listbase.h"
42 #include "BLI_threads.h"
43 #include "BLI_utildefines.h"
44
45 #include "BKE_context.h"
46 #include "BKE_icons.h"
47 #include "BKE_layer.h"
48 #include "BKE_main.h"
49 #include "BKE_material.h"
50 #include "BKE_node.h"
51 #include "BKE_paint.h"
52 #include "BKE_scene.h"
53 #include "BKE_workspace.h"
54
55 #include "RE_engine.h"
56 #include "RE_pipeline.h"
57
58 #include "ED_node.h"
59 #include "ED_render.h"
60 #include "ED_view3d.h"
61
62 #include "DEG_depsgraph.h"
63
64 #include "WM_api.h"
65
66 #include "render_intern.h"  // own include
67
68 /***************************** Render Engines ********************************/
69
70 void ED_render_scene_update(const DEGEditorUpdateContext *update_ctx, int updated)
71 {
72   /* viewport rendering update on data changes, happens after depsgraph
73    * updates if there was any change. context is set to the 3d view */
74   Main *bmain = update_ctx->bmain;
75   Scene *scene = update_ctx->scene;
76   ViewLayer *view_layer = update_ctx->view_layer;
77   bContext *C;
78   wmWindowManager *wm;
79   wmWindow *win;
80   static bool recursive_check = false;
81
82   /* don't do this render engine update if we're updating the scene from
83    * other threads doing e.g. rendering or baking jobs */
84   if (!BLI_thread_is_main()) {
85     return;
86   }
87
88   /* don't call this recursively for frame updates */
89   if (recursive_check) {
90     return;
91   }
92
93   /* Do not call if no WM available, see T42688. */
94   if (BLI_listbase_is_empty(&bmain->wm)) {
95     return;
96   }
97
98   recursive_check = true;
99
100   C = CTX_create();
101   CTX_data_main_set(C, bmain);
102   CTX_data_scene_set(C, scene);
103
104   CTX_wm_manager_set(C, bmain->wm.first);
105   wm = bmain->wm.first;
106
107   for (win = wm->windows.first; win; win = win->next) {
108     bScreen *sc = WM_window_get_active_screen(win);
109     ScrArea *sa;
110     ARegion *ar;
111
112     CTX_wm_window_set(C, win);
113
114     for (sa = sc->areabase.first; sa; sa = sa->next) {
115       if (sa->spacetype != SPACE_VIEW3D) {
116         continue;
117       }
118       View3D *v3d = sa->spacedata.first;
119       for (ar = sa->regionbase.first; ar; ar = ar->next) {
120         if (ar->regiontype != RGN_TYPE_WINDOW) {
121           continue;
122         }
123         RegionView3D *rv3d = ar->regiondata;
124         RenderEngine *engine = rv3d->render_engine;
125         /* call update if the scene changed, or if the render engine
126          * tagged itself for update (e.g. because it was busy at the
127          * time of the last update) */
128         if (engine && (updated || (engine->flag & RE_ENGINE_DO_UPDATE))) {
129
130           CTX_wm_screen_set(C, sc);
131           CTX_wm_area_set(C, sa);
132           CTX_wm_region_set(C, ar);
133
134           engine->flag &= ~RE_ENGINE_DO_UPDATE;
135           engine->type->view_update(engine, C);
136         }
137         else {
138           RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
139           if (updated) {
140             DRW_notify_view_update((&(DRWUpdateContext){
141                 .bmain = bmain,
142                 .depsgraph = update_ctx->depsgraph,
143                 .scene = scene,
144                 .view_layer = view_layer,
145                 .ar = ar,
146                 .v3d = (View3D *)sa->spacedata.first,
147                 .engine_type = engine_type,
148             }));
149           }
150         }
151       }
152     }
153   }
154
155   CTX_free(C);
156
157   recursive_check = false;
158 }
159
160 void ED_render_engine_area_exit(Main *bmain, ScrArea *sa)
161 {
162   /* clear all render engines in this area */
163   ARegion *ar;
164   wmWindowManager *wm = bmain->wm.first;
165
166   if (sa->spacetype != SPACE_VIEW3D) {
167     return;
168   }
169
170   for (ar = sa->regionbase.first; ar; ar = ar->next) {
171     if (ar->regiontype != RGN_TYPE_WINDOW || !(ar->regiondata)) {
172       continue;
173     }
174     ED_view3d_stop_render_preview(wm, ar);
175   }
176 }
177
178 void ED_render_engine_changed(Main *bmain)
179 {
180   /* on changing the render engine type, clear all running render engines */
181   for (bScreen *sc = bmain->screens.first; sc; sc = sc->id.next) {
182     for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
183       ED_render_engine_area_exit(bmain, sa);
184     }
185   }
186   RE_FreePersistentData();
187   /* Inform all render engines and draw managers. */
188   DEGEditorUpdateContext update_ctx = {NULL};
189   update_ctx.bmain = bmain;
190   for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
191     update_ctx.scene = scene;
192     LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
193       /* TDODO(sergey): Iterate over depsgraphs instead? */
194       update_ctx.depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
195       update_ctx.view_layer = view_layer;
196       ED_render_id_flush_update(&update_ctx, &scene->id);
197     }
198     if (scene->nodetree) {
199       ntreeCompositUpdateRLayers(scene->nodetree);
200     }
201   }
202 }
203
204 void ED_render_view_layer_changed(Main *bmain, bScreen *sc)
205 {
206   for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
207     ED_render_engine_area_exit(bmain, sa);
208   }
209 }
210
211 /***************************** Updates ***********************************
212  * ED_render_id_flush_update gets called from DEG_id_tag_update, to do   *
213  * editor level updates when the ID changes. when these ID blocks are in *
214  * the dependency graph, we can get rid of the manual dependency checks  */
215
216 static void material_changed(Main *UNUSED(bmain), Material *ma)
217 {
218   /* icons */
219   BKE_icon_changed(BKE_icon_id_ensure(&ma->id));
220 }
221
222 static void lamp_changed(Main *UNUSED(bmain), Light *la)
223 {
224   /* icons */
225   BKE_icon_changed(BKE_icon_id_ensure(&la->id));
226 }
227
228 static void texture_changed(Main *bmain, Tex *tex)
229 {
230   Scene *scene;
231   ViewLayer *view_layer;
232   bNode *node;
233
234   /* icons */
235   BKE_icon_changed(BKE_icon_id_ensure(&tex->id));
236
237   for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
238     /* paint overlays */
239     for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
240       BKE_paint_invalidate_overlay_tex(scene, view_layer, tex);
241     }
242     /* find compositing nodes */
243     if (scene->use_nodes && scene->nodetree) {
244       for (node = scene->nodetree->nodes.first; node; node = node->next) {
245         if (node->id == &tex->id) {
246           ED_node_tag_update_id(&scene->id);
247         }
248       }
249     }
250   }
251 }
252
253 static void world_changed(Main *UNUSED(bmain), World *wo)
254 {
255   /* icons */
256   BKE_icon_changed(BKE_icon_id_ensure(&wo->id));
257 }
258
259 static void image_changed(Main *bmain, Image *ima)
260 {
261   Tex *tex;
262
263   /* icons */
264   BKE_icon_changed(BKE_icon_id_ensure(&ima->id));
265
266   /* textures */
267   for (tex = bmain->textures.first; tex; tex = tex->id.next) {
268     if (tex->ima == ima) {
269       texture_changed(bmain, tex);
270     }
271   }
272 }
273
274 static void scene_changed(Main *bmain, Scene *scene)
275 {
276   Object *ob;
277
278   /* glsl */
279   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
280     if (ob->mode & OB_MODE_TEXTURE_PAINT) {
281       BKE_texpaint_slots_refresh_object(scene, ob);
282       BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
283     }
284   }
285 }
286
287 void ED_render_id_flush_update(const DEGEditorUpdateContext *update_ctx, ID *id)
288 {
289   /* this can be called from render or baking thread when a python script makes
290    * changes, in that case we don't want to do any editor updates, and making
291    * GPU changes is not possible because OpenGL only works in the main thread */
292   if (!BLI_thread_is_main()) {
293     return;
294   }
295   Main *bmain = update_ctx->bmain;
296   /* Internal ID update handlers. */
297   switch (GS(id->name)) {
298     case ID_MA:
299       material_changed(bmain, (Material *)id);
300       break;
301     case ID_TE:
302       texture_changed(bmain, (Tex *)id);
303       break;
304     case ID_WO:
305       world_changed(bmain, (World *)id);
306       break;
307     case ID_LA:
308       lamp_changed(bmain, (Light *)id);
309       break;
310     case ID_IM:
311       image_changed(bmain, (Image *)id);
312       break;
313     case ID_SCE:
314       scene_changed(bmain, (Scene *)id);
315       break;
316     default:
317       break;
318   }
319 }