← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/render/intern/source/external_engine.c
115
115
        type = BLI_findstring(&R_engines, idname, offsetof(RenderEngineType, idname));
116
116
        if (!type)
117
117
                type = &internal_render_type;
118
 
 
 
118
        
119
119
        return type;
120
120
}
121
121
 
132
132
        return RE_engine_create_ex(type, FALSE);
133
133
}
134
134
 
135
 
RenderEngine *RE_engine_create_ex(RenderEngineType *type, int use_for_viewport)
 
135
RenderEngine *RE_engine_create_ex(RenderEngineType *type, bool use_for_viewport)
136
136
{
137
137
        RenderEngine *engine = MEM_callocN(sizeof(RenderEngine), "RenderEngine");
138
138
        engine->type = type;
158
158
                BLI_end_threaded_malloc();
159
159
        }
160
160
 
161
 
        if (engine->text)
162
 
                MEM_freeN(engine->text);
163
 
 
164
161
        MEM_freeN(engine);
165
162
}
166
163
 
253
250
                /* for exr tile render, detect tiles that are done */
254
251
                RenderPart *pa = get_part_from_result(re, result);
255
252
 
256
 
                if (pa)
 
253
                if (pa) {
257
254
                        pa->status = PART_STATUS_READY;
 
255
                }
 
256
                else if (re->result->do_exr_tile) {
 
257
                        /* if written result does not match any tile and we are using save
 
258
                         * buffers, we are going to get openexr save errors */
 
259
                        fprintf(stderr, "RenderEngine.end_result: dimensions do not match any OpenEXR tile.\n");
 
260
                }
258
261
 
259
262
                if (re->result->do_exr_tile)
260
263
                        render_result_exr_file_merge(re->result, result);
261
 
                else if (!(re->test_break(re->tbh) && (re->r.scemode & R_PREVIEWBUTS)))
 
264
                else if (!(re->test_break(re->tbh) && (re->r.scemode & R_BUTS_PREVIEW)))
262
265
                        render_result_merge(re->result, result);
263
266
 
264
267
                /* draw */
301
304
        }
302
305
 
303
306
        /* set engine text */
304
 
        if (engine->text) {
305
 
                MEM_freeN(engine->text);
306
 
                engine->text = NULL;
307
 
        }
 
307
        engine->text[0] = '\0';
308
308
 
309
309
        if (stats && stats[0] && info && info[0])
310
 
                engine->text = BLI_sprintfN("%s | %s", stats, info);
 
310
                BLI_snprintf(engine->text, sizeof(engine->text), "%s | %s", stats, info);
311
311
        else if (info && info[0])
312
 
                engine->text = BLI_strdup(info);
 
312
                BLI_strncpy(engine->text, info, sizeof(engine->text));
313
313
        else if (stats && stats[0])
314
 
                engine->text = BLI_strdup(stats);
 
314
                BLI_strncpy(engine->text, info, sizeof(engine->text));
315
315
}
316
316
 
317
317
void RE_engine_update_progress(RenderEngine *engine, float progress)
385
385
        *tiles_r = tiles;
386
386
}
387
387
 
 
388
RenderData *RE_engine_get_render_data(Render *re)
 
389
{
 
390
        return &re->r;
 
391
}
 
392
 
388
393
/* Render */
389
394
 
390
395
int RE_engine_render(Render *re, int do_all)
396
401
        /* verify if we can render */
397
402
        if (!type->render)
398
403
                return 0;
399
 
        if ((re->r.scemode & R_PREVIEWBUTS) && !(type->flag & RE_USE_PREVIEW))
 
404
        if ((re->r.scemode & R_BUTS_PREVIEW) && !(type->flag & RE_USE_PREVIEW))
400
405
                return 0;
401
406
        if (do_all && !(type->flag & RE_USE_POSTPROCESS))
402
407
                return 0;
403
408
        if (!do_all && (type->flag & RE_USE_POSTPROCESS))
404
409
                return 0;
405
410
 
 
411
        /* update animation here so any render layer animation is applied before
 
412
         * creating the render result */
 
413
        if ((re->r.scemode & (R_NO_FRAME_UPDATE | R_BUTS_PREVIEW)) == 0) {
 
414
                unsigned int lay = re->lay;
 
415
 
 
416
                /* don't update layers excluded on all render layers */
 
417
                if (type->flag & RE_USE_EXCLUDE_LAYERS) {
 
418
                        SceneRenderLayer *srl;
 
419
                        unsigned int non_excluded_lay = 0;
 
420
 
 
421
                        if (re->r.scemode & R_SINGLE_LAYER) {
 
422
                                srl = BLI_findlink(&re->r.layers, re->r.actlay);
 
423
                                if (srl)
 
424
                                        non_excluded_lay |= ~srl->lay_exclude;
 
425
                        }
 
426
                        else {
 
427
                                for (srl = re->r.layers.first; srl; srl = srl->next)
 
428
                                        if (!(srl->layflag & SCE_LAY_DISABLE))
 
429
                                                non_excluded_lay |= ~srl->lay_exclude;
 
430
                        }
 
431
 
 
432
                        lay &= non_excluded_lay;
 
433
                }
 
434
 
 
435
                BKE_scene_update_for_newframe(re->main, re->scene, lay);
 
436
        }
 
437
 
406
438
        /* create render result */
407
439
        BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
408
 
        if (re->result == NULL || !(re->r.scemode & R_PREVIEWBUTS)) {
409
 
                int savebuffers;
 
440
        if (re->result == NULL || !(re->r.scemode & R_BUTS_PREVIEW)) {
 
441
                int savebuffers = RR_USE_MEM;
410
442
 
411
443
                if (re->result)
412
444
                        render_result_free(re->result);
413
445
 
414
 
                savebuffers = (re->r.scemode & R_EXR_TILE_FILE) ? RR_USE_EXR : RR_USE_MEM;
 
446
                if ((type->flag & RE_USE_SAVE_BUFFERS) && (re->r.scemode & R_EXR_TILE_FILE))
 
447
                        savebuffers = RR_USE_EXR;
415
448
                re->result = render_result_new(re, &re->disprect, 0, savebuffers, RR_ALL_LAYERS);
416
449
        }
417
450
        BLI_rw_mutex_unlock(&re->resultmutex);
439
472
 
440
473
        if (re->flag & R_ANIMATION)
441
474
                engine->flag |= RE_ENGINE_ANIMATION;
442
 
        if (re->r.scemode & R_PREVIEWBUTS)
 
475
        if (re->r.scemode & R_BUTS_PREVIEW)
443
476
                engine->flag |= RE_ENGINE_PREVIEW;
444
477
        engine->camera_override = re->camera_override;
445
478
 
446
479
        engine->resolution_x = re->winx;
447
480
        engine->resolution_y = re->winy;
448
481
 
449
 
        if ((re->r.scemode & (R_NO_FRAME_UPDATE | R_PREVIEWBUTS)) == 0)
450
 
                BKE_scene_update_for_newframe(re->main, re->scene, re->lay);
451
 
 
452
482
        RE_parts_init(re, FALSE);
453
483
        engine->tile_x = re->partx;
454
484
        engine->tile_y = re->party;