← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/blender/intrepid-updates

« back to all changes in this revision

Viewing changes to source/blender/render/intern/source/pipeline.c

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2008-08-08 02:45:40 UTC
  • mfrom: (12.1.14 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080808024540-kkjp7ekfivzhuw3l
Tags: 2.46+dfsg-4
http://bugs.debian.org/492280
* Fix python syntax warning in import_dxf.py, which led to nasty output
  in installation/upgrade logs during byte-compilation, using a patch
  provided by the script author (Closes: #492280):
   - debian/patches/45_fix_python_syntax_warning

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/render/intern/source/pipeline.c
40
40
 
41
41
#include "BKE_global.h"
42
42
#include "BKE_image.h"
 
43
#include "BKE_main.h"
43
44
#include "BKE_node.h"
44
45
#include "BKE_object.h"
45
46
#include "BKE_scene.h"
63
64
 
64
65
#include "BSE_sequence.h"  /* <----------------- bad!!! */
65
66
 
 
67
#ifndef DISABLE_YAFRAY
66
68
/* yafray: include for yafray export/render */
67
69
#include "YafRay_Api.h"
68
70
 
 
71
#endif /* disable yafray */
 
72
 
69
73
/* internal */
70
74
#include "render_types.h"
71
75
#include "renderpipeline.h"
74
78
#include "envmap.h"
75
79
#include "initrender.h"
76
80
#include "shadbuf.h"
 
81
#include "pixelblending.h"
77
82
#include "zbuf.h"
78
83
 
79
84
 
111
116
/* hardcopy of current render, used while rendering for speed */
112
117
Render R;
113
118
 
 
119
/* commandline thread override */
 
120
static int commandline_threads= -1;
 
121
 
114
122
/* ********* alloc and free ******** */
115
123
 
116
124
 
134
142
        float megs_used_memory= mem_in_use/(1024.0*1024.0);
135
143
        char str[400], *spos= str;
136
144
        
137
 
        if(rs->convertdone) {
138
 
                
139
 
                spos+= sprintf(spos, "Fra:%d Mem:%.2fM ", G.scene->r.cfra, megs_used_memory);
140
 
                
141
 
                if(rs->curfield)
142
 
                        spos+= sprintf(spos, "Field %d ", rs->curfield);
143
 
                if(rs->curblur)
144
 
                        spos+= sprintf(spos, "Blur %d ", rs->curblur);
145
 
                
146
 
                if(rs->infostr) {
147
 
                        spos+= sprintf(spos, "| %s", rs->infostr);
148
 
                }
149
 
                else {
150
 
                        if(rs->tothalo)
151
 
                                spos+= sprintf(spos, "Sce: %s Ve:%d Fa:%d Ha:%d La:%d", G.scene->id.name+2, rs->totvert, rs->totface, rs->tothalo, rs->totlamp);
152
 
                        else 
153
 
                                spos+= sprintf(spos, "Sce: %s Ve:%d Fa:%d La:%d", G.scene->id.name+2, rs->totvert, rs->totface, rs->totlamp);
154
 
                }
155
 
                printf(str); printf("\n");
156
 
        }       
 
145
        spos+= sprintf(spos, "Fra:%d Mem:%.2fM ", G.scene->r.cfra, megs_used_memory);
 
146
        
 
147
        if(rs->curfield)
 
148
                spos+= sprintf(spos, "Field %d ", rs->curfield);
 
149
        if(rs->curblur)
 
150
                spos+= sprintf(spos, "Blur %d ", rs->curblur);
 
151
        
 
152
        if(rs->infostr) {
 
153
                spos+= sprintf(spos, "| %s", rs->infostr);
 
154
        }
 
155
        else {
 
156
                if(rs->tothalo)
 
157
                        spos+= sprintf(spos, "Sce: %s Ve:%d Fa:%d Ha:%d La:%d", G.scene->id.name+2, rs->totvert, rs->totface, rs->tothalo, rs->totlamp);
 
158
                else 
 
159
                        spos+= sprintf(spos, "Sce: %s Ve:%d Fa:%d La:%d", G.scene->id.name+2, rs->totvert, rs->totface, rs->totlamp);
 
160
        }
 
161
        printf(str); printf("\n");
157
162
}
158
163
 
159
 
static void free_render_result(RenderResult *res)
 
164
void RE_FreeRenderResult(RenderResult *res)
160
165
{
161
166
        if(res==NULL) return;
162
167
 
163
168
        while(res->layers.first) {
164
169
                RenderLayer *rl= res->layers.first;
165
170
                
166
 
                if(rl->rectf) MEM_freeT(rl->rectf);
167
 
                /* acolrect is optionally allocated in shade_tile, only free here since it can be used for drawing */
168
 
                if(rl->acolrect) MEM_freeT(rl->acolrect);
 
171
                if(rl->rectf) MEM_freeN(rl->rectf);
 
172
                /* acolrect and scolrect are optionally allocated in shade_tile, only free here since it can be used for drawing */
 
173
                if(rl->acolrect) MEM_freeN(rl->acolrect);
 
174
                if(rl->scolrect) MEM_freeN(rl->scolrect);
169
175
                
170
176
                while(rl->passes.first) {
171
177
                        RenderPass *rpass= rl->passes.first;
172
 
                        if(rpass->rect) MEM_freeT(rpass->rect);
 
178
                        if(rpass->rect) MEM_freeN(rpass->rect);
173
179
                        BLI_remlink(&rl->passes, rpass);
174
 
                        MEM_freeT(rpass);
 
180
                        MEM_freeN(rpass);
175
181
                }
176
182
                BLI_remlink(&res->layers, rl);
177
 
                MEM_freeT(rl);
 
183
                MEM_freeN(rl);
178
184
        }
179
185
        
180
186
        if(res->rect32)
181
 
                MEM_freeT(res->rect32);
 
187
                MEM_freeN(res->rect32);
182
188
        if(res->rectz)
183
 
                MEM_freeT(res->rectz);
 
189
                MEM_freeN(res->rectz);
184
190
        if(res->rectf)
185
 
                MEM_freeT(res->rectf);
186
 
        
187
 
        MEM_freeT(res);
188
 
}
 
191
                MEM_freeN(res->rectf);
 
192
        
 
193
        MEM_freeN(res);
 
194
}
 
195
 
 
196
/* version that's compatible with fullsample buffers */
 
197
static void free_render_result(ListBase *lb, RenderResult *rr)
 
198
{
 
199
        RenderResult *rrnext;
 
200
        
 
201
        for(; rr; rr= rrnext) {
 
202
                rrnext= rr->next;
 
203
                
 
204
                if(lb && lb->first)
 
205
                        BLI_remlink(lb, rr);
 
206
                
 
207
                RE_FreeRenderResult(rr);
 
208
        }
 
209
}
 
210
 
189
211
 
190
212
/* all layers except the active one get temporally pushed away */
191
213
static void push_render_result(Render *re)
192
214
{
193
215
        /* officially pushed result should be NULL... error can happen with do_seq */
194
 
        free_render_result(re->pushedresult);
 
216
        RE_FreeRenderResult(re->pushedresult);
195
217
        
196
218
        re->pushedresult= re->result;
197
219
        re->result= NULL;
230
252
                        }
231
253
                }
232
254
                
233
 
                free_render_result(re->pushedresult);
 
255
                RE_FreeRenderResult(re->pushedresult);
234
256
                re->pushedresult= NULL;
235
257
        }
236
258
}
237
259
 
238
 
 
 
260
/* NOTE: OpenEXR only supports 32 chars for layer+pass names
 
261
   In blender we now use max 10 chars for pass, max 20 for layer */
239
262
static char *get_pass_name(int passtype, int channel)
240
263
{
241
264
        
242
265
        if(passtype == SCE_PASS_COMBINED) {
 
266
                if(channel==-1) return "Combined";
243
267
                if(channel==0) return "Combined.R";
244
 
                else if(channel==1) return "Combined.G";
245
 
                else if(channel==2) return "Combined.B";
246
 
                else return "Combined.A";
247
 
        }
248
 
        if(passtype == SCE_PASS_Z)
249
 
                return "Z";
 
268
                if(channel==1) return "Combined.G";
 
269
                if(channel==2) return "Combined.B";
 
270
                return "Combined.A";
 
271
        }
 
272
        if(passtype == SCE_PASS_Z) {
 
273
                if(channel==-1) return "Depth";
 
274
                return "Depth.Z";
 
275
        }
250
276
        if(passtype == SCE_PASS_VECTOR) {
 
277
                if(channel==-1) return "Vector";
251
278
                if(channel==0) return "Vector.X";
252
 
                else if(channel==1) return "Vector.Y";
253
 
                else if(channel==2) return "Vector.Z";
254
 
                else return "Vector.W";
 
279
                if(channel==1) return "Vector.Y";
 
280
                if(channel==2) return "Vector.Z";
 
281
                return "Vector.W";
255
282
        }
256
283
        if(passtype == SCE_PASS_NORMAL) {
 
284
                if(channel==-1) return "Normal";
257
285
                if(channel==0) return "Normal.X";
258
 
                else if(channel==1) return "Normal.Y";
259
 
                else return "Normal.Z";
 
286
                if(channel==1) return "Normal.Y";
 
287
                return "Normal.Z";
 
288
        }
 
289
        if(passtype == SCE_PASS_UV) {
 
290
                if(channel==-1) return "UV";
 
291
                if(channel==0) return "UV.U";
 
292
                if(channel==1) return "UV.V";
 
293
                return "UV.A";
260
294
        }
261
295
        if(passtype == SCE_PASS_RGBA) {
 
296
                if(channel==-1) return "Color";
262
297
                if(channel==0) return "Color.R";
263
 
                else if(channel==1) return "Color.G";
264
 
                else if(channel==2) return "Color.B";
265
 
                else return "Color.A";
 
298
                if(channel==1) return "Color.G";
 
299
                if(channel==2) return "Color.B";
 
300
                return "Color.A";
266
301
        }
267
302
        if(passtype == SCE_PASS_DIFFUSE) {
 
303
                if(channel==-1) return "Diffuse";
268
304
                if(channel==0) return "Diffuse.R";
269
 
                else if(channel==1) return "Diffuse.G";
270
 
                else return "Diffuse.B";
 
305
                if(channel==1) return "Diffuse.G";
 
306
                return "Diffuse.B";
271
307
        }
272
308
        if(passtype == SCE_PASS_SPEC) {
 
309
                if(channel==-1) return "Spec";
273
310
                if(channel==0) return "Spec.R";
274
 
                else if(channel==1) return "Spec.G";
275
 
                else return "Spec.B";
 
311
                if(channel==1) return "Spec.G";
 
312
                return "Spec.B";
276
313
        }
277
314
        if(passtype == SCE_PASS_SHADOW) {
 
315
                if(channel==-1) return "Shadow";
278
316
                if(channel==0) return "Shadow.R";
279
 
                else if(channel==1) return "Shadow.G";
280
 
                else return "Shadow.B";
 
317
                if(channel==1) return "Shadow.G";
 
318
                return "Shadow.B";
281
319
        }
282
320
        if(passtype == SCE_PASS_AO) {
 
321
                if(channel==-1) return "AO";
283
322
                if(channel==0) return "AO.R";
284
 
                else if(channel==1) return "AO.G";
285
 
                else return "AO.B";
286
 
        }
287
 
        if(passtype == SCE_PASS_RAY) {
288
 
                if(channel==0) return "Ray.R";
289
 
                else if(channel==1) return "Ray.G";
290
 
                else return "Ray.B";
 
323
                if(channel==1) return "AO.G";
 
324
                return "AO.B";
 
325
        }
 
326
        if(passtype == SCE_PASS_REFLECT) {
 
327
                if(channel==-1) return "Reflect";
 
328
                if(channel==0) return "Reflect.R";
 
329
                if(channel==1) return "Reflect.G";
 
330
                return "Reflect.B";
 
331
        }
 
332
        if(passtype == SCE_PASS_REFRACT) {
 
333
                if(channel==-1) return "Refract";
 
334
                if(channel==0) return "Refract.R";
 
335
                if(channel==1) return "Refract.G";
 
336
                return "Refract.B";
 
337
        }
 
338
        if(passtype == SCE_PASS_RADIO) {
 
339
                if(channel==-1) return "Radio";
 
340
                if(channel==0) return "Radio.R";
 
341
                if(channel==1) return "Radio.G";
 
342
                return "Radio.B";
 
343
        }
 
344
        if(passtype == SCE_PASS_INDEXOB) {
 
345
                if(channel==-1) return "IndexOB";
 
346
                return "IndexOB.X";
 
347
        }
 
348
        if(passtype == SCE_PASS_MIST) {
 
349
                if(channel==-1) return "Mist";
 
350
                return "Mist.Z";
291
351
        }
292
352
        return "Unknown";
293
353
}
294
354
 
295
 
static void render_unique_exr_name(Render *re, char *str)
296
 
{
297
 
        char di[FILE_MAXDIR+FILE_MAXFILE], name[FILE_MAXFILE], fi[FILE_MAXFILE];
298
 
        
299
 
        BLI_strncpy(di, G.sce, FILE_MAXDIR+FILE_MAXFILE);
 
355
static int passtype_from_name(char *str)
 
356
{
 
357
        
 
358
        if(strcmp(str, "Combined")==0)
 
359
                return SCE_PASS_COMBINED;
 
360
 
 
361
        if(strcmp(str, "Depth")==0)
 
362
                return SCE_PASS_Z;
 
363
 
 
364
        if(strcmp(str, "Vector")==0)
 
365
                return SCE_PASS_VECTOR;
 
366
 
 
367
        if(strcmp(str, "Normal")==0)
 
368
                return SCE_PASS_NORMAL;
 
369
 
 
370
        if(strcmp(str, "UV")==0)
 
371
                return SCE_PASS_UV;
 
372
 
 
373
        if(strcmp(str, "Color")==0)
 
374
                return SCE_PASS_RGBA;
 
375
 
 
376
        if(strcmp(str, "Diffuse")==0)
 
377
                return SCE_PASS_DIFFUSE;
 
378
 
 
379
        if(strcmp(str, "Spec")==0)
 
380
                return SCE_PASS_SPEC;
 
381
 
 
382
        if(strcmp(str, "Shadow")==0)
 
383
                return SCE_PASS_SHADOW;
 
384
        
 
385
        if(strcmp(str, "AO")==0)
 
386
                return SCE_PASS_AO;
 
387
 
 
388
        if(strcmp(str, "Reflect")==0)
 
389
                return SCE_PASS_REFLECT;
 
390
 
 
391
        if(strcmp(str, "Refract")==0)
 
392
                return SCE_PASS_REFRACT;
 
393
 
 
394
        if(strcmp(str, "Radio")==0)
 
395
                return SCE_PASS_RADIO;
 
396
 
 
397
        if(strcmp(str, "IndexOB")==0)
 
398
                return SCE_PASS_INDEXOB;
 
399
 
 
400
        if(strcmp(str, "Mist")==0)
 
401
                return SCE_PASS_MIST;
 
402
        
 
403
        return 0;
 
404
}
 
405
 
 
406
static void render_unique_exr_name(Render *re, char *str, int sample)
 
407
{
 
408
        char di[FILE_MAX], name[FILE_MAXFILE], fi[FILE_MAXFILE];
 
409
        
 
410
        BLI_strncpy(di, G.sce, FILE_MAX);
300
411
        BLI_splitdirstring(di, fi);
301
 
        sprintf(name, "%s_%s.exr", fi, re->scene->id.name+2);
302
 
        if(G.background)
303
 
                BLI_make_file_string("/", str, "/tmp/", name);
 
412
        
 
413
        if(sample==0)
 
414
                sprintf(name, "%s_%s.exr", fi, re->scene->id.name+2);
304
415
        else
305
 
                BLI_make_file_string("/", str, U.tempdir, name);
306
 
                
 
416
                sprintf(name, "%s_%s%d.exr", fi, re->scene->id.name+2, sample);
 
417
 
 
418
        BLI_make_file_string("/", str, btempdir, name);
307
419
}
308
420
 
309
421
static void render_layer_add_pass(RenderResult *rr, RenderLayer *rl, int channels, int passtype)
310
422
{
311
423
        char *typestr= get_pass_name(passtype, 0);
312
 
        RenderPass *rpass= MEM_callocT(sizeof(RenderPass), typestr);
 
424
        RenderPass *rpass= MEM_callocN(sizeof(RenderPass), typestr);
313
425
        int rectsize= rr->rectx*rr->recty*channels;
314
426
        
315
427
        BLI_addtail(&rl->passes, rpass);
319
431
        if(rr->exrhandle) {
320
432
                int a;
321
433
                for(a=0; a<channels; a++)
322
 
                        IMB_exr_add_channel(rr->exrhandle, rl->name, get_pass_name(passtype, a));
 
434
                        IMB_exr_add_channel(rr->exrhandle, rl->name, get_pass_name(passtype, a), 0, 0, NULL);
323
435
        }
324
436
        else {
 
437
                float *rect;
 
438
                int x;
 
439
                
 
440
                rpass->rect= MEM_mapallocN(sizeof(float)*rectsize, typestr);
 
441
                
325
442
                if(passtype==SCE_PASS_VECTOR) {
326
 
                        float *rect;
327
 
                        int x;
328
 
                        
329
443
                        /* initialize to max speed */
330
 
                        rect= rpass->rect= MEM_mapallocT(sizeof(float)*rectsize, typestr);
 
444
                        rect= rpass->rect;
331
445
                        for(x= rectsize-1; x>=0; x--)
332
446
                                rect[x]= PASS_VECTOR_MAX;
333
447
                }
334
 
                else
335
 
                        rpass->rect= MEM_mapallocT(sizeof(float)*rectsize, typestr);
 
448
                else if(passtype==SCE_PASS_Z) {
 
449
                        rect= rpass->rect;
 
450
                        for(x= rectsize-1; x>=0; x--)
 
451
                                rect[x]= 10e10;
 
452
                }
336
453
        }
337
454
}
338
455
 
376
493
        if(rectx<=0 || recty<=0)
377
494
                return NULL;
378
495
        
379
 
        rr= MEM_callocT(sizeof(RenderResult), "new render result");
 
496
        rr= MEM_callocN(sizeof(RenderResult), "new render result");
380
497
        rr->rectx= rectx;
381
498
        rr->recty= recty;
382
499
        rr->renrect.xmin= 0; rr->renrect.xmax= rectx-2*crop;
398
515
                
399
516
                if((re->r.scemode & R_SINGLE_LAYER) && nr!=re->r.actlay)
400
517
                        continue;
 
518
                if(srl->layflag & SCE_LAY_DISABLE)
 
519
                        continue;
401
520
                
402
 
                rl= MEM_callocT(sizeof(RenderLayer), "new render layer");
 
521
                rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
403
522
                BLI_addtail(&rr->layers, rl);
404
523
                
405
524
                strcpy(rl->name, srl->name);
406
525
                rl->lay= srl->lay;
 
526
                rl->lay_zmask= srl->lay_zmask;
407
527
                rl->layflag= srl->layflag;
408
528
                rl->passflag= srl->passflag;
 
529
                rl->pass_xor= srl->pass_xor;
 
530
                rl->light_override= srl->light_override;
 
531
                rl->mat_override= srl->mat_override;
409
532
                
410
533
                if(rr->exrhandle) {
411
 
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.R");
412
 
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.G");
413
 
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.B");
414
 
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.A");
 
534
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.R", 0, 0, NULL);
 
535
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.G", 0, 0, NULL);
 
536
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.B", 0, 0, NULL);
 
537
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.A", 0, 0, NULL);
415
538
                }
416
539
                else
417
 
                        rl->rectf= MEM_mapallocT(rectx*recty*sizeof(float)*4, "Combined rgba");
 
540
                        rl->rectf= MEM_mapallocN(rectx*recty*sizeof(float)*4, "Combined rgba");
418
541
                
419
542
                if(srl->passflag  & SCE_PASS_Z)
420
543
                        render_layer_add_pass(rr, rl, 1, SCE_PASS_Z);
422
545
                        render_layer_add_pass(rr, rl, 4, SCE_PASS_VECTOR);
423
546
                if(srl->passflag  & SCE_PASS_NORMAL)
424
547
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_NORMAL);
 
548
                if(srl->passflag  & SCE_PASS_UV) 
 
549
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_UV);
425
550
                if(srl->passflag  & SCE_PASS_RGBA)
426
551
                        render_layer_add_pass(rr, rl, 4, SCE_PASS_RGBA);
427
552
                if(srl->passflag  & SCE_PASS_DIFFUSE)
428
553
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_DIFFUSE);
429
554
                if(srl->passflag  & SCE_PASS_SPEC)
430
555
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_SPEC);
 
556
                if(srl->passflag  & SCE_PASS_AO)
 
557
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_AO);
431
558
                if(srl->passflag  & SCE_PASS_SHADOW)
432
559
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_SHADOW);
433
 
                if(srl->passflag  & SCE_PASS_AO)
434
 
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_AO);
435
 
                if(srl->passflag  & SCE_PASS_RAY)
436
 
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_RAY);
 
560
                if(srl->passflag  & SCE_PASS_REFLECT)
 
561
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_REFLECT);
 
562
                if(srl->passflag  & SCE_PASS_REFRACT)
 
563
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_REFRACT);
 
564
                if(srl->passflag  & SCE_PASS_RADIO)
 
565
                        render_layer_add_pass(rr, rl, 3, SCE_PASS_RADIO);
 
566
                if(srl->passflag  & SCE_PASS_INDEXOB)
 
567
                        render_layer_add_pass(rr, rl, 1, SCE_PASS_INDEXOB);
 
568
                if(srl->passflag  & SCE_PASS_MIST)
 
569
                        render_layer_add_pass(rr, rl, 1, SCE_PASS_MIST);
437
570
                
438
571
        }
439
 
        /* previewrender and envmap don't do layers, so we make a default one */
 
572
        /* sss, previewrender and envmap don't do layers, so we make a default one */
440
573
        if(rr->layers.first==NULL) {
441
 
                rl= MEM_callocT(sizeof(RenderLayer), "new render layer");
 
574
                rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
442
575
                BLI_addtail(&rr->layers, rl);
443
576
                
444
 
                rl->rectf= MEM_mapallocT(rectx*recty*sizeof(float)*4, "prev/env float rgba");
 
577
                /* duplicate code... */
 
578
                if(rr->exrhandle) {
 
579
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.R", 0, 0, NULL);
 
580
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.G", 0, 0, NULL);
 
581
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.B", 0, 0, NULL);
 
582
                        IMB_exr_add_channel(rr->exrhandle, rl->name, "Combined.A", 0, 0, NULL);
 
583
                }
 
584
                else
 
585
                        rl->rectf= MEM_mapallocN(rectx*recty*sizeof(float)*4, "Combined rgba");
445
586
                
446
587
                /* note, this has to be in sync with scene.c */
447
588
                rl->lay= (1<<20) -1;
460
601
 
461
602
static int render_scene_needs_vector(Render *re)
462
603
{
463
 
        if(re->r.scemode & R_DOCOMP) {
464
 
                SceneRenderLayer *srl;
 
604
        SceneRenderLayer *srl;
465
605
        
466
 
                for(srl= re->scene->r.layers.first; srl; srl= srl->next)
 
606
        for(srl= re->scene->r.layers.first; srl; srl= srl->next)
 
607
                if(!(srl->layflag & SCE_LAY_DISABLE))
467
608
                        if(srl->passflag & SCE_PASS_VECTOR)
468
609
                                return 1;
469
 
        }
 
610
 
470
611
        return 0;
471
612
}
472
613
 
524
665
}
525
666
 
526
667
 
527
 
static void save_render_result_tile(Render *re, RenderPart *pa)
 
668
static void save_render_result_tile(RenderResult *rr, RenderResult *rrpart)
528
669
{
529
 
        RenderResult *rrpart= pa->result;
530
670
        RenderLayer *rlp;
531
671
        RenderPass *rpassp;
532
672
        int offs, partx, party;
533
673
        
534
 
        BLI_lock_thread(LOCK_CUSTOM1);
 
674
        BLI_lock_thread(LOCK_IMAGE);
535
675
        
536
676
        for(rlp= rrpart->layers.first; rlp; rlp= rlp->next) {
537
677
                
546
686
                if(rlp->rectf) {
547
687
                        int a, xstride= 4;
548
688
                        for(a=0; a<xstride; a++)
549
 
                                IMB_exr_set_channel(re->result->exrhandle, rlp->name, get_pass_name(SCE_PASS_COMBINED, a), 
550
 
                                                                xstride, xstride*pa->rectx, rlp->rectf+a + xstride*offs);
 
689
                                IMB_exr_set_channel(rr->exrhandle, rlp->name, get_pass_name(SCE_PASS_COMBINED, a), 
 
690
                                                                xstride, xstride*rrpart->rectx, rlp->rectf+a + xstride*offs);
551
691
                }
552
692
                
553
693
                /* passes are allocated in sync */
554
694
                for(rpassp= rlp->passes.first; rpassp; rpassp= rpassp->next) {
555
695
                        int a, xstride= rpassp->channels;
556
696
                        for(a=0; a<xstride; a++)
557
 
                                IMB_exr_set_channel(re->result->exrhandle, rlp->name, get_pass_name(rpassp->passtype, a), 
558
 
                                                                        xstride, xstride*pa->rectx, rpassp->rect+a + xstride*offs);
 
697
                                IMB_exr_set_channel(rr->exrhandle, rlp->name, get_pass_name(rpassp->passtype, a), 
 
698
                                                                        xstride, xstride*rrpart->rectx, rpassp->rect+a + xstride*offs);
559
699
                }
560
700
                
561
701
        }
562
702
 
563
703
        party= rrpart->tilerect.ymin + rrpart->crop;
564
704
        partx= rrpart->tilerect.xmin + rrpart->crop;
565
 
        IMB_exrtile_write_channels(re->result->exrhandle, partx, party);
566
 
 
567
 
        BLI_unlock_thread(LOCK_CUSTOM1);
568
 
 
569
 
}
570
 
 
571
 
static void read_render_result(Render *re)
 
705
        IMB_exrtile_write_channels(rr->exrhandle, partx, party, 0);
 
706
 
 
707
        BLI_unlock_thread(LOCK_IMAGE);
 
708
 
 
709
}
 
710
 
 
711
static void save_empty_result_tiles(Render *re)
 
712
{
 
713
        RenderPart *pa;
 
714
        RenderResult *rr;
 
715
        
 
716
        for(rr= re->result; rr; rr= rr->next) {
 
717
                IMB_exrtile_clear_channels(rr->exrhandle);
 
718
                
 
719
                for(pa= re->parts.first; pa; pa= pa->next) {
 
720
                        if(pa->ready==0) {
 
721
                                int party= pa->disprect.ymin - re->disprect.ymin + pa->crop;
 
722
                                int partx= pa->disprect.xmin - re->disprect.xmin + pa->crop;
 
723
                                IMB_exrtile_write_channels(rr->exrhandle, partx, party, 0);
 
724
                        }
 
725
                }
 
726
        }
 
727
}
 
728
 
 
729
 
 
730
/* for passes read from files, these have names stored */
 
731
static char *make_pass_name(RenderPass *rpass, int chan)
 
732
{
 
733
        static char name[16];
 
734
        int len;
 
735
        
 
736
        BLI_strncpy(name, rpass->name, EXR_PASS_MAXNAME);
 
737
        len= strlen(name);
 
738
        name[len]= '.';
 
739
        name[len+1]= rpass->chan_id[chan];
 
740
        name[len+2]= 0;
 
741
 
 
742
        return name;
 
743
}
 
744
 
 
745
/* filename already made absolute */
 
746
/* called from within UI, saves both rendered result as a file-read result */
 
747
void RE_WriteRenderResult(RenderResult *rr, char *filename, int compress)
 
748
{
 
749
        RenderLayer *rl;
 
750
        RenderPass *rpass;
 
751
        void *exrhandle= IMB_exr_get_handle();
 
752
 
 
753
        BLI_make_existing_file(filename);
 
754
        
 
755
        /* composite result */
 
756
        if(rr->rectf) {
 
757
                IMB_exr_add_channel(exrhandle, "Composite", "Combined.R", 4, 4*rr->rectx, rr->rectf);
 
758
                IMB_exr_add_channel(exrhandle, "Composite", "Combined.G", 4, 4*rr->rectx, rr->rectf+1);
 
759
                IMB_exr_add_channel(exrhandle, "Composite", "Combined.B", 4, 4*rr->rectx, rr->rectf+2);
 
760
                IMB_exr_add_channel(exrhandle, "Composite", "Combined.A", 4, 4*rr->rectx, rr->rectf+3);
 
761
        }
 
762
        
 
763
        /* add layers/passes and assign channels */
 
764
        for(rl= rr->layers.first; rl; rl= rl->next) {
 
765
                
 
766
                /* combined */
 
767
                if(rl->rectf) {
 
768
                        int a, xstride= 4;
 
769
                        for(a=0; a<xstride; a++)
 
770
                                IMB_exr_add_channel(exrhandle, rl->name, get_pass_name(SCE_PASS_COMBINED, a), 
 
771
                                                                        xstride, xstride*rr->rectx, rl->rectf+a);
 
772
                }
 
773
                
 
774
                /* passes are allocated in sync */
 
775
                for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
 
776
                        int a, xstride= rpass->channels;
 
777
                        for(a=0; a<xstride; a++) {
 
778
                                if(rpass->passtype)
 
779
                                        IMB_exr_add_channel(exrhandle, rl->name, get_pass_name(rpass->passtype, a), 
 
780
                                                                                xstride, xstride*rr->rectx, rpass->rect+a);
 
781
                                else
 
782
                                        IMB_exr_add_channel(exrhandle, rl->name, make_pass_name(rpass, a), 
 
783
                                                                                xstride, xstride*rr->rectx, rpass->rect+a);
 
784
                        }
 
785
                }
 
786
        }
 
787
        
 
788
        IMB_exr_begin_write(exrhandle, filename, rr->rectx, rr->recty, compress);
 
789
        
 
790
        IMB_exr_write_channels(exrhandle);
 
791
        IMB_exr_close(exrhandle);
 
792
}
 
793
 
 
794
/* callbacks for RE_MultilayerConvert */
 
795
static void *ml_addlayer_cb(void *base, char *str)
 
796
{
 
797
        RenderResult *rr= base;
 
798
        RenderLayer *rl;
 
799
        
 
800
        rl= MEM_callocN(sizeof(RenderLayer), "new render layer");
 
801
        BLI_addtail(&rr->layers, rl);
 
802
        
 
803
        BLI_strncpy(rl->name, str, EXR_LAY_MAXNAME);
 
804
        return rl;
 
805
}
 
806
static void ml_addpass_cb(void *base, void *lay, char *str, float *rect, int totchan, char *chan_id)
 
807
{
 
808
        RenderLayer *rl= lay;   
 
809
        RenderPass *rpass= MEM_callocN(sizeof(RenderPass), "loaded pass");
 
810
        int a;
 
811
        
 
812
        BLI_addtail(&rl->passes, rpass);
 
813
        rpass->channels= totchan;
 
814
        
 
815
        rpass->passtype= passtype_from_name(str);
 
816
        if(rpass->passtype==0) printf("unknown pass %s\n", str);
 
817
        rl->passflag |= rpass->passtype;
 
818
        
 
819
        BLI_strncpy(rpass->name, str, EXR_PASS_MAXNAME);
 
820
        /* channel id chars */
 
821
        for(a=0; a<totchan; a++)
 
822
                rpass->chan_id[a]= chan_id[a];
 
823
        
 
824
        rpass->rect= rect;
 
825
}
 
826
 
 
827
/* from imbuf, if a handle was returned we convert this to render result */
 
828
RenderResult *RE_MultilayerConvert(void *exrhandle, int rectx, int recty)
 
829
{
 
830
        RenderResult *rr= MEM_callocN(sizeof(RenderResult), "loaded render result");
 
831
        
 
832
        rr->rectx= rectx;
 
833
        rr->recty= recty;
 
834
        
 
835
        IMB_exr_multilayer_convert(exrhandle, rr, ml_addlayer_cb, ml_addpass_cb);
 
836
        
 
837
        return rr;
 
838
}
 
839
 
 
840
/* called in end of render, to add names to passes... for UI only */
 
841
static void renderresult_add_names(RenderResult *rr)
 
842
{
 
843
        RenderLayer *rl;
 
844
        RenderPass *rpass;
 
845
        
 
846
        for(rl= rr->layers.first; rl; rl= rl->next)
 
847
                for(rpass= rl->passes.first; rpass; rpass= rpass->next)
 
848
                        strcpy(rpass->name, get_pass_name(rpass->passtype, -1));
 
849
}
 
850
 
 
851
 
 
852
/* only for temp buffer files, makes exact copy of render result */
 
853
static void read_render_result(Render *re, int sample)
572
854
{
573
855
        RenderLayer *rl;
574
856
        RenderPass *rpass;
575
857
        void *exrhandle= IMB_exr_get_handle();
576
858
        int rectx, recty;
577
 
        char str[FILE_MAXDIR+FILE_MAXFILE];
 
859
        char str[FILE_MAX];
578
860
        
579
 
        free_render_result(re->result);
 
861
        RE_FreeRenderResult(re->result);
580
862
        re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
581
863
 
582
 
        render_unique_exr_name(re, str);
 
864
        render_unique_exr_name(re, str, sample);
583
865
        if(IMB_exr_begin_read(exrhandle, str, &rectx, &recty)==0) {
584
 
                printf("cannot read render result\n");
 
866
                IMB_exr_close(exrhandle);
 
867
                printf("cannot read: %s\n", str);
585
868
                return;
586
869
        }
587
870
        
588
 
        if(rectx!=re->result->rectx || recty!=re->result->recty) {
 
871
        printf("read exr tmp file: %s\n", str);
 
872
        
 
873
        if(re->result == NULL || rectx!=re->result->rectx || recty!=re->result->recty) {
589
874
                printf("error in reading render result\n");
590
875
        }
591
876
        else {
609
894
                        
610
895
                }
611
896
                IMB_exr_read_channels(exrhandle);
 
897
                renderresult_add_names(re->result);
612
898
        }
613
899
        
614
900
        IMB_exr_close(exrhandle);
716
1002
        if(re==NULL) {
717
1003
                
718
1004
                /* new render data struct */
719
 
                re= MEM_callocT(sizeof(Render), "new render");
 
1005
                re= MEM_callocN(sizeof(Render), "new render");
720
1006
                BLI_addtail(&RenderList, re);
721
1007
                strncpy(re->name, name, RE_MAXNAME);
722
1008
        }
747
1033
        free_renderdata_tables(re);
748
1034
        free_sample_tables(re);
749
1035
        
750
 
        free_render_result(re->result);
751
 
        free_render_result(re->pushedresult);
 
1036
        RE_FreeRenderResult(re->result);
 
1037
        RE_FreeRenderResult(re->pushedresult);
752
1038
        
753
1039
        BLI_remlink(&RenderList, re);
754
 
        MEM_freeT(re);
 
1040
        MEM_freeN(re);
755
1041
}
756
1042
 
757
1043
/* exit blender */
767
1053
 
768
1054
/* what doesn't change during entire render sequence */
769
1055
/* disprect is optional, if NULL it assumes full window render */
770
 
void RE_InitState(Render *re, RenderData *rd, int winx, int winy, rcti *disprect)
 
1056
void RE_InitState(Render *re, Render *source, RenderData *rd, int winx, int winy, rcti *disprect)
771
1057
{
772
1058
        re->ok= TRUE;   /* maybe flag */
773
1059
        
789
1075
                re->recty= winy;
790
1076
        }
791
1077
        
792
 
        if(re->rectx < 2 || re->recty < 2) {
 
1078
        if(re->rectx < 2 || re->recty < 2 || (BKE_imtype_is_movie(rd->imtype) &&
 
1079
                                                                                  (re->rectx < 16 || re->recty < 16) )) {
793
1080
                re->error("Image too small");
794
1081
                re->ok= 0;
795
1082
        }
796
1083
        else {
797
 
                /* check state variables, osa? */
798
 
                if(re->r.mode & (R_OSA)) {
799
 
                        re->osa= re->r.osa;
800
 
                        if(re->osa>16) re->osa= 16;
801
 
                }
802
 
                else re->osa= 0;
803
 
                
 
1084
#ifndef WITH_OPENEXR
 
1085
                /* can't do this without openexr support */
 
1086
                re->r.scemode &= ~R_EXR_TILE_FILE;
 
1087
#endif
 
1088
                
 
1089
                if(!(re->r.scemode & R_EXR_TILE_FILE))
 
1090
                        re->r.scemode &= ~R_FULL_SAMPLE;        /* clear, so we can use this flag for test both */
 
1091
                
 
1092
                /* fullsample wants uniform osa levels */
 
1093
                if(source && (re->r.scemode & R_FULL_SAMPLE)) {
 
1094
                        /* but, if source has no full sample we disable it */
 
1095
                        if((source->r.scemode & R_FULL_SAMPLE)==0)
 
1096
                                re->r.scemode &= ~R_FULL_SAMPLE;
 
1097
                        else
 
1098
                                re->r.osa= re->osa= source->osa;
 
1099
                }
 
1100
                else {
 
1101
                        /* check state variables, osa? */
 
1102
                        if(re->r.mode & (R_OSA)) {
 
1103
                                re->osa= re->r.osa;
 
1104
                                if(re->osa>16) re->osa= 16;
 
1105
                        }
 
1106
                        else re->osa= 0;
 
1107
                }
 
1108
 
804
1109
                /* always call, checks for gamma, gamma tables and jitter too */
805
1110
                make_sample_tables(re); 
806
1111
                
807
1112
                /* make empty render result, so display callbacks can initialize */
808
 
                free_render_result(re->result);
 
1113
                RE_FreeRenderResult(re->result);
809
1114
                re->result= MEM_callocN(sizeof(RenderResult), "new render result");
810
1115
                re->result->rectx= re->rectx;
811
1116
                re->result->recty= re->recty;
 
1117
                
 
1118
                /* we clip faces with a minimum of 2 pixel boundary outside of image border. see zbuf.c */
 
1119
                re->clipcrop= 1.0f + 2.0f/(float)(re->winx>re->winy?re->winy:re->winx);
 
1120
                
 
1121
                RE_init_threadcount(re);
812
1122
        }
813
1123
}
814
1124
 
 
1125
/* part of external api, not called for regular render pipeline */
815
1126
void RE_SetDispRect (struct Render *re, rcti *disprect)
816
1127
{
817
1128
        re->disprect= *disprect;
819
1130
        re->recty= disprect->ymax-disprect->ymin;
820
1131
        
821
1132
        /* initialize render result */
822
 
        free_render_result(re->result);
 
1133
        RE_FreeRenderResult(re->result);
823
1134
        re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
824
1135
}
825
1136
 
833
1144
        re->r.mode &= ~R_ORTHO;
834
1145
 
835
1146
        i_window(re->viewplane.xmin, re->viewplane.xmax, re->viewplane.ymin, re->viewplane.ymax, re->clipsta, re->clipend, re->winmat);
 
1147
        
836
1148
}
837
1149
 
838
1150
void RE_SetOrtho(Render *re, rctf *viewplane, float clipsta, float clipend)
902
1214
 
903
1215
/* *************************************** */
904
1216
 
 
1217
static int render_display_draw_enabled(Render *re)
 
1218
{
 
1219
        /* don't show preprocess for previewrender sss */
 
1220
        if(re->sss_points)
 
1221
                return !(re->r.scemode & R_PREVIEWBUTS);
 
1222
        else
 
1223
                return 1;
 
1224
}
 
1225
 
 
1226
/* allocate osa new results for samples */
 
1227
static RenderResult *new_full_sample_buffers(Render *re, ListBase *lb, rcti *partrct, int crop)
 
1228
{
 
1229
        int a;
 
1230
        
 
1231
        if(re->osa==0)
 
1232
                return new_render_result(re, partrct, crop, RR_USEMEM);
 
1233
        
 
1234
        for(a=0; a<re->osa; a++) {
 
1235
                RenderResult *rr= new_render_result(re, partrct, crop, RR_USEMEM);
 
1236
                BLI_addtail(lb, rr);
 
1237
                rr->sample_nr= a;
 
1238
        }
 
1239
        
 
1240
        return lb->first;
 
1241
}
 
1242
 
 
1243
 
 
1244
/* the main thread call, renders an entire part */
905
1245
static void *do_part_thread(void *pa_v)
906
1246
{
907
1247
        RenderPart *pa= pa_v;
909
1249
        /* need to return nicely all parts on esc */
910
1250
        if(R.test_break()==0) {
911
1251
                
912
 
                pa->result= new_render_result(&R, &pa->disprect, pa->crop, RR_USEMEM);
913
 
                
914
 
                if(R.osa)
 
1252
                if(!R.sss_points && (R.r.scemode & R_FULL_SAMPLE))
 
1253
                        pa->result= new_full_sample_buffers(&R, &pa->fullresult, &pa->disprect, pa->crop);
 
1254
                else
 
1255
                        pa->result= new_render_result(&R, &pa->disprect, pa->crop, RR_USEMEM);
 
1256
 
 
1257
                if(R.sss_points)
 
1258
                        zbufshade_sss_tile(pa);
 
1259
                else if(R.osa)
915
1260
                        zbufshadeDA_tile(pa);
916
1261
                else
917
1262
                        zbufshade_tile(pa);
918
1263
                
919
1264
                /* merge too on break! */
920
 
                if(R.result->exrhandle)
921
 
                        save_render_result_tile(&R, pa);
922
 
                else
 
1265
                if(R.result->exrhandle) {
 
1266
                        RenderResult *rr, *rrpart;
 
1267
                        
 
1268
                        for(rr= R.result, rrpart= pa->result; rr && rrpart; rr= rr->next, rrpart= rrpart->next)
 
1269
                                save_render_result_tile(rr, rrpart);
 
1270
                        
 
1271
                }
 
1272
                else if(render_display_draw_enabled(&R))
923
1273
                        merge_render_result(R.result, pa->result);
924
1274
        }
925
1275
        
938
1288
 
939
1289
        /* hrmf... exception, this is used for preview render, re-entrant, so render result has to be re-used */
940
1290
        if(re->result==NULL || re->result->layers.first==NULL) {
941
 
                if(re->result) free_render_result(re->result);
 
1291
                if(re->result) RE_FreeRenderResult(re->result);
942
1292
                re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
943
1293
        }
944
1294
        
962
1312
                        
963
1313
                        if(pa->result) {
964
1314
                                if(!re->test_break()) {
965
 
                                        re->display_draw(pa->result, NULL);
 
1315
                                        if(render_display_draw_enabled(re))
 
1316
                                                re->display_draw(pa->result, NULL);
966
1317
                                        
967
1318
                                        re->i.partsdone++;
968
1319
                                        re->stats_draw(&re->i);
969
1320
                                }
970
 
                                free_render_result(pa->result);
 
1321
                                RE_FreeRenderResult(pa->result);
971
1322
                                pa->result= NULL;
972
1323
                        }               
973
1324
                        if(re->test_break())
1033
1384
                Mat4CpyMat4(R.winmat, re->winmat);
1034
1385
                
1035
1386
                /* rotate database according to part coordinates */
1036
 
                project_renderdata(re, projectverto, 1, -R.panodxp*phi);
 
1387
                project_renderdata(re, projectverto, 1, -R.panodxp*phi, 1);
1037
1388
                R.panosi= sin(R.panodxp*phi);
1038
1389
                R.panoco= cos(R.panodxp*phi);
1039
1390
        }
1091
1442
        re->i.infostr= NULL;
1092
1443
}
1093
1444
 
 
1445
/* make osa new results for samples */
 
1446
static RenderResult *new_full_sample_buffers_exr(Render *re)
 
1447
{
 
1448
        int a;
 
1449
        
 
1450
        for(a=0; a<re->osa; a++) {
 
1451
                RenderResult *rr= new_render_result(re, &re->disprect, 0, 1);
 
1452
                BLI_addtail(&re->fullresult, rr);
 
1453
                rr->sample_nr= a;
 
1454
        }
 
1455
        
 
1456
        return re->fullresult.first;
 
1457
}
 
1458
 
1094
1459
static void threaded_tile_processor(Render *re)
1095
1460
{
1096
1461
        ListBase threads;
1097
1462
        RenderPart *pa, *nextpa;
1098
 
        RenderResult *rr;
1099
1463
        rctf viewplane= re->viewplane;
1100
 
        int maxthreads, rendering=1, counter= 1, drawtimer=0, hasdrawn, minx=0;
1101
 
        
1102
 
        /* first step; the entire render result, or prepare exr buffer saving */
1103
 
        free_render_result(re->result);
1104
 
        rr= re->result= new_render_result(re, &re->disprect, 0, re->r.scemode & R_EXR_TILE_FILE);
1105
 
        
1106
 
        if(rr==NULL)
 
1464
        int rendering=1, counter= 1, drawtimer=0, hasdrawn, minx=0;
 
1465
        
 
1466
        /* first step; free the entire render result, make new, and/or prepare exr buffer saving */
 
1467
        RE_FreeRenderResult(re->result);
 
1468
        
 
1469
        if(re->sss_points)
 
1470
                re->result= new_render_result(re, &re->disprect, 0, 0);
 
1471
        else if(re->r.scemode & R_FULL_SAMPLE)
 
1472
                re->result= new_full_sample_buffers_exr(re);
 
1473
        else
 
1474
                re->result= new_render_result(re, &re->disprect, 0, re->r.scemode & R_EXR_TILE_FILE);
 
1475
        
 
1476
        if(re->result==NULL)
1107
1477
                return;
 
1478
        
1108
1479
        /* warning; no return here without closing exr file */
1109
 
//      if(re->re->test_break())
1110
 
//              return;
1111
1480
        
1112
1481
        initparts(re);
1113
1482
        
1114
 
        if(rr->exrhandle) {
1115
 
                char str[FILE_MAXDIR+FILE_MAXFILE];
1116
 
                
1117
 
                render_unique_exr_name(re, str);
1118
 
                
1119
 
                printf("write exr tmp file, %dx%d, %s\n", rr->rectx, rr->recty, str);
1120
 
                IMB_exrtile_begin_write(rr->exrhandle, str, rr->rectx, rr->recty, rr->rectx/re->xparts, rr->recty/re->yparts);
 
1483
        if(re->result->exrhandle) {
 
1484
                RenderResult *rr;
 
1485
                char str[FILE_MAX];
 
1486
                
 
1487
                for(rr= re->result; rr; rr= rr->next) {
 
1488
                        render_unique_exr_name(re, str, rr->sample_nr);
 
1489
                
 
1490
                        printf("write exr tmp file, %dx%d, %s\n", rr->rectx, rr->recty, str);
 
1491
                        IMB_exrtile_begin_write(rr->exrhandle, str, 0, rr->rectx, rr->recty, re->partx, re->party);
 
1492
                }
1121
1493
        }
1122
1494
        
1123
 
        if(re->r.mode & R_THREADS) maxthreads= 2;
1124
 
        else maxthreads= 1;
1125
 
        
1126
 
        BLI_init_threads(&threads, do_part_thread, maxthreads);
 
1495
        BLI_init_threads(&threads, do_part_thread, re->r.threads);
1127
1496
        
1128
1497
        /* assuming no new data gets added to dbase... */
1129
1498
        R= *re;
1150
1519
                        nextpa= find_next_part(re, minx);
1151
1520
                }
1152
1521
                else if(re->r.mode & R_PANORAMA) {
1153
 
                        if(nextpa==NULL && BLI_available_threads(&threads)==maxthreads)
 
1522
                        if(nextpa==NULL && BLI_available_threads(&threads)==re->r.threads)
1154
1523
                                nextpa= find_next_pano_slice(re, &minx, &viewplane);
1155
1524
                        else {
1156
1525
                                PIL_sleep_ms(50);
1167
1536
                hasdrawn= 0;
1168
1537
                for(pa= re->parts.first; pa; pa= pa->next) {
1169
1538
                        if(pa->ready) {
 
1539
                                
 
1540
                                BLI_remove_thread(&threads, pa);
 
1541
                                
1170
1542
                                if(pa->result) {
1171
 
                                        BLI_remove_thread(&threads, pa);
1172
 
 
1173
 
                                        re->display_draw(pa->result, NULL);
 
1543
                                        if(render_display_draw_enabled(re))
 
1544
                                                re->display_draw(pa->result, NULL);
1174
1545
                                        print_part_stats(re, pa);
1175
1546
                                        
1176
 
                                        free_render_result(pa->result);
 
1547
                                        free_render_result(&pa->fullresult, pa->result);
1177
1548
                                        pa->result= NULL;
1178
1549
                                        re->i.partsdone++;
1179
1550
                                        hasdrawn= 1;
1182
1553
                        else {
1183
1554
                                rendering= 1;
1184
1555
                                if(pa->nr && pa->result && drawtimer>20) {
1185
 
                                        re->display_draw(pa->result, &pa->result->renrect);
 
1556
                                        if(render_display_draw_enabled(re))
 
1557
                                                re->display_draw(pa->result, &pa->result->renrect);
1186
1558
                                        hasdrawn= 1;
1187
1559
                                }
1188
1560
                        }
1191
1563
                        drawtimer= 0;
1192
1564
 
1193
1565
                /* on break, wait for all slots to get freed */
1194
 
                if( (g_break=re->test_break()) && BLI_available_threads(&threads)==maxthreads)
 
1566
                if( (g_break=re->test_break()) && BLI_available_threads(&threads)==re->r.threads)
1195
1567
                        rendering= 0;
1196
1568
                
1197
1569
        }
1198
1570
        
1199
 
        if(rr->exrhandle) {
1200
 
                IMB_exr_close(rr->exrhandle);
1201
 
                rr->exrhandle= NULL;
1202
 
                if(!re->test_break())
1203
 
                        read_render_result(re);
 
1571
        if(re->result->exrhandle) {
 
1572
                RenderResult *rr;
 
1573
 
 
1574
                save_empty_result_tiles(re);
 
1575
                
 
1576
                for(rr= re->result; rr; rr= rr->next) {
 
1577
                        IMB_exr_close(rr->exrhandle);
 
1578
                        rr->exrhandle= NULL;
 
1579
                }
 
1580
                
 
1581
                free_render_result(&re->fullresult, re->result);
 
1582
                re->result= NULL;
 
1583
                
 
1584
                read_render_result(re, 0);
1204
1585
        }
1205
1586
        
1206
1587
        /* unset threadsafety */
1208
1589
        
1209
1590
        BLI_end_threads(&threads);
1210
1591
        freeparts(re);
 
1592
        re->viewplane= viewplane; /* restore viewplane, modified by pano render */
1211
1593
}
1212
1594
 
1213
1595
/* currently only called by preview renders and envmap */
1214
 
void RE_TileProcessor(Render *re, int firsttile)
 
1596
void RE_TileProcessor(Render *re, int firsttile, int threaded)
1215
1597
{
1216
1598
        /* the partsdone variable has to be reset to firsttile, to survive esc before it was set to zero */
1217
1599
        
1218
1600
        re->i.partsdone= firsttile;
1219
1601
 
1220
 
        re->i.starttime= PIL_check_seconds_timer();
 
1602
        if(!re->sss_points)
 
1603
                re->i.starttime= PIL_check_seconds_timer();
1221
1604
 
1222
 
        //if(re->r.mode & R_THREADS) 
1223
 
        //      threaded_tile_processor(re);
1224
 
        //else
 
1605
        if(threaded)
 
1606
                threaded_tile_processor(re);
 
1607
        else
1225
1608
                render_tile_processor(re, firsttile);
1226
1609
                
1227
 
        re->i.lastframetime= PIL_check_seconds_timer()- re->i.starttime;
 
1610
        if(!re->sss_points)
 
1611
                re->i.lastframetime= PIL_check_seconds_timer()- re->i.starttime;
1228
1612
        re->stats_draw(&re->i);
1229
1613
}
1230
1614
 
1323
1707
        }
1324
1708
        
1325
1709
        /* swap results */
1326
 
        free_render_result(re->result);
 
1710
        RE_FreeRenderResult(re->result);
1327
1711
        re->result= rres;
1328
1712
        
1329
1713
        set_mblur_offs(0.0f);
1429
1813
                else
1430
1814
                        merge_renderresult_fields(re->result, rr1, rr2);
1431
1815
                
1432
 
                free_render_result(rr2);
 
1816
                RE_FreeRenderResult(rr2);
1433
1817
        }
1434
 
        free_render_result(rr1);
 
1818
        RE_FreeRenderResult(rr1);
1435
1819
        
1436
1820
        re->i.curfield= 0;      /* stats */
1437
1821
        
1443
1827
static void load_backbuffer(Render *re)
1444
1828
{
1445
1829
        if(re->r.alphamode == R_ADDSKY) {
1446
 
                Image *bima;
 
1830
                ImBuf *ibuf;
1447
1831
                char name[256];
1448
1832
                
1449
1833
                strcpy(name, re->r.backbuf);
1450
 
                BLI_convertstringcode(name, G.sce, re->r.cfra);
 
1834
                BLI_convertstringcode(name, G.sce);
 
1835
                BLI_convertstringframe(name, re->r.cfra);
1451
1836
                
1452
1837
                if(re->backbuf) {
1453
1838
                        re->backbuf->id.us--;
1454
 
                        bima= re->backbuf;
1455
 
                }
1456
 
                else bima= NULL;
1457
 
                
1458
 
                re->backbuf= add_image(name);
1459
 
                
1460
 
                if(bima && bima->id.us<1) {
1461
 
                        free_image_buffers(bima);
1462
 
                }
1463
 
                
1464
 
                if(re->backbuf && re->backbuf->ibuf==NULL) {
1465
 
                        re->backbuf->ibuf= IMB_loadiffname(re->backbuf->name, IB_rect);
1466
 
                        if(re->backbuf->ibuf==NULL) 
1467
 
                                re->backbuf->ok= 0;
1468
 
                        else {
1469
 
                                re->backbuf->ok= 1;
1470
 
                                
1471
 
                                if (re->r.mode & R_FIELDS)
1472
 
                                        image_de_interlace(re->backbuf, re->r.mode & R_ODDFIELD);
1473
 
                        }
1474
 
                }
1475
 
                if(re->backbuf==NULL || re->backbuf->ok==0) {
 
1839
                        if(re->backbuf->id.us<1)
 
1840
                                BKE_image_signal(re->backbuf, NULL, IMA_SIGNAL_RELOAD);
 
1841
                }
 
1842
                
 
1843
                re->backbuf= BKE_add_image_file(name);
 
1844
                ibuf= BKE_image_get_ibuf(re->backbuf, NULL);
 
1845
                if(ibuf==NULL) {
1476
1846
                        // error() doesnt work with render window open
1477
1847
                        //error("No backbuf there!");
1478
1848
                        printf("Error: No backbuf %s\n", name);
1479
1849
                }
 
1850
                else {
 
1851
                        if (re->r.mode & R_FIELDS)
 
1852
                                image_de_interlace(re->backbuf, re->r.mode & R_ODDFIELD);
 
1853
                }
1480
1854
        }
1481
1855
}
1482
1856
 
1523
1897
                                rres= new_render_result(re, &re->disprect, 0, RR_USEMEM);
1524
1898
                                
1525
1899
                                merge_render_result(rres, re->result);
1526
 
                                free_render_result(re->result);
 
1900
                                RE_FreeRenderResult(re->result);
1527
1901
                                re->result= rres;
1528
1902
                                
1529
1903
                                /* weak... the display callback wants an active renderlayer pointer... */
1543
1917
static void render_scene(Render *re, Scene *sce, int cfra)
1544
1918
{
1545
1919
        Render *resc= RE_NewRender(sce->id.name);
 
1920
        int winx= re->winx, winy= re->winy;
1546
1921
        
1547
1922
        sce->r.cfra= cfra;
1548
1923
                
 
1924
        /* exception: scene uses own size (unfinished code) */
 
1925
        if(0) {
 
1926
                winx= (sce->r.size*sce->r.xsch)/100;
 
1927
                winy= (sce->r.size*sce->r.ysch)/100;
 
1928
        }
 
1929
        
1549
1930
        /* initial setup */
1550
 
        RE_InitState(resc, &sce->r, re->winx, re->winy, &re->disprect);
1551
 
        
1552
 
        /* this to enable this scene to create speed vectors */
1553
 
        resc->r.scemode |= R_DOCOMP;
 
1931
        RE_InitState(resc, re, &sce->r, winx, winy, &re->disprect);
1554
1932
        
1555
1933
        /* still unsure entity this... */
1556
1934
        resc->scene= sce;
1566
1944
        do_render_fields_blur_3d(resc);
1567
1945
}
1568
1946
 
1569
 
static void ntree_render_scenes(Render *re)
 
1947
static void tag_scenes_for_render(Render *re)
1570
1948
{
1571
1949
        bNode *node;
1572
 
        int cfra= re->scene->r.cfra;
 
1950
        Scene *sce;
 
1951
        
 
1952
        for(sce= G.main->scene.first; sce; sce= sce->id.next)
 
1953
                sce->id.flag &= ~LIB_DOIT;
 
1954
        
 
1955
        re->scene->id.flag |= LIB_DOIT;
1573
1956
        
1574
1957
        if(re->scene->nodetree==NULL) return;
1575
1958
        
1579
1962
                        if(node->id) {
1580
1963
                                if(node->id != (ID *)re->scene)
1581
1964
                                        node->id->flag |= LIB_DOIT;
1582
 
                                else
1583
 
                                        node->id->flag &= ~LIB_DOIT;
1584
1965
                        }
1585
1966
                }
1586
1967
        }
1587
1968
        
 
1969
}
 
1970
 
 
1971
static void ntree_render_scenes(Render *re)
 
1972
{
 
1973
        bNode *node;
 
1974
        int cfra= re->scene->r.cfra;
 
1975
        
 
1976
        if(re->scene->nodetree==NULL) return;
 
1977
        
 
1978
        tag_scenes_for_render(re);
 
1979
        
1588
1980
        /* now foreach render-result node tagged we do a full render */
1589
1981
        /* results are stored in a way compisitor will find it */
1590
1982
        for(node= re->scene->nodetree->nodes.first; node; node= node->next) {
1630
2022
        R.i.infostr= NULL;
1631
2023
}
1632
2024
 
 
2025
 
 
2026
/* reads all buffers, calls optional composite, merges in first result->rectf */
 
2027
static void do_merge_fullsample(Render *re, bNodeTree *ntree)
 
2028
{
 
2029
        float *rectf, filt[3][3];
 
2030
        int sample;
 
2031
        
 
2032
        /* filtmask needs it */
 
2033
        R= *re;
 
2034
        
 
2035
        /* we accumulate in here */
 
2036
        rectf= MEM_mapallocN(re->rectx*re->recty*sizeof(float)*4, "fullsample rgba");
 
2037
        
 
2038
        for(sample=0; sample<re->r.osa; sample++) {
 
2039
                RenderResult rres;
 
2040
                int x, y, mask;
 
2041
                
 
2042
                /* set all involved renders on the samplebuffers (first was done by render itself) */
 
2043
                /* also function below assumes this */
 
2044
                if(sample) {
 
2045
                        Render *re1;
 
2046
                        
 
2047
                        tag_scenes_for_render(re);
 
2048
                        for(re1= RenderList.first; re1; re1= re1->next) {
 
2049
                                if(re1->scene->id.flag & LIB_DOIT)
 
2050
                                        if(re1->r.scemode & R_FULL_SAMPLE)
 
2051
                                                read_render_result(re1, sample);
 
2052
                        }
 
2053
                }
 
2054
 
 
2055
                /* composite */
 
2056
                if(ntree) {
 
2057
                        ntreeCompositTagRender(re->scene);
 
2058
                        ntreeCompositTagAnimated(ntree);
 
2059
                        
 
2060
                        ntreeCompositExecTree(ntree, &re->r, G.background==0);
 
2061
                }
 
2062
                
 
2063
                /* ensure we get either composited result or the active layer */
 
2064
                RE_GetResultImage(re, &rres);
 
2065
                
 
2066
                /* accumulate with filter, and clip */
 
2067
                mask= (1<<sample);
 
2068
                mask_array(mask, filt);
 
2069
 
 
2070
                for(y=0; y<re->recty; y++) {
 
2071
                        float *rf= rectf + 4*y*re->rectx;
 
2072
                        float *col= rres.rectf + 4*y*re->rectx;
 
2073
                                
 
2074
                        for(x=0; x<re->rectx; x++, rf+=4, col+=4) {
 
2075
                                if(col[0]<0.0f) col[0]=0.0f; else if(col[0] > 1.0f) col[0]= 1.0f;
 
2076
                                if(col[1]<0.0f) col[1]=0.0f; else if(col[1] > 1.0f) col[1]= 1.0f;
 
2077
                                if(col[2]<0.0f) col[2]=0.0f; else if(col[2] > 1.0f) col[2]= 1.0f;
 
2078
                                
 
2079
                                add_filt_fmask_coord(filt, col, rf, re->rectx, re->recty, x, y);
 
2080
                        }
 
2081
                }
 
2082
                
 
2083
                /* show stuff */
 
2084
                if(sample!=re->osa-1) {
 
2085
                        /* weak... the display callback wants an active renderlayer pointer... */
 
2086
                        re->result->renlay= render_get_active_layer(re, re->result);
 
2087
                        re->display_draw(re->result, NULL);
 
2088
                }
 
2089
                
 
2090
                if(re->test_break())
 
2091
                        break;
 
2092
        }
 
2093
        
 
2094
        if(re->result->rectf) 
 
2095
                MEM_freeN(re->result->rectf);
 
2096
        re->result->rectf= rectf;
 
2097
}
 
2098
 
 
2099
void RE_MergeFullSample(Render *re, Scene *sce, bNodeTree *ntree)
 
2100
{
 
2101
        Scene *scene;
 
2102
        bNode *node;
 
2103
        
 
2104
        /* first call RE_ReadRenderResult on every renderlayer scene. this creates Render structs */
 
2105
        
 
2106
        /* tag scenes unread */
 
2107
        for(scene= G.main->scene.first; scene; scene= scene->id.next) 
 
2108
                scene->id.flag |= LIB_DOIT;
 
2109
        
 
2110
        for(node= ntree->nodes.first; node; node= node->next) {
 
2111
                if(node->type==CMP_NODE_R_LAYERS) {
 
2112
                        Scene *nodescene= (Scene *)node->id;
 
2113
                        
 
2114
                        if(nodescene==NULL) nodescene= sce;
 
2115
                        if(nodescene->id.flag & LIB_DOIT) {
 
2116
                                nodescene->r.mode |= R_OSA;     /* render struct needs tables */
 
2117
                                RE_ReadRenderResult(sce, nodescene);
 
2118
                                nodescene->id.flag &= ~LIB_DOIT;
 
2119
                        }
 
2120
                }
 
2121
        }
 
2122
        
 
2123
        /* own render result should be read/allocated */
 
2124
        if(G.scene->id.flag & LIB_DOIT)
 
2125
                RE_ReadRenderResult(G.scene, G.scene);
 
2126
        
 
2127
        /* and now we can draw (result is there) */
 
2128
        re->display_init(re->result);
 
2129
        re->display_clear(re->result);
 
2130
        
 
2131
        do_merge_fullsample(re, ntree);
 
2132
}
 
2133
 
1633
2134
/* returns fully composited render-result on given time step (in RenderData) */
1634
2135
static void do_render_composite_fields_blur_3d(Render *re)
1635
2136
{
1636
2137
        bNodeTree *ntree= re->scene->nodetree;
1637
2138
        
1638
2139
        /* INIT seeding, compositor can use random texture */
1639
 
        BLI_srand(re->r.cfra);
 
2140
        BLI_srandom(re->r.cfra);
1640
2141
        
1641
2142
        if(composite_needs_render(re->scene)) {
1642
2143
                /* save memory... free all cached images */
1649
2150
        if(re->r.scemode & R_SINGLE_LAYER)
1650
2151
                pop_render_result(re);
1651
2152
        
1652
 
        if(!re->test_break() && ntree) {
1653
 
                ntreeCompositTagRender(ntree);
1654
 
                ntreeCompositTagAnimated(ntree);
1655
 
                
1656
 
                if(re->r.scemode & R_DOCOMP) {
1657
 
                        /* checks if there are render-result nodes that need scene */
1658
 
                        if((re->r.scemode & R_SINGLE_LAYER)==0)
1659
 
                                ntree_render_scenes(re);
1660
 
                        
1661
 
                        if(!re->test_break()) {
1662
 
                                ntree->stats_draw= render_composit_stats;
1663
 
                                ntree->test_break= re->test_break;
1664
 
                                /* in case it was never initialized */
1665
 
                                R.stats_draw= re->stats_draw;
 
2153
        if(!re->test_break()) {
 
2154
                
 
2155
                if(ntree) {
 
2156
                        ntreeCompositTagRender(re->scene);
 
2157
                        ntreeCompositTagAnimated(ntree);
 
2158
                }
 
2159
                
 
2160
                if(1 || !(re->r.scemode & R_COMP_RERENDER)) {
 
2161
                        if(ntree && re->r.scemode & R_DOCOMP) {
 
2162
                                /* checks if there are render-result nodes that need scene */
 
2163
                                if((re->r.scemode & R_SINGLE_LAYER)==0)
 
2164
                                        ntree_render_scenes(re);
1666
2165
                                
1667
 
                                ntreeCompositExecTree(ntree, &re->r, G.background==0);
1668
 
                                ntree->stats_draw= NULL;
1669
 
                                ntree->test_break= NULL;
 
2166
                                if(!re->test_break()) {
 
2167
                                        ntree->stats_draw= render_composit_stats;
 
2168
                                        ntree->test_break= re->test_break;
 
2169
                                        /* in case it was never initialized */
 
2170
                                        R.stats_draw= re->stats_draw;
 
2171
                                        
 
2172
                                        if(re->r.scemode & R_FULL_SAMPLE) 
 
2173
                                                do_merge_fullsample(re, ntree);
 
2174
                                        else
 
2175
                                                ntreeCompositExecTree(ntree, &re->r, G.background==0);
 
2176
                                        
 
2177
                                        ntree->stats_draw= NULL;
 
2178
                                        ntree->test_break= NULL;
 
2179
                                }
1670
2180
                        }
 
2181
                        else if(re->r.scemode & R_FULL_SAMPLE)
 
2182
                                do_merge_fullsample(re, NULL);
1671
2183
                }
1672
2184
        }
1673
2185
 
 
2186
        /* weak... the display callback wants an active renderlayer pointer... */
 
2187
        re->result->renlay= render_get_active_layer(re, re->result);
1674
2188
        re->display_draw(re->result, NULL);
1675
2189
}
1676
2190
 
1677
 
 
 
2191
#ifndef DISABLE_YAFRAY
1678
2192
/* yafray: main yafray render/export call */
1679
2193
static void yafrayRender(Render *re)
1680
2194
{
1681
 
        free_render_result(re->result);
 
2195
        RE_FreeRenderResult(re->result);
1682
2196
        re->result= new_render_result(re, &re->disprect, 0, RR_USEMEM);
1683
2197
        
1684
2198
        // need this too, for aspect/ortho/etc info
1718
2232
                                rres= new_render_result(re, &re->disprect, 0, RR_USEMEM);
1719
2233
                                
1720
2234
                                merge_render_result(rres, re->result);
1721
 
                                free_render_result(re->result);
 
2235
                                RE_FreeRenderResult(re->result);
1722
2236
                                re->result= rres;
1723
2237
                                
1724
2238
                                re->display_init(re->result);
1734
2248
}
1735
2249
 
1736
2250
 
 
2251
 
 
2252
#endif /* disable yafray */
 
2253
 
 
2254
static void renderresult_stampinfo()
 
2255
{
 
2256
        RenderResult rres;
 
2257
        /* this is the basic trick to get the displayed float or char rect from render result */
 
2258
        RE_GetResultImage(RE_GetRender(G.scene->id.name), &rres);
 
2259
        BKE_stamp_buf((unsigned char *)rres.rect32, rres.rectf, rres.rectx, rres.recty, 4);
 
2260
}
 
2261
 
1737
2262
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
1738
2263
 
1739
 
 
1740
2264
/* main loop: doing sequence + fields + blur + 3d render + compositing */
1741
2265
static void do_render_all_options(Render *re)
1742
2266
{
1743
2267
        re->i.starttime= PIL_check_seconds_timer();
1744
2268
 
 
2269
        /* ensure no images are in memory from previous animated sequences */
 
2270
        BKE_image_all_free_anim_ibufs(re->r.cfra);
 
2271
        
1745
2272
        if(re->r.scemode & R_DOSEQ) {
 
2273
                /* note: do_render_seq() frees rect32 when sequencer returns float images */
1746
2274
                if(!re->test_break()) 
1747
2275
                        do_render_seq(re->result, re->r.cfra);
1748
2276
                
1751
2279
                
1752
2280
        }
1753
2281
        else {
 
2282
#ifndef DISABLE_YAFRAY
1754
2283
                if(re->r.renderer==R_YAFRAY)
1755
2284
                        yafrayRender(re);
1756
2285
                else
1757
2286
                        do_render_composite_fields_blur_3d(re);
 
2287
#else
 
2288
                do_render_composite_fields_blur_3d(re);
 
2289
#endif
1758
2290
        }
1759
2291
        
 
2292
        /* for UI only */
 
2293
        renderresult_add_names(re->result);
 
2294
        
1760
2295
        re->i.lastframetime= PIL_check_seconds_timer()- re->i.starttime;
 
2296
        
1761
2297
        re->stats_draw(&re->i);
 
2298
        
 
2299
        /* stamp image info here */
 
2300
        if((G.scene->r.scemode & R_STAMP_INFO) && (G.scene->r.stamp & R_STAMP_DRAW)) {
 
2301
                renderresult_stampinfo();
 
2302
                re->display_draw(re->result, NULL);
 
2303
        }
1762
2304
}
1763
2305
 
1764
2306
static int is_rendering_allowed(Render *re)
1765
2307
{
 
2308
        SceneRenderLayer *srl;
1766
2309
        
1767
2310
        /* forbidden combinations */
1768
2311
        if(re->r.mode & R_PANORAMA) {
1789
2332
        }
1790
2333
        
1791
2334
        if(re->r.scemode & R_EXR_TILE_FILE) {
1792
 
                char str[FILE_MAXDIR+FILE_MAXFILE];
 
2335
                char str[FILE_MAX];
1793
2336
                
1794
 
                render_unique_exr_name(re, str);
 
2337
                render_unique_exr_name(re, str, 0);
1795
2338
                
1796
2339
                if (BLI_is_writable(str)==0) {
1797
2340
                        re->error("Can not save render buffers, check the temp default path");
1798
2341
                        return 0;
1799
2342
                }
1800
2343
                
 
2344
                /* no osa + fullsample won't work... */
 
2345
                if(re->osa==0)
 
2346
                        re->r.scemode &= ~R_FULL_SAMPLE;
 
2347
                
1801
2348
        }
 
2349
        else
 
2350
                re->r.scemode &= ~R_FULL_SAMPLE;        /* clear to be sure */
1802
2351
        
1803
2352
        if(re->r.scemode & R_DOCOMP) {
1804
2353
                if(re->scene->use_nodes) {
1809
2358
                                re->error("No Nodetree in Scene");
1810
2359
                                return 0;
1811
2360
                        }
1812
 
                
 
2361
                        
1813
2362
                        for(node= ntree->nodes.first; node; node= node->next)
1814
2363
                                if(node->type==CMP_NODE_COMPOSITE)
1815
2364
                                        break;
1816
2365
                        
 
2366
                        
1817
2367
                        if(node==NULL) {
1818
2368
                                re->error("No Render Output Node in Scene");
1819
2369
                                return 0;
1832
2382
                }
1833
2383
        }
1834
2384
        
 
2385
        /* layer flag tests */
 
2386
        if(re->r.scemode & R_SINGLE_LAYER) {
 
2387
                srl= BLI_findlink(&re->scene->r.layers, re->r.actlay);
 
2388
                /* force layer to be enabled */
 
2389
                srl->layflag &= ~SCE_LAY_DISABLE;
 
2390
        }
 
2391
        
 
2392
        for(srl= re->scene->r.layers.first; srl; srl= srl->next)
 
2393
                if(!(srl->layflag & SCE_LAY_DISABLE))
 
2394
                        break;
 
2395
        if(srl==NULL) {
 
2396
                re->error("All RenderLayers are disabled");
 
2397
                return 0;
 
2398
        }
 
2399
        
 
2400
        /* renderer */
 
2401
        if(!ELEM(re->r.renderer, R_INTERN, R_YAFRAY)) {
 
2402
                re->error("Unknown render engine set");
 
2403
                return 0;
 
2404
        }
1835
2405
        return 1;
1836
2406
}
1837
2407
 
1862
2432
                disprect.ymax= winy;
1863
2433
        }
1864
2434
        
1865
 
        if(scene->r.scemode & R_EXR_TILE_FILE) {
1866
 
                int partx= winx/scene->r.xparts, party= winy/scene->r.yparts;
1867
 
                
1868
 
                /* stupid exr tiles dont like different sizes */
1869
 
                if(winx != partx*scene->r.xparts || winy != party*scene->r.yparts) {
1870
 
                        re->error("Sorry... exr tile saving only allowed with equally sized parts");
1871
 
                        return 0;
1872
 
                }
1873
 
                if((scene->r.mode & R_FIELDS) && (party & 1)) {
1874
 
                        re->error("Sorry... exr tile saving only allowed with equally sized parts");
1875
 
                        return 0;
1876
 
                }
1877
 
        }
 
2435
        re->scene= scene;
 
2436
        
 
2437
        /* check all scenes involved */
 
2438
        tag_scenes_for_render(re);
1878
2439
        
1879
2440
        if(scene->r.scemode & R_SINGLE_LAYER)
1880
2441
                push_render_result(re);
1881
2442
        
1882
 
        RE_InitState(re, &scene->r, winx, winy, &disprect);
1883
 
        
1884
 
        re->scene= scene;
 
2443
        RE_InitState(re, NULL, &scene->r, winx, winy, &disprect);
 
2444
        if(!re->ok)  /* if an error was printed, abort */
 
2445
                return 0;
 
2446
        
 
2447
        /* initstate makes new result, have to send changed tags around */
 
2448
        ntreeCompositTagRender(re->scene);
 
2449
        
1885
2450
        if(!is_rendering_allowed(re))
1886
2451
                return 0;
1887
2452
        
1910
2475
 
1911
2476
static void do_write_image_or_movie(Render *re, Scene *scene, bMovieHandle *mh)
1912
2477
{
1913
 
        char name[FILE_MAXDIR+FILE_MAXFILE];
 
2478
        char name[FILE_MAX];
1914
2479
        RenderResult rres;
1915
2480
        
1916
2481
        RE_GetResultImage(re, &rres);
1920
2485
                int dofree = 0;
1921
2486
                /* note; the way it gets 32 bits rects is weak... */
1922
2487
                if(rres.rect32==NULL) {
1923
 
                        rres.rect32= MEM_mapallocT(sizeof(int)*rres.rectx*rres.recty, "temp 32 bits rect");
 
2488
                        rres.rect32= MEM_mapallocN(sizeof(int)*rres.rectx*rres.recty, "temp 32 bits rect");
1924
2489
                        dofree = 1;
1925
2490
                }
1926
 
                RE_ResultGet32(re, rres.rect32);
 
2491
                RE_ResultGet32(re, (unsigned int *)rres.rect32);
1927
2492
                mh->append_movie(scene->r.cfra, rres.rect32, rres.rectx, rres.recty);
1928
2493
                if(dofree) {
1929
 
                        MEM_freeT(rres.rect32);
 
2494
                        MEM_freeN(rres.rect32);
1930
2495
                }
1931
2496
                printf("Append frame %d", scene->r.cfra);
1932
 
        } else {
1933
 
                ImBuf *ibuf= IMB_allocImBuf(rres.rectx, rres.recty, scene->r.planes, 0, 0);
1934
 
                int ok;
1935
 
                
1936
 
                BKE_makepicstring(name, (scene->r.cfra));
1937
 
 
1938
 
                /* if not exists, BKE_write_ibuf makes one */
1939
 
                ibuf->rect= rres.rect32;    
1940
 
                ibuf->rect_float= rres.rectf;
1941
 
                ibuf->zbuf_float= rres.rectz;
1942
 
                
1943
 
                /* float factor for random dither, imbuf takes care of it */
1944
 
                ibuf->dither= scene->r.dither_intensity;
1945
 
 
1946
 
                ok= BKE_write_ibuf(ibuf, name, scene->r.imtype, scene->r.subimtype, scene->r.quality);
1947
 
                
1948
 
                if(ok==0) {
1949
 
                        printf("Render error: cannot save %s\n", name);
1950
 
                        G.afbreek=1;
1951
 
                        return;
1952
 
                }
1953
 
                else printf("Saved: %s", name);
1954
 
                
1955
 
                /* optional preview images for exr */
1956
 
                if(ok && scene->r.imtype==R_OPENEXR && (scene->r.subimtype & R_PREVIEW_JPG)) {
1957
 
                        if(BLI_testextensie(name, ".exr")) 
1958
 
                                name[strlen(name)-4]= 0;
1959
 
                        BKE_add_image_extension(name, R_JPEG90);
1960
 
                        ibuf->depth= 24; 
1961
 
                        BKE_write_ibuf(ibuf, name, R_JPEG90, scene->r.subimtype, scene->r.quality);
1962
 
                        printf("\nSaved: %s", name);
1963
 
                }
1964
 
                
1965
 
                /* imbuf knows which rects are not part of ibuf */
1966
 
                IMB_freeImBuf(ibuf);    
 
2497
        } 
 
2498
        else {
 
2499
                BKE_makepicstring(name, scene->r.pic, scene->r.cfra, scene->r.imtype);
 
2500
                
 
2501
                if(re->r.imtype==R_MULTILAYER) {
 
2502
                        if(re->result) {
 
2503
                                RE_WriteRenderResult(re->result, name, scene->r.quality);
 
2504
                                printf("Saved: %s", name);
 
2505
                        }
 
2506
                }
 
2507
                else {
 
2508
                        ImBuf *ibuf= IMB_allocImBuf(rres.rectx, rres.recty, scene->r.planes, 0, 0);
 
2509
                        int ok;
 
2510
                        
 
2511
                                        /* if not exists, BKE_write_ibuf makes one */
 
2512
                        ibuf->rect= (unsigned int *)rres.rect32;    
 
2513
                        ibuf->rect_float= rres.rectf;
 
2514
                        ibuf->zbuf_float= rres.rectz;
 
2515
                        
 
2516
                        /* float factor for random dither, imbuf takes care of it */
 
2517
                        ibuf->dither= scene->r.dither_intensity;
 
2518
 
 
2519
                        ok= BKE_write_ibuf(ibuf, name, scene->r.imtype, scene->r.subimtype, scene->r.quality);
 
2520
                        
 
2521
                        if(ok==0) {
 
2522
                                printf("Render error: cannot save %s\n", name);
 
2523
                                G.afbreek=1;
 
2524
                        }
 
2525
                        else printf("Saved: %s", name);
 
2526
                        
 
2527
                        /* optional preview images for exr */
 
2528
                        if(ok && scene->r.imtype==R_OPENEXR && (scene->r.subimtype & R_PREVIEW_JPG)) {
 
2529
                                if(BLI_testextensie(name, ".exr")) 
 
2530
                                        name[strlen(name)-4]= 0;
 
2531
                                BKE_add_image_extension(name, R_JPEG90);
 
2532
                                ibuf->depth= 24; 
 
2533
                                BKE_write_ibuf(ibuf, name, R_JPEG90, scene->r.subimtype, scene->r.quality);
 
2534
                                printf("\nSaved: %s", name);
 
2535
                        }
 
2536
                        
 
2537
                                        /* imbuf knows which rects are not part of ibuf */
 
2538
                        IMB_freeImBuf(ibuf);
 
2539
                }
1967
2540
        }
1968
2541
        
1969
2542
        BLI_timestr(re->i.lastframetime, name);
2004
2577
                        }
2005
2578
                }
2006
2579
        } else {
2007
 
                for(scene->r.cfra= sfra; 
2008
 
                    scene->r.cfra<=efra; scene->r.cfra++) {
 
2580
                for(scene->r.cfra= sfra; scene->r.cfra<=efra; scene->r.cfra++) {
 
2581
                        char name[FILE_MAX];
 
2582
                        if (scene->r.mode & (R_NO_OVERWRITE | R_TOUCH) ) {
 
2583
                                BKE_makepicstring(name, scene->r.pic, scene->r.cfra, scene->r.imtype);
 
2584
                        }
 
2585
                        
 
2586
                        if (scene->r.mode & R_NO_OVERWRITE && BLI_exist(name)) {
 
2587
                                printf("skipping existing frame \"%s\"\n", name);
 
2588
                                continue;
 
2589
                        }
 
2590
                        if (scene->r.mode & R_TOUCH && !BLI_exist(name)) {
 
2591
                                BLI_make_existing_file(name); /* makes the dir if its not there */
 
2592
                                BLI_touch(name);
 
2593
                        }
 
2594
 
2009
2595
                        re->r.cfra= scene->r.cfra;         /* weak.... */
2010
 
                
 
2596
                        
2011
2597
                        do_render_all_options(re);
2012
 
 
 
2598
                        
2013
2599
                        if(re->test_break() == 0) {
2014
2600
                                do_write_image_or_movie(re, scene, mh);
2015
2601
                        }
2016
2602
                
2017
 
                        if(G.afbreek==1) break;
 
2603
                        if(G.afbreek==1) {
 
2604
                                /* remove touched file */
 
2605
                                if (scene->r.mode & R_TOUCH && BLI_exist(name) && BLI_filepathsize(name) == 0) {
 
2606
                                        BLI_delete(name, 0, 0);
 
2607
                                }
 
2608
                                
 
2609
                                break;
 
2610
                        }
2018
2611
                }
2019
2612
        }
2020
2613
        
2030
2623
 
2031
2624
/* note; repeated win/disprect calc... solve that nicer, also in compo */
2032
2625
 
 
2626
/* only the temp file! */
2033
2627
void RE_ReadRenderResult(Scene *scene, Scene *scenode)
2034
2628
{
2035
2629
        Render *re;
2057
2651
        if(scenode)
2058
2652
                scene= scenode;
2059
2653
        
2060
 
        re= RE_NewRender(scene->id.name);
2061
 
        RE_InitState(re, &scene->r, winx, winy, &disprect);
 
2654
        /* get render: it can be called from UI with draw callbacks */
 
2655
        re= RE_GetRender(scene->id.name);
 
2656
        if(re==NULL)
 
2657
                re= RE_NewRender(scene->id.name);
 
2658
        RE_InitState(re, NULL, &scene->r, winx, winy, &disprect);
2062
2659
        re->scene= scene;
2063
2660
        
2064
 
        read_render_result(re);
 
2661
        read_render_result(re, 0);
 
2662
}
 
2663
 
 
2664
void RE_set_max_threads(int threads)
 
2665
{
 
2666
        if (threads==0) {
 
2667
                commandline_threads = BLI_system_thread_count();
 
2668
        } else if(threads>=1 && threads<=BLENDER_MAX_THREADS) {
 
2669
                commandline_threads= threads;
 
2670
        } else {
 
2671
                printf("Error, threads has to be in range 1-%d\n", BLENDER_MAX_THREADS);
 
2672
        }
 
2673
}
 
2674
 
 
2675
void RE_init_threadcount(Render *re) 
 
2676
{
 
2677
        if ((re->r.mode & R_FIXED_THREADS)==0 || commandline_threads == 0) { /* Automatic threads */
 
2678
                re->r.threads = BLI_system_thread_count();
 
2679
        } else if(commandline_threads >= 1 && commandline_threads<=BLENDER_MAX_THREADS) {
 
2680
                re->r.threads= commandline_threads;
 
2681
        }
2065
2682
}