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