Merging r45936 through r46042 from trunk into soc-2011-tomato
[blender.git] / source / blender / editors / render / render_update.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  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software Foundation,
15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16  *
17  * The Original Code is Copyright (C) 2009 Blender Foundation.
18  * All rights reserved.
19  *
20  * Contributor(s): Blender Foundation
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/render/render_update.c
26  *  \ingroup edrend
27  */
28
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_lamp_types.h"
35 #include "DNA_material_types.h"
36 #include "DNA_node_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_space_types.h"
41 #include "DNA_view3d_types.h"
42 #include "DNA_world_types.h"
43
44 #include "BLI_threads.h"
45 #include "BLI_utildefines.h"
46
47 #include "BKE_context.h"
48 #include "BKE_depsgraph.h"
49 #include "BKE_icons.h"
50 #include "BKE_image.h"
51 #include "BKE_main.h"
52 #include "BKE_material.h"
53 #include "BKE_node.h"
54 #include "BKE_scene.h"
55 #include "BKE_texture.h"
56 #include "BKE_world.h"
57
58 #include "GPU_material.h"
59
60 #include "RE_engine.h"
61
62 #include "ED_node.h"
63 #include "ED_render.h"
64
65 #include "render_intern.h"  // own include
66
67 /***************************** Render Engines ********************************/
68
69 void ED_render_scene_update(Main *bmain, Scene *scene, int updated)
70 {
71         /* viewport rendering update on data changes, happens after depsgraph
72          * updates if there was any change. context is set to the 3d view */
73         bContext *C;
74         bScreen *sc;
75         ScrArea *sa;
76         ARegion *ar;
77
78         /* don't do this render engine update if we're updating the scene from
79          * other threads doing e.g. rendering or baking jobs */
80         if (!BLI_thread_is_main())
81                 return;
82
83         C = CTX_create();
84         CTX_data_main_set(C, bmain);
85         CTX_data_scene_set(C, scene);
86
87         CTX_wm_manager_set(C, bmain->wm.first);
88
89         for (sc = bmain->screen.first; sc; sc = sc->id.next) {
90                 for (sa = sc->areabase.first; sa; sa = sa->next) {
91                         if (sa->spacetype != SPACE_VIEW3D)
92                                 continue;
93
94                         for (ar = sa->regionbase.first; ar; ar = ar->next) {
95                                 RegionView3D *rv3d;
96                                 RenderEngine *engine;
97
98                                 if (ar->regiontype != RGN_TYPE_WINDOW)
99                                         continue;
100
101                                 rv3d = ar->regiondata;
102                                 engine = rv3d->render_engine;
103
104                                 if (engine && (updated || (engine->flag & RE_ENGINE_DO_UPDATE))) {
105                                         CTX_wm_screen_set(C, sc);
106                                         CTX_wm_area_set(C, sa);
107                                         CTX_wm_region_set(C, ar);
108
109                                         engine->flag &= ~RE_ENGINE_DO_UPDATE;
110                                         engine->type->view_update(engine, C);
111                                 }
112                         }
113                 }
114         }
115
116         CTX_free(C);
117 }
118
119 void ED_render_engine_area_exit(ScrArea *sa)
120 {
121         /* clear all render engines in this area */
122         ARegion *ar;
123
124         if (sa->spacetype != SPACE_VIEW3D)
125                 return;
126
127         for (ar = sa->regionbase.first; ar; ar = ar->next) {
128                 RegionView3D *rv3d;
129
130                 if (ar->regiontype != RGN_TYPE_WINDOW)
131                         continue;
132                 
133                 rv3d = ar->regiondata;
134
135                 if (rv3d->render_engine) {
136                         RE_engine_free(rv3d->render_engine);
137                         rv3d->render_engine = NULL;
138                 }
139         }
140 }
141
142 void ED_render_engine_changed(Main *bmain)
143 {
144         /* on changing the render engine type, clear all running render engines */
145         bScreen *sc;
146         ScrArea *sa;
147
148         for (sc = bmain->screen.first; sc; sc = sc->id.next)
149                 for (sa = sc->areabase.first; sa; sa = sa->next)
150                         ED_render_engine_area_exit(sa);
151 }
152
153 /***************************** Updates ***********************************
154  * ED_render_id_flush_update gets called from DAG_id_tag_update, to do   *
155  * editor level updates when the ID changes. when these ID blocks are in *
156  * the dependency graph, we can get rid of the manual dependency checks  */
157
158 static int mtex_use_tex(MTex **mtex, int tot, Tex *tex)
159 {
160         int a;
161
162         if (!mtex)
163                 return 0;
164
165         for (a = 0; a < tot; a++)
166                 if (mtex[a] && mtex[a]->tex == tex)
167                         return 1;
168         
169         return 0;
170 }
171
172 static int nodes_use_tex(bNodeTree *ntree, Tex *tex)
173 {
174         bNode *node;
175
176         for (node = ntree->nodes.first; node; node = node->next) {
177                 if (node->id) {
178                         if (node->id == (ID *)tex) {
179                                 return 1;
180                         }
181                         else if (GS(node->id->name) == ID_MA) {
182                                 if (mtex_use_tex(((Material *)node->id)->mtex, MAX_MTEX, tex))
183                                         return 1;
184                         }
185                         else if (node->type == NODE_GROUP) {
186                                 if (nodes_use_tex((bNodeTree *)node->id, tex))
187                                         return 1;
188                         }
189                 }
190         }
191
192         return 0;
193 }
194
195 static int nodes_use_material(bNodeTree *ntree, Material *ma)
196 {
197         bNode *node;
198
199         for (node = ntree->nodes.first; node; node = node->next) {
200                 if (node->id) {
201                         if (node->id == (ID *)ma) {
202                                 return 1;
203                         }
204                         else if (node->type == NODE_GROUP) {
205                                 if (nodes_use_material((bNodeTree *)node->id, ma))
206                                         return 1;
207                         }
208                 }
209         }
210
211         return 0;
212 }
213
214 static void material_changed(Main *bmain, Material *ma)
215 {
216         Material *parent;
217
218         /* icons */
219         BKE_icon_changed(BKE_icon_getid(&ma->id));
220
221         /* glsl */
222         if (ma->gpumaterial.first)
223                 GPU_material_free(ma);
224
225         /* find node materials using this */
226         for (parent = bmain->mat.first; parent; parent = parent->id.next) {
227                 if (parent->use_nodes && parent->nodetree && nodes_use_material(parent->nodetree, ma)) ;
228                 else continue;
229
230                 BKE_icon_changed(BKE_icon_getid(&parent->id));
231
232                 if (parent->gpumaterial.first)
233                         GPU_material_free(parent);
234         }
235 }
236
237 static void texture_changed(Main *bmain, Tex *tex)
238 {
239         Material *ma;
240         Lamp *la;
241         World *wo;
242         Scene *scene;
243         bNode *node;
244
245         /* icons */
246         BKE_icon_changed(BKE_icon_getid(&tex->id));
247
248         /* find materials */
249         for (ma = bmain->mat.first; ma; ma = ma->id.next) {
250                 if (mtex_use_tex(ma->mtex, MAX_MTEX, tex)) ;
251                 else if (ma->use_nodes && ma->nodetree && nodes_use_tex(ma->nodetree, tex)) ;
252                 else continue;
253
254                 BKE_icon_changed(BKE_icon_getid(&ma->id));
255
256                 if (ma->gpumaterial.first)
257                         GPU_material_free(ma);
258         }
259
260         /* find lamps */
261         for (la = bmain->lamp.first; la; la = la->id.next) {
262                 if (mtex_use_tex(la->mtex, MAX_MTEX, tex)) ;
263                 else if (la->nodetree && nodes_use_tex(la->nodetree, tex)) ;
264                 else continue;
265
266                 BKE_icon_changed(BKE_icon_getid(&la->id));
267         }
268
269         /* find worlds */
270         for (wo = bmain->world.first; wo; wo = wo->id.next) {
271                 if (mtex_use_tex(wo->mtex, MAX_MTEX, tex)) ;
272                 else if (wo->nodetree && nodes_use_tex(wo->nodetree, tex)) ;
273                 else continue;
274
275                 BKE_icon_changed(BKE_icon_getid(&wo->id));
276         }
277
278         /* find compositing nodes */
279         for (scene = bmain->scene.first; scene; scene = scene->id.next) {
280                 if (scene->use_nodes && scene->nodetree) {
281                         for (node = scene->nodetree->nodes.first; node; node = node->next) {
282                                 if (node->id == &tex->id)
283                                         ED_node_changed_update(&scene->id, node);
284                         }
285                 }
286         }
287 }
288
289 static void lamp_changed(Main *bmain, Lamp *la)
290 {
291         Object *ob;
292         Material *ma;
293
294         /* icons */
295         BKE_icon_changed(BKE_icon_getid(&la->id));
296
297         /* glsl */
298         for (ob = bmain->object.first; ob; ob = ob->id.next)
299                 if (ob->data == la && ob->gpulamp.first)
300                         GPU_lamp_free(ob);
301
302         for (ma = bmain->mat.first; ma; ma = ma->id.next)
303                 if (ma->gpumaterial.first)
304                         GPU_material_free(ma);
305 }
306
307 static void world_changed(Main *bmain, World *wo)
308 {
309         Material *ma;
310
311         /* icons */
312         BKE_icon_changed(BKE_icon_getid(&wo->id));
313
314         /* glsl */
315         for (ma = bmain->mat.first; ma; ma = ma->id.next)
316                 if (ma->gpumaterial.first)
317                         GPU_material_free(ma);
318 }
319
320 static void image_changed(Main *bmain, Image *ima)
321 {
322         Tex *tex;
323
324         /* icons */
325         BKE_icon_changed(BKE_icon_getid(&ima->id));
326
327         /* textures */
328         for (tex = bmain->tex.first; tex; tex = tex->id.next)
329                 if (tex->ima == ima)
330                         texture_changed(bmain, tex);
331 }
332
333 static void scene_changed(Main *bmain, Scene *UNUSED(scene))
334 {
335         Object *ob;
336         Material *ma;
337
338         /* glsl */
339         for (ob = bmain->object.first; ob; ob = ob->id.next)
340                 if (ob->gpulamp.first)
341                         GPU_lamp_free(ob);
342
343         for (ma = bmain->mat.first; ma; ma = ma->id.next)
344                 if (ma->gpumaterial.first)
345                         GPU_material_free(ma);
346 }
347
348 void ED_render_id_flush_update(Main *bmain, ID *id)
349 {
350         switch (GS(id->name)) {
351                 case ID_MA:
352                         material_changed(bmain, (Material *)id);
353                         break;
354                 case ID_TE:
355                         texture_changed(bmain, (Tex *)id);
356                         break;
357                 case ID_WO:
358                         world_changed(bmain, (World *)id);
359                         break;
360                 case ID_LA:
361                         lamp_changed(bmain, (Lamp *)id);
362                         break;
363                 case ID_IM:
364                         image_changed(bmain, (Image *)id);
365                         break;
366                 case ID_SCE:
367                         scene_changed(bmain, (Scene *)id);
368                         break;
369                 default:
370                         break;
371         }
372 }
373