← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

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

  • Committer: Reinhard Tartler
  • Date: 2014-05-31 01:50:05 UTC
  • mfrom: (14.2.27 sid)
  • Revision ID: siretart@tauware.de-20140531015005-ml6druahuj82nsav
merge from debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/render/intern/source/pipeline.c
59
59
 
60
60
#include "BKE_animsys.h"  /* <------ should this be here?, needed for sequencer update */
61
61
#include "BKE_camera.h"
 
62
#include "BKE_depsgraph.h"
62
63
#include "BKE_global.h"
63
64
#include "BKE_image.h"
64
65
#include "BKE_main.h"
 
66
#include "BKE_modifier.h"
65
67
#include "BKE_node.h"
66
68
#include "BKE_pointcache.h"
67
69
#include "BKE_report.h"
228
230
{
229
231
        SceneRenderLayer *srl;
230
232
        
231
 
        for (srl = re->scene->r.layers.first; srl; srl = srl->next)
 
233
        for (srl = re->r.layers.first; srl; srl = srl->next)
232
234
                if (!(srl->layflag & SCE_LAY_DISABLE))
233
235
                        if (srl->passflag & SCE_PASS_VECTOR)
234
236
                                return 1;
373
375
                BLI_addtail(&RenderGlobal.renderlist, re);
374
376
                BLI_strncpy(re->name, name, RE_MAXNAME);
375
377
                BLI_rw_mutex_init(&re->resultmutex);
 
378
                re->eval_ctx = MEM_callocN(sizeof(EvaluationContext), "re->eval_ctx");
 
379
                re->eval_ctx->for_render = true;
376
380
        }
377
381
        
378
382
        RE_InitRenderCB(re);
390
394
        /* set default empty callbacks */
391
395
        re->display_init = result_nothing;
392
396
        re->display_clear = result_nothing;
393
 
        re->display_draw = result_rcti_nothing;
 
397
        re->display_update = result_rcti_nothing;
394
398
        re->progress = float_nothing;
395
399
        re->test_break = default_break;
396
400
        if (G.background)
398
402
        else
399
403
                re->stats_draw = stats_nothing;
400
404
        /* clear callback handles */
401
 
        re->dih = re->dch = re->ddh = re->sdh = re->prh = re->tbh = NULL;
 
405
        re->dih = re->dch = re->duh = re->sdh = re->prh = re->tbh = NULL;
402
406
}
403
407
 
404
408
/* only call this while you know it will remove the link too */
408
412
                RE_engine_free(re->engine);
409
413
 
410
414
        BLI_rw_mutex_end(&re->resultmutex);
 
415
 
 
416
        BLI_freelistN(&re->r.layers);
411
417
        
412
418
        /* main dbase can already be invalid now, some database-free code checks it */
413
419
        re->main = NULL;
420
426
        render_result_free(re->pushedresult);
421
427
        
422
428
        BLI_remlink(&RenderGlobal.renderlist, re);
 
429
        MEM_freeN(re->eval_ctx);
423
430
        MEM_freeN(re);
424
431
}
425
432
 
502
509
        re->ok = TRUE;   /* maybe flag */
503
510
        
504
511
        re->i.starttime = PIL_check_seconds_timer();
505
 
        re->r = *rd;     /* hardcopy */
 
512
 
 
513
        /* copy render data and render layers for thread safety */
 
514
        BLI_freelistN(&re->r.layers);
 
515
        re->r = *rd;
 
516
        BLI_duplicatelist(&re->r.layers, &rd->layers);
506
517
 
507
518
        if (source) {
508
519
                /* reuse border flags from source renderer */
577
588
        }
578
589
        
579
590
        if (srl) {
580
 
                int index = BLI_findindex(&re->r.layers, srl);
 
591
                int index = BLI_findindex(&rd->layers, srl);
581
592
                if (index != -1) {
582
593
                        re->r.actlay = index;
583
594
                        re->r.scemode |= R_SINGLE_LAYER;
597
608
                        re->result = NULL;
598
609
                }
599
610
                else if (re->result) {
600
 
                        if (re->result->rectx == re->rectx && re->result->recty == re->recty) {
 
611
                        SceneRenderLayer *actsrl = BLI_findlink(&re->r.layers, re->r.actlay);
 
612
                        RenderLayer *rl;
 
613
                        bool have_layer = false;
 
614
 
 
615
                        for (rl = re->result->layers.first; rl; rl = rl->next)
 
616
                                if (STREQ(rl->name, actsrl->name))
 
617
                                        have_layer = true;
 
618
 
 
619
                        if (re->result->rectx == re->rectx && re->result->recty == re->recty &&
 
620
                            have_layer)
 
621
                        {
601
622
                                /* keep render result, this avoids flickering black tiles
602
623
                                 * when the preview changes */
603
624
                        }
709
730
        re->display_clear = f;
710
731
        re->dch = handle;
711
732
}
712
 
void RE_display_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr, volatile rcti *rect))
 
733
void RE_display_update_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr, volatile rcti *rect))
713
734
{
714
 
        re->display_draw = f;
715
 
        re->ddh = handle;
 
735
        re->display_update = f;
 
736
        re->duh = handle;
716
737
}
717
738
void RE_stats_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderStats *rs))
718
739
{
751
772
 
752
773
/* *************************************** */
753
774
 
754
 
static int render_display_draw_enabled(Render *re)
 
775
static int render_display_update_enabled(Render *re)
755
776
{
756
777
        /* don't show preprocess for previewrender sss */
757
778
        if (re->sss_points)
775
796
                else
776
797
                        pa->result = render_result_new(&R, &pa->disprect, pa->crop, RR_USE_MEM, RR_ALL_LAYERS);
777
798
 
 
799
                /* Copy EXR tile settings, so pipeline knows whether this is a result
 
800
                 * for Save Buffers enabled rendering.
 
801
                 *
 
802
                 * TODO(sergey): This actually duplicates logic with external engine, so
 
803
                 * worth looking into more generic solution.
 
804
                 */
 
805
                pa->result->do_exr_tile = R.result->do_exr_tile;
 
806
 
778
807
                if (R.sss_points)
779
808
                        zbufshade_sss_tile(pa);
780
809
                else if (R.osa)
790
819
                if (R.result->do_exr_tile) {
791
820
                        render_result_exr_file_merge(R.result, pa->result);
792
821
                }
793
 
                else if (render_display_draw_enabled(&R)) {
 
822
                else if (render_display_update_enabled(&R)) {
794
823
                        /* on break, don't merge in result for preview renders, looks nicer */
795
824
                        if (R.test_break(R.tbh) && (R.r.scemode & (R_BUTS_PREVIEW|R_VIEWPORT_PREVIEW))) {
796
825
                                /* pass */
941
970
        ThreadQueue *donequeue;
942
971
        
943
972
        int number;
 
973
 
 
974
        void (*display_update)(void *handle, RenderResult *rr, volatile rcti *rect);
 
975
        void *duh;
944
976
} RenderThread;
945
977
 
946
978
static void *do_render_thread(void *thread_v)
951
983
        while ((pa = BLI_thread_queue_pop(thread->workqueue))) {
952
984
                pa->thread = thread->number;
953
985
                do_part_thread(pa);
 
986
 
 
987
                if (thread->display_update) {
 
988
                        thread->display_update(thread->duh, pa->result, NULL);
 
989
                }
 
990
 
954
991
                BLI_thread_queue_push(thread->donequeue, pa);
955
992
                
956
993
                if (R.test_break(R.tbh))
976
1013
        if (re->result == NULL || !(re->r.scemode & (R_BUTS_PREVIEW|R_VIEWPORT_PREVIEW))) {
977
1014
                render_result_free(re->result);
978
1015
 
979
 
                if (re->sss_points && render_display_draw_enabled(re))
 
1016
                if (re->sss_points && render_display_update_enabled(re))
980
1017
                        re->result = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS);
981
1018
                else if (re->r.scemode & R_FULL_SAMPLE)
982
1019
                        re->result = render_result_new_full_sample(re, &re->fullresult, &re->disprect, 0, RR_USE_EXR);
1025
1062
                        thread[a].workqueue = workqueue;
1026
1063
                        thread[a].donequeue = donequeue;
1027
1064
                        thread[a].number = a;
 
1065
 
 
1066
                        if (render_display_update_enabled(re)) {
 
1067
                                thread[a].display_update = re->display_update;
 
1068
                                thread[a].duh = re->duh;
 
1069
                        }
 
1070
                        else {
 
1071
                                thread[a].display_update = NULL;
 
1072
                                thread[a].duh = NULL;
 
1073
                        }
 
1074
 
1028
1075
                        BLI_insert_thread(&threads, &thread[a]);
1029
1076
                }
1030
1077
                
1038
1085
                        /* handle finished part */
1039
1086
                        if ((pa=BLI_thread_queue_pop_timeout(donequeue, wait))) {
1040
1087
                                if (pa->result) {
1041
 
                                        if (render_display_draw_enabled(re))
1042
 
                                                re->display_draw(re->ddh, pa->result, NULL);
1043
1088
                                        print_part_stats(re, pa);
1044
1089
                                        
1045
1090
                                        render_result_free_list(&pa->fullresult, pa->result);
1062
1107
                        /* redraw in progress parts */
1063
1108
                        elapsed = PIL_check_seconds_timer() - lastdraw;
1064
1109
                        if (elapsed > redrawtime) {
1065
 
                                if (render_display_draw_enabled(re))
 
1110
                                if (render_display_update_enabled(re))
1066
1111
                                        for (pa = re->parts.first; pa; pa = pa->next)
1067
1112
                                                if ((pa->status == PART_STATUS_IN_PROGRESS) && pa->nr && pa->result)
1068
 
                                                        re->display_draw(re->ddh, pa->result, &pa->result->renrect);
 
1113
                                                        re->display_update(re->duh, pa->result, &pa->result->renrect);
1069
1114
                                
1070
1115
                                lastdraw = PIL_check_seconds_timer();
1071
1116
                        }
1310
1355
        re->i.curblur = 0;   /* stats */
1311
1356
        
1312
1357
        /* make sure motion blur changes get reset to current frame */
1313
 
        if ((re->r.scemode & (R_NO_FRAME_UPDATE|R_BUTS_PREVIEW|R_VIEWPORT_PREVIEW))==0)
1314
 
                BKE_scene_update_for_newframe(re->main, re->scene, re->lay);
 
1358
        if ((re->r.scemode & (R_NO_FRAME_UPDATE|R_BUTS_PREVIEW|R_VIEWPORT_PREVIEW))==0) {
 
1359
                BKE_scene_update_for_newframe(re->eval_ctx, re->main, re->scene, re->lay);
 
1360
        }
1315
1361
        
1316
1362
        /* weak... the display callback wants an active renderlayer pointer... */
1317
1363
        re->result->renlay = render_get_active_layer(re, re->result);
1318
 
        re->display_draw(re->ddh, re->result, NULL);
 
1364
        re->display_update(re->duh, re->result, NULL);
1319
1365
}
1320
1366
 
1321
1367
 
1436
1482
 
1437
1483
        BLI_rw_mutex_unlock(&re->resultmutex);
1438
1484
 
1439
 
        re->display_draw(re->ddh, re->result, NULL);
 
1485
        re->display_update(re->duh, re->result, NULL);
1440
1486
}
1441
1487
 
1442
1488
/* make sure disprect is not affected by the render border */
1496
1542
                                BLI_rw_mutex_unlock(&re->resultmutex);
1497
1543
                
1498
1544
                                re->display_init(re->dih, re->result);
1499
 
                                re->display_draw(re->ddh, re->result, NULL);
 
1545
                                re->display_update(re->duh, re->result, NULL);
1500
1546
                        }
1501
1547
                        else {
1502
1548
                                /* set offset (again) for use in compositor, disprect was manipulated. */
1539
1585
        BKE_scene_set_background(re->main, sce);
1540
1586
 
1541
1587
        /* copy callbacks */
1542
 
        resc->display_draw = re->display_draw;
1543
 
        resc->ddh = re->ddh;
 
1588
        resc->display_update = re->display_update;
 
1589
        resc->duh = re->duh;
1544
1590
        resc->test_break = re->test_break;
1545
1591
        resc->tbh = re->tbh;
1546
1592
        resc->stats_draw = re->stats_draw;
1580
1626
        return false;
1581
1627
}
1582
1628
 
 
1629
bool RE_allow_render_generic_object(Object *ob)
 
1630
{
 
1631
        /* override not showing object when duplis are used with particles */
 
1632
        if (ob->transflag & OB_DUPLIPARTS) {
 
1633
                /* pass */  /* let particle system(s) handle showing vs. not showing */
 
1634
        }
 
1635
        else if ((ob->transflag & OB_DUPLI) && !(ob->transflag & OB_DUPLIFRAMES)) {
 
1636
                return false;
 
1637
        }
 
1638
        return true;
 
1639
}
 
1640
 
 
1641
/* Issue here is that it's possible that object which is used by boolean,
 
1642
 * array or shrinkwrap modifiers weren't displayed in the viewport before
 
1643
 * rendering. This leads to situations when apply() of this modifiers
 
1644
 * could not get ob->derivedFinal and modifiers are not being applied.
 
1645
 *
 
1646
 * This was worked around by direct call of get_derived_final() from those
 
1647
 * modifiers, but such approach leads to write conflicts with threaded
 
1648
 * update.
 
1649
 *
 
1650
 * Here we make sure derivedFinal will be calculated by update_for_newframe
 
1651
 * function later in the pipeline and all the modifiers are applied
 
1652
 * properly without hacks from their side.
 
1653
 *                                                  - sergey -
 
1654
 */
 
1655
#define DEPSGRAPH_WORKAROUND_HACK
 
1656
 
 
1657
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1658
static void tag_dependend_objects_for_render(Scene *scene, int renderlay)
 
1659
{
 
1660
        Scene *sce_iter;
 
1661
        Base *base;
 
1662
        for (SETLOOPER(scene, sce_iter, base)) {
 
1663
                Object *object = base->object;
 
1664
 
 
1665
                if ((base->lay & renderlay) == 0) {
 
1666
                        continue;
 
1667
                }
 
1668
 
 
1669
                if (object->type == OB_MESH) {
 
1670
                        if (RE_allow_render_generic_object(object)) {
 
1671
                                ModifierData *md;
 
1672
                                VirtualModifierData virtualModifierData;
 
1673
 
 
1674
                                for (md = modifiers_getVirtualModifierList(object, &virtualModifierData);
 
1675
                                     md;
 
1676
                                     md = md->next)
 
1677
                                {
 
1678
                                        if (!modifier_isEnabled(scene, md, eModifierMode_Render)) {
 
1679
                                                continue;
 
1680
                                        }
 
1681
 
 
1682
                                        if (md->type == eModifierType_Boolean) {
 
1683
                                                BooleanModifierData *bmd = (BooleanModifierData *)md;
 
1684
                                                if (bmd->object && bmd->object->type == OB_MESH) {
 
1685
                                                        DAG_id_tag_update(&bmd->object->id, OB_RECALC_DATA);
 
1686
                                                }
 
1687
                                        }
 
1688
                                        else if (md->type == eModifierType_Array) {
 
1689
                                                ArrayModifierData *amd = (ArrayModifierData *)md;
 
1690
                                                if (amd->start_cap && amd->start_cap->type == OB_MESH) {
 
1691
                                                        DAG_id_tag_update(&amd->start_cap->id, OB_RECALC_DATA);
 
1692
                                                }
 
1693
                                                if (amd->end_cap && amd->end_cap->type == OB_MESH) {
 
1694
                                                        DAG_id_tag_update(&amd->end_cap->id, OB_RECALC_DATA);
 
1695
                                                }
 
1696
                                        }
 
1697
                                        else if (md->type == eModifierType_Shrinkwrap) {
 
1698
                                                ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *)md;
 
1699
                                                if (smd->target  && smd->target->type == OB_MESH) {
 
1700
                                                        DAG_id_tag_update(&smd->target->id, OB_RECALC_DATA);
 
1701
                                                }
 
1702
                                        }
 
1703
                                }
 
1704
                        }
 
1705
                }
 
1706
        }
 
1707
}
 
1708
#endif
 
1709
 
1583
1710
static void tag_scenes_for_render(Render *re)
1584
1711
{
1585
1712
        bNode *node;
1586
1713
        Scene *sce;
 
1714
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1715
        int renderlay = re->lay;
 
1716
#endif
1587
1717
        
1588
 
        for (sce = re->main->scene.first; sce; sce = sce->id.next)
 
1718
        for (sce = re->main->scene.first; sce; sce = sce->id.next) {
1589
1719
                sce->id.flag &= ~LIB_DOIT;
 
1720
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1721
                tag_dependend_objects_for_render(sce, renderlay);
 
1722
#endif
 
1723
        }
1590
1724
        
1591
1725
#ifdef WITH_FREESTYLE
1592
 
        for (sce = re->freestyle_bmain.scene.first; sce; sce = sce->id.next)
 
1726
        for (sce = re->freestyle_bmain.scene.first; sce; sce = sce->id.next) {
1593
1727
                sce->id.flag &= ~LIB_DOIT;
 
1728
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1729
                tag_dependend_objects_for_render(sce, renderlay);
 
1730
#endif
 
1731
        }
1594
1732
#endif
1595
1733
 
1596
 
        if (RE_GetCamera(re) && composite_needs_render(re->scene, 1))
 
1734
        if (RE_GetCamera(re) && composite_needs_render(re->scene, 1)) {
1597
1735
                re->scene->id.flag |= LIB_DOIT;
 
1736
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1737
                tag_dependend_objects_for_render(re->scene, renderlay);
 
1738
#endif
 
1739
        }
1598
1740
        
1599
1741
        if (re->scene->nodetree == NULL) return;
1600
1742
        
1601
1743
        /* check for render-layers nodes using other scenes, we tag them LIB_DOIT */
1602
1744
        for (node = re->scene->nodetree->nodes.first; node; node = node->next) {
 
1745
                node->flag &= ~NODE_TEST;
1603
1746
                if (node->type == CMP_NODE_R_LAYERS) {
1604
1747
                        if (node->id) {
1605
1748
                                if (!MAIN_VERSION_ATLEAST(re->main, 265, 5)) {
1617
1760
                                        }
1618
1761
                                }
1619
1762
 
1620
 
                                if (node->id != (ID *)re->scene)
1621
 
                                        node->id->flag |= LIB_DOIT;
 
1763
                                if (node->id != (ID *)re->scene) {
 
1764
                                        if ((node->id->flag & LIB_DOIT) == 0) {
 
1765
                                                node->flag |= NODE_TEST;
 
1766
                                                node->id->flag |= LIB_DOIT;
 
1767
#ifdef DEPSGRAPH_WORKAROUND_HACK
 
1768
                                                tag_dependend_objects_for_render((Scene *) node->id, renderlay);
 
1769
#endif
 
1770
                                        }
 
1771
                                }
1622
1772
                        }
1623
1773
                }
1624
1774
        }
1640
1790
        for (node = re->scene->nodetree->nodes.first; node; node = node->next) {
1641
1791
                if (node->type == CMP_NODE_R_LAYERS) {
1642
1792
                        if (node->id && node->id != (ID *)re->scene) {
1643
 
                                if (node->id->flag & LIB_DOIT) {
 
1793
                                if (node->flag & NODE_TEST) {
1644
1794
                                        Scene *scene = (Scene *)node->id;
1645
1795
 
1646
1796
                                        render_scene(re, scene, cfra);
1647
1797
                                        restore_scene = (scene != re->scene);
1648
 
                                        node->id->flag &= ~LIB_DOIT;
 
1798
                                        node->flag &= ~NODE_TEST;
1649
1799
                                        
1650
1800
                                        nodeUpdate(re->scene->nodetree, node);
1651
1801
                                }
1679
1829
         * real bmain uses. This is needed because freestyle's
1680
1830
         * bmain could be used to tag scenes for update, which
1681
1831
         * implies call of ED_render_scene_update in some cases
1682
 
         * and that function requires proper windoew manager
 
1832
         * and that function requires proper window manager
1683
1833
         * to present (sergey)
1684
1834
         */
1685
1835
        re->freestyle_bmain.wm = re->main->wm;
1814
1964
                        ntreeCompositTagRender(re->scene);
1815
1965
                        ntreeCompositTagAnimated(ntree);
1816
1966
                        
1817
 
                        ntreeCompositExecTree(ntree, &re->r, TRUE, G.background == 0, &re->scene->view_settings, &re->scene->display_settings);
 
1967
                        ntreeCompositExecTree(re->scene, ntree, &re->r, TRUE, G.background == 0, &re->scene->view_settings, &re->scene->display_settings);
1818
1968
                }
1819
1969
                
1820
1970
                /* ensure we get either composited result or the active layer */
1844
1994
                if (sample != re->osa - 1) {
1845
1995
                        /* weak... the display callback wants an active renderlayer pointer... */
1846
1996
                        re->result->renlay = render_get_active_layer(re, re->result);
1847
 
                        re->display_draw(re->ddh, re->result, NULL);
 
1997
                        re->display_update(re->duh, re->result, NULL);
1848
1998
                }
1849
1999
                
1850
2000
                if (re->test_break(re->tbh))
2005
2155
                                R.stats_draw = re->stats_draw;
2006
2156
                                
2007
2157
                                if (update_newframe)
2008
 
                                        BKE_scene_update_for_newframe(re->main, re->scene, re->lay);
 
2158
                                        BKE_scene_update_for_newframe(re->eval_ctx, re->main, re->scene, re->lay);
2009
2159
                                
2010
2160
                                if (re->r.scemode & R_FULL_SAMPLE)
2011
2161
                                        do_merge_fullsample(re, ntree);
2012
2162
                                else {
2013
 
                                        ntreeCompositExecTree(ntree, &re->r, TRUE, G.background == 0, &re->scene->view_settings, &re->scene->display_settings);
 
2163
                                        ntreeCompositExecTree(re->scene, ntree, &re->r, TRUE, G.background == 0, &re->scene->view_settings, &re->scene->display_settings);
2014
2164
                                }
2015
2165
                                
2016
2166
                                ntree->stats_draw = NULL;
2029
2179
 
2030
2180
        /* weak... the display callback wants an active renderlayer pointer... */
2031
2181
        re->result->renlay = render_get_active_layer(re, re->result);
2032
 
        re->display_draw(re->ddh, re->result, NULL);
 
2182
        re->display_update(re->duh, re->result, NULL);
2033
2183
}
2034
2184
 
2035
2185
static void renderresult_stampinfo(Render *re)
2080
2230
        if ((re->r.mode & R_BORDER) && (re->r.mode & R_CROP) == 0) {
2081
2231
                /* if border rendering is used and cropping is disabled, final buffer should
2082
2232
                 * be as large as the whole frame */
2083
 
                context = BKE_sequencer_new_render_data(re->main, re->scene,
2084
 
                                              re->winx, re->winy,
2085
 
                                              100);
 
2233
                context = BKE_sequencer_new_render_data(re->eval_ctx, re->main, re->scene,
 
2234
                                                        re->winx, re->winy, 100);
2086
2235
        }
2087
2236
        else {
2088
 
                context = BKE_sequencer_new_render_data(re->main, re->scene,
2089
 
                                              re->result->rectx, re->result->recty,
2090
 
                                              100);
 
2237
                context = BKE_sequencer_new_render_data(re->eval_ctx, re->main, re->scene,
 
2238
                                                        re->result->rectx, re->result->recty, 100);
2091
2239
        }
2092
2240
 
2093
 
        out = BKE_sequencer_give_ibuf(context, cfra, 0);
 
2241
        out = BKE_sequencer_give_ibuf(&context, cfra, 0);
2094
2242
 
2095
2243
        if (out) {
2096
2244
                ibuf = IMB_dupImBuf(out);
2135
2283
                re->progress(re->prh, 1.0f);
2136
2284
 
2137
2285
        /* would mark display buffers as invalid */
2138
 
        re->display_draw(re->ddh, re->result, NULL);
 
2286
        re->display_update(re->duh, re->result, NULL);
2139
2287
}
2140
2288
 
2141
2289
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
2159
2307
                        do_render_seq(re);
2160
2308
                
2161
2309
                re->stats_draw(re->sdh, &re->i);
2162
 
                re->display_draw(re->ddh, re->result, NULL);
 
2310
                re->display_update(re->duh, re->result, NULL);
2163
2311
        }
2164
2312
        else {
2165
2313
                re->pool = BKE_image_pool_new();
2177
2325
        /* stamp image info here */
2178
2326
        if ((re->r.stamp & R_STAMP_ALL) && (re->r.stamp & R_STAMP_DRAW)) {
2179
2327
                renderresult_stampinfo(re);
2180
 
                re->display_draw(re->ddh, re->result, NULL);
2181
 
        }
2182
 
}
2183
 
 
2184
 
static int check_valid_camera(Scene *scene, Object *camera_override)
2185
 
{
2186
 
        int check_comp = 1;
2187
 
 
 
2328
                re->display_update(re->duh, re->result, NULL);
 
2329
        }
 
2330
}
 
2331
 
 
2332
bool RE_force_single_renderlayer(Scene *scene)
 
2333
{
 
2334
        int scemode = check_mode_full_sample(&scene->r);
 
2335
        if (scemode & R_SINGLE_LAYER) {
 
2336
                SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 
2337
                /* force layer to be enabled */
 
2338
                if (srl->layflag & SCE_LAY_DISABLE) {
 
2339
                        srl->layflag &= ~SCE_LAY_DISABLE;
 
2340
                        return true;
 
2341
                }
 
2342
        }
 
2343
        return false;
 
2344
}
 
2345
 
 
2346
static bool check_valid_compositing_camera(Scene *scene, Object *camera_override)
 
2347
{
 
2348
        if (scene->r.scemode & R_DOCOMP && scene->use_nodes) {
 
2349
                bNode *node = scene->nodetree->nodes.first;
 
2350
 
 
2351
                while (node) {
 
2352
                        if (node->type == CMP_NODE_R_LAYERS) {
 
2353
                                Scene *sce = node->id ? (Scene *)node->id : scene;
 
2354
 
 
2355
                                if (!sce->camera && !BKE_scene_camera_find(sce)) {
 
2356
                                        /* all render layers nodes need camera */
 
2357
                                        return false;
 
2358
                                }
 
2359
                        }
 
2360
 
 
2361
                        node = node->next;
 
2362
                }
 
2363
 
 
2364
                return true;
 
2365
        }
 
2366
        else {
 
2367
                return (camera_override != NULL || scene->camera != NULL);
 
2368
        }
 
2369
}
 
2370
 
 
2371
static int check_valid_camera(Scene *scene, Object *camera_override, ReportList *reports)
 
2372
{
2188
2373
        if (camera_override == NULL && scene->camera == NULL)
2189
2374
                scene->camera = BKE_scene_camera_find(scene);
2190
2375
 
2191
 
        if (scene->r.scemode & R_DOSEQ) {
 
2376
        if (RE_seq_render_active(scene, &scene->r)) {
2192
2377
                if (scene->ed) {
2193
2378
                        Sequence *seq = scene->ed->seqbase.first;
2194
2379
 
2195
 
                        check_comp = 0;
2196
 
 
2197
2380
                        while (seq) {
2198
2381
                                if (seq->type == SEQ_TYPE_SCENE && seq->scene) {
2199
2382
                                        if (!seq->scene_camera) {
2200
2383
                                                if (!seq->scene->camera && !BKE_scene_camera_find(seq->scene)) {
2201
 
                                                        if (seq->scene == scene) {
2202
 
                                                                /* for current scene camera could be unneeded due to compisite nodes */
2203
 
                                                                check_comp = 1;
2204
 
                                                        }
2205
 
                                                        else {
2206
 
                                                                /* for other scenes camera is necessary */
2207
 
                                                                return 0;
 
2384
                                                        /* camera could be unneeded due to composite nodes */
 
2385
                                                        Object *override = (seq->scene == scene) ? camera_override : NULL;
 
2386
 
 
2387
                                                        if (!check_valid_compositing_camera(seq->scene, override)) {
 
2388
                                                                BKE_reportf(reports, RPT_ERROR, "No camera found in scene \"%s\"", seq->scene->id.name+2);
 
2389
                                                                return false;
2208
2390
                                                        }
2209
2391
                                                }
2210
2392
                                        }
2214
2396
                        }
2215
2397
                }
2216
2398
        }
2217
 
 
2218
 
        if (check_comp) { /* no sequencer or sequencer depends on compositor */
2219
 
                if (scene->r.scemode & R_DOCOMP && scene->use_nodes) {
2220
 
                        bNode *node = scene->nodetree->nodes.first;
2221
 
 
2222
 
                        while (node) {
2223
 
                                if (node->type == CMP_NODE_R_LAYERS) {
2224
 
                                        Scene *sce = node->id ? (Scene *)node->id : scene;
2225
 
 
2226
 
                                        if (!sce->camera && !BKE_scene_camera_find(sce)) {
2227
 
                                                /* all render layers nodes need camera */
2228
 
                                                return 0;
2229
 
                                        }
2230
 
                                }
2231
 
 
2232
 
                                node = node->next;
2233
 
                        }
2234
 
                }
2235
 
                else {
2236
 
                        return (camera_override != NULL || scene->camera != NULL);
2237
 
                }
 
2399
        else if (!check_valid_compositing_camera(scene, camera_override)) {
 
2400
                BKE_report(reports, RPT_ERROR, "No camera found in scene");
 
2401
                return false;
2238
2402
        }
2239
2403
 
2240
 
        return 1;
 
2404
        return true;
2241
2405
}
2242
2406
 
2243
2407
static int node_tree_has_composite_output(bNodeTree *ntree)
2265
2429
        return node_tree_has_composite_output(scene->nodetree);
2266
2430
}
2267
2431
 
2268
 
int RE_is_rendering_allowed(Scene *scene, Object *camera_override, ReportList *reports)
 
2432
bool RE_is_rendering_allowed(Scene *scene, Object *camera_override, ReportList *reports)
2269
2433
{
2270
2434
        SceneRenderLayer *srl;
2271
2435
        int scemode = check_mode_full_sample(&scene->r);
2319
2483
        }
2320
2484
        
2321
2485
        /* check valid camera, without camera render is OK (compo, seq) */
2322
 
        if (!check_valid_camera(scene, camera_override)) {
2323
 
                BKE_report(reports, RPT_ERROR, "No camera");
 
2486
        if (!check_valid_camera(scene, camera_override, reports)) {
2324
2487
                return 0;
2325
2488
        }
2326
2489
        
2341
2504
                }
2342
2505
#endif
2343
2506
        }
2344
 
 
 
2507
        
2345
2508
        /* layer flag tests */
2346
 
        if (scemode & R_SINGLE_LAYER) {
2347
 
                srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
2348
 
                /* force layer to be enabled */
2349
 
                srl->layflag &= ~SCE_LAY_DISABLE;
2350
 
        }
2351
 
        
2352
2509
        for (srl = scene->r.layers.first; srl; srl = srl->next)
2353
2510
                if (!(srl->layflag & SCE_LAY_DISABLE))
2354
2511
                        break;
2534
2691
 
2535
2692
        /* write movie or image */
2536
2693
        if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
2537
 
                int do_free = FALSE;
 
2694
                bool do_free = false;
2538
2695
                ImBuf *ibuf = render_result_rect_to_ibuf(&rres, &scene->r);
2539
2696
 
2540
2697
                /* note; the way it gets 32 bits rects is weak... */
2645
2802
 
2646
2803
        re->flag |= R_ANIMATION;
2647
2804
 
2648
 
        if (BKE_imtype_is_movie(scene->r.im_format.imtype))
2649
 
                if (!mh->start_movie(scene, &re->r, re->rectx, re->recty, re->reports))
 
2805
        if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
 
2806
                int width, height;
 
2807
                if (re->r.mode & R_BORDER) {
 
2808
                        if ((re->r.mode & R_CROP) == 0) {
 
2809
                                width = re->winx;
 
2810
                                height = re->winy;
 
2811
                        }
 
2812
                        else {
 
2813
                                width = re->rectx;
 
2814
                                height = re->recty;
 
2815
                        }
 
2816
                }
 
2817
                else {
 
2818
                        width = re->rectx;
 
2819
                        height = re->recty;
 
2820
                }
 
2821
 
 
2822
                if (!mh->start_movie(scene, &re->r, width, height, re->reports))
2650
2823
                        G.is_break = TRUE;
 
2824
        }
2651
2825
 
2652
2826
        if (mh->get_next_frame) {
2653
2827
                while (!(G.is_break == 1)) {
2696
2870
                                else
2697
2871
                                        updatelay = re->lay;
2698
2872
 
2699
 
                                BKE_scene_update_for_newframe(bmain, scene, updatelay);
 
2873
                                BKE_scene_update_for_newframe(re->eval_ctx, bmain, scene, updatelay);
2700
2874
                                continue;
2701
2875
                        }
2702
2876
                        else