svn merge -r 13415:13452 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender.git] / source / blender / src / buttons_scene.c
1 /**
2  * $Id$ 
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #include <time.h>
34 #include <math.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include "MEM_guardedalloc.h"
39 #include "DNA_node_types.h"
40 #include "DNA_screen_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_sound_types.h"
44 #include "DNA_sequence_types.h"
45 #include "DNA_userdef_types.h"
46 #include "DNA_packedFile_types.h"
47
48 #include "BKE_global.h"
49 #include "BKE_main.h"
50 #include "BKE_node.h"
51 #include "BKE_library.h"
52 #include "BKE_scene.h"
53 #include "BKE_sound.h"
54 #include "BKE_packedFile.h"
55 #include "BKE_utildefines.h"
56
57 #include "BLI_blenlib.h"
58
59 #include "BSE_filesel.h"
60
61 #include "BIF_gl.h"
62 #include "BIF_graphics.h"
63 #include "BIF_glutil.h"
64 #include "BIF_interface.h"
65 #include "BIF_imasel.h"
66 #include "BIF_keyval.h"
67 #include "BIF_mainqueue.h"
68 #include "BIF_mywindow.h"
69 #include "BIF_meshtools.h"
70 #include "BIF_resources.h"
71 #include "BIF_renderwin.h"
72 #include "BIF_screen.h"
73 #include "BIF_space.h"
74 #include "BIF_toolbox.h"
75 #include "BIF_editseq.h"
76
77 #include "BIF_butspace.h"
78
79 #include "mydevice.h"
80 #include "blendef.h"
81
82 /* -----includes for this file specific----- */
83
84 #include "DNA_image_types.h"
85
86 #include "BKE_writeavi.h"
87 #include "BKE_writeffmpeg.h"
88 #include "BKE_image.h"
89 #include "BKE_plugin_types.h"
90
91 #include "BLI_threads.h"
92
93 #include "BIF_editsound.h"
94 #include "BIF_writeimage.h"
95 #include "BIF_writeavicodec.h"
96
97 #include "BSE_headerbuttons.h"
98 #include "BSE_sequence.h"
99 #include "BSE_seqeffects.h"
100 #include "BSE_seqscopes.h"
101 #include "BSE_seqaudio.h"
102
103 #include "RE_pipeline.h"
104
105 #include "butspace.h" // own module
106
107 #ifdef WITH_QUICKTIME
108 #include "quicktime_export.h"
109 #endif
110
111 #ifdef WITH_FFMPEG
112
113 #include <ffmpeg/avcodec.h> /* for PIX_FMT_* and CODEC_ID_* */
114 #include <ffmpeg/avformat.h>
115
116 static int ffmpeg_preset_sel = 0;
117
118 extern int is_container(int);
119
120 extern void makeffmpegstring(char* string);
121
122 #endif
123
124 /* here the calls for scene buttons
125    - render
126    - world
127    - anim settings, audio
128 */
129
130 /* prototypes */
131 void playback_anim(void);
132
133 /* ************************ SOUND *************************** */
134 static void load_new_sample(char *str)  /* called from fileselect */
135 {
136         char name[FILE_MAX];
137         bSound *sound;
138         bSample *sample, *newsample;
139
140         sound = G.buts->lockpoin;
141
142         if (sound) {
143                 // save values
144                 sample = sound->sample;
145                 strcpy(name, sound->sample->name);
146
147                 strcpy(sound->name, str);
148                 sound_set_sample(sound, NULL);
149                 sound_initialize_sample(sound);
150
151                 if (sound->sample->type == SAMPLE_INVALID) {
152                         error("Not a valid sample: %s", str);
153
154                         newsample = sound->sample;
155
156                         // restore values
157                         strcpy(sound->name, name);
158                         sound_set_sample(sound, sample);
159
160                         // remove invalid sample
161
162                         sound_free_sample(newsample);
163                         BLI_remlink(samples, newsample);
164                         MEM_freeN(newsample);
165                 }
166         }
167
168         BIF_undo_push("Load new audio file");
169         allqueue(REDRAWBUTSSCENE, 0);
170
171 }
172
173
174 void do_soundbuts(unsigned short event)
175 {
176         char name[FILE_MAX];
177         bSound *sound;
178         bSample *sample;
179         bSound* tempsound;
180         ID *id;
181         
182         sound = G.buts->lockpoin;
183         
184         switch(event) {
185         case B_SOUND_REDRAW:
186                 allqueue(REDRAWBUTSSCENE, 0);
187                 break;
188
189         case B_SOUND_LOAD_SAMPLE:
190                 if (sound) strcpy(name, sound->name);
191                 else strcpy(name, U.sounddir);
192                         
193                 activate_fileselect(FILE_SPECIAL, "SELECT WAV FILE", name, load_new_sample);
194                 break;
195
196         case B_SOUND_PLAY_SAMPLE:
197                 if (sound) {
198                         if (sound->sample->type != SAMPLE_INVALID) {
199                                 sound_play_sound(sound);
200                                 allqueue(REDRAWBUTSSCENE, 0);
201                         }
202                 }
203                 break;
204
205         case B_SOUND_MENU_SAMPLE:
206                 if (G.buts->menunr > 0) {
207                         sample = BLI_findlink(samples, G.buts->menunr - 1);
208                         if (sample && sound) {
209                                 BLI_strncpy(sound->name, sample->name, sizeof(sound->name));
210                                 sound_set_sample(sound, sample);
211                                 do_soundbuts(B_SOUND_REDRAW);
212                         }
213                 }
214                         
215                 break;
216         case B_SOUND_NAME_SAMPLE:
217                 load_new_sample(sound->name);
218                 break;
219         
220         case B_SOUND_UNPACK_SAMPLE:
221                 if(sound && sound->sample) {
222                         sample = sound->sample;
223                         
224                         if (sample->packedfile) {
225                                 if (G.fileflags & G_AUTOPACK) {
226                                         if (okee("Disable AutoPack ?")) {
227                                                 G.fileflags &= ~G_AUTOPACK;
228                                         }
229                                 }
230                                 
231                                 if ((G.fileflags & G_AUTOPACK) == 0) {
232                                         unpackSample(sample, PF_ASK);
233                                 }
234                         } else {
235                                 sound_set_packedfile(sample, newPackedFile(sample->name));
236                         }
237                         allqueue(REDRAWHEADERS, 0);
238                         do_soundbuts(B_SOUND_REDRAW);
239                 }
240                 break;
241
242         case B_SOUND_COPY_SOUND:
243                 if (sound) {
244                         tempsound = sound_make_copy(sound);
245                         sound = tempsound;
246                         id = &sound->id;
247                         G.buts->lockpoin = (bSound*)id;
248                         BIF_undo_push("Copy sound");
249                         do_soundbuts(B_SOUND_REDRAW);
250                 }
251                 break;
252
253         case B_SOUND_RECALC:
254                 waitcursor(1);
255                 sound = G.main->sound.first;
256                 while (sound) {
257                         free(sound->stream);
258                         sound->stream = 0;
259                         audio_makestream(sound);
260                         sound = (bSound *) sound->id.next;
261                 }
262                 waitcursor(0);
263                 allqueue(REDRAWSEQ, 0);
264                 break;
265
266         case B_SOUND_RATECHANGED:
267
268                 allqueue(REDRAWBUTSSCENE, 0);
269                 allqueue(REDRAWSEQ, 0);
270                 break;
271
272         case B_SOUND_MIXDOWN:
273                 audio_mixdown();
274                 break;
275
276         default: 
277                 if (G.f & G_DEBUG) {
278                         printf("do_soundbuts: unhandled event %d\n", event);
279                 }
280         }
281 }
282
283
284 static void sound_panel_listener(void)
285 {
286         uiBlock *block;
287         int xco= 100, yco=100, mixrate;
288         char mixrateinfo[256];
289         
290         block= uiNewBlock(&curarea->uiblocks, "sound_panel_listener", UI_EMBOSS, UI_HELV, curarea->win);
291         if(uiNewPanel(curarea, block, "Listener", "Sound", 320, 0, 318, 204)==0) return;
292
293         mixrate = sound_get_mixrate();
294         sprintf(mixrateinfo, "Game Mixrate: %d Hz", mixrate);
295         uiDefBut(block, LABEL, 0, mixrateinfo, xco,yco,295,20, 0, 0, 0, 0, 0, "");
296
297         yco -= 30;
298         uiDefBut(block, LABEL, 0, "Game listener settings:",xco,yco,195,20, 0, 0, 0, 0, 0, "");
299
300         yco -= 30;
301         uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Volume: ",
302                 xco,yco,195,24,&G.listener->gain, 0.0, 1.0, 1.0, 0, "Sets the maximum volume for the overall sound");
303         
304         yco -= 30;
305         uiDefBut(block, LABEL, 0, "Game Doppler effect settings:",xco,yco,195,20, 0, 0, 0, 0, 0, "");
306
307         yco -= 30;
308         uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Doppler: ",
309         xco,yco,195,24,&G.listener->dopplerfactor, 0.0, 10.0, 1.0, 0, "Use this for scaling the doppler effect");
310         
311         yco -=30;
312         uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Velocity: ",
313         xco,yco,195,24,&G.listener->dopplervelocity,0.0,10000.0, 1.0,0, "Sets the propagation speed of sound");
314
315         
316 }
317
318 static void sound_panel_sequencer(void)
319 {
320         uiBlock *block;
321         short xco, yco;
322         char mixrateinfo[256];
323         
324         block= uiNewBlock(&curarea->uiblocks, "sound_panel_sequencer", UI_EMBOSS, UI_HELV, curarea->win);
325         if(uiNewPanel(curarea, block, "Sequencer", "Sound", 640, 0, 318, 204)==0) return;
326
327         /* audio sequence engine settings ------------------------------------------------------------------ */
328
329         xco = 1010;
330         yco = 195;
331
332         uiDefBut(block, LABEL, 0, "Audio sequencer settings", xco,yco,295,20, 0, 0, 0, 0, 0, "");
333
334         yco -= 25;
335         sprintf(mixrateinfo, "Mixing/Sync (latency: %d ms)", (int)( (((float)U.mixbufsize)/(float)G.scene->audio.mixrate)*1000.0 ) );
336         uiDefBut(block, LABEL, 0, mixrateinfo, xco,yco,295,20, 0, 0, 0, 0, 0, "");
337
338         yco -= 25;              
339         uiDefButI(block, ROW, B_SOUND_RATECHANGED, "44.1 kHz",  xco,yco,75,20, &G.scene->audio.mixrate, 2.0, 44100.0, 0, 0, "Mix at 44.1 kHz");
340         uiDefButI(block, ROW, B_SOUND_RATECHANGED, "48.0 kHz",          xco+80,yco,75,20, &G.scene->audio.mixrate, 2.0, 48000.0, 0, 0, "Mix at 48 kHz");
341         uiDefBut(block, BUT, B_SOUND_RECALC, "Recalc",          xco+160,yco,75,20, 0, 0, 0, 0, 0, "Recalculate samples");
342
343         yco -= 25;
344         uiDefButBitS(block, TOG, AUDIO_SYNC, B_SOUND_CHANGED, "Sync",   xco,yco,115,20, &G.scene->audio.flag, 0, 0, 0, 0, "Use sample clock for syncing animation to audio");
345         uiDefButBitS(block, TOG, AUDIO_SCRUB, B_SOUND_CHANGED, "Scrub",         xco+120,yco,115,20, &G.scene->audio.flag, 0, 0, 0, 0, "Scrub when changing frames");
346
347         yco -= 25;
348         uiDefBut(block, LABEL, 0, "Main mix", xco,yco,295,20, 0, 0, 0, 0, 0, "");
349
350         yco -= 25;              
351         uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Main (dB): ",
352                 xco,yco,235,24,&G.scene->audio.main, -24.0, 6.0, 0, 0, "Set the audio master gain/attenuation in dB");
353
354         yco -= 25;
355         uiDefButBitS(block, TOG, AUDIO_MUTE, 0, "Mute", xco,yco,235,24, &G.scene->audio.flag, 0, 0, 0, 0, "Mute audio from sequencer");         
356         
357         yco -= 35;
358         uiDefBut(block, BUT, B_SOUND_MIXDOWN, "MIXDOWN",        xco,yco,235,24, 0, 0, 0, 0, 0, "Create WAV file from sequenced audio (output goes to render output dir)");
359         
360 }
361
362 static char *make_sample_menu(void)
363 {
364         int len= BLI_countlist(samples);        /* BKE_sound.h */
365         
366         if(len) {
367                 bSample *sample;
368                 char *str;
369                 int nr, a=0;
370                 
371                 str= MEM_callocN(32*len, "menu");
372                 
373                 for(nr=1, sample= samples->first; sample; sample= sample->id.next, nr++) {
374                         a+= sprintf(str+a, "|%s %%x%d", sample->id.name+2, nr);
375                 }
376                 return str;
377         }
378         return NULL;
379 }
380
381 static void sound_panel_sound(bSound *sound)
382 {
383         static int packdummy=0;
384         ID *id, *idfrom;
385         uiBlock *block;
386         bSample *sample;
387         char *strp, ch[256];
388
389         block= uiNewBlock(&curarea->uiblocks, "sound_panel_sound", UI_EMBOSS, UI_HELV, curarea->win);
390         if(uiNewPanel(curarea, block, "Sound", "Sound", 0, 0, 318, 204)==0) return;
391         
392         uiDefBut(block, LABEL, 0, "Blender Sound block",10,180,195,20, 0, 0, 0, 0, 0, "");
393         
394         // warning: abuse of texnr here! (ton didnt code!)
395         buttons_active_id(&id, &idfrom);
396         std_libbuttons(block, 10, 160, 0, NULL, B_SOUNDBROWSE2, ID_SO, 0, id, idfrom, &(G.buts->texnr), 1, 0, 0, 0, 0);
397
398         if (sound) {
399         
400                 uiDefBut(block, BUT, B_SOUND_COPY_SOUND, "Copy sound", 220,160,90,20, 0, 0, 0, 0, 0, "Make another copy (duplicate) of the current sound");
401
402                 uiSetButLock(sound->id.lib!=0, ERROR_LIBDATA_MESSAGE);
403                 sound_initialize_sample(sound);
404                 sample = sound->sample;
405
406                 /* info string */
407                 if (sound->sample && sound->sample->len) {
408                         char *tmp;
409                         if (sound->sample->channels == 1) tmp= "Mono";
410                         else if (sound->sample->channels == 2) tmp= "Stereo";
411                         else tmp= "Unknown";
412                         
413                         sprintf(ch, "Sample: %s, %d bit, %d Hz, %d samples", tmp, sound->sample->bits, sound->sample->rate, (sound->sample->len/(sound->sample->bits/8)/sound->sample->channels));
414                         uiDefBut(block, LABEL, 0, ch,                   35,140,225,20, 0, 0, 0, 0, 0, "");
415                 }
416                 else {
417                         uiDefBut(block, LABEL, 0, "Sample: No sample info available.",35,140,225,20, 0, 0, 0, 0, 0, "");
418                 }
419
420                 /* sample browse buttons */
421                 uiBlockBeginAlign(block);
422                 strp= make_sample_menu();
423                 if (strp) {
424                         uiDefButS(block, MENU, B_SOUND_MENU_SAMPLE, strp, 10,120,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Select another loaded sample");
425                         MEM_freeN(strp);
426                 }
427                 uiDefBut(block, TEX, B_SOUND_NAME_SAMPLE, "",           35,120,250,20, sound->name, 0.0, 79.0, 0, 0, "The sample file used by this Sound");
428                 
429                 if (sound->sample->packedfile) packdummy = 1;
430                 else packdummy = 0;
431                 
432                 uiDefIconButBitI(block, TOG, 1, B_SOUND_UNPACK_SAMPLE, ICON_PACKAGE,
433                         285, 120,25,20, &packdummy, 0, 0, 0, 0,"Pack/Unpack this sample");
434                 
435                 uiBlockBeginAlign(block);
436                 uiDefBut(block, BUT, B_SOUND_LOAD_SAMPLE, "Load sample", 10, 95,150,24, 0, 0, 0, 0, 0, "Load a different sample file");
437
438                 uiDefBut(block, BUT, B_SOUND_PLAY_SAMPLE, "Play",       160, 95, 150, 24, 0, 0.0, 0, 0, 0, "Playback sample using settings below");
439                 
440                 uiBlockBeginAlign(block);
441                 uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Volume: ",
442                         10,70,150,20, &sound->volume, 0.0, 1.0, 0, 0, "Game engine only: Set the volume of this sound");
443
444                 uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Pitch: ",
445                         160,70,150,20, &sound->pitch, -12.0, 12.0, 0, 0, "Game engine only: Set the pitch of this sound");
446
447                 /* looping */
448                 uiBlockBeginAlign(block);
449                 uiDefButBitI(block, TOG, SOUND_FLAGS_LOOP, B_SOUND_REDRAW, "Loop",
450                         10, 50, 95, 20, &sound->flags, 0.0, 0.0, 0, 0, "Game engine only: Toggle between looping on/off");
451
452                 if (sound->flags & SOUND_FLAGS_LOOP) {
453                         uiDefButBitI(block, TOG, SOUND_FLAGS_BIDIRECTIONAL_LOOP, B_SOUND_REDRAW, "Ping Pong",
454                                 105, 50, 95, 20, &sound->flags, 0.0, 0.0, 0, 0, "Game engine only: Toggle between A->B and A->B->A looping");
455                         
456                 }
457         
458
459                 /* 3D settings ------------------------------------------------------------------ */
460                 uiBlockBeginAlign(block);
461
462                 if (sound->sample->channels == 1) {
463                         uiDefButBitI(block, TOG, SOUND_FLAGS_3D, B_SOUND_REDRAW, "3D Sound",
464                                 10, 10, 90, 20, &sound->flags, 0, 0, 0, 0, "Game engine only: Turns 3D sound on");
465                         
466                         if (sound->flags & SOUND_FLAGS_3D) {
467                                 uiDefButF(block, NUMSLI, B_SOUND_CHANGED, "Scale: ",
468                                         100,10,210,20, &sound->attenuation, 0.0, 5.0, 1.0, 0, "Game engine only: Sets the surround scaling factor for this sound");
469                                 
470                         }
471                 }
472         }
473 }
474
475 /* ************************* Sequencer *********************** */
476
477 #define SEQ_PANEL_EDITING 1
478 #define SEQ_PANEL_INPUT   2
479 #define SEQ_PANEL_FILTER  4
480 #define SEQ_PANEL_EFFECT  8
481 #define SEQ_PANEL_PROXY   16
482
483 static char* seq_panel_blend_modes()
484 {
485         static char string[2048];
486
487         Sequence *last_seq = get_last_seq();
488
489         sprintf(string, "Blend mode: %%t|%s %%x%d",
490                 "Replace", SEQ_BLEND_REPLACE);
491
492         /*
493           Blending can only work without effect strips. 
494           Otherwise, one would have
495           to decide, what the effect strips IPO should do:
496           - drive the effect _or_
497           - drive the blend mode ?
498
499           Also: effectdata is used by these implicit effects,
500           so that would collide also.
501         */
502
503         if (!(last_seq->type & SEQ_EFFECT)) {
504                 int i;
505
506                 for (i = SEQ_EFFECT; i <= SEQ_EFFECT_MAX; i++) {
507                         if (get_sequence_effect_num_inputs(i) == 2) {
508                                 sprintf(string + strlen(string), 
509                                         "|%s %%x%d", 
510                                         give_seqname_by_type(i), i);
511                         }
512                 }
513         }
514         return string;
515 }
516
517 static char* seq_panel_scenes()
518 {
519         static char rstr[8192];
520         char * str;
521
522         IDnames_to_pupstring(&str, NULL, NULL, 
523                              &G.main->scene, (ID *)G.scene, NULL);
524
525         strncpy(rstr, str, 8192);
526         MEM_freeN(str);
527
528         return rstr;
529 }
530
531 static void seq_update_scenenr(Sequence * seq)
532 {
533         Scene * sce;
534         int nr;
535         if (seq->type != SEQ_SCENE) {
536                 return;
537         }
538
539         seq->scenenr = 0;
540
541         sce = G.main->scene.first;
542         nr = 1;
543         while(sce) {
544                 if (sce == seq->scene) {
545                         seq->scenenr = nr;
546                         break;
547                 }
548                 nr++;
549                 sce = sce->id.next;
550         }
551 }
552
553
554 static void seq_panel_editing()
555 {
556         Sequence *last_seq = get_last_seq();
557         uiBlock *block;
558         static char strdata[1024];
559         char * str = strdata;
560         char * p;
561         int yco;
562
563         block = uiNewBlock(&curarea->uiblocks, "seq_panel_editing", 
564                            UI_EMBOSS, UI_HELV, curarea->win);
565
566         if(uiNewPanel(curarea, block, "Edit", "Sequencer", 
567                       10, 230, 318, 204) == 0) return;
568
569         uiDefBut(block, LABEL, 
570                  0, give_seqname(last_seq), 
571                  10,140,60,19, 0, 
572                  0, 0, 0, 0, "");
573
574         uiDefBut(block, TEX, 
575                  B_NOP, "Name: ", 
576                  70,140,180,19, last_seq->name+2, 
577                  0.0, 21.0, 100, 0, "");
578
579         uiDefButI(block, MENU, B_SEQ_BUT_RELOAD, seq_panel_blend_modes(), 
580                   10, 120, 120, 19, &last_seq->blend_mode, 
581                   0,0,0,0, "Strip Blend Mode");
582
583         uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Blend:",
584                   130, 120, 120, 19, &last_seq->blend_opacity, 
585                   0.0, 100.0, 100.0, 0, 
586                   "Blend opacity");
587
588         uiDefButBitI(block, TOG, SEQ_MUTE,
589                      B_SEQ_BUT_RELOAD_ALL, "Mute",
590                      10,100,60,19, &last_seq->flag,
591                      0.0, 1.0, 0, 0,
592                      "Mute the current strip.");
593
594         uiDefButBitI(block, TOG, SEQ_LOCK,
595                      B_NOP, "Lock",
596                      70,100,60,19, &last_seq->flag,
597                      0.0, 1.0, 0, 0,
598                      "Lock strip, so that it can't be transformed.");
599         
600         uiDefButBitI(block, TOG, SEQ_IPO_FRAME_LOCKED,
601                      B_SEQ_BUT_RELOAD_ALL, "IPO Frame locked",
602                      130,100,120,19, &last_seq->flag,
603                      0.0, 1.0, 0, 0,
604                      "Lock the IPO coordinates to the "
605                      "global frame counter.");
606         
607         if (!(last_seq->flag & SEQ_LOCK)) {
608                 uiDefButI(block, NUM, 
609                           B_SEQ_BUT_TRANSFORM, "Start", 
610                           10, 80, 120, 20, &last_seq->start, 
611                           0.0, MAXFRAMEF, 0.0, 0.0, "Start of strip");
612                 uiDefButI(block, NUM, 
613                           B_SEQ_BUT_TRANSFORM, "Chan", 
614                           130, 80, 120, 20, &last_seq->machine, 
615                           0.0, MAXSEQ, 0.0, 0.0, "Channel used (Y position)");
616                 
617                 if (check_single_seq(last_seq)) {
618                         uiDefButI(block, NUM, 
619                                 B_SEQ_BUT_TRANSFORM, "End-Still", 
620                                 130, 60, 120, 19, &last_seq->endstill, 
621                                 0.0, MAXFRAMEF, 0.0, 0.0, "End still");
622                 } else {
623                         uiDefButI(block, NUM, 
624                                   B_SEQ_BUT_TRANSFORM, "Start-Still", 
625                                   10, 60, 120, 20, &last_seq->startstill, 
626                                   0.0, MAXFRAMEF, 0.0, 0.0, "Start still");
627                         uiDefButI(block, NUM, 
628                                   B_SEQ_BUT_TRANSFORM, "End-Still", 
629                                   130, 60, 120, 19, &last_seq->endstill, 
630                                   0.0, MAXFRAMEF, 0.0, 0.0, "End still");
631                         uiDefButI(block, NUM, 
632                                   B_SEQ_BUT_TRANSFORM, "Start-Ofs", 
633                                   10, 40, 120, 20, &last_seq->startofs, 
634                                   0.0, last_seq->len - last_seq->endofs, 
635                                   0.0, 0.0, "Start offset");
636                         uiDefButI(block, NUM, 
637                                   B_SEQ_BUT_TRANSFORM, "End-Ofs", 
638                                   130, 40, 120, 19, &last_seq->endofs, 
639                                   0.0, last_seq->len - last_seq->startofs, 
640                                   0.0, 0.0, "End offset");
641                 }
642         }
643
644
645         if(last_seq->type & SEQ_EFFECT)
646                 sprintf(str, "Len: %d\nFrom %d - %d\n", last_seq->len, last_seq->startdisp, last_seq->enddisp-1);
647         else
648                 sprintf(str, "Len: %d(%d)\n", last_seq->enddisp-last_seq->startdisp, last_seq->len);
649
650         str += strlen(str);
651
652         if(last_seq->type==SEQ_IMAGE) {
653                 if (last_seq->len > 1) {
654                         /* CURRENT */
655                         StripElem * se= give_stripelem(last_seq, CFRA);
656                         StripElem * last;
657
658                         /* FIRST AND LAST */
659         
660                         if(last_seq->strip) {
661                                 se= last_seq->strip->stripdata;
662                                 last= se+last_seq->len-1;
663                                 if(last_seq->startofs) se+= last_seq->startofs;
664                                 if(last_seq->endofs) last-= last_seq->endofs;
665         
666                                 sprintf(str, "First: %s at %d\nLast: %s at %d\n", se->name, last_seq->startdisp, last->name, last_seq->enddisp-1);
667                         }
668                 } else { /* single image */
669                         if (last_seq->strip) {
670                                 sprintf(str, "Len: %d\n", last_seq->enddisp-last_seq->startdisp);
671                         }
672                 }
673
674                 str += strlen(str);
675
676                 /* orig size */
677                 if(last_seq->strip) {
678                         sprintf(str, "OrigSize: %d x %d\n", last_seq->strip->orx, last_seq->strip->ory);
679                 }
680         }
681         else if(last_seq->type==SEQ_MOVIE) {
682                 int sta= last_seq->startofs;
683                 int end= last_seq->len-1-last_seq->endofs;
684
685                 sprintf(str, "First: %d at %d\nLast: %d at %d\nCur: %d\n",
686                         sta, last_seq->startdisp, end, last_seq->enddisp-1,  
687                         (G.scene->r.cfra)-last_seq->startdisp);
688         }
689         else if(last_seq->type==SEQ_SCENE) {
690                 TStripElem * se= give_tstripelem(last_seq,  (G.scene->r.cfra));
691                 if(se && last_seq->scene) {
692                         sprintf(str, "First: %d\nLast: %d\nCur: %d\n", last_seq->sfra+se->nr, last_seq->sfra, last_seq->sfra+last_seq->len-1); 
693                 }
694         }
695         else if(last_seq->type==SEQ_RAM_SOUND
696                 || last_seq->type == SEQ_HD_SOUND) {
697
698                 int sta= last_seq->startofs;
699                 int end= last_seq->len-1-last_seq->endofs;
700
701                 sprintf(str, "First: %d at %d\nLast: %d at %d\nCur: %d\n",
702                         sta, last_seq->startdisp, end, last_seq->enddisp-1,  
703                         (G.scene->r.cfra)-last_seq->startdisp);
704         }
705         else if(last_seq->type == SEQ_SPEED) {
706                 SpeedControlVars * vars = 
707                         (SpeedControlVars*) last_seq->effectdata;
708
709                 if (vars) {
710                         sprintf(str, "Last mapped frame: %d at %d\n", 
711                                 vars->lastValidFrame, 
712                                 vars->lastValidFrame 
713                                 + last_seq->startdisp);
714                 }
715         }
716
717         str = strdata;
718         yco = 20;
719
720         while ((p = strchr(str, '\n'))) {
721                 *p = 0;
722                 uiDefBut(block, LABEL, 0, str, 10,yco,240,17, 0, 
723                          0, 0, 0, 0, "");
724                 str = p+1;
725                 yco -= 18;
726         }
727 }
728
729 static void seq_panel_input()
730 {
731         Sequence *last_seq = get_last_seq();
732         uiBlock *block;
733
734         block = uiNewBlock(&curarea->uiblocks, "seq_panel_input", 
735                            UI_EMBOSS, UI_HELV, curarea->win);
736
737         if(uiNewPanel(curarea, block, "Input", "Sequencer", 
738                       10, 230, 318, 204) == 0) return;
739
740         if (last_seq->type == SEQ_MOVIE 
741             || last_seq->type == SEQ_IMAGE) {
742                 uiDefBut(block, TEX, 
743                          B_SEQ_BUT_RELOAD_FILE, "Dir: ", 
744                          10,140,240,19, last_seq->strip->dir, 
745                          0.0, 160.0, 100, 0, "");
746         }
747
748         if (last_seq->type == SEQ_IMAGE) {
749                 StripElem * se = give_stripelem(last_seq, CFRA);
750
751                 if (se) {
752                         uiDefBut(block, TEX, 
753                                  B_SEQ_BUT_RELOAD_FILE, "File: ", 
754                                  10, 120, 190,19, se->name, 
755                                  0.0, 80.0, 100, 0, "");
756                 }
757
758         } else if (last_seq->type == SEQ_MOVIE || 
759                    last_seq->type == SEQ_HD_SOUND ||
760                    last_seq->type == SEQ_RAM_SOUND) {
761                 uiDefBut(block, TEX, 
762                          B_SEQ_BUT_RELOAD_FILE, "File: ", 
763                          10,120,190,19, last_seq->strip->stripdata->name, 
764                          0.0, 80.0, 100, 0, "");
765         } else if (last_seq->type == SEQ_SCENE) {
766                 seq_update_scenenr(last_seq);
767                 uiDefButI(block, MENU, B_SEQ_BUT_RELOAD_FILE, 
768                           seq_panel_scenes(), 
769                           10, 120, 190, 19, &last_seq->scenenr, 
770                           0,0,0,0, "Linked Scene");
771         }
772
773         uiDefBut(block, BUT, B_SEQ_BUT_RELOAD_FILE, 
774                  "Reload",
775                  200,120,50,19, 0, 0, 0, 0, 0, 
776                  "Reload files/scenes from disk and update strip length.");
777
778         if (last_seq->type == SEQ_MOVIE 
779             || last_seq->type == SEQ_IMAGE 
780             || last_seq->type == SEQ_SCENE) {
781                 uiDefButBitI(block, TOG, SEQ_USE_CROP,
782                              B_SEQ_BUT_RELOAD, "Use Crop",
783                              10,100,240,19, &last_seq->flag,
784                              0.0, 1.0, 0, 0,
785                              "Crop image before processing.");
786
787                 if (last_seq->flag & SEQ_USE_CROP) {
788                         if (!last_seq->strip->crop) {
789                                 last_seq->strip->crop = 
790                                         MEM_callocN(sizeof(struct StripCrop), 
791                                                     "StripCrop");
792                         }
793                         uiDefButI(block, NUM, 
794                                   B_SEQ_BUT_RELOAD, "Top", 
795                                   10, 80, 120, 20, 
796                                   &last_seq->strip->crop->top, 
797                                   0.0, 4096, 0.0, 0.0, "Top of source image");
798                         uiDefButI(block, NUM, 
799                                   B_SEQ_BUT_RELOAD, "Bottom", 
800                                   130, 80, 120, 20, 
801                                   &last_seq->strip->crop->bottom, 
802                                   0.0, 4096, 0.0, 0.0,
803                                   "Bottom of source image");
804                         
805                         uiDefButI(block, NUM, 
806                                   B_SEQ_BUT_RELOAD, "Left", 
807                                   10, 60, 120, 20,
808                                   &last_seq->strip->crop->left, 
809                                   0.0, 4096, 0.0, 0.0, "Left");
810                         uiDefButI(block, NUM, 
811                                   B_SEQ_BUT_RELOAD, "Right", 
812                                   130, 60, 120, 19, 
813                                   &last_seq->strip->crop->right, 
814                                   0.0, 4096, 0.0, 0.0, "Right");
815                 }
816                 
817                 uiDefButBitI(block, TOG, SEQ_USE_TRANSFORM,
818                              B_SEQ_BUT_RELOAD, "Use Translate",
819                              10,40,240,19, &last_seq->flag,
820                              0.0, 1.0, 0, 0,
821                              "Translate image before processing.");
822                 
823                 if (last_seq->flag & SEQ_USE_TRANSFORM) {
824                         if (!last_seq->strip->transform) {
825                                 last_seq->strip->transform = 
826                                         MEM_callocN(
827                                                 sizeof(struct StripTransform), 
828                                                 "StripTransform");
829                         }
830                         uiDefButI(block, NUM, 
831                                   B_SEQ_BUT_RELOAD, "X-Ofs", 
832                                   10, 20, 120, 20, 
833                                   &last_seq->strip->transform->xofs, 
834                                   0.0, 4096, 0.0, 0.0, "X Offset");
835                         uiDefButI(block, NUM, 
836                                   B_SEQ_BUT_RELOAD, "Y-Ofs", 
837                                   130, 20, 120, 20, 
838                                   &last_seq->strip->transform->yofs, 
839                                   0.0, 4096, 0.0, 0.0, "Y Offset");
840                 }
841         }
842
843         uiDefButI(block, NUM, 
844                   B_SEQ_BUT_RELOAD_FILE, "A-Start", 
845                   10, 0, 120, 20, &last_seq->anim_startofs, 
846                   0.0, last_seq->len + last_seq->anim_startofs, 0.0, 0.0, 
847                   "Animation start offset in file");
848         uiDefButI(block, NUM, 
849                   B_SEQ_BUT_RELOAD_FILE, "A-End", 
850                   130, 0, 120, 20, &last_seq->anim_endofs, 
851                   0.0, last_seq->len + last_seq->anim_endofs, 0.0, 0.0, 
852                   "Animation end offset in file");
853
854
855         if (last_seq->type == SEQ_MOVIE) {
856                 uiDefButI(block, NUM, B_SEQ_BUT_RELOAD, "MPEG-Preseek:",
857                           10, -20, 240,19, &last_seq->anim_preseek, 
858                           0.0, 50.0, 100,0,
859                           "On MPEG-seeking preseek this many frames");
860         }
861
862 }
863
864 static void seq_panel_filter_video()
865 {
866         Sequence *last_seq = get_last_seq();
867         uiBlock *block;
868         block = uiNewBlock(&curarea->uiblocks, "seq_panel_filter", 
869                            UI_EMBOSS, UI_HELV, curarea->win);
870
871         if(uiNewPanel(curarea, block, "Filter", "Sequencer", 
872                       10, 230, 318, 204) == 0) return;
873
874
875         uiBlockBeginAlign(block);
876
877
878         uiDefButBitI(block, TOG, SEQ_MAKE_PREMUL, 
879                      B_SEQ_BUT_RELOAD, "Convert to Premul", 
880                      10,110,150,19, &last_seq->flag, 
881                      0.0, 21.0, 100, 0, 
882                      "Converts RGB values to become premultiplied with Alpha");
883
884         uiDefButBitI(block, TOG, SEQ_FILTERY, 
885                      B_SEQ_BUT_RELOAD, "FilterY",       
886                      10,90,75,19, &last_seq->flag, 
887                      0.0, 21.0, 100, 0, 
888                      "For video movies to remove fields");
889
890         uiDefButBitI(block, TOG, SEQ_MAKE_FLOAT, 
891                      B_SEQ_BUT_RELOAD, "Make Float",    
892                      85,90,75,19, &last_seq->flag, 
893                      0.0, 21.0, 100, 0, 
894                      "Convert input to float data");
895                 
896         uiDefButBitI(block, TOG, SEQ_FLIPX, 
897                      B_SEQ_BUT_RELOAD, "FlipX", 
898                      10,70,75,19, &last_seq->flag, 
899                      0.0, 21.0, 100, 0, 
900                      "Flip on the X axis");
901         uiDefButBitI(block, TOG, SEQ_FLIPY, 
902                      B_SEQ_BUT_RELOAD, "FlipY", 
903                      85,70,75,19, &last_seq->flag, 
904                      0.0, 21.0, 100, 0, 
905                      "Flip on the Y axis");
906                 
907         uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Mul:",
908                   10,50,150,19, &last_seq->mul, 
909                   0.001, 5.0, 100, 0, 
910                   "Multiply colors");
911
912         uiDefButBitI(block, TOG, SEQ_REVERSE_FRAMES,
913                      B_SEQ_BUT_RELOAD, "Reverse Frames", 
914                      10,30,150,19, &last_seq->flag, 
915                      0.0, 21.0, 100, 0, 
916                      "Reverse frame order");
917
918         uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Strobe:",
919                   10,10,150,19, &last_seq->strobe, 
920                   1.0, 30.0, 100, 0, 
921                   "Only display every nth frame");
922
923         uiBlockEndAlign(block);
924
925 }
926
927
928 static void seq_panel_filter_audio()
929 {
930         Sequence *last_seq = get_last_seq();
931         uiBlock *block;
932         block = uiNewBlock(&curarea->uiblocks, "seq_panel_filter", 
933                            UI_EMBOSS, UI_HELV, curarea->win);
934
935         if(uiNewPanel(curarea, block, "Filter", "Sequencer", 
936                       10, 230, 318, 204) == 0) return;
937
938         uiBlockBeginAlign(block);
939         uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Gain (dB):", 10,50,150,19, &last_seq->level, -96.0, 6.0, 100, 0, "");
940         uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Pan:",         10,30,150,19, &last_seq->pan, -1.0, 1.0, 100, 0, "");
941         uiBlockEndAlign(block);
942 }
943
944 static void seq_panel_effect()
945 {
946         Sequence *last_seq = get_last_seq();
947         uiBlock *block;
948         block = uiNewBlock(&curarea->uiblocks, "seq_panel_effect", 
949                            UI_EMBOSS, UI_HELV, curarea->win);
950
951         if(uiNewPanel(curarea, block, "Effect", "Sequencer", 
952                       10, 230, 318, 204) == 0) return;
953
954         if(last_seq->type == SEQ_PLUGIN) {
955                 PluginSeq *pis;
956                 VarStruct *varstr;
957                 int a, xco, yco;
958
959                 get_sequence_effect(last_seq);/* make sure, plugin is loaded */
960
961                 pis= last_seq->plugin;
962                 if(pis->vars==0) return;
963
964                 varstr= pis->varstr;
965                 if(varstr) {
966                         for(a=0; a<pis->vars; a++, varstr++) {
967                                 xco= 150*(a/6)+10;
968                                 yco= 125 - 20*(a % 6)+1;
969                                 uiDefBut(block, varstr->type, B_SEQ_BUT_PLUGIN, varstr->name, xco,yco,150,19, &(pis->data[a]), varstr->min, varstr->max, 100, 0, varstr->tip);
970
971                         }
972                 }
973                 return;
974         } 
975
976         uiBlockBeginAlign(block);
977
978         if(last_seq->type==SEQ_WIPE){
979                 WipeVars *wipe = (WipeVars *)last_seq->effectdata;
980                 char formatstring[256];
981                         
982                 strncpy(formatstring, "Transition Type %t|Single Wipe%x0|Double Wipe %x1|Iris Wipe %x4|Clock Wipe %x5", 255);
983                 uiDefButS(block, MENU,B_SEQ_BUT_EFFECT, formatstring,   10,65,220,22, &wipe->wipetype, 0, 0, 0, 0, "What type of wipe should be performed");
984                 uiDefButF(block, NUM,B_SEQ_BUT_EFFECT,"Blur:",  10,40,220,22, &wipe->edgeWidth,0.0,1.0, 1, 2, "The percent width of the blur edge");
985                 switch(wipe->wipetype){ /*Skip Types that do not require angle*/
986                 case DO_IRIS_WIPE:
987                 case DO_CLOCK_WIPE:
988                         break;
989                         
990                 default:
991                         uiDefButF(block, NUM,B_SEQ_BUT_EFFECT,"Angle:", 10,15,220,22, &wipe->angle,-90.0,90.0, 1, 2, "The Angle of the Edge");
992                 }
993                 uiDefButS(block, TOG,B_SEQ_BUT_EFFECT,"Wipe In",  10,-10,220,22, &wipe->forward,0,0, 0, 0, "Controls Primary Direction of Wipe");                               
994         } else if(last_seq->type==SEQ_GLOW){
995                 GlowVars *glow = (GlowVars *)last_seq->effectdata;
996
997                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "Threshold:",   10,70,150,19, &glow->fMini, 0.0, 1.0, 0, 0, "Trigger Intensity");
998                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "Clamp:",                       10,50,150,19, &glow->fClamp, 0.0, 1.0, 0, 0, "Brightness limit of intensity");
999                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "Boost factor:",        10,30,150,19, &glow->fBoost, 0.0, 10.0, 0, 0, "Brightness multiplier");
1000                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "Blur distance:",       10,10,150,19, &glow->dDist, 0.5, 20.0, 0, 0, "Radius of glow effect");
1001                 uiDefButI(block, NUM, B_NOP, "Quality:", 10,-5,150,19, &glow->dQuality, 1.0, 5.0, 0, 0, "Accuracy of the blur effect");
1002                 uiDefButI(block, TOG, B_NOP, "Only boost", 10,-25,150,19, &glow->bNoComp, 0.0, 0.0, 0, 0, "Show the glow buffer only");
1003         }
1004         else if(last_seq->type==SEQ_TRANSFORM){
1005                 TransformVars *transform = (TransformVars *)last_seq->effectdata;
1006
1007                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "xScale Start:",        10,70,150,19, &transform->ScalexIni, 0.0, 10.0, 0, 0, "X Scale Start");
1008                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "xScale End:",  160,70,150,19, &transform->ScalexFin, 0.0, 10.0, 0, 0, "X Scale End");
1009                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "yScale Start:",        10,50,150,19, &transform->ScaleyIni, 0.0, 10.0, 0, 0, "Y Scale Start");
1010                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "yScale End:",  160,50,150,19, &transform->ScaleyFin, 0.0, 10.0, 0, 0, "Y Scale End");
1011                 
1012                 uiDefButI(block, ROW, B_SEQ_BUT_EFFECT, "Percent", 10, 30, 150, 19, &transform->percent, 0.0, 1.0, 0.0, 0.0, "Percent Translate");
1013                 uiDefButI(block, ROW, B_SEQ_BUT_EFFECT, "Pixels", 160, 30, 150, 19, &transform->percent, 0.0, 0.0, 0.0, 0.0, "Pixels Translate");
1014                 if(transform->percent==1){
1015                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "x Start:",     10,10,150,19, &transform->xIni, -500.0, 500.0, 0, 0, "X Position Start");
1016                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "x End:",       160,10,150,19, &transform->xFin, -500.0, 500.0, 0, 0, "X Position End");
1017                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "y Start:",     10,-10,150,19, &transform->yIni, -500.0, 500.0, 0, 0, "Y Position Start");
1018                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "y End:",       160,-10,150,19, &transform->yFin, -500.0, 500.0, 0, 0, "Y Position End");
1019                 } else {
1020                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "x Start:",     10,10,150,19, &transform->xIni, -10000.0, 10000.0, 0, 0, "X Position Start");
1021                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "x End:",       160,10,150,19, &transform->xFin, -10000.0, 10000.0, 0, 0, "X Position End");
1022                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "y Start:",     10,-10,150,19, &transform->yIni, -10000.0, 10000.0, 0, 0, "Y Position Start");
1023                         uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "y End:",       160,-10,150,19, &transform->yFin, -10000.0, 10000.0, 0, 0, "Y Position End");
1024                         
1025                 }
1026                 
1027                 
1028                 
1029                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "rot Start:",10,-30,150,19, &transform->rotIni, 0.0, 360.0, 0, 0, "Rotation Start");
1030                 uiDefButF(block, NUM, B_SEQ_BUT_EFFECT, "rot End:",160,-30,150,19, &transform->rotFin, 0.0, 360.0, 0, 0, "Rotation End");
1031                 
1032                 uiDefButI(block, ROW, B_SEQ_BUT_EFFECT, "No Interpolat", 10, -50, 100, 19, &transform->interpolation, 0.0, 0.0, 0.0, 0.0, "No interpolation");
1033                 uiDefButI(block, ROW, B_SEQ_BUT_EFFECT, "Bilinear", 101, -50, 100, 19, &transform->interpolation, 0.0, 1.0, 0.0, 0.0, "Bilinear interpolation");
1034                 uiDefButI(block, ROW, B_SEQ_BUT_EFFECT, "Bicubic", 202, -50, 100, 19, &transform->interpolation, 0.0, 2.0, 0.0, 0.0, "Bicubic interpolation");
1035         } else if(last_seq->type==SEQ_COLOR) {
1036                 SolidColorVars *colvars = (SolidColorVars *)last_seq->effectdata;
1037                 uiDefButF(block, COL, B_SEQ_BUT_RELOAD, "",10,90,150,19, colvars->col, 0, 0, 0, 0, "");
1038         } else if(last_seq->type==SEQ_SPEED){
1039                 SpeedControlVars *sp = 
1040                         (SpeedControlVars *)last_seq->effectdata;
1041                 
1042                 uiDefButF(block, NUM, B_SEQ_BUT_RELOAD, "Global Speed:",        10,70,150,19, &sp->globalSpeed, 0.0, 100.0, 0, 0, "Global Speed");
1043                 
1044                 uiDefButBitI(block, TOG, SEQ_SPEED_INTEGRATE,
1045                              B_SEQ_BUT_RELOAD, 
1046                              "IPO is velocity",
1047                              10,50,150,19, &sp->flags, 
1048                              0.0, 1.0, 0, 0, 
1049                              "Interpret the IPO value as a "
1050                              "velocity instead of a frame number");
1051
1052                 uiDefButBitI(block, TOG, SEQ_SPEED_BLEND,
1053                              B_SEQ_BUT_RELOAD, 
1054                              "Enable frame blending",
1055                              10,30,150,19, &sp->flags, 
1056                              0.0, 1.0, 0, 0, 
1057                              "Blend two frames into the "
1058                              "target for a smoother result");
1059                 
1060                 uiDefButBitI(block, TOG, SEQ_SPEED_COMPRESS_IPO_Y,
1061                              B_SEQ_BUT_RELOAD, 
1062                              "IPO value runs from [0..1]",
1063                              10,10,150,19, &sp->flags, 
1064                              0.0, 1.0, 0, 0, 
1065                              "Scale IPO value to get the "
1066                              "target frame number.");
1067         }
1068
1069         uiBlockEndAlign(block);
1070 }
1071
1072 static void seq_panel_proxy()
1073 {
1074         Sequence *last_seq = get_last_seq();
1075         uiBlock *block;
1076         block = uiNewBlock(&curarea->uiblocks, "seq_panel_proxy", 
1077                            UI_EMBOSS, UI_HELV, curarea->win);
1078
1079         if(uiNewPanel(curarea, block, "Proxy", "Sequencer", 
1080                       10, 230, 318, 204) == 0) return;
1081
1082         uiBlockBeginAlign(block);
1083
1084         uiDefButBitI(block, TOG, SEQ_USE_PROXY, 
1085                      B_SEQ_BUT_RELOAD, "Use Proxy", 
1086                      10,140,150,19, &last_seq->flag, 
1087                      0.0, 21.0, 100, 0, 
1088                      "Use a preview proxy for this strip");
1089         
1090         if (last_seq->flag & SEQ_USE_PROXY) {
1091
1092
1093         }
1094
1095         uiBlockEndAlign(block);
1096 }
1097
1098
1099 void sequencer_panels()
1100 {
1101         Sequence *last_seq = get_last_seq();
1102         int panels = 0;
1103         int type;
1104
1105         if(last_seq == NULL) {
1106                 return;
1107         }
1108         
1109         type = last_seq->type;
1110
1111         panels = SEQ_PANEL_EDITING;
1112
1113         if (type == SEQ_MOVIE || type == SEQ_IMAGE || type == SEQ_SCENE
1114             || type == SEQ_HD_SOUND) {
1115                 panels |= SEQ_PANEL_INPUT | SEQ_PANEL_FILTER | SEQ_PANEL_PROXY;
1116         }
1117
1118         if (type == SEQ_RAM_SOUND) {
1119                 panels |= SEQ_PANEL_FILTER;
1120         }
1121
1122         if (type == SEQ_PLUGIN || type >= SEQ_EFFECT) {
1123                 panels |= SEQ_PANEL_EFFECT | SEQ_PANEL_PROXY;
1124         }
1125
1126         if (panels & SEQ_PANEL_EDITING) {
1127                 seq_panel_editing();
1128         }
1129
1130         if (panels & SEQ_PANEL_INPUT) {
1131                 seq_panel_input();
1132         }
1133
1134         if (panels & SEQ_PANEL_FILTER) {
1135                 if (type == SEQ_RAM_SOUND || type == SEQ_HD_SOUND) {
1136                         seq_panel_filter_audio();
1137                 } else {
1138                         seq_panel_filter_video();
1139                 }
1140         }
1141
1142         if (panels & SEQ_PANEL_EFFECT) {
1143                 seq_panel_effect();
1144         }
1145
1146         if (panels & SEQ_PANEL_PROXY) {
1147                 seq_panel_proxy();
1148         }
1149 }
1150
1151
1152 void do_sequencer_panels(unsigned short event)
1153 {
1154         Sequence *last_seq = get_last_seq();
1155
1156         switch(event) {
1157         case B_SEQ_BUT_PLUGIN:
1158         case B_SEQ_BUT_EFFECT:
1159                 update_changed_seq_and_deps(last_seq, 0, 1);
1160                 break;
1161         case B_SEQ_BUT_RELOAD_FILE:
1162                 reload_sequence_new_file(last_seq);
1163                 break;
1164         case B_SEQ_BUT_RELOAD:
1165         case B_SEQ_BUT_RELOAD_ALL:
1166                 update_seq_ipo_rect(last_seq);
1167                 update_seq_icu_rects(last_seq);
1168
1169                 free_imbuf_seq();       // frees all
1170
1171                 break;
1172         case B_SEQ_BUT_TRANSFORM:
1173                 calc_sequence(last_seq);
1174                 if (test_overlap_seq(last_seq))
1175                         shuffle_seq(last_seq);
1176                 break;
1177         }
1178
1179         if (event == B_SEQ_BUT_RELOAD_ALL) {
1180                 allqueue(REDRAWALL, 0);
1181         } else {
1182                 allqueue(REDRAWSEQ, 0);
1183         }
1184 }
1185
1186
1187 /* ************************* SCENE *********************** */
1188
1189
1190 static void output_pic(char *name)
1191 {
1192         strcpy(G.scene->r.pic, name);
1193         allqueue(REDRAWBUTSSCENE, 0);
1194         BIF_undo_push("Change output picture directory");
1195 }
1196
1197 static void backbuf_pic(char *name)
1198 {
1199         Image *ima;
1200         
1201         strcpy(G.scene->r.backbuf, name);
1202         allqueue(REDRAWBUTSSCENE, 0);
1203
1204         ima= BKE_add_image_file(name);
1205         if(ima)
1206                 BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);
1207
1208         BIF_undo_push("Change background picture");
1209 }
1210
1211 static void run_playanim(char *file) 
1212 {
1213         extern char bprogname[];        /* usiblender.c */
1214         char str[FILE_MAX];
1215         int pos[2], size[2];
1216
1217         /* use current settings for defining position of window. it actually should test image size */
1218         calc_renderwin_rectangle((G.scene->r.xsch*G.scene->r.size)/100, 
1219                                                          (G.scene->r.ysch*G.scene->r.size)/100, G.winpos, pos, size);
1220 #ifdef WIN32
1221         sprintf(str, "%s -a -p %d %d -f %d %g \"%s\"", bprogname, pos[0], pos[1], G.scene->r.frs_sec, G.scene->r.frs_sec_base, file);
1222 #else
1223         sprintf(str, "\"%s\" -a -p %d %d -f %d %g \"%s\"", bprogname, pos[0], pos[1], G.scene->r.frs_sec, G.scene->r.frs_sec_base, file);
1224 #endif
1225         system(str);
1226 }
1227
1228 void playback_anim(void)
1229 {       
1230         char file[FILE_MAX];
1231
1232         if(BKE_imtype_is_movie(G.scene->r.imtype)) {
1233                 switch (G.scene->r.imtype) {
1234 #ifdef WITH_QUICKTIME
1235                         case R_QUICKTIME:
1236                                 makeqtstring(file);
1237                                 break;
1238 #endif
1239 #ifdef WITH_FFMPEG
1240                 case R_FFMPEG:
1241                         makeffmpegstring(file);
1242                         break;
1243 #endif
1244                 default:
1245                         makeavistring(&G.scene->r, file);
1246                         break;
1247                 }
1248                 if(BLI_exist(file)) {
1249                         run_playanim(file);
1250                 }
1251                 else error("Can't find movie: %s", file);
1252         }
1253         else {
1254                 BKE_makepicstring(file, G.scene->r.pic, G.scene->r.sfra, G.scene->r.imtype);
1255                 if(BLI_exist(file)) {
1256                         run_playanim(file);
1257                 }
1258                 else error("Can't find image: %s", file);
1259         }
1260 }
1261
1262 #ifdef WITH_FFMPEG
1263 static void set_ffmpeg_preset(int preset);
1264 #endif
1265
1266 void do_render_panels(unsigned short event)
1267 {
1268         ScrArea *sa;
1269         ID *id;
1270
1271         switch(event) {
1272
1273         case B_DORENDER:
1274                 BIF_do_render(0);
1275                 break;
1276         case B_RTCHANGED:
1277                 allqueue(REDRAWALL, 0);
1278                 break;
1279         case B_SWITCHRENDER:
1280                 /* new panels added, so... */
1281                 G.buts->re_align= 1;
1282                 allqueue(REDRAWBUTSSCENE, 0);
1283                 break;
1284         case B_PLAYANIM:
1285                 playback_anim();
1286                 break;
1287                 
1288         case B_DOANIM:
1289                 BIF_do_render(1);
1290                 break;
1291         
1292         case B_FS_PIC:
1293                 sa= closest_bigger_area();
1294                 areawinset(sa->win);
1295                 if(G.qual == LR_CTRLKEY)
1296                         activate_imageselect(FILE_SPECIAL, "SELECT OUTPUT PICTURES", G.scene->r.pic, output_pic);
1297                 else
1298                         activate_fileselect(FILE_SPECIAL, "SELECT OUTPUT PICTURES", G.scene->r.pic, output_pic);
1299                 break;
1300
1301         case B_FS_BACKBUF:
1302                 sa= closest_bigger_area();
1303                 areawinset(sa->win);
1304                 if(G.qual == LR_CTRLKEY)
1305                         activate_imageselect(FILE_SPECIAL, "SELECT BACKBUF PICTURE", G.scene->r.backbuf, backbuf_pic);
1306                 else
1307                         activate_fileselect(FILE_SPECIAL, "SELECT BACKBUF PICTURE", G.scene->r.backbuf, backbuf_pic);
1308                 break;
1309         
1310         case B_PR_PAL:
1311                 G.scene->r.xsch= 720;
1312                 G.scene->r.ysch= 576;
1313                 G.scene->r.xasp= 54;
1314                 G.scene->r.yasp= 51;
1315                 G.scene->r.size= 100;
1316                 G.scene->r.frs_sec= 25;
1317                 G.scene->r.frs_sec_base= 1;
1318                 G.scene->r.mode &= ~R_PANORAMA;
1319                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1320 #ifdef WITH_FFMPEG
1321                 G.scene->r.ffcodecdata.gop_size = 15;
1322 #endif          
1323                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1324                 BIF_undo_push("Set PAL");
1325                 allqueue(REDRAWBUTSSCENE, 0);
1326                 allqueue(REDRAWVIEWCAM, 0);
1327                 break;
1328
1329         case B_FILETYPEMENU:
1330                 allqueue(REDRAWBUTSSCENE, 0);
1331 #ifdef WITH_FFMPEG
1332                 if (G.scene->r.imtype == R_FFMPEG) {
1333                         if (G.scene->r.ffcodecdata.type <= 0 ||
1334                             G.scene->r.ffcodecdata.codec <= 0 ||
1335                             G.scene->r.ffcodecdata.audio_codec <= 0 ||
1336                             G.scene->r.ffcodecdata.video_bitrate <= 1) {
1337                                 G.scene->r.ffcodecdata.codec 
1338                                         = CODEC_ID_MPEG2VIDEO;
1339                                 set_ffmpeg_preset(FFMPEG_PRESET_DVD);
1340                         }
1341
1342                         if (G.scene->r.ffcodecdata.audio_codec <= 0) {
1343                                 G.scene->r.ffcodecdata.audio_codec 
1344                                         = CODEC_ID_MP2;
1345                                 G.scene->r.ffcodecdata.audio_bitrate = 128;
1346                         }
1347                         break;
1348                 }
1349 #endif
1350 #if defined (_WIN32) || defined (__APPLE__)
1351                 // fall through to codec settings if this is the first
1352                 // time R_AVICODEC is selected for this scene.
1353                 if (((G.scene->r.imtype == R_AVICODEC) 
1354                          && (G.scene->r.avicodecdata == NULL)) ||
1355                         ((G.scene->r.imtype == R_QUICKTIME) 
1356                          && (G.scene->r.qtcodecdata == NULL))) {
1357                 } else {
1358                   break;
1359                 }
1360 #endif /*_WIN32 || __APPLE__ */
1361
1362         case B_SELECTCODEC:
1363 #if defined (_WIN32) || defined (__APPLE__)
1364                 if ((G.scene->r.imtype == R_QUICKTIME)) { /* || (G.scene->r.qtcodecdata)) */
1365 #ifdef WITH_QUICKTIME
1366                         get_qtcodec_settings();
1367 #endif /* WITH_QUICKTIME */
1368                 }
1369 #if defined (_WIN32) && !defined(FREE_WINDOWS)
1370                 else
1371                         get_avicodec_settings();
1372 #endif /* _WIN32 && !FREE_WINDOWS */
1373 #endif /* _WIN32 || __APPLE__ */
1374                 break;
1375
1376         case B_PR_HD:
1377                 G.scene->r.xsch= 1920;
1378                 G.scene->r.ysch= 1080;
1379                 G.scene->r.xasp= 1;
1380                 G.scene->r.yasp= 1;
1381                 G.scene->r.size= 100;
1382                 G.scene->r.mode &= ~R_PANORAMA;
1383                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1384                 
1385                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1386                 BIF_undo_push("Set FULL");
1387                 allqueue(REDRAWBUTSSCENE, 0);
1388                 allqueue(REDRAWVIEWCAM, 0);
1389                 break;
1390         case B_PR_FULL:
1391                 G.scene->r.xsch= 1280;
1392                 G.scene->r.ysch= 1024;
1393                 G.scene->r.xasp= 1;
1394                 G.scene->r.yasp= 1;
1395                 G.scene->r.size= 100;
1396                 G.scene->r.mode &= ~R_PANORAMA;
1397                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1398
1399                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1400                 BIF_undo_push("Set FULL");
1401                 allqueue(REDRAWBUTSSCENE, 0);
1402                 allqueue(REDRAWVIEWCAM, 0);
1403                 break;
1404         case B_PR_PRV:
1405                 G.scene->r.xsch= 640;
1406                 G.scene->r.ysch= 512;
1407                 G.scene->r.xasp= 1;
1408                 G.scene->r.yasp= 1;
1409                 G.scene->r.size= 50;
1410                 G.scene->r.mode &= ~R_PANORAMA;
1411                 G.scene->r.xparts=  G.scene->r.yparts= 2;
1412
1413                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1414                 allqueue(REDRAWVIEWCAM, 0);
1415                 allqueue(REDRAWBUTSSCENE, 0);
1416                 break;
1417         case B_PR_PAL169:
1418                 G.scene->r.xsch= 720;
1419                 G.scene->r.ysch= 576;
1420                 G.scene->r.xasp= 64;
1421                 G.scene->r.yasp= 45;
1422                 G.scene->r.size= 100;
1423                 G.scene->r.frs_sec= 25;
1424                 G.scene->r.frs_sec_base= 1;
1425                 G.scene->r.mode &= ~R_PANORAMA;
1426                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1427 #ifdef WITH_FFMPEG
1428                 G.scene->r.ffcodecdata.gop_size = 15;
1429 #endif          
1430
1431                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1432                 BIF_undo_push("Set PAL 16/9");
1433                 allqueue(REDRAWVIEWCAM, 0);
1434                 allqueue(REDRAWBUTSSCENE, 0);
1435                 break;
1436         case B_PR_PC:
1437                 G.scene->r.xsch= 640;
1438                 G.scene->r.ysch= 480;
1439                 G.scene->r.xasp= 100;
1440                 G.scene->r.yasp= 100;
1441                 G.scene->r.size= 100;
1442                 G.scene->r.mode &= ~R_PANORAMA;
1443                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1444
1445                 BLI_init_rctf(&G.scene->r.safety, 0.0, 1.0, 0.0, 1.0);
1446                 BIF_undo_push("Set PC");
1447                 allqueue(REDRAWVIEWCAM, 0);
1448                 allqueue(REDRAWBUTSSCENE, 0);
1449                 break;
1450         case B_PR_PRESET:
1451                 G.scene->r.xsch= 720;
1452                 G.scene->r.ysch= 576;
1453                 G.scene->r.xasp= 54;
1454                 G.scene->r.yasp= 51;
1455                 G.scene->r.size= 100;
1456                 G.scene->r.mode= R_OSA+R_SHADOW+R_FIELDS;
1457                 G.scene->r.imtype= R_TARGA;
1458                 G.scene->r.xparts=  G.scene->r.yparts= 4;
1459
1460                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1461                 BIF_undo_push("Set Default");
1462                 allqueue(REDRAWVIEWCAM, 0);
1463                 allqueue(REDRAWBUTSSCENE, 0);
1464                 break;
1465         case B_PR_PANO:
1466                 G.scene->r.xsch= 576;
1467                 G.scene->r.ysch= 176;
1468                 G.scene->r.xasp= 115;
1469                 G.scene->r.yasp= 100;
1470                 G.scene->r.size= 100;
1471                 G.scene->r.mode |= R_PANORAMA;
1472                 G.scene->r.xparts=  16;
1473                 G.scene->r.yparts= 1;
1474
1475                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1476                 BIF_undo_push("Set Panorama");
1477                 allqueue(REDRAWVIEWCAM, 0);
1478                 allqueue(REDRAWBUTSSCENE, 0);
1479                 break;
1480         case B_PR_NTSC:
1481                 G.scene->r.xsch= 720;
1482                 G.scene->r.ysch= 480;
1483                 G.scene->r.xasp= 10;
1484                 G.scene->r.yasp= 11;
1485                 G.scene->r.size= 100;
1486                 G.scene->r.frs_sec= 30;
1487                 G.scene->r.frs_sec_base = 1.001;
1488                 G.scene->r.mode &= ~R_PANORAMA;
1489                 G.scene->r.xparts=  G.scene->r.yparts= 2;
1490 #ifdef WITH_FFMPEG
1491                 G.scene->r.ffcodecdata.gop_size = 18;
1492 #endif          
1493                 
1494                 BLI_init_rctf(&G.scene->r.safety, 0.1, 0.9, 0.1, 0.9);
1495                 BIF_undo_push("Set NTSC");
1496                 allqueue(REDRAWBUTSSCENE, 0);
1497                 allqueue(REDRAWVIEWCAM, 0);
1498                 break;
1499
1500         case B_SETBROWSE:
1501                 id= (ID*) G.scene->set;
1502                 
1503                 if (G.buts->menunr==-2) {
1504                          activate_databrowse(id, ID_SCE, 0, B_SETBROWSE, &G.buts->menunr, do_render_panels);
1505                 } 
1506                 else if (G.buts->menunr>0) {
1507                         Scene *newset= (Scene*) BLI_findlink(&G.main->scene, G.buts->menunr-1);
1508                         
1509                         if (newset==G.scene)
1510                                 error("Can't use the same scene as its own set");
1511                         else if (newset) {
1512                                 G.scene->set= newset;
1513                                 if (scene_check_setscene(G.scene)==0)
1514                                         error("This would create a cycle");
1515
1516                                 allqueue(REDRAWBUTSSCENE, 0);
1517                                 allqueue(REDRAWVIEW3D, 0);
1518                                 BIF_undo_push("Change Set Scene");
1519                         }
1520                 }  
1521                 break;
1522         case B_CLEARSET:
1523                 G.scene->set= NULL;
1524                 allqueue(REDRAWBUTSSCENE, 0);
1525                 allqueue(REDRAWVIEW3D, 0);
1526                 BIF_undo_push("Clear Set Scene");
1527                 
1528                 break;
1529         case B_SET_EDGE:
1530                 allqueue(REDRAWBUTSSCENE, 0);
1531                 break;
1532         case B_SET_ZBLUR:
1533                 G.scene->r.mode &= ~R_EDGE;
1534                 allqueue(REDRAWBUTSSCENE, 0);
1535                 break;
1536         case B_ADD_RENDERLAYER:
1537                 if(G.scene->r.actlay==32767) {
1538                         scene_add_render_layer(G.scene);
1539                         G.scene->r.actlay= BLI_countlist(&G.scene->r.layers) - 1;
1540                 }
1541                 allqueue(REDRAWBUTSSCENE, 0);
1542                 allqueue(REDRAWNODE, 0);
1543                 break;
1544         case B_SET_PASS:
1545                 if(G.scene->nodetree) {
1546                         ntreeCompositForceHidden(G.scene->nodetree);
1547                         allqueue(REDRAWNODE, 0);
1548                 }
1549                 allqueue(REDRAWBUTSSCENE, 0);
1550                 allqueue(REDRAWOOPS, 0);
1551         }
1552 }
1553
1554 /* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */
1555 static uiBlock *edge_render_menu(void *arg_unused)
1556 {
1557         uiBlock *block;
1558         
1559         block= uiNewBlock(&curarea->uiblocks, "edge render", UI_EMBOSS, UI_HELV, curarea->win);
1560                 
1561         /* use this for a fake extra empy space around the buttons */
1562         uiDefBut(block, LABEL, 0, "",  0, 0, 220, 115, NULL,  0, 0, 0, 0, "");
1563         
1564         uiDefButS(block, NUM, 0,"Eint:",        45,75,175,19,  &G.scene->r.edgeint, 0.0, 255.0, 0, 0,
1565                   "Sets edge intensity for Toon shading");
1566
1567         /* color settings for the toon shading */
1568         uiDefButF(block, COL, 0, "",            10, 10,30,60,  &(G.scene->r.edgeR), 0, 0, 0, B_EDGECOLSLI, "");
1569         
1570         uiBlockBeginAlign(block);
1571         uiDefButF(block, NUMSLI, 0, "R ",   45, 50, 175,19,   &G.scene->r.edgeR, 0.0, 1.0, B_EDGECOLSLI, 0,
1572                   "Color for edges in toon shading mode.");
1573         uiDefButF(block, NUMSLI, 0, "G ",       45, 30, 175,19,  &G.scene->r.edgeG, 0.0, 1.0, B_EDGECOLSLI, 0,
1574                   "Color for edges in toon shading mode.");
1575         uiDefButF(block, NUMSLI, 0, "B ",       45, 10, 175,19,  &G.scene->r.edgeB, 0.0, 1.0, B_EDGECOLSLI, 0,
1576                   "Color for edges in toon shading mode.");
1577
1578         
1579         uiBlockSetDirection(block, UI_TOP);
1580         
1581         return block;
1582 }
1583
1584
1585 /* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */
1586 static uiBlock *framing_render_menu(void *arg_unused)
1587 {
1588         uiBlock *block;
1589         short yco = 190, xco = 0;
1590         int randomcolorindex = 1234;
1591
1592         block= uiNewBlock(&curarea->uiblocks, "framing_options", UI_EMBOSS, UI_HELV, curarea->win);
1593
1594         /* use this for a fake extra empy space around the buttons */
1595         uiDefBut(block, LABEL, 0, "",                   -5, -10, 295, 224, NULL, 0, 0, 0, 0, "");
1596
1597         uiDefBut(block, LABEL, 0, "Framing:", xco, yco, 68,19, 0, 0, 0, 0, 0, "");
1598         uiBlockBeginAlign(block);
1599         uiDefButC(block, ROW, 0, "Stretch",     xco += 70, yco, 68, 19, &G.scene->framing.type, 1.0, SCE_GAMEFRAMING_SCALE , 0, 0, "Stretch or squeeze the viewport to fill the display window");
1600         uiDefButC(block, ROW, 0, "Expose",      xco += 70, yco, 68, 19, &G.scene->framing.type, 1.0, SCE_GAMEFRAMING_EXTEND, 0, 0, "Show the entire viewport in the display window, viewing more horizontally or vertically");
1601         uiDefButC(block, ROW, 0, "Letterbox",       xco += 70, yco, 68, 19, &G.scene->framing.type, 1.0, SCE_GAMEFRAMING_BARS  , 0, 0, "Show the entire viewport in the display window, using bar horizontally or vertically");
1602         uiBlockEndAlign(block);
1603
1604         yco -= 25;
1605         xco = 40;
1606
1607         uiDefButF(block, COL, 0, "",                0, yco - 58 + 18, 33, 58, &G.scene->framing.col[0], 0, 0, 0, randomcolorindex, "");
1608
1609         uiBlockBeginAlign(block);
1610         uiDefButF(block, NUMSLI, 0, "R ", xco,yco,243,18, &G.scene->framing.col[0], 0.0, 1.0, randomcolorindex, 0, "Set the red component of the bars");
1611         yco -= 20;
1612         uiDefButF(block, NUMSLI, 0, "G ", xco,yco,243,18, &G.scene->framing.col[1], 0.0, 1.0, randomcolorindex, 0, "Set the green component of the bars");
1613         yco -= 20;
1614         uiDefButF(block, NUMSLI, 0, "B ", xco,yco,243,18, &G.scene->framing.col[2], 0.0, 1.0, randomcolorindex, 0, "Set the blue component of the bars");
1615         uiBlockEndAlign(block);
1616         
1617         xco = 0;
1618         uiDefBut(block, LABEL, 0, "Fullscreen:",                xco, yco-=30, 100, 19, 0, 0.0, 0.0, 0, 0, "");
1619         uiDefButS(block, TOG, 0, "Fullscreen", xco+70, yco, 68, 19, &G.scene->r.fullscreen, 0.0, 0.0, 0, 0, "Starts player in a new fullscreen display");
1620         uiBlockBeginAlign(block);
1621         uiDefButS(block, NUM, 0, "X:",          xco+40, yco-=27, 100, 19, &G.scene->r.xplay, 10.0, 2000.0, 0, 0, "Displays current X screen/window resolution. Click to change.");
1622         uiDefButS(block, NUM, 0, "Y:",          xco+140, yco, 100, 19, &G.scene->r.yplay,    10.0, 2000.0, 0, 0, "Displays current Y screen/window resolution. Click to change.");
1623         uiDefButS(block, NUM, 0, "Freq:",       xco+40, yco-=21, 100, 19, &G.scene->r.freqplay, 10.0, 2000.0, 0, 0, "Displays clock frequency of fullscreen display. Click to change.");
1624         uiDefButS(block, NUM, 0, "Bits:",       xco+140, yco, 100, 19, &G.scene->r.depth, 8.0, 32.0, 800.0, 0, "Displays bit depth of full screen display. Click to change.");
1625         uiBlockEndAlign(block);
1626
1627         /* stereo settings */
1628         /* can't use any definition from the game engine here so hardcode it. Change it here when it changes there!
1629          * RAS_IRasterizer has definitions:
1630          * RAS_STEREO_NOSTEREO           1
1631          * RAS_STEREO_QUADBUFFERED 2
1632          * RAS_STEREO_ABOVEBELOW         3
1633          * RAS_STEREO_INTERLACED         4       future
1634          * RAS_STEREO_ANAGLYPH          5
1635          * RAS_STEREO_SIDEBYSIDE        6
1636          * RAS_STEREO_VINTERLACE        7
1637          */
1638         uiBlockBeginAlign(block);
1639         uiDefButS(block, ROW, 0, "No Stereo", xco, yco-=30, 88, 19, &(G.scene->r.stereomode), 7.0, 1.0, 0, 0, "Disables stereo");
1640         uiDefButS(block, ROW, 0, "Pageflip", xco+=90, yco, 88, 19, &(G.scene->r.stereomode), 7.0, 2.0, 0, 0, "Enables hardware pageflip stereo method");
1641         uiDefButS(block, ROW, 0, "Syncdouble", xco+=90, yco, 88, 19, &(G.scene->r.stereomode), 7.0, 3.0, 0, 0, "Enables syncdoubling stereo method");
1642         uiDefButS(block, ROW, 0, "Anaglyph", xco-=180, yco-=21, 88, 19, &(G.scene->r.stereomode), 7.0, 5.0, 0, 0, "Enables anaglyph (Red-Blue) stereo method");
1643         uiDefButS(block, ROW, 0, "Side by Side", xco+=90, yco, 88, 19, &(G.scene->r.stereomode), 7.0, 6.0, 0, 0, "Enables side by side left and right images");
1644         uiDefButS(block, ROW, 0, "V Interlace", xco+=90, yco, 88, 19, &(G.scene->r.stereomode), 7.0, 7.0, 0, 0, "Enables interlaced vertical strips for autostereo display");
1645         
1646         uiBlockEndAlign(block);
1647
1648         uiBlockSetDirection(block, UI_TOP);
1649
1650         return block;
1651 }
1652
1653 #ifdef WITH_FFMPEG
1654
1655 static char* ffmpeg_format_pup(void) 
1656 {
1657         static char string[2048];
1658         char formatstring[2048];
1659 #if 0
1660        int i = 0;
1661        int stroffs = 0;
1662        AVOutputFormat* next = first_oformat;
1663        formatstring = "FFMpeg format: %%t";
1664       sprintf(string, formatstring);
1665        formatstring = "|%s %%x%d";
1666        /* FIXME: This should only be generated once */
1667        while (next != NULL) {
1668                if (next->video_codec != CODEC_ID_NONE && !(next->flags & AVFMT_NOFILE)) {
1669                        sprintf(string+stroffs, formatstring, next->name, i++);
1670                        stroffs += strlen(string+stroffs);
1671                }
1672                next = next->next;
1673        }
1674        return string;
1675 #endif
1676        strcpy(formatstring, "FFMpeg format: %%t|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d");
1677        sprintf(string, formatstring,
1678                "MPEG-1", FFMPEG_MPEG1,
1679                "MPEG-2", FFMPEG_MPEG2,
1680                "MPEG-4", FFMPEG_MPEG4,
1681                "AVI",    FFMPEG_AVI,
1682                "Quicktime", FFMPEG_MOV,
1683                "DV", FFMPEG_DV,
1684                "H264", FFMPEG_H264,
1685                "XVid", FFMPEG_XVID);
1686        return string;
1687 }
1688
1689 static char* ffmpeg_preset_pup(void) 
1690 {
1691         static char string[2048];
1692         char formatstring[2048];
1693
1694        strcpy(formatstring, "FFMpeg preset: %%t|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d");
1695        sprintf(string, formatstring,
1696                "", FFMPEG_PRESET_NONE,
1697                "DVD", FFMPEG_PRESET_DVD,
1698                "SVCD", FFMPEG_PRESET_SVCD,
1699                "VCD", FFMPEG_PRESET_VCD,
1700                "DV", FFMPEG_PRESET_DV);
1701        return string;
1702 }
1703
1704
1705 static char* ffmpeg_codec_pup(void) {
1706        static char string[2048];
1707        char formatstring[2048];
1708        strcpy(formatstring, "FFMpeg format: %%t|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d");
1709        sprintf(string, formatstring,
1710                "MPEG1", CODEC_ID_MPEG1VIDEO,
1711                "MPEG2", CODEC_ID_MPEG2VIDEO,
1712                "MPEG4(divx)", CODEC_ID_MPEG4,
1713                "HuffYUV", CODEC_ID_HUFFYUV,
1714                "DV", CODEC_ID_DVVIDEO,
1715                "H264", CODEC_ID_H264,
1716                "XVid", CODEC_ID_XVID);
1717        return string;
1718
1719 }
1720
1721 static char* ffmpeg_audio_codec_pup(void) {
1722        static char string[2048];
1723        char formatstring[2048];
1724        strcpy(formatstring, "FFMpeg format: %%t|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d");
1725        sprintf(string, formatstring,
1726                "MP2", CODEC_ID_MP2,
1727                "MP3", CODEC_ID_MP3,
1728                "AC3", CODEC_ID_AC3,
1729                "AAC", CODEC_ID_AAC,
1730                "PCM", CODEC_ID_PCM_S16LE);
1731        return string;
1732
1733 }
1734
1735 #endif
1736
1737 static char *imagetype_pup(void)
1738 {
1739         static char string[1024];
1740         char formatstring[1024];
1741         char appendstring[1024];
1742
1743         strcpy(formatstring, "Save image as: %%t|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d|%s %%x%d");
1744
1745 #ifdef __sgi
1746         strcat(formatstring, "|%s %%x%d");      // add space for Movie
1747 #endif
1748
1749         strcat(formatstring, "|%s %%x%d");      // add space for PNG
1750 /*  Commented out until implemented
1751 #ifdef WITH_DDS
1752         strcat(formatstring, "|%s %%x%d");      // add space for DDS
1753 #endif
1754 */
1755         strcat(formatstring, "|%s %%x%d");      // add space for BMP
1756         strcat(formatstring, "|%s %%x%d");      // add space for Radiance HDR
1757         strcat(formatstring, "|%s %%x%d");      // add space for Cineon
1758         strcat(formatstring, "|%s %%x%d");      // add space for DPX
1759         
1760 #ifdef _WIN32
1761         strcat(formatstring, "|%s %%x%d");      // add space for AVI Codec
1762 #endif
1763
1764 #ifdef WITH_FFMPEG
1765        strcat(formatstring, "|%s %%x%d"); // Add space for ffmpeg
1766 #endif
1767        strcat(formatstring, "|%s %%x%d"); // Add space for frameserver
1768
1769 #ifdef WITH_QUICKTIME
1770         if(G.have_quicktime)
1771                 strcat(formatstring, "|%s %%x%d");      // add space for Quicktime
1772 #endif
1773
1774         if(G.have_quicktime) {
1775                 sprintf(string, formatstring,
1776                         "Frameserver",   R_FRAMESERVER,
1777 #ifdef WITH_FFMPEG
1778                        "FFMpeg",         R_FFMPEG,
1779 #endif
1780                         "AVI Raw",        R_AVIRAW,
1781                         "AVI Jpeg",       R_AVIJPEG,
1782 #ifdef _WIN32
1783                         "AVI Codec",      R_AVICODEC,
1784 #endif
1785 #ifdef WITH_QUICKTIME
1786                         "QuickTime",      R_QUICKTIME,
1787 #endif
1788                         "Targa",          R_TARGA,
1789                         "Targa Raw",      R_RAWTGA,
1790                         "PNG",            R_PNG,
1791 /* commented out until implemented 
1792 #ifdef WITH_DDS
1793                         "DDS",            R_DDS,
1794 #endif
1795 */
1796                         "BMP",            R_BMP,
1797                         "Jpeg",           R_JPEG90,
1798                         "HamX",           R_HAMX,
1799                         "Iris",           R_IRIS,
1800                         "Radiance HDR",   R_RADHDR,
1801                         "Cineon",                 R_CINEON,
1802                         "DPX",                    R_DPX
1803 #ifdef __sgi
1804                         ,"Movie",          R_MOVIE
1805 #endif
1806                 );
1807         } else {
1808                 sprintf(string, formatstring,
1809                         "Frameserver",   R_FRAMESERVER,
1810 #ifdef WITH_FFMPEG
1811                        "FFMpeg",         R_FFMPEG,
1812 #endif
1813                         "AVI Raw",        R_AVIRAW,
1814                         "AVI Jpeg",       R_AVIJPEG,
1815 #ifdef _WIN32
1816                         "AVI Codec",      R_AVICODEC,
1817 #endif
1818                         "Targa",          R_TARGA,
1819                         "Targa Raw",      R_RAWTGA,
1820                         "PNG",            R_PNG,
1821 #ifdef WITH_DDS
1822                         "DDS",            R_DDS,
1823 #endif
1824                         "BMP",            R_BMP,
1825                         "Jpeg",           R_JPEG90,
1826                         "HamX",           R_HAMX,
1827                         "Iris",           R_IRIS,
1828                         "Radiance HDR",   R_RADHDR,
1829                         "Cineon",                 R_CINEON,
1830                         "DPX",                    R_DPX
1831 #ifdef __sgi
1832                         ,"Movie",          R_MOVIE
1833 #endif
1834                 );
1835         }
1836
1837 #ifdef WITH_OPENEXR
1838         strcpy(formatstring, "|%s %%x%d");
1839         sprintf(appendstring, formatstring, "OpenEXR", R_OPENEXR);
1840         strcat(string, appendstring);
1841         sprintf(appendstring, formatstring, "MultiLayer", R_MULTILAYER);
1842         strcat(string, appendstring);
1843 #endif
1844         
1845         if (G.have_libtiff) {
1846                 strcpy(formatstring, "|%s %%x%d");
1847                 sprintf(appendstring, formatstring, "TIFF", R_TIFF);
1848                 strcat(string, appendstring);
1849         }
1850
1851         return (string);
1852 }
1853
1854 #ifdef _WIN32
1855 static char *avicodec_str(void)
1856 {
1857         static char string[1024];
1858
1859         sprintf(string, "Codec: %s", G.scene->r.avicodecdata->avicodecname);
1860
1861         return string;
1862 }
1863 #endif
1864
1865 static void render_panel_output(void)
1866 {
1867         ID *id;
1868         int a,b;
1869         uiBlock *block;
1870         char *strp;
1871
1872         block= uiNewBlock(&curarea->uiblocks, "render_panel_output", UI_EMBOSS, UI_HELV, curarea->win);
1873         if(uiNewPanel(curarea, block, "Output", "Render", 0, 0, 318, 204)==0) return;
1874         
1875         uiBlockBeginAlign(block);
1876         uiDefIconBut(block, BUT, B_FS_PIC, ICON_FILESEL,        10, 190, 20, 20, 0, 0, 0, 0, 0, "Open Fileselect to get Pics dir/name");
1877         uiDefBut(block, TEX,0,"",                                                       31, 190, 279, 20,G.scene->r.pic, 0.0,79.0, 0, 0, "Directory/name to save rendered Pics to");
1878         uiDefIconBut(block, BUT,B_FS_BACKBUF, ICON_FILESEL, 10, 168, 20, 20, 0, 0, 0, 0, 0, "Open Fileselect to get Backbuf image");
1879         uiDefBut(block, TEX,0,"",                                                       31, 168, 279, 20,G.scene->r.backbuf, 0.0,79.0, 0, 0, "Image to use as background for rendering");
1880         uiBlockEndAlign(block);
1881         
1882         uiBlockBeginAlign(block);
1883         uiDefButBitI(block, TOG, R_TOUCH, B_NOP, "Touch",       10, 142, 50, 20, &G.scene->r.mode, 0.0, 0.0, 0, 0, "Create an empty file before rendering each frame, remove if cancelled (and empty)");
1884         uiDefButBitI(block, TOG, R_NO_OVERWRITE, B_NOP, "No Overwrite", 60, 142, 90, 20, &G.scene->r.mode, 0.0, 0.0, 0, 0, "Skip rendering frames when the file exists (image output only)");
1885         uiBlockEndAlign(block);
1886         uiDefButBitS(block, TOG, R_BACKBUF, B_NOP,"Backbuf",    160, 142, 80, 20, &G.scene->r.bufflag, 0, 0, 0, 0, "Enable/Disable use of Backbuf image");      
1887         
1888         /* SET BUTTON */
1889         uiBlockBeginAlign(block);
1890         id= (ID *)G.scene->set;
1891         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->scene), id, &(G.buts->menunr));
1892         if(strp[0])
1893                 uiDefButS(block, MENU, B_SETBROWSE, strp,                       10, 114, 20, 20, &(G.buts->menunr), 0, 0, 0, 0, "Scene to link as a Set");
1894         MEM_freeN(strp);
1895
1896         if(G.scene->set) {
1897                 uiSetButLock(1, NULL);
1898                 uiDefIDPoinBut(block, test_scenepoin_but, ID_SCE, B_NOP, "",    31, 114, 100, 20, &(G.scene->set), "Name of the Set");
1899                 uiClearButLock();
1900                 uiDefIconBut(block, BUT, B_CLEARSET, ICON_X,            132, 114, 20, 20, 0, 0, 0, 0, 0, "Remove Set link");
1901         }
1902         uiBlockEndAlign(block);
1903
1904         uiDefButS(block, NUM, B_NOP, "Threads:",                                10, 63, 100, 20, &G.scene->r.threads, 1, BLENDER_MAX_THREADS, 0, 0, "Amount of threads for render (takes advantage of multi-core and multi-processor computers)");
1905         uiBlockSetCol(block, TH_AUTO);
1906                 
1907         uiBlockBeginAlign(block);
1908         for(b=2; b>=0; b--)
1909                 for(a=0; a<3; a++)
1910                         uiDefButBitS(block, TOG, 1<<(3*b+a), 800,"",    (short)(10+18*a),(short)(10+14*b),16,12, &G.winpos, 0, 0, 0, 0, "Render window placement on screen");
1911
1912         uiBlockBeginAlign(block);
1913         uiDefButBitS(block, TOG, R_EXR_TILE_FILE, B_REDR, "Save Buffers", 72, 31, 120, 19, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Save the tiles for all RenderLayers and used SceneNodes to files, to save memory");
1914         if(G.scene->r.scemode & R_EXR_TILE_FILE)
1915                 uiDefButBitS(block, TOG, R_FULL_SAMPLE, B_REDR, "FullSample",    192, 31, 118, 19, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Saves for every OSA sample the entire RenderLayer results");
1916         uiBlockEndAlign(block);
1917         
1918         uiDefButS(block, MENU, B_REDR, "Render Display %t|Render Window %x1|Image Editor %x0|Full Screen %x2",  
1919                                         72, 10, 120, 19, &G.displaymode, 0.0, (float)R_DISPLAYWIN, 0, 0, "Sets render output display");
1920
1921         uiDefButBitS(block, TOG, R_EXTENSION, B_NOP, "Extensions", 205, 10, 105, 19, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Adds filetype extensions to the filename when rendering animations");
1922         
1923         /* Dither control */
1924         uiDefButF(block, NUM,B_DIFF, "Dither:",         10,89,100,19, &G.scene->r.dither_intensity, 0.0, 2.0, 0, 0, "The amount of dithering noise present in the output image (0.0 = no dithering)");
1925         
1926         /* Toon shading buttons */
1927         uiBlockBeginAlign(block);
1928         uiDefButBitI(block, TOG, R_EDGE, B_NOP,"Edge",   115, 89, 60, 20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Toon Edge-enhance");
1929         uiDefBlockBut(block, edge_render_menu, NULL, "Edge Settings", 175, 89, 135, 20, "Display Edge settings");
1930         uiBlockEndAlign(block);
1931         
1932         uiBlockBeginAlign(block);
1933         uiDefButBitS(block, TOG, R_NO_TEX, B_NOP, "Disable Tex", 115, 63, 70, 20, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Disables Textures for render");
1934         uiDefButBitS(block, TOG, R_FREE_IMAGE, B_NOP, "Free Tex Images", 205, 63, 100, 20, &G.scene->r.scemode, 0.0, 0.0, 0, 0, "Frees all Images used by Textures after each render");
1935         uiBlockEndAlign(block);
1936 }
1937
1938 static void do_bake_func(void *unused_v, void *unused_p)
1939 {
1940         objects_bake_render(0);
1941 }
1942
1943 static void render_panel_bake(void)
1944 {
1945         uiBlock *block;
1946         uiBut *but;
1947         
1948         block= uiNewBlock(&curarea->uiblocks, "render_panel_bake", UI_EMBOSS, UI_HELV, curarea->win);
1949         uiNewPanelTabbed("Anim", "Render");
1950         if(uiNewPanel(curarea, block, "Bake", "Render", 320, 0, 318, 204)==0) return;
1951         
1952         but= uiDefBut(block, BUT, B_NOP, "BAKE",        10, 150, 190,40, 0, 0, 0, 0, 0, "Start the bake render for selected Objects");
1953         uiButSetFunc(but, do_bake_func, NULL, NULL);
1954
1955         uiBlockBeginAlign(block);
1956         uiDefButBitS(block, TOG, R_BAKE_TO_ACTIVE, B_DIFF, "Selected to Active", 10,120,190,20,&G.scene->r.bake_flag, 0.0, 0, 0, 0, "Bake shading on the surface of selected objects to the active object");
1957         uiDefButF(block, NUM, B_DIFF, "Dist:", 10,100,(G.scene->r.bake_mode == RE_BAKE_NORMALS)? 95: 190,20,&G.scene->r.bake_maxdist, 0.0, 10.0, 1, 0, "Maximum distance from active object to other object");
1958
1959         if(G.scene->r.bake_mode == RE_BAKE_NORMALS)
1960                 uiDefButS(block, MENU, B_DIFF, "Normal Space %t|Camera %x0|World %x1|Object %x2|Tangent %x3", 
1961                         105,100,95,20, &G.scene->r.bake_normal_space, 0, 0, 0, 0, "Choose normal space for baking");
1962         uiBlockEndAlign(block);
1963
1964 #if 0   
1965         uiBlockBeginAlign(block);
1966         uiDefButBitS(block, TOG, R_BAKE_OSA, B_DIFF, "OSA",             10,120,190,20, &G.scene->r.bake_flag, 0, 0, 0, 0, "Enables Oversampling (Anti-aliasing)");
1967         uiDefButS(block, ROW,B_DIFF,"5",                        10,100,50,20,&G.scene->r.bake_osa,2.0,5.0, 0, 0, "Sets oversample level to 5");
1968         uiDefButS(block, ROW,B_DIFF,"8",                        60,100,45,20,&G.scene->r.bake_osa,2.0,8.0, 0, 0, "Sets oversample level to 8");
1969         uiDefButS(block, ROW,B_DIFF,"11",                       105,100,45,20,&G.scene->r.bake_osa,2.0,11.0, 0, 0, "Sets oversample level to 11");
1970         uiDefButS(block, ROW,B_DIFF,"16",                       150,100,50,20,&G.scene->r.bake_osa,2.0,16.0, 0, 0, "Sets oversample level to 16");
1971 #endif  
1972         uiBlockBeginAlign(block);
1973         uiDefButS(block, ROW,B_REDR,"Full Render",              210,170,120,20,&G.scene->r.bake_mode, 1.0, RE_BAKE_ALL, 0, 0, "");
1974         uiDefButS(block, ROW,B_REDR,"Ambient Occlusion",210,150,120,20,&G.scene->r.bake_mode, 1.0, RE_BAKE_AO, 0, 0, "");
1975         uiDefButS(block, ROW,B_REDR,"Normals",          210,130,120,20,&G.scene->r.bake_mode, 1.0, RE_BAKE_NORMALS, 0, 0, "");
1976         uiDefButS(block, ROW,B_REDR,"Textures",         210,110,120,20,&G.scene->r.bake_mode, 1.0, RE_BAKE_TEXTURE, 0, 0, "");
1977         uiDefButS(block, ROW,B_REDR,"Displacement",             210,90,120,20,&G.scene->r.bake_mode, 1.0, RE_BAKE_DISPLACEMENT, 0, 0, "");
1978         uiBlockEndAlign(block);
1979         
1980         uiDefButBitS(block, TOG, R_BAKE_CLEAR, B_DIFF, "Clear",         210,60,120,20,&G.scene->r.bake_flag, 0.0, 0, 0, 0, "Clear Images before baking");
1981         
1982         uiDefButS(block, NUM, B_DIFF,"Margin:",                         210,30,120,20,&G.scene->r.bake_filter, 0.0, 32.0, 0, 0, "Amount of pixels to extend the baked result with, as post process filter");
1983 }
1984
1985 static void render_panel_render(void)
1986 {
1987         uiBlock *block;
1988         char str[256];
1989
1990         block= uiNewBlock(&curarea->uiblocks, "render_panel_render", UI_EMBOSS, UI_HELV, curarea->win);
1991         if(uiNewPanel(curarea, block, "Render", "Render", 320, 0, 318, 204)==0) return;
1992
1993         uiBlockBeginAlign(block);
1994         uiDefBut(block, BUT,B_DORENDER,"RENDER",        369, 164, 191,37, 0, 0, 0, 0, 0, "Render the current frame (F12)");
1995 #ifndef DISABLE_YAFRAY
1996         /* yafray: on request, render engine menu is back again, and moved to Render panel */
1997         uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0|YafRay %x1", 
1998                                                                                                 369, 142, 191, 20, &G.scene->r.renderer, 0, 0, 0, 0, "Choose rendering engine");        
1999 #else
2000         uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0", 
2001                                                                                                 369, 142, 191, 20, &G.scene->r.renderer, 0, 0, 0, 0, "Choose rendering engine");        
2002 #endif /* disable yafray */
2003
2004         uiBlockBeginAlign(block);
2005         if((G.scene->r.scemode & R_FULL_SAMPLE) && (G.scene->r.scemode & R_EXR_TILE_FILE))
2006                 uiDefButBitI(block, TOG, R_OSA, B_DIFF, "FSA",  369,109,122,20,&G.scene->r.mode, 0, 0, 0, 0, "Saves all samples, then composites, and then merges (for best Anti-aliasing)");
2007         else
2008                 uiDefButBitI(block, TOG, R_OSA, B_DIFF, "OSA",  369,109,122,20,&G.scene->r.mode, 0, 0, 0, 0, "Enables Oversampling (Anti-aliasing)");
2009         uiDefButS(block, ROW,B_DIFF,"5",                        369,88,29,20,&G.scene->r.osa,2.0,5.0, 0, 0, "Render 5 samples per pixel for smooth edges (Fast)");
2010         uiDefButS(block, ROW,B_DIFF,"8",                        400,88,29,20,&G.scene->r.osa,2.0,8.0, 0, 0, "Render 8 samples per pixel for smooth edges (Recommended)");
2011         uiDefButS(block, ROW,B_DIFF,"11",                       431,88,29,20,&G.scene->r.osa,2.0,11.0, 0, 0, "Render 11 samples per pixel for smooth edges (High Quality)");
2012         uiDefButS(block, ROW,B_DIFF,"16",                       462,88,29,20,&G.scene->r.osa,2.0,16.0, 0, 0, "Render 16 samples per pixel for smooth edges (Highest Quality)");
2013         uiBlockEndAlign(block);
2014
2015         uiBlockBeginAlign(block);
2016         uiDefButBitI(block, TOG, R_MBLUR, B_REDR, "MBLUR",      496,109,64,20,&G.scene->r.mode, 0, 0, 0, 0, "Enables Motion Blur calculation");
2017         uiDefButF(block, NUM,B_DIFF,"Bf:",                      496,88,64,20,&G.scene->r.blurfac, 0.01, 5.0, 10, 2, "Sets motion blur factor");
2018         uiBlockEndAlign(block);
2019
2020         uiBlockBeginAlign(block);
2021         uiDefButS(block, NUM,B_DIFF,"Xparts:",          369,46,95,29,&G.scene->r.xparts,1.0, 512.0, 0, 0, "Sets the number of horizontal parts to render image in (For panorama sets number of camera slices)");
2022         uiDefButS(block, NUM,B_DIFF,"Yparts:",          465,46,95,29,&G.scene->r.yparts,1.0, 64.0, 0, 0, "Sets the number of vertical parts to render image in");
2023         uiBlockEndAlign(block);
2024
2025         uiBlockBeginAlign(block);
2026         uiDefButS(block, ROW,800,"Sky",         369,13,35,20,&G.scene->r.alphamode,3.0,0.0, 0, 0, "Fill background with sky");
2027         uiDefButS(block, ROW,800,"Premul",      405,13,50,20,&G.scene->r.alphamode,3.0,1.0, 0, 0, "Multiply alpha in advance");
2028         uiDefButS(block, ROW,800,"Key",         456,13,35,20,&G.scene->r.alphamode,3.0,2.0, 0, 0, "Alpha and color values remain unchanged");
2029         uiBlockEndAlign(block);
2030
2031         if(G.scene->r.mode & R_RAYTRACE)
2032                 uiDefButS(block, MENU, B_DIFF,"Octree resolution %t|64 %x64|128 %x128|256 %x256|512 %x512",     496,13,64,20,&G.scene->r.ocres,0.0,0.0, 0, 0, "Octree resolution for ray tracing");
2033
2034         uiBlockBeginAlign(block);
2035         uiDefButBitI(block, TOG, R_SHADOW, B_REDR,"Shadow",     565,172,60,29, &G.scene->r.mode, 0, 0, 0, 0, "Enable shadow calculation");
2036         uiDefButBitI(block, TOG, R_ENVMAP, B_REDR,"EnvMap",     627,172,60,29, &G.scene->r.mode, 0, 0, 0, 0, "Enable environment map rendering");
2037         uiDefButBitI(block, TOG, R_PANORAMA, B_REDR,"Pano",     565,142,40,29, &G.scene->r.mode, 0, 0, 0, 0, "Enable panorama rendering (output width is multiplied by Xparts)");
2038         uiDefButBitI(block, TOG, R_RAYTRACE, B_REDR,"Ray",606,142,40,29, &G.scene->r.mode, 0, 0, 0, 0, "Enable ray tracing");
2039         uiDefButBitI(block, TOG, R_RADIO, B_REDR,"Radio",       647,142,40,29, &G.scene->r.mode, 0, 0, 0, 0, "Enable radiosity rendering");
2040         uiBlockEndAlign(block);
2041         
2042         uiBlockBeginAlign(block);
2043         uiDefButS(block, ROW,B_DIFF,"100%",                     565,109,122,20,&G.scene->r.size,1.0,100.0, 0, 0, "Set render size to defined size");
2044         uiDefButS(block, ROW,B_DIFF,"75%",                      565,88,40,20,&G.scene->r.size,1.0,75.0, 0, 0, "Set render size to 3/4 of defined size");
2045         uiDefButS(block, ROW,B_DIFF,"50%",                      606,88,40,20,&G.scene->r.size,1.0,50.0, 0, 0, "Set render size to 1/2 of defined size");
2046         uiDefButS(block, ROW,B_DIFF,"25%",                      647,88,40,20,&G.scene->r.size,1.0,25.0, 0, 0, "Set render size to 1/4 of defined size");
2047         uiBlockEndAlign(block);
2048
2049         uiBlockBeginAlign(block);
2050         uiDefButBitI(block, TOG, R_FIELDS, B_REDR,"Fields",  565,55,60,20,&G.scene->r.mode, 0, 0, 0, 0, "Enables field rendering");
2051         uiDefButBitI(block, TOG, R_ODDFIELD, B_REDR,"Odd",      627,55,39,20,&G.scene->r.mode, 0, 0, 0, 0, "Enables Odd field first rendering (Default: Even field)");
2052         uiDefButBitI(block, TOG, R_FIELDSTILL, B_REDR,"X",              668,55,19,20,&G.scene->r.mode, 0, 0, 0, 0, "Disables time difference in field calculations");
2053         
2054         sprintf(str, "Filter%%t|Box %%x%d|Tent %%x%d|Quad %%x%d|Cubic %%x%d|Gauss %%x%d|CatRom %%x%d|Mitch %%x%d", R_FILTER_BOX, R_FILTER_TENT, R_FILTER_QUAD, R_FILTER_CUBIC, R_FILTER_GAUSS, R_FILTER_CATROM, R_FILTER_MITCH);
2055         uiDefButS(block, MENU, B_DIFF,str,              565,34,60,20, &G.scene->r.filtertype, 0, 0, 0, 0, "Set sampling filter for antialiasing");
2056         uiDefButF(block, NUM,B_DIFF,"",                 627,34,60,20,&G.scene->r.gauss,0.5, 1.5, 10, 2, "Sets the filter size");
2057         
2058         uiDefButBitI(block, TOG, R_BORDER, REDRAWVIEWCAM, "Border",     565,13,122,20, &G.scene->r.mode, 0, 0, 0, 0, "Render a small cut-out of the image (Shift+B to set in the camera view)");
2059         uiBlockEndAlign(block);
2060
2061 }
2062
2063 static void render_panel_anim(void)
2064 {
2065         uiBlock *block;
2066
2067
2068         block= uiNewBlock(&curarea->uiblocks, "render_panel_anim", UI_EMBOSS, UI_HELV, curarea->win);
2069         if(uiNewPanel(curarea, block, "Anim", "Render", 640, 0, 318, 204)==0) return;
2070
2071
2072         uiDefBut(block, BUT,B_DOANIM,"ANIM",            692,142,192,47, 0, 0, 0, 0, 0, "Render the animation to disk (start to end frame)");
2073
2074         uiBlockSetCol(block, TH_BUT_SETTING1);
2075         uiBlockBeginAlign(block);
2076         uiDefButBitS(block, TOG, R_DOSEQ, B_NOP, "Do Sequence",692,114,192,20, &G.scene->r.scemode, 0, 0, 0, 0, "Enables sequence output rendering (Default: 3D rendering)");
2077         uiDefButBitS(block, TOG, R_DOCOMP, B_NOP, "Do Composite",692,90,192,20, &G.scene->r.scemode, 0, 0, 0, 0, "Uses compositing nodes for output rendering");
2078         uiBlockEndAlign(block);
2079
2080         uiBlockSetCol(block, TH_AUTO);
2081         uiDefBut(block, BUT,B_PLAYANIM, "PLAY",692,40,94,33, 0, 0, 0, 0, 0, "Play rendered images/avi animation (Ctrl+F11), (Play Hotkeys: A-Noskip, P-PingPong)");
2082         uiDefButS(block, NUM, B_RTCHANGED, "rt:",789,40,95,33, &G.rt, -1000.0, 1000.0, 0, 0, "General testing/debug button");
2083
2084         uiBlockBeginAlign(block);
2085         uiDefButI(block, NUM,REDRAWSEQ,"Sta:",692,10,94,24, &G.scene->r.sfra,1.0,MAXFRAMEF, 0, 0, "The start frame of the animation (inclusive)");
2086         uiDefButI(block, NUM,REDRAWSEQ,"End:",789,10,95,24, &G.scene->r.efra,SFRA,MAXFRAMEF, 0, 0, "The end  frame of the animation  (inclusive)");
2087         uiBlockEndAlign(block);
2088 }
2089
2090 #ifdef WITH_FFMPEG
2091 static void set_ffmpeg_preset(int preset)
2092 {
2093         int isntsc = (G.scene->r.frs_sec != 25);
2094         switch (preset) {
2095         case FFMPEG_PRESET_VCD:
2096                 G.scene->r.ffcodecdata.type = FFMPEG_MPEG1;
2097                 G.scene->r.ffcodecdata.video_bitrate = 1150;
2098                 G.scene->r.xsch = 352;
2099                 G.scene->r.ysch = isntsc ? 240 : 288;
2100                 G.scene->r.ffcodecdata.gop_size = isntsc ? 18 : 15;
2101                 G.scene->r.ffcodecdata.rc_max_rate = 1150;
2102                 G.scene->r.ffcodecdata.rc_min_rate = 1150;
2103                 G.scene->r.ffcodecdata.rc_buffer_size = 40*8;
2104                 G.scene->r.ffcodecdata.mux_packet_size = 2324;
2105                 G.scene->r.ffcodecdata.mux_rate = 2352 * 75 * 8;
2106                 break;
2107         case FFMPEG_PRESET_SVCD:
2108                 G.scene->r.ffcodecdata.type = FFMPEG_MPEG2;
2109                 G.scene->r.ffcodecdata.video_bitrate = 2040;
2110                 G.scene->r.xsch = 480;
2111                 G.scene->r.ysch = isntsc ? 480 : 576;
2112                 G.scene->r.ffcodecdata.gop_size = isntsc ? 18 : 15;
2113                 G.scene->r.ffcodecdata.rc_max_rate = 2516;
2114                 G.scene->r.ffcodecdata.rc_min_rate = 0;
2115                 G.scene->r.ffcodecdata.rc_buffer_size = 224*8;
2116                 G.scene->r.ffcodecdata.mux_packet_size = 2324;
2117                 G.scene->r.ffcodecdata.mux_rate = 0;
2118                 
2119                 break;
2120         case FFMPEG_PRESET_DVD:
2121                 G.scene->r.ffcodecdata.type = FFMPEG_MPEG2;
2122                 G.scene->r.ffcodecdata.video_bitrate = 6000;
2123                 G.scene->r.xsch = 720;
2124                 G.scene->r.ysch = isntsc ? 480 : 576;
2125                 G.scene->r.ffcodecdata.gop_size = isntsc ? 18 : 15;
2126                 G.scene->r.ffcodecdata.rc_max_rate = 9000;
2127                 G.scene->r.ffcodecdata.rc_min_rate = 0;
2128                 G.scene->r.ffcodecdata.rc_buffer_size = 224*8;
2129                 G.scene->r.ffcodecdata.mux_packet_size = 2048;
2130                 G.scene->r.ffcodecdata.mux_rate = 10080000;
2131                 
2132                 break;
2133         case FFMPEG_PRESET_DV:
2134                 G.scene->r.ffcodecdata.type = FFMPEG_DV;
2135                 G.scene->r.xsch = 720;
2136                 G.scene->r.ysch = isntsc ? 480 : 576;
2137                 break;
2138         }
2139 }
2140
2141 static void render_panel_ffmpeg_video(void)
2142 {
2143         uiBlock *block;
2144         int yofs;
2145         int xcol1;
2146         int xcol2;
2147         
2148         block = uiNewBlock(&curarea->uiblocks, "render_panel_ffmpeg_video", 
2149                                            UI_EMBOSS, UI_HELV, curarea->win);
2150         
2151         uiNewPanelTabbed("Format", "Render");
2152         if (uiNewPanel(curarea, block, "Video", "Render", 960, 0, 318, 204)== 0) 
2153                 return;
2154         
2155         if (ffmpeg_preset_sel != 0) {
2156                 set_ffmpeg_preset(ffmpeg_preset_sel);
2157                 ffmpeg_preset_sel = 0;
2158                 allqueue(REDRAWBUTSSCENE, 0);
2159         }
2160         
2161         xcol1 = 872;
2162         xcol2 = 1002;
2163         
2164         yofs = 54;
2165         uiDefBut(block, LABEL, B_DIFF, "Format", xcol1, yofs+88, 
2166                          110, 20, 0, 0, 0, 0, 0, "");
2167         uiDefBut(block, LABEL, B_DIFF, "Preset", xcol2, yofs+88, 
2168                          110, 20, 0, 0, 0, 0, 0, "");
2169         uiDefButI(block, MENU, B_DIFF, ffmpeg_format_pup(), 
2170                           xcol1, yofs+66, 110, 20, &G.scene->r.ffcodecdata.type, 
2171                           0,0,0,0, "output file format");
2172         uiDefButI(block, NUM, B_DIFF, "Bitrate", 
2173                           xcol1, yofs+44, 110, 20, 
2174                           &G.scene->r.ffcodecdata.video_bitrate, 
2175                           1, 14000, 0, 0, "Video bitrate(kb/s)");
2176         uiDefButI(block, NUM, B_DIFF, "Min Rate", 
2177                           xcol1, yofs+22, 110, 20, &G.scene->r.ffcodecdata.rc_min_rate, 
2178                           0, 14000, 0, 0, "Rate control: min rate(kb/s)");
2179         uiDefButI(block, NUM, B_DIFF, "Max Rate", 
2180                           xcol1, yofs, 110, 20, &G.scene->r.ffcodecdata.rc_max_rate, 
2181                           1, 14000, 0, 0, "Rate control: max rate(kb/s)");
2182         
2183         uiDefButI(block, NUM, B_DIFF, "Mux Rate", 
2184                           xcol1, yofs-22, 110, 20, 
2185                           &G.scene->r.ffcodecdata.mux_rate, 
2186                           0, 100000000, 0, 0, "Mux rate (bits/s(!))");
2187         
2188         
2189         uiDefButI(block, MENU, B_REDR, ffmpeg_preset_pup(), 
2190                           xcol2, yofs+66, 110, 20, &ffmpeg_preset_sel, 
2191                           0,0,0,0, "Output file format preset selection");
2192         uiDefButI(block, NUM, B_DIFF, "GOP Size", 
2193                           xcol2, yofs+44, 110, 20, &G.scene->r.ffcodecdata.gop_size, 
2194                           0, 100, 0, 0, "Distance between key frames");
2195         uiDefButI(block, NUM, B_DIFF, "Buffersize", 
2196                           xcol2, yofs+22, 110, 20,
2197                           &G.scene->r.ffcodecdata.rc_buffer_size, 
2198                           0, 2000, 0, 0, "Rate control: buffer size (kb)");
2199         uiDefButI(block, NUM, B_DIFF, "Mux PSize", 
2200                           xcol2, yofs, 110, 20, 
2201                           &G.scene->r.ffcodecdata.mux_packet_size, 
2202                           0, 16384, 0, 0, "Mux packet size (byte)");
2203         
2204         uiDefButBitI(block, TOG, FFMPEG_AUTOSPLIT_OUTPUT, B_NOP,
2205                                  "Autosplit Output", 
2206                                  xcol2, yofs-22, 110, 20, 
2207                                  &G.scene->r.ffcodecdata.flags, 
2208                                  0, 1, 0,0, "Autosplit output at 2GB boundary.");
2209         
2210         
2211         if (ELEM(G.scene->r.ffcodecdata.type, FFMPEG_AVI, FFMPEG_MOV)) {
2212                 uiDefBut(block, LABEL, 0, "Codec", 
2213                                 xcol1, yofs-44, 110, 20, 0, 0, 0, 0, 0, "");
2214                 uiDefButI(block, MENU,B_REDR, ffmpeg_codec_pup(), 
2215                                   xcol1, yofs-66, 110, 20, 
2216                                   &G.scene->r.ffcodecdata.codec, 
2217                                   0,0,0,0, "FFMpeg codec to use");
2218         }
2219 }
2220
2221 static void render_panel_ffmpeg_audio(void)
2222 {
2223         uiBlock *block;
2224         int yofs;
2225         int xcol;
2226         
2227         block = uiNewBlock(&curarea->uiblocks, "render_panel_ffmpeg_audio", UI_EMBOSS, UI_HELV, curarea->win);
2228         uiNewPanelTabbed("Format", "Render");
2229         if (uiNewPanel(curarea, block, "Audio", "Render", 960, 0, 318, 204) == 0) return;
2230         
2231         yofs = 54;
2232         xcol = 892;
2233         
2234         uiDefButBitI(block, TOG, FFMPEG_MULTIPLEX_AUDIO, B_NOP,
2235                                  "Multiplex audio", xcol, yofs, 225, 20, 
2236                                  &G.scene->r.ffcodecdata.flags, 
2237                                  0, 1, 0,0, "Interleave audio with the output video");
2238         uiDefBut(block, LABEL, 0, "Codec", 
2239                          xcol, yofs-22, 225, 20, 0, 0, 0, 0, 0, "");
2240         uiDefButI(block, MENU,B_NOP, ffmpeg_audio_codec_pup(), 
2241                           xcol, yofs-44, 225, 20, 
2242                           &G.scene->r.ffcodecdata.audio_codec, 
2243                           0,0,0,0, "FFMpeg codec to use");
2244         uiDefButI(block, NUM, B_DIFF, "Bitrate", 
2245                           xcol, yofs-66, 110, 20, 
2246                           &G.scene->r.ffcodecdata.audio_bitrate, 
2247                           32, 384, 0, 0, "Audio bitrate(kb/s)");
2248 }
2249 #endif
2250
2251 static void render_panel_stamp(void)
2252 {
2253         uiBlock *block;
2254         int yofs=0, xofs=550;
2255
2256         block= uiNewBlock (&curarea->uiblocks, "render_panel_stamp", UI_EMBOSS, UI_HELV, curarea->win);
2257         uiNewPanelTabbed ("Format", "Render");
2258         if(uiNewPanel (curarea, block, "Stamp", "Render", 960, 0, 318, 204)==0) return;
2259
2260         if (G.scene->r.scemode & R_STAMP_INFO) {
2261                 uiBlockBeginAlign(block);
2262                 uiDefButBitI(block, TOG, R_STAMP_NOTE, B_REDR, "Note", xofs, yofs, 120, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp user data");
2263                 uiDefBut(block, TEX, B_NOP, "", xofs+120, yofs, 180, 19, &G.scene->r.stamp_udata, 0.0, 128.0, 100, 0, "User Note");
2264                 uiBlockEndAlign(block);
2265                 yofs += 30; /* gap */
2266                 
2267                 
2268                 yofs += 80;
2269                 /* Order is important for alligning ... grr */
2270                 uiBlockBeginAlign(block);
2271                 uiDefButBitI(block, TOG, R_STAMP_FILENAME, B_REDR, "Filename", xofs, yofs, 120, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp blend filename");
2272                 yofs -= 20;
2273                 uiDefButBitI(block, TOG, R_STAMP_SCENE, B_REDR, "Scene", xofs, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp scene name");
2274                 uiDefButBitI(block, TOG, R_STAMP_CAMERA, B_REDR, "Camera", xofs+60, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp camera name");
2275                 yofs -= 20;
2276                 uiDefButBitI(block, TOG, R_STAMP_TIME, B_REDR, "Time", xofs, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp time (HH:MM:SS)");
2277                 uiDefButBitI(block, TOG, R_STAMP_DATE, B_REDR, "Date", xofs+60, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp date");
2278                 yofs -= 20;
2279                 uiDefButBitI(block, TOG, R_STAMP_FRAME, B_REDR, "Frame", xofs, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp frame number");
2280                 uiDefButBitI(block, TOG, R_STAMP_MARKER, B_REDR, "Marker", xofs+60, yofs, 60, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp the last marker");
2281                 yofs -= 20;
2282                 uiDefButBitI(block, TOG, R_STAMP_SEQSTRIP, B_REDR, "Sequence Strip", xofs, yofs, 120, 19, &G.scene->r.stamp, 0, 0, 0, 0, "Stamp the forground sequence strip name");
2283                 uiBlockEndAlign(block);
2284                 yofs += 80;
2285                 
2286                 /* draw font selector */
2287                 if (G.scene->r.stamp & R_STAMP_DRAW) {
2288                         uiDefButS(block, MENU, B_REDR, "Stamp Font Size%t|Tiny Text%x1|Small Text%x2|Medium Text%x3|Large Text%x0|Extra Large Text%x4|",
2289                                         xofs+130, yofs, 170, 19, &G.scene->r.stamp_font_id, 0, 0, 0, 0, "Choose stamp text size");
2290                         
2291                         /* draw fg/bg next to the scene */
2292                         yofs -= 25;
2293                         uiDefBut(block, LABEL, B_NOP, "Text Color", xofs+130, yofs, 70, 19, 0, 0, 0, 0, 0, "");
2294                         uiDefBut(block, LABEL, B_NOP, "Background", xofs+215, yofs, 70, 19, 0, 0, 0, 0, 0, "");
2295                         yofs -= 20;
2296                         uiDefButF(block, COL, B_NOP, "", xofs+130, yofs, 80, 19, G.scene->r.fg_stamp, 0, 0, 0, 0, "Foreground text color");
2297                         uiDefButF(block, COL, B_NOP, "", xofs+220, yofs, 80, 19, G.scene->r.bg_stamp, 0, 0, 0, 0, "Background color");
2298                         yofs -= 30;
2299                         uiDefButF(block, NUMSLI, B_NOP, "A ", xofs+130, yofs, 170, 19, &G.scene->r.bg_stamp[3], 0, 1.0, 0, 0, "Alpha for text background");
2300                         yofs += 105;
2301                 } else {
2302                         yofs += 30;
2303                 }
2304                 
2305                 uiDefButBitS(block, TOG, R_STAMP_INFO, B_REDR, "Enable Stamp", xofs, yofs, 120, 20, &G.scene->r.scemode, 0, 0, 0, 0, "Disable stamp info in images metadata");
2306                 uiDefButBitI(block, TOG, R_STAMP_DRAW, B_REDR, "Draw Stamp", xofs+130, yofs, 170, 20, &G.scene->r.stamp, 0, 0, 0, 0, "Draw the stamp info into each frame");
2307                 yofs += 20;
2308         }
2309         else {
2310                 uiDefButBitS(block, TOG, R_STAMP_INFO, B_REDR, "Enable Stamp", xofs, 142, 120, 20, &G.scene->r.scemode, 0, 0, 0, 0, "Enable stamp info to image metadata");
2311                 yofs += 20;
2312                 uiDefBut(block, LABEL, 0, "", xofs, yofs, 300, 19, 0, 0, 0, 0, 0, "");
2313         }
2314 }
2315
2316 static void render_panel_format(void)
2317 {
2318         uiBlock *block;
2319         int yofs;
2320
2321
2322         block= uiNewBlock(&curarea->uiblocks, "render_panel_format", UI_EMBOSS, UI_HELV, curarea->win);
2323         if(uiNewPanel(curarea, block, "Format", "Render", 960, 0, 318, 204)==0) return;
2324         uiDefBlockBut(block, framing_render_menu, NULL, 
2325                                   "Game framing settings", 
2326                                   892, 169, 227, 20, "Display game framing settings");
2327         /* uiDefIconTextBlockBut(block, framing_render_menu, NULL, 
2328                                                    ICON_BLOCKBUT_CORNER, 
2329                                                    "Game framing settings", 
2330                                                    892, 169, 227, 20, 
2331                                                    "Display game framing settings"); */
2332
2333         uiBlockBeginAlign(block);
2334         uiDefButS(block, NUM,REDRAWVIEWCAM,"SizeX:",    892 ,136,112,27, &G.scene->r.xsch, 4.0, 10000.0, 0, 0, "The image width in pixels");
2335         uiDefButS(block, NUM,REDRAWVIEWCAM,"SizeY:",    1007,136,112,27, &G.scene->r.ysch, 4.0,10000.0, 0, 0, "The image height in scanlines");
2336         uiDefButS(block, NUM,REDRAWVIEWCAM,"AspX:",     892 ,114,112,20, &G.scene->r.xasp, 1.0,200.0, 0, 0, "The horizontal aspect ratio");
2337         uiDefButS(block, NUM,REDRAWVIEWCAM,"AspY:",     1007,114,112,20, &G.scene->r.yasp, 1.0,200.0, 0, 0, "The vertical aspect ratio");
2338         uiBlockEndAlign(block);
2339
2340         yofs = 54;
2341
2342 #ifdef __sgi
2343         yofs = 76;
2344         uiDefButS(block, NUM,B_DIFF,"MaxSize:",                 892,32,165,20, &G.scene->r.maximsize, 0.0, 500.0, 0, 0, "Maximum size per frame to save in an SGI movie");
2345         uiDefButBitI(block, TOG, R_COSMO, 0,"Cosmo",    1059,32,60,20, &G.scene->r.mode, 0, 0, 0, 0, "Attempt to save SGI movies using Cosmo hardware");
2346 #endif
2347
2348         uiDefButS(block, MENU,B_FILETYPEMENU,imagetype_pup(),   892,yofs,174,20, &G.scene->r.imtype, 0, 0, 0, 0, "Images are saved in this file format");
2349         uiDefButBitI(block, TOG, R_CROP, B_DIFF, "Crop",        1068,yofs,51,20, &G.scene->r.mode, 0, 0, 0, 0, "When Border render, the resulting image gets cropped");
2350
2351         yofs -= 22;
2352
2353         if(G.scene->r.quality==0) G.scene->r.quality= 90;
2354
2355         if (G.scene->r.imtype == R_AVICODEC || G.scene->r.imtype == R_QUICKTIME) {
2356                 if(G.scene->r.imtype == R_QUICKTIME) {
2357 #ifdef WITH_QUICKTIME
2358 #if defined (_WIN32) || defined (__APPLE__)
2359                         //glColor3f(0.65, 0.65, 0.7);
2360                         //glRecti(892,yofs+46,892+225,yofs+45+20);
2361                         if(G.scene->r.qtcodecdata == NULL)
2362                                 uiDefBut(block, LABEL, 0, "Codec: not set",  892,yofs+44,225,20, 0, 0, 0, 0, 0, "");
2363                         else
2364                                 uiDefBut(block, LABEL, 0, G.scene->r.qtcodecdata->qtcodecname,  892,yofs+44,225,20, 0, 0, 0, 0, 0, "");
2365                         uiDefBut(block, BUT,B_SELECTCODEC, "Set codec",  892,yofs,74,20, 0, 0, 0, 0, 0, "Set codec settings for Quicktime");
2366 #endif
2367 #endif /* WITH_QUICKTIME */
2368                 } else {
2369 #ifdef _WIN32
2370                         //glColor3f(0.65, 0.65, 0.7);
2371                         //glRecti(892,yofs+46,892+225,yofs+45+20);
2372                         if(G.scene->r.avicodecdata == NULL)
2373                                 uiDefBut(block, LABEL, 0, "Codec: not set.",  892,yofs+43,225,20, 0, 0, 0, 0, 0, "");
2374                         else
2375                                 uiDefBut(block, LABEL, 0, avicodec_str(),  892,yofs+43,225,20, 0, 0, 0, 0, 0, "");
2376 #endif
2377                         uiDefBut(block, BUT,B_SELECTCODEC, "Set codec",  892,yofs,74,20, 0, 0, 0, 0, 0, "Set codec settings for AVI");
2378                 }
2379 #ifdef WITH_OPENEXR
2380         } 
2381         else if (ELEM(G.scene->r.imtype, R_OPENEXR, R_MULTILAYER)) {
2382                 if (G.scene->r.quality > 5) G.scene->r.quality = 2;
2383                 
2384                 if(G.scene->r.imtype==R_OPENEXR) {
2385                         uiBlockBeginAlign(block);
2386                         uiDefButBitS(block, TOG, R_OPENEXR_HALF, B_NOP,"Half",  892,yofs+44,60,20, &G.scene->r.subimtype, 0, 0, 0, 0, "Use 16 bit floats instead of 32 bit floats per channel");
2387                         uiDefButBitS(block, TOG, R_OPENEXR_ZBUF, B_NOP,"Zbuf",  952,yofs+44,60,20, &G.scene->r.subimtype, 0, 0, 0, 0, "Save the z-depth per pixel (32 bit unsigned int zbuffer)");
2388                         uiBlockEndAlign(block);
2389                         uiDefButBitS(block, TOG, R_PREVIEW_JPG, B_NOP,"Preview",1027,yofs+44,90,20, &G.scene->r.subimtype, 0, 0, 0, 0, "When animation render, save JPG preview images in same directory");
2390                 }               
2391                 uiDefButS(block, MENU,B_NOP, "Codec %t|None %x0|Pxr24 (lossy) %x1|ZIP (lossless) %x2|PIZ (lossless) %x3|RLE (lossless) %x4",  
2392                                                                                                                         892,yofs,74,20, &G.scene->r.quality, 0, 0, 0, 0, "Set codec settings for OpenEXR");
2393                 
2394 #endif
2395         } else {
2396                 if(G.scene->r.quality < 5) G.scene->r.quality = 90;     /* restore from openexr */
2397                 
2398                 uiDefButS(block, NUM,B_DIFF, "Q:",           892,yofs,74,20, &G.scene->r.quality, 10.0, 100.0, 0, 0, "Quality setting for JPEG images, AVI Jpeg and SGI movies");
2399         }
2400         uiDefButS(block, NUM,B_FRAMEMAP,"FPS:",   968,yofs,75,20, &G.scene->r.frs_sec, 1.0, 120.0, 100.0, 0, "Frames per second");
2401         uiDefButF(block, NUM,B_FRAMEMAP,"/",  1043,yofs,75,20, &G.scene->r.frs_sec_base, 1.0, 120.0, 0.1, 3, "Frames per second base");
2402
2403
2404         uiBlockBeginAlign(block);
2405         uiDefButS(block, ROW,B_DIFF,"BW",                       892, 10,74,19, &G.scene->r.planes, 5.0,(float)R_PLANESBW, 0, 0, "Images are saved with BW (grayscale) data");
2406         uiDefButS(block, ROW,B_DIFF,"RGB",                  968, 10,74,19, &G.scene->r.planes, 5.0,(float)R_PLANES24, 0, 0, "Images are saved with RGB (color) data");
2407         uiDefButS(block, ROW,B_DIFF,"RGBA",                1044, 10,75,19, &G.scene->r.planes, 5.0,(float)R_PLANES32, 0, 0, "Images are saved with RGB and Alpha data (if supported)");
2408
2409         uiBlockBeginAlign(block);
2410         uiDefBut(block, BUT,B_PR_PAL, "PAL",            1146,170,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 720x576, Aspect ratio - 54x51, 25 fps");
2411         uiDefBut(block, BUT,B_PR_NTSC, "NTSC",          1146,150,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 720x480, Aspect ratio - 10x11, 30 fps");
2412         uiDefBut(block, BUT,B_PR_PRESET, "Default",     1146,130,100,18, 0, 0, 0, 0, 0, "Same as PAL, with render settings (OSA, Shadows, Fields)");
2413         uiDefBut(block, BUT,B_PR_PRV, "Preview",        1146,110,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 640x512, Render size 50%");
2414         uiDefBut(block, BUT,B_PR_PC, "PC",                      1146,90,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 640x480, Aspect ratio - 100x100");
2415         uiDefBut(block, BUT,B_PR_PAL169, "PAL 16:9",1146,70,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 720x576, Aspect ratio - 64x45");
2416         uiDefBut(block, BUT,B_PR_PANO, "PANO",          1146,50,100,18, 0, 0, 0, 0, 0, "Standard panorama settings");
2417         uiDefBut(block, BUT,B_PR_FULL, "FULL",          1146,30,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 1280x1024, Aspect ratio - 1x1");
2418         uiDefBut(block, BUT,B_PR_HD, "HD",              1146,10,100,18, 0, 0, 0, 0, 0, "Size preset: Image size - 1920x1080, Aspect ratio - 1x1");
2419         uiBlockEndAlign(block);
2420 }
2421
2422 #ifndef DISABLE_YAFRAY /* disable yafray stuff */
2423 /* yafray: global illumination options panel */
2424 static void render_panel_yafrayGI()
2425 {
2426         uiBlock *block;
2427
2428         block= uiNewBlock(&curarea->uiblocks, "render_panel_yafrayGI", UI_EMBOSS, UI_HELV, curarea->win);
2429         uiNewPanelTabbed("Render", "Render");
2430         if(uiNewPanel(curarea, block, "YafRay GI", "Render", 320, 0, 318, 204)==0) return;
2431
2432         // label to force a boundbox for buttons not to be centered
2433         uiDefBut(block, LABEL, 0, " ", 305,180,10,10, 0, 0, 0, 0, 0, "");
2434
2435         uiDefBut(block, LABEL, 0, "Method", 5,175,70,20, 0, 1.0, 0, 0, 0, "");
2436         uiDefButS(block, MENU, B_REDR, "GiMethod %t|None %x0|SkyDome %x1|Full %x2", 70,175,89,20, &G.scene->r.GImethod, 0, 0, 0, 0, "Global Illumination Method");
2437
2438         uiDefBut(block, LABEL, 0, "Quality", 5,150,70,20, 0, 1.0, 0, 0, 0, "");
2439         uiDefButS(block, MENU, B_REDR, "GiQuality %t|None %x0|Low %x1|Medium %x2 |High %x3|Higher %x4|Best %x5|Use Blender AO settings %x6", 70,150,89,20, &G.scene->r.GIquality, 0, 0, 0, 0, "Global Illumination Quality");
2440
2441         if (G.scene->r.GImethod>0) {
2442                 uiDefButF(block, NUM, B_DIFF, "EmitPwr:", 5,35,154,20, &G.scene->r.GIpower, 0.01, 100.0, 10, 0, "arealight, material emit and background intensity scaling, 1 is normal");
2443                 if (G.scene->r.GImethod==2) uiDefButF(block, NUM, B_DIFF, "GI Pwr:", 5,10,154,20, &G.scene->r.GIindirpower, 0.01, 100.0, 10, 0, "GI indirect lighting intensity scaling, 1 is normal");
2444         }
2445
2446         if (G.scene->r.GImethod>0)
2447         {
2448                 if (G.scene->r.GIdepth==0) G.scene->r.GIdepth=2;
2449
2450                 if (G.scene->r.GImethod==2) {
2451                         uiDefButI(block, NUM, B_DIFF, "Depth:", 180,175,110,20, &G.scene->r.GIdepth, 1.0, 100.0, 10, 10, "Number of bounces of the indirect light");
2452                         uiDefButI(block, NUM, B_DIFF, "CDepth:", 180,150,110,20, &G.scene->r.GIcausdepth, 1.0, 100.0, 10, 10, "Number of bounces inside objects (for caustics)");
2453                         uiDefButBitS(block, TOG, 1,  B_REDR, "Photons",210,125,100,20, &G.scene->r.GIphotons, 0, 0, 0, 0, "Use global photons to help in GI");
2454                 }
2455
2456                 uiDefButBitS(block, TOG, 1, B_REDR, "Cache",6,125,95,20, &G.scene->r.GIcache, 0, 0, 0, 0, "Cache occlusion/irradiance samples (faster)");
2457                 if (G.scene->r.GIcache) 
2458                 {
2459                         uiDefButBitS(block,TOG, 1, B_REDR, "NoBump",108,125,95,20, &G.scene->r.YF_nobump, 0, 0, 0, 0, "Don't use bumpnormals for cache (faster, but no bumpmapping in total indirectly lit areas)");
2460                         uiDefBut(block, LABEL, 0, "Cache parameters:", 5,105,130,20, 0, 1.0, 0, 0, 0, "");
2461                         if (G.scene->r.GIshadowquality==0.0) G.scene->r.GIshadowquality=0.9;
2462                         uiDefButF(block, NUM, B_DIFF,"ShadQu:", 5,85,154,20,    &(G.scene->r.GIshadowquality), 0.01, 1.0 ,1,0, "Sets the shadow quality, keep it under 0.95 :-) ");
2463                         if (G.scene->r.GIpixelspersample==0) G.scene->r.GIpixelspersample=10;
2464                         uiDefButI(block, NUM, B_DIFF, "Prec:",  5,60,75,20, &G.scene->r.GIpixelspersample, 1, 50, 10, 10, "Maximum number of pixels without samples, the lower the better and slower");
2465                         if (G.scene->r.GIrefinement==0) G.scene->r.GIrefinement=1.0;
2466                         uiDefButF(block, NUM, B_DIFF, "Ref:", 84,60,75,20, &G.scene->r.GIrefinement, 0.001, 1.0, 1, 0, "Threshold to refine shadows EXPERIMENTAL. 1 = no refinement");
2467                 }
2468
2469                 if (G.scene->r.GImethod==2) {
2470                         if (G.scene->r.GIphotons)
2471                         {
2472                                 uiDefBut(block, LABEL, 0, "Photon parameters:", 170,105,130,20, 0, 1.0, 0, 0, 0, "");
2473                                 if(G.scene->r.GIphotoncount==0) G.scene->r.GIphotoncount=100000;
2474                                 uiDefButI(block, NUM, B_DIFF, "Count:", 170,85,140,20, &G.scene->r.GIphotoncount, 
2475                                                 0, 10000000, 10, 10, "Number of photons to shoot");
2476                                 if(G.scene->r.GIphotonradius==0.0) G.scene->r.GIphotonradius=1.0;
2477                                 uiDefButF(block, NUMSLI, B_DIFF,"Radius:", 170,60,140,20,       &(G.scene->r.GIphotonradius), 
2478                                                 0.00001, 100.0 ,0,0, "Radius to search for photons to mix (blur)");
2479                                 if(G.scene->r.GImixphotons==0) G.scene->r.GImixphotons=100;
2480                                 uiDefButI(block, NUM, B_DIFF, "MixCount:", 170,35,140,20, &G.scene->r.GImixphotons, 
2481                                                 0, 1000, 10, 10, "Number of photons to mix");
2482                                 uiDefButBitS(block, TOG, 1, B_REDR, "Tune Photons",170,10,140,20, &G.scene->r.GIdirect, 
2483                                                 0, 0, 0, 0, "Show the photonmap directly in the render for tuning");
2484                         }
2485                 }
2486
2487         }
2488 }
2489
2490 /* yafray: global  options panel */
2491 static void render_panel_yafrayGlobal()
2492 {
2493         uiBlock *block;
2494
2495         block= uiNewBlock(&curarea->uiblocks, "render_panel_yafrayGlobal", UI_EMBOSS, UI_HELV, curarea->win);
2496         uiNewPanelTabbed("Render", "Render");
2497         if(uiNewPanel(curarea, block, "YafRay", "Render", 320, 0, 318, 204)==0) return;
2498
2499         // label to force a boundbox for buttons not to be centered
2500         uiDefBut(block, LABEL, 0, " ", 305,180,10,10, 0, 0, 0, 0, 0, "");
2501
2502         uiDefButBitS(block, TOGN, 1, B_REDR, "xml", 5,180,75,20, &G.scene->r.YFexportxml,
2503                                         0, 0, 0, 0, "Export to an xml file and call yafray instead of plugin");
2504
2505         uiDefButF(block, NUMSLI, B_DIFF,"Bi ", 5,35,150,20,     &(G.scene->r.YF_raybias), 
2506                                 0.0, 10.0 ,0,0, "Shadow ray bias to avoid self shadowing");
2507         uiDefButI(block, NUM, B_DIFF, "Raydepth ", 5,60,150,20,
2508                                 &G.scene->r.YF_raydepth, 1.0, 80.0, 10, 10, "Maximum render ray depth from the camera");
2509         uiDefButF(block, NUMSLI, B_DIFF, "Gam ", 5,10,150,20, &G.scene->r.YF_gamma, 0.001, 5.0, 0, 0, "Gamma correction, 1 is off");
2510         uiDefButF(block, NUMSLI, B_DIFF, "Exp ", 160,10,150,20,&G.scene->r.YF_exposure, 0.0, 10.0, 0, 0, "Exposure adjustment, 0 is off");
2511         
2512         uiDefButI(block, NUM, B_DIFF, "Processors:", 160,60,150,20, &G.scene->r.YF_numprocs, 1.0, 8.0, 10, 10, "Number of processors to use");
2513
2514         /*AA Settings*/
2515         uiDefButBitS(block, TOGN, 1, B_REDR, "Auto AA", 5,140,150,20, &G.scene->r.YF_AA, 
2516                                         0, 0, 0, 0, "Set AA using OSA and GI quality, disable for manual control");
2517         uiDefButBitS(block, TOGN, 1, B_DIFF, "Clamp RGB", 160,140,150,20, &G.scene->r.YF_clamprgb, 1.0, 8.0, 10, 10, "For AA on fast high contrast changes. Not advisable for Bokeh! Dulls lens shape detail.");
2518         if(G.scene->r.YF_AA){
2519                 uiDefButI(block, NUM, B_DIFF, "AA Passes ", 5,115,150,20, &G.scene->r.YF_AApasses, 0, 64, 10, 10, "Number of AA passes (0 is no AA)");
2520                 uiDefButI(block, NUM, B_DIFF, "AA Samples ", 160,115,150,20, &G.scene->r.YF_AAsamples, 0, 2048, 10, 10, "Number of samples per pass");
2521                 uiDefButF(block, NUMSLI, B_DIFF, "Psz ", 5,90,150,20, &G.scene->r.YF_AApixelsize, 1.0, 2.0, 0, 0, "AA pixel filter size");
2522                 uiDefButF(block, NUMSLI, B_DIFF, "Thr ", 160,90,150,20, &G.scene->r.YF_AAthreshold, 0.000001, 1.0, 0, 0, "AA threshold");
2523         }
2524 }
2525 #endif /* disable yafray stuff */
2526
2527 static void layer_copy_func(void *lay_v, void *lay_p)
2528 {
2529         unsigned int *lay= lay_p;
2530         int laybit= (int)lay_v;
2531
2532         if(G.qual & (LR_SHIFTKEY|LR_CTRLKEY)) {
2533                 if(*lay==0) *lay= 1<<laybit;
2534         }
2535         else
2536                 *lay= 1<<laybit;
2537         
2538         copy_view3d_lock(REDRAW);
2539         allqueue(REDRAWBUTSSCENE, 0);
2540 }
2541
2542 static void delete_scene_layer_func(void *srl_v, void *act_i)
2543 {
2544         if(BLI_countlist(&G.scene->r.layers)>1) {
2545                 long act= (long)act_i;
2546                 
2547                 BLI_remlink(&G.scene->r.layers, srl_v);
2548                 MEM_freeN(srl_v);
2549                 G.scene->r.actlay= 0;
2550                 
2551                 if(G.scene->nodetree) {
2552                         bNode *node;
2553                         for(node= G.scene->nodetree->nodes.first; node; node= node->next) {
2554                                 if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
2555                                         if(node->custom1==act)
2556                                                 node->custom1= 0;
2557                                         else if(node->custom1>act)
2558                                                 node->custom1--;
2559                                 }
2560                         }
2561                 }
2562                 allqueue(REDRAWBUTSSCENE, 0);
2563                 allqueue(REDRAWNODE, 0);
2564         }
2565 }
2566
2567 static void rename_scene_layer_func(void *srl_v, void *unused_v)
2568 {
2569         if(G.scene->nodetree) {
2570                 SceneRenderLayer *srl= srl_v;
2571                 bNode *node;
2572                 for(node= G.scene->nodetree->nodes.first; node; node= node->next) {
2573                         if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
2574                                 if(node->custom1==G.scene->r.actlay)
2575                                         BLI_strncpy(node->name, srl->name, NODE_MAXSTR);
2576                         }
2577                 }
2578         }
2579         allqueue(REDRAWBUTSSCENE, 0);
2580         allqueue(REDRAWOOPS, 0);
2581         allqueue(REDRAWNODE, 0);
2582 }
2583
2584 static char *scene_layer_menu(void)
2585 {
2586         SceneRenderLayer *srl;
2587         int len= 32 + 32*BLI_countlist(&G.scene->r.layers);
2588         short a, nr;
2589         char *str= MEM_callocN(len, "menu layers");
2590         
2591         strcpy(str, "ADD NEW %x32767");
2592         a= strlen(str);
2593         for(nr=0, srl= G.scene->r.layers.first; srl; srl= srl->next, nr++) {
2594                 if(srl->layflag & SCE_LAY_DISABLE)
2595                         a+= sprintf(str+a, "|%s %%i%d %%x%d", srl->name, ICON_BLANK1, nr);
2596                 else 
2597                         a+= sprintf(str+a, "|%s %%i%d %%x%d", srl->name, ICON_CHECKBOX_HLT, nr);
2598         }
2599         
2600         return str;
2601 }
2602
2603 static void draw_3d_layer_buttons(uiBlock *block, int type, unsigned int *poin, short xco, short yco, short dx, short dy, char *tip)
2604 {
2605         uiBut *bt;
2606         long a;
2607         
2608         uiBlockBeginAlign(block);
2609         for(a=0; a<5; a++) {
2610                 bt= uiDefButBitI(block, type, 1<<a, B_NOP, "",  (short)(xco+a*(dx/2)), yco+dy/2, (short)(dx/2), (short)(dy/2), (int *)poin, 0, 0, 0, 0, tip);
2611                 uiButSetFunc(bt, layer_copy_func, (void *)a, poin);
2612         }
2613         for(a=0; a<5; a++) {
2614                 bt=uiDefButBitI(block, type, 1<<(a+10), B_NOP, "",      (short)(xco+a*(dx/2)), yco, (short)(dx/2), (short)(dy/2), (int *)poin, 0, 0, 0, 0, tip);
2615                 uiButSetFunc(bt, layer_copy_func, (void *)(a+10), poin);
2616         }
2617         
2618         xco+= 7;
2619         uiBlockBeginAlign(block);
2620         for(a=5; a<10; a++) {
2621                 bt=uiDefButBitI(block, type, 1<<a, B_NOP, "",   (short)(xco+a*(dx/2)), yco+dy/2, (short)(dx/2), (short)(dy/2), (int *)poin, 0, 0, 0, 0, tip);
2622                 uiButSetFunc(bt, layer_copy_func, (void *)a, poin);
2623         }
2624         for(a=5; a<10; a++) {
2625                 bt=uiDefButBitI(block, type, 1<<(a+10), B_NOP, "",      (short)(xco+a*(dx/2)), yco, (short)(dx/2), (short)(dy/2), (int *)poin, 0, 0, 0, 0, tip);
2626                 uiButSetFunc(bt, layer_copy_func, (void *)(a+10), poin);
2627         }
2628         
2629         uiBlockEndAlign(block);
2630 }
2631
2632 static void render_panel_layers(void)
2633 {
2634         uiBlock *block;
2635         uiBut *bt;
2636         SceneRenderLayer *srl= BLI_findlink(&G.scene->r.layers, G.scene->r.actlay);
2637         char *strp;
2638         
2639         if(srl==NULL) {
2640                 G.scene->r.actlay= 0;
2641                 srl= G.scene->r.layers.first;
2642         }
2643         
2644         block= uiNewBlock(&curarea->uiblocks, "render_panel_layers", UI_EMBOSS, UI_HELV, curarea->win);
2645         uiNewPanelTabbed("Output", "Render");
2646         if(uiNewPanel(curarea, block, "Render Layers", "Render", 320, 0, 318, 204)==0) return;
2647         
2648         /* first, as reminder, the scene layers */
2649         uiDefBut(block, LABEL, 0, "Scene:",                             10,170,100,20, NULL, 0, 0, 0, 0, "");
2650         draw_3d_layer_buttons(block, TOG, &G.scene->lay,                130, 170, 35, 30, "Scene layers to render");
2651         
2652         /* layer disable, menu, name, delete button */
2653         uiBlockBeginAlign(block);
2654         uiDefIconButBitI(block, ICONTOGN, SCE_LAY_DISABLE, B_REDR, ICON_CHECKBOX_HLT-1, 10, 145, 20, 20, &srl->layflag, 0.0, 0.0, 0, 0, "Disable or enable this RenderLayer");
2655         strp= scene_layer_menu();
2656         uiDefButS(block, MENU, B_ADD_RENDERLAYER, strp, 30,145,23,20, &(G.scene->r.actlay), 0, 0, 0, 0, "Choose Active Render Layer");
2657         MEM_freeN(strp);
2658         
2659         /* name max 20, exr format limit... */
2660         bt= uiDefBut(block, TEX, REDRAWNODE, "",  53,145,172,20, srl->name, 0.0, 20.0, 0, 0, "");
2661         uiButSetFunc(bt, rename_scene_layer_func, srl, NULL);
2662         
2663         uiDefButBitS(block, TOG, R_SINGLE_LAYER, B_NOP, "Single",       230,145,60,20, &G.scene->r.scemode, 0, 0, 0, 0, "Only render this layer");      
2664         bt=uiDefIconBut(block, BUT, B_NOP, ICON_X,      285, 145, 25, 20, 0, 0, 0, 0, 0, "Deletes current Render Layer");
2665         uiButSetFunc(bt, delete_scene_layer_func, srl, (void *)(long)G.scene->r.actlay);
2666         uiBlockEndAlign(block);
2667
2668         /* RenderLayer visible-layers */
2669         uiDefBut(block, LABEL, 0, "Layer:",                     10,110,100,20, NULL, 0, 0, 0, 0, "");
2670         draw_3d_layer_buttons(block, BUT_TOGDUAL, &srl->lay,            130,110, 35, 30, "Scene-layers included in this render-layer (Hold CTRL for Z-mask)");
2671         
2672         uiBlockBeginAlign(block);
2673         uiDefButBitI(block, TOG, SCE_LAY_ALL_Z, B_NOP,"AllZ",   10, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Fill in Z values for solid faces in invisible layers, for masking");        
2674         uiDefButBitI(block, TOG, SCE_LAY_ZMASK, B_NOP,"Zmask",  10, 65, 40, 20, &srl->layflag, 0, 0, 0, 0, "Only render what's in front of the solid z values");        
2675         uiBlockBeginAlign(block);
2676         uiDefButBitI(block, TOG, SCE_LAY_SOLID, B_NOP,"Solid",  50,  85, 45, 20, &srl->layflag, 0, 0, 0, 0, "Render Solid faces in this Layer");        
2677         uiDefButBitI(block, TOG, SCE_LAY_HALO, B_NOP,"Halo",    95,  85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Halos in this Layer (on top of Solid)");    
2678         uiDefButBitI(block, TOG, SCE_LAY_ZTRA, B_NOP,"Ztra",    135, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Z-Transparent faces in this Layer (On top of Solid and Halos)");    
2679         uiDefButBitI(block, TOG, SCE_LAY_SKY, B_NOP,"Sky",              175, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Sky or backbuffer in this Layer");  
2680         uiDefButBitI(block, TOG, SCE_LAY_EDGE, B_NOP,"Edge",    215, 85, 45, 20, &srl->layflag, 0, 0, 0, 0, "Render Edge-enhance in this Layer (only works for Solid faces)");  
2681         uiDefButBitI(block, TOG, SCE_LAY_STRAND, B_NOP,"Strand",260, 85, 50, 20, &srl->layflag, 0, 0, 0, 0, "Render Strands in this Layer");    
2682         
2683         uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_SET_PASS, "Light:",  50, 65, 130, 20, &(srl->light_override), "Name of Group to use as Lamps instead");
2684         uiDefIDPoinBut(block, test_matpoin_but, ID_MA, B_SET_PASS, "Mat:",      180, 65, 130, 20, &(srl->mat_override), "Name of Material to use as Materials instead");
2685         uiBlockEndAlign(block);
2686
2687         uiBlockBeginAlign(block);
2688         uiDefButBitI(block, TOG, SCE_PASS_COMBINED, B_SET_PASS,"Combined",      10, 30, 80, 20, &srl->passflag, 0, 0, 0, 0, "Deliver full combined RGBA buffer");       
2689         uiDefButBitI(block, TOG, SCE_PASS_Z, B_SET_PASS,"Z",                    90, 30, 30, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Z values pass");   
2690         uiDefButBitI(block, TOG, SCE_PASS_VECTOR, B_SET_PASS,"Vec",             120, 30, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Speed Vector pass");      
2691         uiDefButBitI(block, TOG, SCE_PASS_NORMAL, B_SET_PASS,"Nor",             160, 30, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Normal pass");    
2692         uiDefButBitI(block, TOG, SCE_PASS_UV, B_SET_PASS,"UV",                  200, 30, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Texture UV pass");        
2693         uiDefButBitI(block, TOG, SCE_PASS_MIST, B_SET_PASS,"Mist",              240, 30, 35, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Mist factor pass (0-1)"); 
2694         uiDefButBitI(block, TOG, SCE_PASS_INDEXOB, B_SET_PASS,"Index",  275, 30, 35, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Object Index pass");      
2695         
2696         uiDefButBitI(block, TOG, SCE_PASS_RGBA, B_SET_PASS,"Col",                               10, 10, 35, 20, &srl->passflag, 0, 0, 0, 0, "Deliver shade-less Color pass");   
2697         uiDefButBitI(block, TOG, SCE_PASS_DIFFUSE, B_SET_PASS,"Diff",                   45, 10, 35, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Diffuse pass");    
2698         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_SPEC, B_SET_PASS,"Spec",              80, 10, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Specular pass (Hold Ctrl to exclude from combined)");      
2699         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_SHADOW, B_SET_PASS,"Shad",    120, 10, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Shadow pass (Hold Ctrl to exclude from combined)");       
2700         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_AO, B_SET_PASS,"AO",                  160, 10, 30, 20, &srl->passflag, 0, 0, 0, 0, "Deliver AO pass (Hold Ctrl to exclude from combined)");
2701         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_REFLECT, B_SET_PASS,"Refl",   190, 10, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Raytraced Reflection pass (Hold Ctrl to exclude from combined)"); 
2702         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_REFRACT, B_SET_PASS,"Refr",   230, 10, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Raytraced Refraction pass (Hold Ctrl to exclude from combined)"); 
2703         uiDefButBitI(block, BUT_TOGDUAL, SCE_PASS_RADIO, B_SET_PASS,"Rad",              270, 10, 40, 20, &srl->passflag, 0, 0, 0, 0, "Deliver Radiosity pass (Hold Ctrl to exclude from combined)");    
2704 }       
2705
2706 void render_panels()
2707 {
2708
2709         render_panel_output();
2710         render_panel_layers();
2711         render_panel_render();
2712         render_panel_anim();
2713         render_panel_bake();
2714
2715         render_panel_format();
2716         render_panel_stamp();
2717 #ifdef WITH_FFMPEG
2718        if (G.scene->r.imtype == R_FFMPEG) {
2719                    render_panel_ffmpeg_video();
2720                render_panel_ffmpeg_audio();
2721        }
2722 #endif
2723
2724 #ifndef DISABLE_YAFRAY
2725         /* yafray: GI & Global panel, only available when yafray enabled for rendering */
2726         if (G.scene->r.renderer==R_YAFRAY) {
2727                 if (G.scene->r.YF_gamma==0.0) G.scene->r.YF_gamma=1.0;
2728                 if (G.scene->r.YF_raybias==0.0) G.scene->r.YF_raybias=0.001;
2729                 if (G.scene->r.YF_raydepth==0) G.scene->r.YF_raydepth=5;
2730                 if (G.scene->r.YF_AApixelsize==0.0) G.scene->r.YF_AApixelsize=1.5;
2731                 if (G.scene->r.YF_AAthreshold==0.0) G.scene->r.YF_AAthreshold=0.05;
2732                 if (G.scene->r.GIpower==0.0) G.scene->r.GIpower=1.0;
2733                 if (G.scene->r.GIindirpower==0.0) G.scene->r.GIindirpower=1.0;
2734                 render_panel_yafrayGlobal();
2735                 render_panel_yafrayGI();
2736         }
2737 #endif
2738
2739 }
2740
2741 /* --------------------------------------------- */
2742
2743 void anim_panels()
2744 {
2745         uiBlock *block;
2746
2747         block= uiNewBlock(&curarea->uiblocks, "anim_panel", UI_EMBOSS, UI_HELV, curarea->win);
2748         if(uiNewPanel(curarea, block, "Anim", "Anim", 0, 0, 318, 204)==0) return;
2749
2750         uiBlockBeginAlign(block);
2751         uiDefButI(block, NUM,B_FRAMEMAP,"Map Old:",     10,160,150,20,&G.scene->r.framapto,1.0,900.0, 0, 0, "Specify old mapping value in frames");
2752         uiDefButI(block, NUM,B_FRAMEMAP,"Map New:",     160,160,150,20,&G.scene->r.images,1.0,900.0, 0, 0, "Specify how many frames the Map Old will last");
2753
2754         uiBlockBeginAlign(block);
2755         uiDefButS(block, NUM,B_FRAMEMAP,"FPS:",  10,130,75,20, &G.scene->r.frs_sec, 1.0, 120.0, 100.0, 0, "Frames per second");
2756         uiDefButF(block, NUM,B_FRAMEMAP,"/",  85,130,75,20, &G.scene->r.frs_sec_base, 1.0, 120.0, 0.1, 3, "Frames per second base");
2757
2758         uiDefButBitS(block, TOG, AUDIO_SYNC, B_SOUND_CHANGED, "Sync",160,130,150,20, &G.scene->audio.flag, 0, 0, 0, 0, "Use sample clock for syncing animation to audio");
2759         
2760         uiBlockBeginAlign(block);
2761         uiDefButI(block, NUM,REDRAWALL,"Sta:",  10,100,150,20,&G.scene->r.sfra,1.0,MAXFRAMEF, 0, 0, "Specify the start frame of the animation");
2762         uiDefButI(block, NUM,REDRAWALL,"End:",  160,100,150,20,&G.scene->r.efra,1.0,MAXFRAMEF, 0, 0, "Specify the end frame of the animation");
2763
2764         uiBlockBeginAlign(block);
2765         uiDefButS(block, NUM, REDRAWTIME, "Steps:",10, 70, 150, 20,&(G.scene->jumpframe), 1, 100, 1, 100, "Set spacing between frames changes with up and down arrow keys");
2766
2767
2768 }
2769
2770 /* --------------------------------------------- */
2771
2772 void sound_panels()
2773 {
2774         bSound *sound;
2775
2776         /* paranoia check */
2777         sound = G.buts->lockpoin;
2778         if(sound && GS(sound->id.name)!=ID_SO) {
2779                 sound= NULL;
2780                 G.buts->lockpoin= NULL;
2781         }
2782         
2783         sound_panel_sound(sound);
2784         sound_panel_listener();
2785         sound_panel_sequencer();
2786 }
2787
2788
2789