Cycles: svn merge -r41232:41266 ^/trunk/blender
[blender.git] / source / blender / editors / render / render_internal.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  * The Original Code is Copyright (C) 2008 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/render/render_internal.c
26  *  \ingroup edrend
27  */
28
29
30 #include <math.h>
31 #include <string.h>
32 #include <stddef.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_blenlib.h"
37 #include "BLI_math.h"
38 #include "BLI_threads.h"
39 #include "BLI_rand.h"
40 #include "BLI_utildefines.h"
41
42 #include "DNA_scene_types.h"
43
44 #include "BKE_blender.h"
45 #include "BKE_context.h"
46 #include "BKE_global.h"
47 #include "BKE_image.h"
48 #include "BKE_library.h"
49 #include "BKE_main.h"
50 #include "BKE_node.h"
51 #include "BKE_multires.h"
52 #include "BKE_report.h"
53 #include "BKE_sequencer.h"
54 #include "BKE_screen.h"
55 #include "BKE_scene.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "ED_screen.h"
61 #include "ED_object.h"
62
63 #include "RE_pipeline.h"
64 #include "IMB_imbuf.h"
65 #include "IMB_imbuf_types.h"
66
67 #include "RNA_access.h"
68 #include "RNA_define.h"
69
70 #include "wm_window.h"
71
72 #include "render_intern.h"
73
74 /* Render Callbacks */
75
76 /* called inside thread! */
77 void image_buffer_rect_update(Scene *scene, RenderResult *rr, ImBuf *ibuf, volatile rcti *renrect)
78 {
79         float x1, y1, *rectf= NULL;
80         int ymin, ymax, xmin, xmax;
81         int rymin, rxmin, do_color_management;
82         char *rectc;
83
84         /* if renrect argument, we only refresh scanlines */
85         if(renrect) {
86                 /* if ymax==recty, rendering of layer is ready, we should not draw, other things happen... */
87                 if(rr->renlay==NULL || renrect->ymax>=rr->recty)
88                         return;
89
90                 /* xmin here is first subrect x coord, xmax defines subrect width */
91                 xmin = renrect->xmin + rr->crop;
92                 xmax = renrect->xmax - xmin + rr->crop;
93                 if(xmax<2)
94                         return;
95
96                 ymin= renrect->ymin + rr->crop;
97                 ymax= renrect->ymax - ymin + rr->crop;
98                 if(ymax<2)
99                         return;
100                 renrect->ymin= renrect->ymax;
101
102         }
103         else {
104                 xmin = ymin = rr->crop;
105                 xmax = rr->rectx - 2*rr->crop;
106                 ymax = rr->recty - 2*rr->crop;
107         }
108
109         /* xmin ymin is in tile coords. transform to ibuf */
110         rxmin= rr->tilerect.xmin + xmin;
111         if(rxmin >= ibuf->x) return;
112         rymin= rr->tilerect.ymin + ymin;
113         if(rymin >= ibuf->y) return;
114
115         if(rxmin + xmax > ibuf->x)
116                 xmax= ibuf->x - rxmin;
117         if(rymin + ymax > ibuf->y)
118                 ymax= ibuf->y - rymin;
119
120         if(xmax < 1 || ymax < 1) return;
121
122         /* find current float rect for display, first case is after composit... still weak */
123         if(rr->rectf)
124                 rectf= rr->rectf;
125         else {
126                 if(rr->rect32)
127                         return;
128                 else {
129                         if(rr->renlay==NULL || rr->renlay->rectf==NULL) return;
130                         rectf= rr->renlay->rectf;
131                 }
132         }
133         if(rectf==NULL) return;
134
135         if(ibuf->rect==NULL)
136                 imb_addrectImBuf(ibuf);
137         
138         rectf+= 4*(rr->rectx*ymin + xmin);
139         rectc= (char *)(ibuf->rect + ibuf->x*rymin + rxmin);
140
141         do_color_management = (scene && (scene->r.color_mgt_flag & R_COLOR_MANAGEMENT));
142         
143         /* XXX make nice consistent functions for this */
144         for(y1= 0; y1<ymax; y1++) {
145                 float *rf= rectf;
146                 float srgb[3];
147                 char *rc= rectc;
148                 const float dither = ibuf->dither / 255.0f;
149
150                 /* XXX temp. because crop offset */
151                 if(rectc >= (char *)(ibuf->rect)) {
152                         for(x1= 0; x1<xmax; x1++, rf += 4, rc+=4) {
153                                 /* color management */
154                                 if(do_color_management) {
155                                         srgb[0]= linearrgb_to_srgb(rf[0]);
156                                         srgb[1]= linearrgb_to_srgb(rf[1]);
157                                         srgb[2]= linearrgb_to_srgb(rf[2]);
158                                 }
159                                 else {
160                                         copy_v3_v3(srgb, rf);
161                                 }
162
163                                 /* dither */
164                                 if(dither != 0.0f) {
165                                         const float d = (BLI_frand()-0.5f)*dither;
166
167                                         srgb[0] += d;
168                                         srgb[1] += d;
169                                         srgb[2] += d;
170                                 }
171
172                                 /* write */
173                                 rc[0]= FTOCHAR(srgb[0]);
174                                 rc[1]= FTOCHAR(srgb[1]);
175                                 rc[2]= FTOCHAR(srgb[2]);
176                                 rc[3]= FTOCHAR(rf[3]);
177                         }
178                 }
179
180                 rectf += 4*rr->rectx;
181                 rectc += 4*ibuf->x;
182         }
183 }
184
185 /* ****************************** render invoking ***************** */
186
187 /* set callbacks, exported to sequence render too.
188  Only call in foreground (UI) renders. */
189
190 /* executes blocking render */
191 static int screen_render_exec(bContext *C, wmOperator *op)
192 {
193         Scene *scene= CTX_data_scene(C);
194         Render *re= RE_NewRender(scene->id.name);
195         Image *ima;
196         View3D *v3d= CTX_wm_view3d(C);
197         Main *mainp= CTX_data_main(C);
198         unsigned int lay= (v3d)? v3d->lay: scene->lay;
199         const short is_animation= RNA_boolean_get(op->ptr, "animation");
200         const short is_write_still= RNA_boolean_get(op->ptr, "write_still");
201         struct Object *camera_override= v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
202
203         if(!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.imtype)) {
204                 BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected");
205                 return OPERATOR_CANCELLED;
206         }
207
208         G.afbreek= 0;
209         RE_test_break_cb(re, NULL, (int (*)(void *)) blender_test_break);
210
211         ima= BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
212         BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
213         BKE_image_backup_render(scene, ima);
214
215         /* cleanup sequencer caches before starting user triggered render.
216            otherwise, invalidated cache entries can make their way into
217            the output rendering. We can't put that into RE_BlenderFrame,
218            since sequence rendering can call that recursively... (peter) */
219         seq_stripelem_cache_cleanup();
220
221         RE_SetReports(re, op->reports);
222
223         if(is_animation)
224                 RE_BlenderAnim(re, mainp, scene, camera_override, lay, scene->r.sfra, scene->r.efra, scene->r.frame_step);
225         else
226                 RE_BlenderFrame(re, mainp, scene, NULL, camera_override, lay, scene->r.cfra, is_write_still);
227
228         RE_SetReports(re, NULL);
229
230         // no redraw needed, we leave state as we entered it
231         ED_update_for_newframe(mainp, scene, CTX_wm_screen(C), 1);
232
233         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_RESULT, scene);
234
235         return OPERATOR_FINISHED;
236 }
237
238 typedef struct RenderJob {
239         Main *main;
240         Scene *scene;
241         Render *re;
242         wmWindow *win;
243         SceneRenderLayer *srl;
244         struct Object *camera_override;
245         int lay;
246         short anim, write_still;
247         Image *image;
248         ImageUser iuser;
249         short *stop;
250         short *do_update;
251         float *progress;
252         ReportList *reports;
253 } RenderJob;
254
255 static void render_freejob(void *rjv)
256 {
257         RenderJob *rj= rjv;
258
259         MEM_freeN(rj);
260 }
261
262 /* str is IMA_MAX_RENDER_TEXT in size */
263 static void make_renderinfo_string(RenderStats *rs, Scene *scene, char *str)
264 {
265         char info_time_str[32]; // used to be extern to header_info.c
266         uintptr_t mem_in_use, mmap_in_use, peak_memory;
267         float megs_used_memory, mmap_used_memory, megs_peak_memory;
268         char *spos= str;
269
270         mem_in_use= MEM_get_memory_in_use();
271         mmap_in_use= MEM_get_mapped_memory_in_use();
272         peak_memory = MEM_get_peak_memory();
273
274         megs_used_memory= (mem_in_use-mmap_in_use)/(1024.0*1024.0);
275         mmap_used_memory= (mmap_in_use)/(1024.0*1024.0);
276         megs_peak_memory = (peak_memory)/(1024.0*1024.0);
277
278         if(scene->lay & 0xFF000000)
279                 spos+= sprintf(spos, "Localview | ");
280         else if(scene->r.scemode & R_SINGLE_LAYER)
281                 spos+= sprintf(spos, "Single Layer | ");
282
283         if(rs->statstr) {
284                 spos+= sprintf(spos, "%s ", rs->statstr);
285         }
286         else {
287                 spos+= sprintf(spos, "Fra:%d  Ve:%d Fa:%d ", (scene->r.cfra), rs->totvert, rs->totface);
288                 if(rs->tothalo) spos+= sprintf(spos, "Ha:%d ", rs->tothalo);
289                 if(rs->totstrand) spos+= sprintf(spos, "St:%d ", rs->totstrand);
290                 spos+= sprintf(spos, "La:%d Mem:%.2fM (%.2fM, peak %.2fM) ", rs->totlamp, megs_used_memory, mmap_used_memory, megs_peak_memory);
291
292                 if(rs->curfield)
293                         spos+= sprintf(spos, "Field %d ", rs->curfield);
294                 if(rs->curblur)
295                         spos+= sprintf(spos, "Blur %d ", rs->curblur);
296         }
297
298         BLI_timestr(rs->lastframetime, info_time_str);
299         spos+= sprintf(spos, "Time:%s ", info_time_str);
300
301         if(rs->curfsa)
302                 spos+= sprintf(spos, "| Full Sample %d ", rs->curfsa);
303         
304         if(rs->infostr && rs->infostr[0])
305                 spos+= sprintf(spos, "| %s ", rs->infostr);
306
307         /* very weak... but 512 characters is quite safe */
308         if(spos >= str+IMA_MAX_RENDER_TEXT)
309                 if (G.f & G_DEBUG)
310                         printf("WARNING! renderwin text beyond limit \n");
311
312 }
313
314 static void image_renderinfo_cb(void *rjv, RenderStats *rs)
315 {
316         RenderJob *rj= rjv;
317         RenderResult *rr;
318
319         rr= RE_AcquireResultRead(rj->re);
320
321         if(rr) {
322                 /* malloc OK here, stats_draw is not in tile threads */
323                 if(rr->text==NULL)
324                         rr->text= MEM_callocN(IMA_MAX_RENDER_TEXT, "rendertext");
325
326                 make_renderinfo_string(rs, rj->scene, rr->text);
327         }
328
329         RE_ReleaseResult(rj->re);
330
331         /* make jobs timer to send notifier */
332         *(rj->do_update)= 1;
333
334 }
335
336 static void render_progress_update(void *rjv, float progress)
337 {
338         RenderJob *rj= rjv;
339         
340         if(rj->progress)
341                 *rj->progress = progress;
342 }
343
344 static void image_rect_update(void *rjv, RenderResult *rr, volatile rcti *renrect)
345 {
346         RenderJob *rj= rjv;
347         Image *ima= rj->image;
348         ImBuf *ibuf;
349         void *lock;
350
351         /* only update if we are displaying the slot being rendered */
352         if(ima->render_slot != ima->last_render_slot)
353                 return;
354
355         ibuf= BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
356         if(ibuf) {
357                 image_buffer_rect_update(rj->scene, rr, ibuf, renrect);
358
359                 /* make jobs timer to send notifier */
360                 *(rj->do_update)= 1;
361         }
362         BKE_image_release_ibuf(ima, lock);
363 }
364
365 static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
366 {
367         RenderJob *rj= rjv;
368
369         rj->stop= stop;
370         rj->do_update= do_update;
371         rj->progress= progress;
372
373         RE_SetReports(rj->re, rj->reports);
374
375         if(rj->anim)
376                 RE_BlenderAnim(rj->re, rj->main, rj->scene, rj->camera_override, rj->lay, rj->scene->r.sfra, rj->scene->r.efra, rj->scene->r.frame_step);
377         else
378                 RE_BlenderFrame(rj->re, rj->main, rj->scene, rj->srl, rj->camera_override, rj->lay, rj->scene->r.cfra, rj->write_still);
379
380         RE_SetReports(rj->re, NULL);
381 }
382
383 static void render_endjob(void *rjv)
384 {
385         RenderJob *rj= rjv;     
386
387         /* this render may be used again by the sequencer without the active 'Render' where the callbacks
388          * would be re-assigned. assign dummy callbacks to avoid referencing freed renderjobs bug [#24508] */
389         RE_InitRenderCB(rj->re);
390
391         if(rj->main != G.main)
392                 free_main(rj->main);
393
394         /* else the frame will not update for the original value */
395         if(!(rj->scene->r.scemode & R_NO_FRAME_UPDATE))
396                 ED_update_for_newframe(G.main, rj->scene, rj->win->screen, 1);
397         
398         /* XXX above function sets all tags in nodes */
399         ntreeCompositClearTags(rj->scene->nodetree);
400         
401         /* potentially set by caller */
402         rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;
403         
404         if(rj->srl) {
405                 nodeUpdateID(rj->scene->nodetree, &rj->scene->id);
406                 WM_main_add_notifier(NC_NODE|NA_EDITED, rj->scene);
407         }
408         
409         /* XXX render stability hack */
410         G.rendering = 0;
411         WM_main_add_notifier(NC_WINDOW, NULL);
412 }
413
414 /* called by render, check job 'stop' value or the global */
415 static int render_breakjob(void *rjv)
416 {
417         RenderJob *rj= rjv;
418
419         if(G.afbreek)
420                 return 1;
421         if(rj->stop && *(rj->stop))
422                 return 1;
423         return 0;
424 }
425
426 /* runs in thread, no cursor setting here works. careful with notifiers too (malloc conflicts) */
427 /* maybe need a way to get job send notifer? */
428 static void render_drawlock(void *UNUSED(rjv), int lock)
429 {
430         BKE_spacedata_draw_locks(lock);
431         
432 }
433
434 /* catch esc */
435 static int screen_render_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
436 {
437         /* no running blender, remove handler and pass through */
438         if(0==WM_jobs_test(CTX_wm_manager(C), CTX_data_scene(C))) {
439                 return OPERATOR_FINISHED|OPERATOR_PASS_THROUGH;
440         }
441
442         /* running render */
443         switch (event->type) {
444                 case ESCKEY:
445                         return OPERATOR_RUNNING_MODAL;
446                         break;
447         }
448         return OPERATOR_PASS_THROUGH;
449 }
450
451 /* using context, starts job */
452 static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
453 {
454         /* new render clears all callbacks */
455         Main *mainp;
456         Scene *scene= CTX_data_scene(C);
457         SceneRenderLayer *srl=NULL;
458         bScreen *screen= CTX_wm_screen(C);
459         View3D *v3d= CTX_wm_view3d(C);
460         Render *re;
461         wmJob *steve;
462         RenderJob *rj;
463         Image *ima;
464         int jobflag;
465         const short is_animation= RNA_boolean_get(op->ptr, "animation");
466         const short is_write_still= RNA_boolean_get(op->ptr, "write_still");
467         struct Object *camera_override= v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
468         
469         /* only one render job at a time */
470         if(WM_jobs_test(CTX_wm_manager(C), scene))
471                 return OPERATOR_CANCELLED;
472
473         if(!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
474                 return OPERATOR_CANCELLED;
475         }
476
477         if(!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.imtype)) {
478                 BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected");
479                 return OPERATOR_CANCELLED;
480         }       
481         
482         /* stop all running jobs, currently previews frustrate Render */
483         WM_jobs_stop_all(CTX_wm_manager(C));
484
485         /* get main */
486         if(G.rt == 101) {
487                 /* thread-safety experiment, copy main from the undo buffer */
488                 mainp= BKE_undo_get_main(&scene);
489         }
490         else
491                 mainp= CTX_data_main(C);
492
493         /* cancel animation playback */
494         if (screen->animtimer)
495                 ED_screen_animation_play(C, 0, 0);
496         
497         /* handle UI stuff */
498         WM_cursor_wait(1);
499
500         /* flush multires changes (for sculpt) */
501         multires_force_render_update(CTX_data_active_object(C));
502
503         /* cleanup sequencer caches before starting user triggered render.
504            otherwise, invalidated cache entries can make their way into
505            the output rendering. We can't put that into RE_BlenderFrame,
506            since sequence rendering can call that recursively... (peter) */
507         seq_stripelem_cache_cleanup();
508
509         /* get editmode results */
510         ED_object_exit_editmode(C, 0);  /* 0 = does not exit editmode */
511
512         // store spare
513         // get view3d layer, local layer, make this nice api call to render
514         // store spare
515
516         /* ensure at least 1 area shows result */
517         render_view_open(C, event->x, event->y);
518
519         jobflag= WM_JOB_EXCL_RENDER|WM_JOB_PRIORITY|WM_JOB_PROGRESS;
520         
521         /* single layer re-render */
522         if(RNA_property_is_set(op->ptr, "layer")) {
523                 SceneRenderLayer *rl;
524                 Scene *scn;
525                 char scene_name[MAX_ID_NAME-2], rl_name[RE_MAXNAME];
526
527                 RNA_string_get(op->ptr, "layer", rl_name);
528                 RNA_string_get(op->ptr, "scene", scene_name);
529
530                 scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);
531                 rl = (SceneRenderLayer *)BLI_findstring(&scene->r.layers, rl_name, offsetof(SceneRenderLayer, name));
532                 
533                 if (scn && rl) {
534                         /* camera switch wont have updated */
535                         scn->r.cfra= scene->r.cfra;
536                         scene_camera_switch_update(scn);
537
538                         scene = scn;
539                         srl = rl;
540                 }
541                 jobflag |= WM_JOB_SUSPEND;
542         }
543
544         /* job custom data */
545         rj= MEM_callocN(sizeof(RenderJob), "render job");
546         rj->main= mainp;
547         rj->scene= scene;
548         rj->win= CTX_wm_window(C);
549         rj->srl = srl;
550         rj->camera_override = camera_override;
551         rj->lay = (v3d)? v3d->lay: scene->lay;
552         rj->anim= is_animation;
553         rj->write_still= is_write_still && !is_animation;
554         rj->iuser.scene= scene;
555         rj->iuser.ok= 1;
556         rj->reports= op->reports;
557
558         /* setup job */
559         steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Render", jobflag);
560         WM_jobs_customdata(steve, rj, render_freejob);
561         WM_jobs_timer(steve, 0.2, NC_SCENE|ND_RENDER_RESULT, 0);
562         WM_jobs_callbacks(steve, render_startjob, NULL, NULL, render_endjob);
563
564         /* get a render result image, and make sure it is empty */
565         ima= BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
566         BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
567         BKE_image_backup_render(rj->scene, ima);
568         rj->image= ima;
569
570         /* setup new render */
571         re= RE_NewRender(scene->id.name);
572         RE_test_break_cb(re, rj, render_breakjob);
573         RE_draw_lock_cb(re, rj, render_drawlock);
574         RE_display_draw_cb(re, rj, image_rect_update);
575         RE_stats_draw_cb(re, rj, image_renderinfo_cb);
576         RE_progress_cb(re, rj, render_progress_update);
577
578         rj->re= re;
579         G.afbreek= 0;
580
581         WM_jobs_start(CTX_wm_manager(C), steve);
582
583         WM_cursor_wait(0);
584         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_RESULT, scene);
585
586         /* we set G.rendering here already instead of only in the job, this ensure
587            main loop or other scene updates are disabled in time, since they may
588            have started before the job thread */
589         G.rendering = 1;
590
591         /* add modal handler for ESC */
592         WM_event_add_modal_handler(C, op);
593
594         return OPERATOR_RUNNING_MODAL;
595 }
596
597 /* contextual render, using current scene, view3d? */
598 void RENDER_OT_render(wmOperatorType *ot)
599 {
600         /* identifiers */
601         ot->name= "Render";
602         ot->description= "Render active scene";
603         ot->idname= "RENDER_OT_render";
604
605         /* api callbacks */
606         ot->invoke= screen_render_invoke;
607         ot->modal= screen_render_modal;
608         ot->exec= screen_render_exec;
609
610         /*ot->poll= ED_operator_screenactive;*/ /* this isnt needed, causes failer in background mode */
611
612         RNA_def_boolean(ot->srna, "animation", 0, "Animation", "Render files from the animation range of this scene");
613         RNA_def_boolean(ot->srna, "write_still", 0, "Write Image", "Save rendered the image to the output path (used only when animation is disabled)");
614         RNA_def_string(ot->srna, "layer", "", RE_MAXNAME, "Render Layer", "Single render layer to re-render");
615         RNA_def_string(ot->srna, "scene", "", MAX_ID_NAME-2, "Scene", "Re-render single layer in this scene");
616 }
617