← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/src/renderwin.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/renderwin.c
1
1
/**
2
 
 * $Id: renderwin.c,v 1.34 2004/04/27 12:17:16 ton Exp $
 
2
 * $Id: renderwin.c,v 1.53 2005/06/06 13:10:02 ton Exp $
3
3
 *
4
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5
5
 *
53
53
 
54
54
#endif
55
55
 
 
56
#include <limits.h>
 
57
 
56
58
#include "BLI_blenlib.h"
57
59
 
58
60
#include "MEM_guardedalloc.h"
72
74
#include "BIF_screen.h"
73
75
#include "BIF_space.h"
74
76
#include "BIF_mywindow.h"
 
77
#include "BIF_previewrender.h"
75
78
#include "BIF_renderwin.h"
 
79
#include "BIF_resources.h"
76
80
#include "BIF_toets.h"
77
81
 
78
82
#include "BDR_editobject.h"
 
83
#include "BPY_extern.h" /* for BPY_do_all_scripts */
79
84
 
80
85
#include "BSE_view.h"
81
86
#include "BSE_drawview.h"
108
113
*/
109
114
#define RW_FLAGS_PIXEL_EXAMINING        (1<<3)
110
115
 
 
116
/* forces draw of alpha */
 
117
#define RW_FLAGS_ALPHA          (1<<4)
 
118
 
 
119
/* space for info text */
 
120
#define RW_HEADERY              18
111
121
 
112
122
typedef struct {
113
123
        Window *win;
123
133
        float pan_mouse_start[2], pan_ofs_start[2];
124
134
 
125
135
        char *info_text;
 
136
        char *render_text, *render_text_spare;
 
137
        
126
138
} RenderWin;
127
139
 
128
140
static RenderWin *render_win= NULL;
140
152
        rw->flags= 0;
141
153
        rw->zoomofs[0]= rw->zoomofs[1]= 0;
142
154
        rw->info_text= NULL;
 
155
        rw->render_text= rw->render_text_spare= NULL;
143
156
 
144
157
        rw->lmouse[0]= rw->lmouse[1]= 0;
145
158
        rw->mbut[0]= rw->mbut[1]= rw->mbut[2]= 0;
165
178
        int w, h;
166
179
 
167
180
        window_get_size(rw->win, &w, &h);
 
181
        h-= RW_HEADERY;
168
182
 
169
183
        display_w= R.rectx*rw->zoom;
170
184
        display_h= R.recty*rw->zoom;
202
216
        int w, h;
203
217
 
204
218
        window_get_size(rw->win, &w, &h);
 
219
        h-= RW_HEADERY;
205
220
 
206
221
        ndc_r[0]=  ((float)(win_co[0]*2)/(w-1) - 1.0);
207
222
        ndc_r[1]=  ((float)(win_co[1]*2)/(h-1) - 1.0);
223
238
 
224
239
        /* now calculate a zoom for when image is larger than window */
225
240
        window_get_size(rw->win, &w, &h);
226
 
                /* at this point the r.rectx/y values are not correct yet */
 
241
        h-= RW_HEADERY;
 
242
        
 
243
        /* at this point the r.rectx/y values are not correct yet */
227
244
        rectx= (G.scene->r.size*G.scene->r.xsch)/100;
228
245
        recty= (G.scene->r.size*G.scene->r.ysch)/100;
229
 
 
 
246
        
 
247
        /* crop option makes image smaller */
 
248
        if ((G.scene->r.mode & R_BORDER) && (G.scene->r.mode & R_MOVIECROP)) { 
 
249
                if(!(G.scene->r.scemode & R_OGL)) {
 
250
                        rectx*= (G.scene->r.border.xmax-G.scene->r.border.xmin);
 
251
                        recty*= (G.scene->r.border.ymax-G.scene->r.border.ymin);
 
252
                }
 
253
        }
 
254
        
230
255
        if(rectx>w || recty>h) {
231
256
                if(rectx-w > recty-h) rw->zoom= ((float)w)/((float)rectx);
232
257
                else rw->zoom= ((float)h)/((float)recty);
237
262
        renderwin_queue_redraw(rw);
238
263
}
239
264
 
 
265
static void renderwin_draw_render_info(RenderWin *rw)
 
266
{
 
267
        /* render text is added to top */
 
268
        if(RW_HEADERY) {
 
269
                float colf[3];
 
270
                rcti rect;
 
271
                
 
272
                window_get_size(rw->win, &rect.xmax, &rect.ymax);
 
273
                rect.xmin= 0;
 
274
                rect.ymin= rect.ymax-RW_HEADERY;
 
275
                glEnable(GL_SCISSOR_TEST);
 
276
                glaDefine2DArea(&rect);
 
277
                
 
278
                /* clear header rect */
 
279
                BIF_SetTheme(NULL);     // sets view3d theme by default
 
280
                BIF_GetThemeColor3fv(TH_HEADER, colf);
 
281
                glClearColor(colf[0], colf[1], colf[2], 1.0); 
 
282
                glClear(GL_COLOR_BUFFER_BIT);
 
283
                
 
284
                if(rw->render_text) {
 
285
                        BIF_ThemeColor(TH_TEXT);
 
286
                        glRasterPos2i(12, 5);
 
287
                        BMF_DrawString(G.fonts, rw->render_text);
 
288
                }
 
289
        }       
 
290
        
 
291
}
 
292
 
240
293
static void renderwin_draw(RenderWin *rw, int just_clear)
241
294
{
242
295
        float disprect[2][2];
 
296
        int set_back_mainwindow;
243
297
        rcti rect;
244
 
 
 
298
        
 
299
        /* since renderwin uses callbacks (controlled by ghost) it can
 
300
           mess up active window output with redraw events after a render. 
 
301
           this is patchy, still WIP */
 
302
        set_back_mainwindow = (winlay_get_active_window() != rw->win);
 
303
        window_make_active(rw->win);
 
304
        
245
305
        rect.xmin= rect.ymin= 0;
246
306
        window_get_size(rw->win, &rect.xmax, &rect.ymax);
 
307
        rect.ymax-= RW_HEADERY;
 
308
        
247
309
        renderwin_get_disprect(rw, disprect);
248
310
        
249
 
        window_make_active(rw->win);
 
311
        /* do this first, so window ends with correct scissor */
 
312
        renderwin_draw_render_info(rw);
250
313
        
251
314
        glEnable(GL_SCISSOR_TEST);
252
315
        glaDefine2DArea(&rect);
259
322
                glRectfv(disprect[0], disprect[1]);
260
323
        } else {
261
324
                glPixelZoom(rw->zoom, rw->zoom);
262
 
                glaDrawPixelsSafe(disprect[0][0], disprect[0][1], R.rectx, R.recty, R.rectot);
 
325
                if(rw->flags & RW_FLAGS_ALPHA) {
 
326
                        char *rect= (char *)R.rectot;
 
327
                        
 
328
                        glColorMask(1, 0, 0, 0);
 
329
                        glaDrawPixelsSafe(disprect[0][0], disprect[0][1], R.rectx, R.recty, rect+3);
 
330
                        glColorMask(0, 1, 0, 0);
 
331
                        glaDrawPixelsSafe(disprect[0][0], disprect[0][1], R.rectx, R.recty, rect+2);
 
332
                        glColorMask(0, 0, 1, 0);
 
333
                        glaDrawPixelsSafe(disprect[0][0], disprect[0][1], R.rectx, R.recty, rect+1);
 
334
                        glColorMask(1, 1, 1, 1);
 
335
                        
 
336
                }
 
337
                else {
 
338
                        glaDrawPixelsSafe(disprect[0][0], disprect[0][1], R.rectx, R.recty, R.rectot);
 
339
                }
263
340
                glPixelZoom(1.0, 1.0);
264
341
        }
265
342
        
 
343
        /* info text is overlayed on bottom */
266
344
        if (rw->info_text) {
267
345
                float w;
268
346
                glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
275
353
                glRasterPos2i(10, 10);
276
354
                BMF_DrawString(G.font, rw->info_text);
277
355
        }
278
 
 
 
356
        
279
357
        window_swap_buffers(rw->win);
 
358
        
 
359
        if (set_back_mainwindow) mainwindow_make_active();      
280
360
}
281
361
 
282
362
/* ------ interactivity calls for RenderWin ------------- */
286
366
        if (rw->flags & RW_FLAGS_PIXEL_EXAMINING) {
287
367
                int imgco[2];
288
368
                char buf[64];
 
369
                int *pxlz;      // zbuffer is signed 
 
370
                char *pxl;
289
371
 
290
372
                if (R.rectot && renderwin_win_to_image_co(rw, rw->lmouse, imgco)) {
291
 
                        unsigned char *pxl= (char*) &R.rectot[R.rectx*imgco[1] + imgco[0]];
 
373
                        pxl= (char*) &R.rectot[R.rectx*imgco[1] + imgco[0]];
 
374
                        
 
375
                        if (R.rectz) {
 
376
                                pxlz= &R.rectz[R.rectx*imgco[1] + imgco[0]];                    
 
377
                                sprintf(buf, "R: %d, G: %d, B: %d, A: %d, Z: %f", pxl[0], pxl[1], pxl[2], pxl[3], 0.5+0.5*( ((float)*pxlz)/(float)INT_MAX) );
 
378
                        }
 
379
                        else {
 
380
                                sprintf(buf, "R: %d, G: %d, B: %d, A: %d", pxl[0], pxl[1], pxl[2], pxl[3]);                     
 
381
                        }
292
382
 
293
 
                        sprintf(buf, "R: %d, G: %d, B: %d, A: %d", pxl[0], pxl[1], pxl[2], pxl[3]);
294
383
                        renderwin_set_infotext(rw, buf);
295
384
                        renderwin_queue_redraw(rw);
296
385
                } else {
314
403
                int w, h;
315
404
 
316
405
                window_get_size(rw->win, &w, &h);
 
406
                h-= RW_HEADERY;
317
407
                renderwin_win_to_ndc(rw, rw->lmouse, ndc);
318
408
 
319
409
                rw->zoomofs[0]= -0.5*ndc[0]*(w-R.rectx*rw->zoom)/rw->zoom;
354
444
{
355
445
        RenderWin *rw= user_data;
356
446
 
 
447
        // added this for safety, while render it's just creating bezerk results
 
448
        if(R.flag & R_RENDERING) {
 
449
                if(evt==ESCKEY && val) 
 
450
                        rw->flags|= RW_FLAGS_ESCAPE;
 
451
                return;
 
452
        }
 
453
        
357
454
        if (evt==RESHAPE) {
358
455
                renderwin_reshape(rw);
359
456
        } 
393
490
                                rw->active= 0;
394
491
                        }
395
492
                } 
 
493
                else if( evt==AKEY) {
 
494
                        rw->flags ^= RW_FLAGS_ALPHA;
 
495
                        renderwin_queue_redraw(render_win);
 
496
                }
396
497
                else if (evt==JKEY) {
397
498
                        if(R.flag==0) BIF_swap_render_rects();
398
499
                } 
445
546
        }
446
547
}
447
548
 
 
549
static char *renderwin_get_title(int doswap)
 
550
{
 
551
        static int swap= 0;
 
552
        char *title="";
 
553
        
 
554
        swap+= doswap;
 
555
        
 
556
        if(swap & 1) {
 
557
                if (G.scene->r.renderer==R_YAFRAY) title = "YafRay:Render (spare)";
 
558
                else title = "Blender:Render (spare)";
 
559
        }
 
560
        else {
 
561
                if (G.scene->r.renderer==R_YAFRAY) title = "YafRay:Render";
 
562
                else title = "Blender:Render";
 
563
        }
 
564
 
 
565
        return title;
 
566
}
448
567
 
449
568
/* opens window and allocs struct */
450
569
static void open_renderwin(int winpos[2], int winsize[2])
451
570
{
 
571
        extern void mywindow_build_and_set_renderwin( int orx, int ory, int sizex, int sizey); // mywindow.c
452
572
        Window *win;
453
 
        /* yafray: Window title change for yafray, totally unnecessary of course, but... */
454
 
        char* title;
455
 
        if (G.scene->r.renderer==R_YAFRAY)
456
 
                title = "YafRay:Render";
457
 
        else
458
 
                title = "Blender:Render";
459
 
 
460
 
        win= window_open(title, winpos[0], winpos[1], winsize[0], winsize[1], 0);
 
573
        char *title;
 
574
        
 
575
        title= renderwin_get_title(0);  /* 0 = no swap */
 
576
        win= window_open(title, winpos[0], winpos[1], winsize[0], winsize[1]+RW_HEADERY, 0);
461
577
 
462
578
        render_win= renderwin_alloc(win);
463
579
 
467
583
        winlay_process_events(0);
468
584
        window_make_active(render_win->win);
469
585
        winlay_process_events(0);
470
 
 
 
586
        
 
587
        /* mywindow has to know about it too */
 
588
        mywindow_build_and_set_renderwin(winpos[0], winpos[1], winsize[0], winsize[1]+RW_HEADERY);
 
589
        /* and we should be able to draw 3d in it */
 
590
        init_gl_stuff();
 
591
        
471
592
        renderwin_draw(render_win, 1);
472
593
        renderwin_draw(render_win, 1);
473
594
}
488
609
        
489
610
        rendersize_r[0]= (G.scene->r.size*G.scene->r.xsch)/100;
490
611
        rendersize_r[1]= (G.scene->r.size*G.scene->r.ysch)/100;
 
612
        
 
613
        /* crop option makes image smaller */
 
614
        if ((G.scene->r.mode & R_BORDER) && (G.scene->r.mode & R_MOVIECROP)) { 
 
615
                rendersize_r[0]*= (G.scene->r.border.xmax-G.scene->r.border.xmin);
 
616
                rendersize_r[1]*= (G.scene->r.border.ymax-G.scene->r.border.ymin);
 
617
        }
 
618
        
491
619
        if(G.scene->r.mode & R_PANORAMA) {
492
620
                rendersize_r[0]*= G.scene->r.xparts;
493
621
                rendersize_r[1]*= G.scene->r.yparts;
521
649
        if (G.afbreek == 0) {
522
650
                int rendersize[2], renderpos[2];
523
651
 
524
 
                calc_renderwin_rectangle(R.winpos, renderpos, rendersize);
 
652
                calc_renderwin_rectangle(G.winpos, renderpos, rendersize);
525
653
 
526
654
                if (!render_win) {
527
655
                        open_renderwin(renderpos, rendersize);
532
660
 
533
661
                        window_get_position(render_win->win, &win_x, &win_y);
534
662
                        window_get_size(render_win->win, &win_w, &win_h);
 
663
                        win_h-= RW_HEADERY;
535
664
 
536
665
                                /* XXX, this is nasty and I guess bound to cause problems,
537
666
                                 * but to ensure the window is at the user specified position
538
667
                                 * and size we reopen the window all the time... we need
539
668
                                 * a ghost _set_position to fix this -zr
540
669
                                 */
541
 
                        BIF_close_render_display();
542
 
                        open_renderwin(renderpos, rendersize);
 
670
                                 
 
671
                                 /* XXX, well... it is nasty yes, and reopens windows each time on
 
672
                                    subsequent renders. Better rule is to make it reopen only only
 
673
                                    size change, and use the preferred position only on open_renderwin
 
674
                                        cases (ton)
 
675
                                 */
 
676
                        if(rendersize[0]!= win_w || rendersize[1]!= win_h) {
 
677
                                BIF_close_render_display();
 
678
                                open_renderwin(renderpos, rendersize);
 
679
                        }
 
680
                        else {
 
681
                                window_raise(render_win->win);
 
682
                                window_make_active(render_win->win);
 
683
                                mywinset(2);    // to assign scissor/viewport again in mywindow.c. is hackish yes
 
684
                        }
543
685
 
544
686
                        renderwin_reset_view(render_win);
545
687
                        render_win->flags&= ~RW_FLAGS_ESCAPE;
546
688
                        render_win->active= 1;
547
689
                }
 
690
                /* make sure we are in normal draw again */
 
691
                render_win->flags &= ~RW_FLAGS_ALPHA;
548
692
        }
549
693
}
550
694
 
561
705
* ... better is to make this an optimization of a more clear
562
706
* implementation. the bug shows up when you do something like
563
707
* open the window, then draw part of the progress, then get
564
 
* a redraw event. whatever can go wrong will.
 
708
* a redraw event. whatever can go wrong will. -zr
 
709
*
 
710
* Note: blocked queue handling while rendering to prevent that (ton)
565
711
*/
566
712
 
567
713
/* in render window; display a couple of scanlines of rendered image (see callback below) */
572
718
 
573
719
        win_rct.xmin= win_rct.ymin= 0;
574
720
        window_get_size(rw->win, &win_rct.xmax, &win_rct.ymax);
 
721
        win_rct.ymax-= RW_HEADERY;
 
722
        
575
723
        renderwin_get_disprect(rw, disprect);
576
 
 
577
 
        window_make_active(rw->win);
 
724
        
 
725
        /* for efficiency & speed; not drawing in Blender UI while rendering */
 
726
        //window_make_active(rw->win);
578
727
 
579
728
        glEnable(GL_SCISSOR_TEST);
580
729
        glaDefine2DArea(&win_rct);
637
786
                rcti win_rct, vb;
638
787
 
639
788
                calc_viewborder(v3d, &vb);
640
 
 
 
789
                
 
790
                /* if border render  */
 
791
                if(G.scene->r.mode & R_BORDER) { 
 
792
                        
 
793
                        /* but, if image is full (at end of border render, without crop) we don't */
 
794
                        if(R.rectx != (G.scene->r.size*G.scene->r.xsch)/100 ||
 
795
                           R.recty != (G.scene->r.size*G.scene->r.ysch)/100 ) {
 
796
                        
 
797
                                facx= (float) (vb.xmax-vb.xmin);
 
798
                                facy= (float) (vb.ymax-vb.ymin);
 
799
                                
 
800
                                vb.xmax= vb.xmin + facx*G.scene->r.border.xmax;
 
801
                                vb.ymax= vb.ymin + facy*G.scene->r.border.ymax;
 
802
                                vb.xmin+= facx*G.scene->r.border.xmin;
 
803
                                vb.ymin+= facy*G.scene->r.border.ymin;
 
804
                        }
 
805
                }
 
806
                        
641
807
                facx= (float) (vb.xmax-vb.xmin)/R.rectx;
642
808
                facy= (float) (vb.ymax-vb.ymin)/R.recty;
643
809
 
662
828
        }
663
829
}
664
830
 
 
831
/* in 3d view; display stats of rendered image */
 
832
static void renderview_draw_render_info(char *str)
 
833
{
 
834
        if (render_view3d) {
 
835
                View3D *v3d= render_view3d;
 
836
                rcti vb, win_rct;
 
837
                
 
838
                calc_viewborder(v3d, &vb);
 
839
                
 
840
                bwin_get_rect(v3d->area->win, &win_rct);
 
841
                glaDefine2DArea(&win_rct);
 
842
                
 
843
                glDrawBuffer(GL_FRONT);
 
844
                
 
845
                /* clear header rect */
 
846
                BIF_ThemeColor(TH_HEADER);
 
847
                glRecti(vb.xmin, vb.ymax, vb.xmax, vb.ymax+RW_HEADERY);
 
848
                
 
849
                if(str) {
 
850
                        BIF_ThemeColor(TH_TEXT);
 
851
                        glRasterPos2i(vb.xmin+12, vb.ymax+5);
 
852
                        BMF_DrawString(G.fonts, str);
 
853
                }
 
854
                
 
855
                glFlush();
 
856
                glDrawBuffer(GL_BACK);
 
857
 
 
858
                v3d->area->win_swap= WIN_FRONT_OK;
 
859
                
 
860
        }
 
861
}
 
862
 
 
863
 
665
864
/* -------------- callbacks for render loop: interactivity ----------------------- */
666
865
 
667
866
 
668
 
/* callback for print info in top header in interface */
 
867
/* callback for print info in top header of renderwin */
 
868
/* time is only not zero on last call, we then don't update the other stats */ 
669
869
static void printrenderinfo_cb(double time, int sample)
670
870
{
671
871
        extern int mem_in_use;
672
 
        float megs_used_memory= mem_in_use/(1024.0*1024.0);
673
 
        char str[300], tstr[32], *spos= str;
 
872
        static int totvert=0, totvlak=0, tothalo=0, totlamp=0;
 
873
        static float megs_used_memory=0.0;
 
874
        char str[300], *spos= str;
674
875
                
675
 
        timestr(time, tstr);
676
 
        spos+= sprintf(spos, "RENDER  Fra:%d  Ve:%d Fa:%d La:%d", (G.scene->r.cfra), R.totvert, R.totvlak, R.totlamp);
677
 
        spos+= sprintf(spos, "Mem:%.2fM Time:%s ", megs_used_memory, tstr);
 
876
        if(time==0.0) {
 
877
                megs_used_memory= mem_in_use/(1024.0*1024.0);
 
878
                totvert= R.totvert;
 
879
                totvlak= R.totvlak;
 
880
                totlamp= R.totlamp;
 
881
                tothalo= R.tothalo;
 
882
        }
 
883
        
 
884
        if(tothalo)
 
885
                spos+= sprintf(spos, "Fra:%d  Ve:%d Fa:%d Ha:%d La:%d Mem:%.2fM", (G.scene->r.cfra), totvert, totvlak, tothalo, totlamp, megs_used_memory);
 
886
        else 
 
887
                spos+= sprintf(spos, "Fra:%d  Ve:%d Fa:%d La:%d Mem:%.2fM", (G.scene->r.cfra), totvert, totvlak, totlamp, megs_used_memory);
678
888
 
679
 
        if (R.r.mode & R_FIELDS) {
680
 
                spos+= sprintf(spos, "Field %c ", (R.flag&R_SEC_FIELD)?'B':'A');
 
889
        if(time==0.0) {
 
890
                if (R.r.mode & R_FIELDS) {
 
891
                        spos+= sprintf(spos, "Field %c ", (R.flag&R_SEC_FIELD)?'B':'A');
 
892
                }
 
893
                if (sample!=-1) {
 
894
                        spos+= sprintf(spos, "Sample: %d    ", sample);
 
895
                }
681
896
        }
682
 
        if (sample!=-1) {
683
 
                spos+= sprintf(spos, "Sample: %d    ", sample);
 
897
        else {
 
898
                extern char info_time_str[32];  // header_info.c
 
899
                timestr(time, info_time_str);
 
900
                spos+= sprintf(spos, " Time:%s ", info_time_str);
684
901
        }
685
902
        
686
 
        screen_draw_info_text(G.curscreen, str);
 
903
        if(render_win) {
 
904
                if(render_win->render_text) MEM_freeN(render_win->render_text);
 
905
                render_win->render_text= BLI_strdup(str);
 
906
                glDrawBuffer(GL_FRONT);
 
907
                renderwin_draw_render_info(render_win);
 
908
                glFlush();
 
909
                glDrawBuffer(GL_BACK);
 
910
        }
 
911
        else renderview_draw_render_info(str);
687
912
}
688
913
 
689
914
/* -------------- callback system to allow ESC from rendering ----------------------- */
797
1022
        
798
1023
        /* we set this flag to prevent renderwindow queue to execute another render */
799
1024
        R.flag= R_RENDERING;
 
1025
        G.afbreek= 0;
800
1026
 
801
 
        if (R.displaymode == R_DISPLAYWIN || force_dispwin) {
 
1027
        if (G.displaymode == R_DISPLAYWIN || force_dispwin) {
802
1028
                RE_set_initrenderdisplay_callback(NULL);
803
1029
                RE_set_clearrenderdisplay_callback(renderwin_clear_display_cb);
804
1030
                RE_set_renderdisplay_callback(renderwin_progress_display_cb);
822
1048
                window_set_cursor(render_win->win, CURSOR_WAIT);
823
1049
                // when opening new window... not cross platform identical behaviour, so
824
1050
                // for now call it each time
825
 
                if(ogl_render_view3d) init_gl_stuff();
 
1051
                // if(ogl_render_view3d) init_gl_stuff();
826
1052
        }
827
1053
        waitcursor(1);
828
1054
 
829
 
        G.afbreek= 0;
830
1055
        if(G.obedit && !(G.scene->r.scemode & R_OGL)) {
831
1056
                exit_editmode(0);       /* 0 = no free data */
832
1057
        }
839
1064
        }
840
1065
 
841
1066
        if(anim) update_for_newframe_muted();  // only when anim, causes redraw event which frustrates dispview
842
 
        R.flag= 0;
843
1067
        
844
1068
        if (render_win) window_set_cursor(render_win->win, CURSOR_STD);
845
 
        waitcursor(0);
846
1069
 
847
1070
        free_filesel_spec(G.scene->r.pic);
848
1071
 
849
1072
        G.afbreek= 0;
850
1073
        end_test_break_callback();
851
 
 
 
1074
        
852
1075
        /* in dispiew it will destroy the image otherwise
853
1076
           window_make_active() raises window at osx and sends redraws */
854
 
        if(R.displaymode==R_DISPLAYWIN) mainwindow_make_active();
855
 
 
 
1077
        if(G.displaymode==R_DISPLAYWIN) {
 
1078
                mainwindow_make_active();
 
1079
        
 
1080
                /* after an envmap creation...  */
 
1081
                if(R.flag & R_REDRAW_PRV) {
 
1082
                        BIF_all_preview_changed();
 
1083
                }
 
1084
                allqueue(REDRAWBUTSSCENE, 0);   // visualize fbuf for example
 
1085
        }
 
1086
        
 
1087
        R.flag= 0;
 
1088
        waitcursor(0);  // waitcursor checks rendering R.flag...
856
1089
}
857
1090
 
858
1091
/* finds area with a 'dispview' set */
897
1130
 
898
1131
/* -------------- API: externally called --------------- */
899
1132
 
 
1133
/* not used anywhere ??? */
 
1134
#if 0
 
1135
void BIF_renderwin_make_active(void)
 
1136
{
 
1137
        if(render_win) {
 
1138
                window_make_active(render_win->win);
 
1139
                mywinset(2);
 
1140
        }
 
1141
}
 
1142
#endif
 
1143
 
900
1144
/* set up display, render an image or scene */
901
1145
void BIF_do_render(int anim)
902
1146
{
903
 
        do_render(NULL, anim, 0);
 
1147
        int slink_flag = 0;
 
1148
 
 
1149
        if (G.f & G_DOSCRIPTLINKS) {
 
1150
                BPY_do_all_scripts(SCRIPT_RENDER);
 
1151
                if (!anim) { /* avoid FRAMECHANGED slink in render callback */
 
1152
                        G.f &= ~G_DOSCRIPTLINKS;
 
1153
                        slink_flag = 1;
 
1154
                }
 
1155
        }
 
1156
 
 
1157
        /* if start render in 3d win, use layer from window (e.g also local view) */
 
1158
        if(curarea && curarea->spacetype==SPACE_VIEW3D) {
 
1159
                int lay= G.scene->lay;
 
1160
                if(G.vd->lay & 0xFF000000)      // localview
 
1161
                        G.scene->lay |= G.vd->lay;
 
1162
                else G.scene->lay= G.vd->lay;
 
1163
                
 
1164
                do_render(NULL, anim, 0);
 
1165
                
 
1166
                G.scene->lay= lay;
 
1167
        }
 
1168
        else do_render(NULL, anim, 0);
 
1169
 
 
1170
        if (slink_flag) G.f |= G_DOSCRIPTLINKS;
 
1171
        if (G.f & G_DOSCRIPTLINKS) BPY_do_all_scripts(SCRIPT_POSTRENDER);
904
1172
}
905
1173
 
906
1174
/* set up display, render the current area view in an image */
911
1179
        G.scene->r.scemode &= ~R_OGL;
912
1180
}
913
1181
 
 
1182
void BIF_redraw_render_rect(void)
 
1183
{
 
1184
        
 
1185
        /* redraw */
 
1186
        if (G.displaymode == R_DISPLAYWIN) {
 
1187
                // don't open render_win if rendering has been
 
1188
            // canceled or the render_win has been actively closed
 
1189
                if (render_win) {
 
1190
                        renderwin_queue_redraw(render_win);
 
1191
                }
 
1192
        } else {
 
1193
                renderview_init_display_cb();
 
1194
                renderview_progress_display_cb(0, R.recty-1, R.rectx, R.recty, R.rectot);
 
1195
        }
 
1196
}       
 
1197
 
914
1198
void BIF_swap_render_rects(void)
915
1199
{
916
1200
        unsigned int *temp;
934
1218
        temp= R.rectot;
935
1219
        R.rectot= R.rectspare;
936
1220
        R.rectspare= temp;
937
 
 
938
 
        /* redraw */
939
 
        if (R.displaymode == R_DISPLAYWIN) {
940
 
                // don't open render_win if rendering has been
941
 
            // canceled or the render_win has been actively closed
 
1221
        
 
1222
        if (G.displaymode == R_DISPLAYWIN) {
942
1223
                if (render_win) {
943
 
                        renderwin_queue_redraw(render_win);
 
1224
                        char *tmp= render_win->render_text_spare;
 
1225
                        render_win->render_text_spare= render_win->render_text;
 
1226
                        render_win->render_text= tmp;
 
1227
                        
 
1228
                        window_set_title(render_win->win, renderwin_get_title(1));
 
1229
                        
944
1230
                }
945
 
        } else {
946
 
                renderview_init_display_cb();
947
 
                renderview_progress_display_cb(0, R.recty-1, R.rectx, R.recty, R.rectot);
948
1231
        }
 
1232
 
 
1233
        /* redraw */
 
1234
        BIF_redraw_render_rect();
949
1235
}                               
950
1236
 
951
1237
/* called from usiblender.c too, to free and close renderwin */
954
1240
        if (render_win) {
955
1241
 
956
1242
                if (render_win->info_text) MEM_freeN(render_win->info_text);
 
1243
                if (render_win->render_text) MEM_freeN(render_win->render_text);
 
1244
                if (render_win->render_text_spare) MEM_freeN(render_win->render_text_spare);
957
1245
 
958
1246
                window_destroy(render_win->win); /* ghost close window */
959
1247
                MEM_freeN(render_win);
969
1257
        ScrArea *sa= find_dispimage_v3d();
970
1258
        
971
1259
        if(R.rectot==NULL);             // do nothing
972
 
        else if (render_win && R.displaymode==R_DISPLAYWIN) {
 
1260
        else if (render_win && G.displaymode==R_DISPLAYWIN) {
973
1261
                if(render_win->active) {
974
1262
                        mainwindow_raise();
975
1263
                        mainwindow_make_active();
981
1269
                        render_win->active= 1;
982
1270
                }
983
1271
        } 
984
 
        else if (sa && R.displaymode==R_DISPLAYVIEW) {
 
1272
        else if (sa && G.displaymode==R_DISPLAYVIEW) {
985
1273
                View3D *vd= sa->spacedata.first;
986
1274
                vd->flag &= ~V3D_DISPIMAGE;
987
1275
                scrarea_queue_winredraw(sa);
988
1276
        } 
989
1277
        else {
990
 
                if (R.displaymode == R_DISPLAYWIN) {
 
1278
                if (G.displaymode == R_DISPLAYWIN) {
991
1279
                        renderwin_init_display_cb();
992
1280
                } else {
993
1281
                        if (render_win) {