replace ImBuf.depth with ImBuf.planes to match ImageFormatData.planes & to avoid...
[blender.git] / source / blender / blenkernel / intern / scene.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/scene.c
29  *  \ingroup bke
30  */
31
32
33 #include <stddef.h>
34 #include <stdio.h>
35 #include <string.h>
36
37 #ifndef WIN32 
38 #include <unistd.h>
39 #else
40 #include <io.h>
41 #endif
42
43 #include "MEM_guardedalloc.h"
44
45 #include "DNA_anim_types.h"
46 #include "DNA_group_types.h"
47 #include "DNA_node_types.h"
48 #include "DNA_object_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_sequence_types.h"
52
53 #include "BLI_math.h"
54 #include "BLI_blenlib.h"
55 #include "BLI_utildefines.h"
56 #include "BLI_callbacks.h"
57
58 #include "BKE_anim.h"
59 #include "BKE_animsys.h"
60 #include "BKE_depsgraph.h"
61 #include "BKE_global.h"
62 #include "BKE_group.h"
63 #include "BKE_idprop.h"
64 #include "BKE_library.h"
65 #include "BKE_main.h"
66 #include "BKE_node.h"
67 #include "BKE_object.h"
68 #include "BKE_paint.h"
69 #include "BKE_pointcache.h"
70 #include "BKE_scene.h"
71 #include "BKE_sequencer.h"
72 #include "BKE_world.h"
73
74 #include "BKE_sound.h"
75
76 #include "RE_engine.h"
77
78 //XXX #include "BIF_previewrender.h"
79 //XXX #include "BIF_editseq.h"
80
81 //XXX #include "nla.h"
82
83 #ifdef WIN32
84 #else
85 #include <sys/time.h>
86 #endif
87
88 void free_avicodecdata(AviCodecData *acd)
89 {
90         if (acd) {
91                 if (acd->lpFormat){
92                         MEM_freeN(acd->lpFormat);
93                         acd->lpFormat = NULL;
94                         acd->cbFormat = 0;
95                 }
96                 if (acd->lpParms){
97                         MEM_freeN(acd->lpParms);
98                         acd->lpParms = NULL;
99                         acd->cbParms = 0;
100                 }
101         }
102 }
103
104 void free_qtcodecdata(QuicktimeCodecData *qcd)
105 {
106         if (qcd) {
107                 if (qcd->cdParms){
108                         MEM_freeN(qcd->cdParms);
109                         qcd->cdParms = NULL;
110                         qcd->cdSize = 0;
111                 }
112         }
113 }
114
115 Scene *copy_scene(Scene *sce, int type)
116 {
117         Scene *scen;
118         ToolSettings *ts;
119         Base *base, *obase;
120         
121         if(type == SCE_COPY_EMPTY) {
122                 ListBase lb;
123                 scen= add_scene(sce->id.name+2);
124                 
125                 lb= scen->r.layers;
126                 scen->r= sce->r;
127                 scen->r.layers= lb;
128         }
129         else {
130                 scen= copy_libblock(&sce->id);
131                 BLI_duplicatelist(&(scen->base), &(sce->base));
132                 
133                 clear_id_newpoins();
134                 
135                 id_us_plus((ID *)scen->world);
136                 id_us_plus((ID *)scen->set);
137                 id_us_plus((ID *)scen->gm.dome.warptext);
138
139                 scen->ed= NULL;
140                 scen->theDag= NULL;
141                 scen->obedit= NULL;
142                 scen->toolsettings= MEM_dupallocN(sce->toolsettings);
143                 scen->stats= NULL;
144                 scen->fps_info= NULL;
145
146                 ts= scen->toolsettings;
147                 if(ts) {
148                         if(ts->vpaint) {
149                                 ts->vpaint= MEM_dupallocN(ts->vpaint);
150                                 ts->vpaint->paintcursor= NULL;
151                                 ts->vpaint->vpaint_prev= NULL;
152                                 ts->vpaint->wpaint_prev= NULL;
153                                 copy_paint(&ts->vpaint->paint, &ts->vpaint->paint);
154                         }
155                         if(ts->wpaint) {
156                                 ts->wpaint= MEM_dupallocN(ts->wpaint);
157                                 ts->wpaint->paintcursor= NULL;
158                                 ts->wpaint->vpaint_prev= NULL;
159                                 ts->wpaint->wpaint_prev= NULL;
160                                 copy_paint(&ts->wpaint->paint, &ts->wpaint->paint);
161                         }
162                         if(ts->sculpt) {
163                                 ts->sculpt= MEM_dupallocN(ts->sculpt);
164                                 copy_paint(&ts->sculpt->paint, &ts->sculpt->paint);
165                         }
166
167                         copy_paint(&ts->imapaint.paint, &ts->imapaint.paint);
168                         ts->imapaint.paintcursor= NULL;
169
170                         ts->particle.paintcursor= NULL;
171                 }
172                 
173                 BLI_duplicatelist(&(scen->markers), &(sce->markers));
174                 BLI_duplicatelist(&(scen->transform_spaces), &(sce->transform_spaces));
175                 BLI_duplicatelist(&(scen->r.layers), &(sce->r.layers));
176                 BKE_keyingsets_copy(&(scen->keyingsets), &(sce->keyingsets));
177
178                 if(sce->nodetree) {
179                         scen->nodetree= ntreeCopyTree(sce->nodetree); /* copies actions */
180                         ntreeSwitchID(scen->nodetree, &sce->id, &scen->id);
181                 }
182
183                 obase= sce->base.first;
184                 base= scen->base.first;
185                 while(base) {
186                         id_us_plus(&base->object->id);
187                         if(obase==sce->basact) scen->basact= base;
188         
189                         obase= obase->next;
190                         base= base->next;
191                 }
192         }
193         
194         /* make a private copy of the avicodecdata */
195         if(sce->r.avicodecdata) {
196                 scen->r.avicodecdata = MEM_dupallocN(sce->r.avicodecdata);
197                 scen->r.avicodecdata->lpFormat = MEM_dupallocN(scen->r.avicodecdata->lpFormat);
198                 scen->r.avicodecdata->lpParms = MEM_dupallocN(scen->r.avicodecdata->lpParms);
199         }
200         
201         /* make a private copy of the qtcodecdata */
202         if(sce->r.qtcodecdata) {
203                 scen->r.qtcodecdata = MEM_dupallocN(sce->r.qtcodecdata);
204                 scen->r.qtcodecdata->cdParms = MEM_dupallocN(scen->r.qtcodecdata->cdParms);
205         }
206         
207         if(sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
208                 scen->r.ffcodecdata.properties= IDP_CopyProperty(sce->r.ffcodecdata.properties);
209         }
210
211         /* NOTE: part of SCE_COPY_LINK_DATA and SCE_COPY_FULL operations
212          * are done outside of blenkernel with ED_objects_single_users! */
213
214         /*  camera */
215         if(type == SCE_COPY_LINK_DATA || type == SCE_COPY_FULL) {
216                 ID_NEW(scen->camera);
217         }
218         
219         /* before scene copy */
220         sound_create_scene(scen);
221
222         /* world */
223         if(type == SCE_COPY_FULL) {
224                 BKE_copy_animdata_id_action((ID *)scen);
225                 if(scen->world) {
226                         id_us_plus((ID *)scen->world);
227                         scen->world= copy_world(scen->world);
228                         BKE_copy_animdata_id_action((ID *)scen->world);
229                 }
230
231                 if(sce->ed) {
232                         scen->ed= MEM_callocN( sizeof(Editing), "addseq");
233                         scen->ed->seqbasep= &scen->ed->seqbase;
234                         seqbase_dupli_recursive(sce, scen, &scen->ed->seqbase, &sce->ed->seqbase, SEQ_DUPE_ALL);
235                 }
236         }
237
238         return scen;
239 }
240
241 /* do not free scene itself */
242 void free_scene(Scene *sce)
243 {
244         Base *base;
245
246         base= sce->base.first;
247         while(base) {
248                 base->object->id.us--;
249                 base= base->next;
250         }
251         /* do not free objects! */
252         
253         if(sce->gpd) {
254 #if 0   // removed since this can be invalid memory when freeing everything
255                 // since the grease pencil data is free'd before the scene.
256                 // since grease pencil data is not (yet?), shared between objects
257                 // its probably safe not to do this, some save and reload will free this.
258                 sce->gpd->id.us--;
259 #endif
260                 sce->gpd= NULL;
261         }
262
263         BLI_freelistN(&sce->base);
264         seq_free_editing(sce);
265
266         BKE_free_animdata((ID *)sce);
267         BKE_keyingsets_free(&sce->keyingsets);
268         
269         if (sce->r.avicodecdata) {
270                 free_avicodecdata(sce->r.avicodecdata);
271                 MEM_freeN(sce->r.avicodecdata);
272                 sce->r.avicodecdata = NULL;
273         }
274         if (sce->r.qtcodecdata) {
275                 free_qtcodecdata(sce->r.qtcodecdata);
276                 MEM_freeN(sce->r.qtcodecdata);
277                 sce->r.qtcodecdata = NULL;
278         }
279         if (sce->r.ffcodecdata.properties) {
280                 IDP_FreeProperty(sce->r.ffcodecdata.properties);
281                 MEM_freeN(sce->r.ffcodecdata.properties);
282                 sce->r.ffcodecdata.properties = NULL;
283         }
284         
285         BLI_freelistN(&sce->markers);
286         BLI_freelistN(&sce->transform_spaces);
287         BLI_freelistN(&sce->r.layers);
288         
289         if(sce->toolsettings) {
290                 if(sce->toolsettings->vpaint) {
291                         free_paint(&sce->toolsettings->vpaint->paint);
292                         MEM_freeN(sce->toolsettings->vpaint);
293                 }
294                 if(sce->toolsettings->wpaint) {
295                         free_paint(&sce->toolsettings->wpaint->paint);
296                         MEM_freeN(sce->toolsettings->wpaint);
297                 }
298                 if(sce->toolsettings->sculpt) {
299                         free_paint(&sce->toolsettings->sculpt->paint);
300                         MEM_freeN(sce->toolsettings->sculpt);
301                 }
302                 free_paint(&sce->toolsettings->imapaint.paint);
303
304                 MEM_freeN(sce->toolsettings);
305                 sce->toolsettings = NULL;       
306         }
307         
308         if (sce->theDag) {
309                 free_forest(sce->theDag);
310                 MEM_freeN(sce->theDag);
311         }
312         
313         if(sce->nodetree) {
314                 ntreeFreeTree(sce->nodetree);
315                 MEM_freeN(sce->nodetree);
316         }
317
318         if(sce->stats)
319                 MEM_freeN(sce->stats);
320         if(sce->fps_info)
321                 MEM_freeN(sce->fps_info);
322
323         sound_destroy_scene(sce);
324 }
325
326 Scene *add_scene(const char *name)
327 {
328         Main *bmain= G.main;
329         Scene *sce;
330         ParticleEditSettings *pset;
331         int a;
332
333         sce= alloc_libblock(&bmain->scene, ID_SCE, name);
334         sce->lay= sce->layact= 1;
335         
336         sce->r.mode= R_GAMMA|R_OSA|R_SHADOW|R_SSS|R_ENVMAP|R_RAYTRACE;
337         sce->r.cfra= 1;
338         sce->r.sfra= 1;
339         sce->r.efra= 250;
340         sce->r.frame_step= 1;
341         sce->r.xsch= 1920;
342         sce->r.ysch= 1080;
343         sce->r.xasp= 1;
344         sce->r.yasp= 1;
345         sce->r.xparts= 8;
346         sce->r.yparts= 8;
347         sce->r.mblur_samples= 1;
348         sce->r.filtertype= R_FILTER_MITCH;
349         sce->r.size= 50;
350
351         sce->r.im_format.planes= R_IMF_PLANES_RGB;
352         sce->r.im_format.imtype= R_PNG;
353         sce->r.im_format.quality= 90;
354
355         sce->r.displaymode= R_OUTPUT_AREA;
356         sce->r.framapto= 100;
357         sce->r.images= 100;
358         sce->r.framelen= 1.0;
359         sce->r.blurfac= 0.5;
360         sce->r.frs_sec= 24;
361         sce->r.frs_sec_base= 1;
362         sce->r.edgeint= 10;
363         sce->r.ocres = 128;
364         sce->r.color_mgt_flag |= R_COLOR_MANAGEMENT;
365         sce->r.gauss= 1.0;
366         
367         /* deprecated but keep for upwards compat */
368         sce->r.postgamma= 1.0;
369         sce->r.posthue= 0.0;
370         sce->r.postsat= 1.0;
371         
372         sce->r.bake_mode= 1;    /* prevent to include render stuff here */
373         sce->r.bake_filter= 2;
374         sce->r.bake_osa= 5;
375         sce->r.bake_flag= R_BAKE_CLEAR;
376         sce->r.bake_normal_space= R_BAKE_SPACE_TANGENT;
377         sce->r.scemode= R_DOCOMP|R_DOSEQ|R_EXTENSION;
378         sce->r.stamp= R_STAMP_TIME|R_STAMP_FRAME|R_STAMP_DATE|R_STAMP_CAMERA|R_STAMP_SCENE|R_STAMP_FILENAME|R_STAMP_RENDERTIME;
379         sce->r.stamp_font_id= 12;
380         sce->r.fg_stamp[0]= sce->r.fg_stamp[1]= sce->r.fg_stamp[2]= 0.8f;
381         sce->r.fg_stamp[3]= 1.0f;
382         sce->r.bg_stamp[0]= sce->r.bg_stamp[1]= sce->r.bg_stamp[2]= 0.0f;
383         sce->r.bg_stamp[3]= 0.25f;
384         sce->r.raytrace_options = R_RAYTRACE_USE_INSTANCES;
385
386         sce->r.seq_prev_type= OB_SOLID;
387         sce->r.seq_rend_type= OB_SOLID;
388         sce->r.seq_flag= R_SEQ_GL_PREV;
389
390         sce->r.threads= 1;
391
392         sce->r.simplify_subsurf= 6;
393         sce->r.simplify_particles= 1.0f;
394         sce->r.simplify_shadowsamples= 16;
395         sce->r.simplify_aosss= 1.0f;
396
397         sce->r.cineonblack= 95;
398         sce->r.cineonwhite= 685;
399         sce->r.cineongamma= 1.7f;
400
401         sce->r.border.xmin= 0.0f;
402         sce->r.border.ymin= 0.0f;
403         sce->r.border.xmax= 1.0f;
404         sce->r.border.ymax= 1.0f;
405         
406         sce->toolsettings = MEM_callocN(sizeof(struct ToolSettings),"Tool Settings Struct");
407         sce->toolsettings->cornertype=1;
408         sce->toolsettings->degr = 90; 
409         sce->toolsettings->step = 9;
410         sce->toolsettings->turn = 1;                            
411         sce->toolsettings->extr_offs = 1; 
412         sce->toolsettings->doublimit = 0.001;
413         sce->toolsettings->segments = 32;
414         sce->toolsettings->rings = 32;
415         sce->toolsettings->vertices = 32;
416         sce->toolsettings->editbutflag = 1;
417         sce->toolsettings->uvcalc_radius = 1.0f;
418         sce->toolsettings->uvcalc_cubesize = 1.0f;
419         sce->toolsettings->uvcalc_mapdir = 1;
420         sce->toolsettings->uvcalc_mapalign = 1;
421         sce->toolsettings->unwrapper = 1;
422         sce->toolsettings->select_thresh= 0.01f;
423         sce->toolsettings->jointrilimit = 0.8f;
424
425         sce->toolsettings->selectmode= SCE_SELECT_VERTEX;
426         sce->toolsettings->uv_selectmode= UV_SELECT_VERTEX;
427         sce->toolsettings->normalsize= 0.1;
428         sce->toolsettings->autokey_mode= U.autokey_mode;
429
430         sce->toolsettings->skgen_resolution = 100;
431         sce->toolsettings->skgen_threshold_internal     = 0.01f;
432         sce->toolsettings->skgen_threshold_external     = 0.01f;
433         sce->toolsettings->skgen_angle_limit                    = 45.0f;
434         sce->toolsettings->skgen_length_ratio                   = 1.3f;
435         sce->toolsettings->skgen_length_limit                   = 1.5f;
436         sce->toolsettings->skgen_correlation_limit              = 0.98f;
437         sce->toolsettings->skgen_symmetry_limit                 = 0.1f;
438         sce->toolsettings->skgen_postpro = SKGEN_SMOOTH;
439         sce->toolsettings->skgen_postpro_passes = 1;
440         sce->toolsettings->skgen_options = SKGEN_FILTER_INTERNAL|SKGEN_FILTER_EXTERNAL|SKGEN_FILTER_SMART|SKGEN_HARMONIC|SKGEN_SUB_CORRELATION|SKGEN_STICK_TO_EMBEDDING;
441         sce->toolsettings->skgen_subdivisions[0] = SKGEN_SUB_CORRELATION;
442         sce->toolsettings->skgen_subdivisions[1] = SKGEN_SUB_LENGTH;
443         sce->toolsettings->skgen_subdivisions[2] = SKGEN_SUB_ANGLE;
444
445         sce->toolsettings->proportional_size = 1.0f;
446
447         sce->physics_settings.gravity[0] = 0.0f;
448         sce->physics_settings.gravity[1] = 0.0f;
449         sce->physics_settings.gravity[2] = -9.81f;
450         sce->physics_settings.flag = PHYS_GLOBAL_GRAVITY;
451
452         sce->unit.scale_length = 1.0f;
453
454         pset= &sce->toolsettings->particle;
455         pset->flag= PE_KEEP_LENGTHS|PE_LOCK_FIRST|PE_DEFLECT_EMITTER|PE_AUTO_VELOCITY;
456         pset->emitterdist= 0.25f;
457         pset->totrekey= 5;
458         pset->totaddkey= 5;
459         pset->brushtype= PE_BRUSH_NONE;
460         pset->draw_step= 2;
461         pset->fade_frames= 2;
462         pset->selectmode= SCE_SELECT_PATH;
463         for(a=0; a<PE_TOT_BRUSH; a++) {
464                 pset->brush[a].strength= 0.5;
465                 pset->brush[a].size= 50;
466                 pset->brush[a].step= 10;
467                 pset->brush[a].count= 10;
468         }
469         pset->brush[PE_BRUSH_CUT].strength= 100;
470
471         sce->r.ffcodecdata.audio_mixrate = 44100;
472         sce->r.ffcodecdata.audio_volume = 1.0f;
473         sce->r.ffcodecdata.audio_bitrate = 192;
474         sce->r.ffcodecdata.audio_channels = 2;
475
476         BLI_strncpy(sce->r.engine, "BLENDER_RENDER", sizeof(sce->r.engine));
477
478         sce->audio.distance_model = 2.0f;
479         sce->audio.doppler_factor = 1.0f;
480         sce->audio.speed_of_sound = 343.3f;
481         sce->audio.volume = 1.0f;
482
483         BLI_strncpy(sce->r.pic, U.renderdir, sizeof(sce->r.pic));
484
485         BLI_init_rctf(&sce->r.safety, 0.1f, 0.9f, 0.1f, 0.9f);
486         sce->r.osa= 8;
487
488         /* note; in header_info.c the scene copy happens..., if you add more to renderdata it has to be checked there */
489         scene_add_render_layer(sce, NULL);
490         
491         /* game data */
492         sce->gm.stereoflag = STEREO_NOSTEREO;
493         sce->gm.stereomode = STEREO_ANAGLYPH;
494         sce->gm.eyeseparation = 0.10;
495
496         sce->gm.dome.angle = 180;
497         sce->gm.dome.mode = DOME_FISHEYE;
498         sce->gm.dome.res = 4;
499         sce->gm.dome.resbuf = 1.0f;
500         sce->gm.dome.tilt = 0;
501
502         sce->gm.xplay= 640;
503         sce->gm.yplay= 480;
504         sce->gm.freqplay= 60;
505         sce->gm.depth= 32;
506
507         sce->gm.gravity= 9.8f;
508         sce->gm.physicsEngine= WOPHY_BULLET;
509         sce->gm.mode = 32; //XXX ugly harcoding, still not sure we should drop mode. 32 == 1 << 5 == use_occlusion_culling 
510         sce->gm.occlusionRes = 128;
511         sce->gm.ticrate = 60;
512         sce->gm.maxlogicstep = 5;
513         sce->gm.physubstep = 1;
514         sce->gm.maxphystep = 5;
515
516         sce->gm.flag = GAME_DISPLAY_LISTS;
517         sce->gm.matmode = GAME_MAT_MULTITEX;
518
519         sce->gm.obstacleSimulation= OBSTSIMULATION_NONE;
520         sce->gm.levelHeight = 2.f;
521
522         sce->gm.recastData.cellsize = 0.3f;
523         sce->gm.recastData.cellheight = 0.2f;
524         sce->gm.recastData.agentmaxslope = M_PI/2;
525         sce->gm.recastData.agentmaxclimb = 0.9f;
526         sce->gm.recastData.agentheight = 2.0f;
527         sce->gm.recastData.agentradius = 0.6f;
528         sce->gm.recastData.edgemaxlen = 12.0f;
529         sce->gm.recastData.edgemaxerror = 1.3f;
530         sce->gm.recastData.regionminsize = 8.f;
531         sce->gm.recastData.regionmergesize = 20.f;
532         sce->gm.recastData.vertsperpoly = 6;
533         sce->gm.recastData.detailsampledist = 6.0f;
534         sce->gm.recastData.detailsamplemaxerror = 1.0f;
535
536         sound_create_scene(sce);
537
538         return sce;
539 }
540
541 Base *object_in_scene(Object *ob, Scene *sce)
542 {
543         Base *base;
544         
545         base= sce->base.first;
546         while(base) {
547                 if(base->object == ob) return base;
548                 base= base->next;
549         }
550         return NULL;
551 }
552
553 void set_scene_bg(Main *bmain, Scene *scene)
554 {
555         Scene *sce;
556         Base *base;
557         Object *ob;
558         Group *group;
559         GroupObject *go;
560         int flag;
561         
562         /* check for cyclic sets, for reading old files but also for definite security (py?) */
563         scene_check_setscene(bmain, scene);
564         
565         /* can happen when switching modes in other scenes */
566         if(scene->obedit && !(scene->obedit->mode & OB_MODE_EDIT))
567                 scene->obedit= NULL;
568
569         /* deselect objects (for dataselect) */
570         for(ob= bmain->object.first; ob; ob= ob->id.next)
571                 ob->flag &= ~(SELECT|OB_FROMGROUP);
572
573         /* group flags again */
574         for(group= bmain->group.first; group; group= group->id.next) {
575                 go= group->gobject.first;
576                 while(go) {
577                         if(go->ob) go->ob->flag |= OB_FROMGROUP;
578                         go= go->next;
579                 }
580         }
581
582         /* sort baselist */
583         DAG_scene_sort(bmain, scene);
584         
585         /* ensure dags are built for sets */
586         for(sce= scene->set; sce; sce= sce->set)
587                 if(sce->theDag==NULL)
588                         DAG_scene_sort(bmain, sce);
589
590         /* copy layers and flags from bases to objects */
591         for(base= scene->base.first; base; base= base->next) {
592                 ob= base->object;
593                 ob->lay= base->lay;
594                 
595                 /* group patch... */
596                 base->flag &= ~(OB_FROMGROUP);
597                 flag= ob->flag & (OB_FROMGROUP);
598                 base->flag |= flag;
599                 
600                 /* not too nice... for recovering objects with lost data */
601                 //if(ob->pose==NULL) base->flag &= ~OB_POSEMODE;
602                 ob->flag= base->flag;
603                 
604                 ob->ctime= -1234567.0;  /* force ipo to be calculated later */
605         }
606         /* no full animation update, this to enable render code to work (render code calls own animation updates) */
607 }
608
609 /* called from creator.c */
610 Scene *set_scene_name(Main *bmain, const char *name)
611 {
612         Scene *sce= (Scene *)find_id("SC", name);
613         if(sce) {
614                 set_scene_bg(bmain, sce);
615                 printf("Scene switch: '%s' in file: '%s'\n", name, G.main->name);
616                 return sce;
617         }
618
619         printf("Can't find scene: '%s' in file: '%s'\n", name, G.main->name);
620         return NULL;
621 }
622
623 void unlink_scene(Main *bmain, Scene *sce, Scene *newsce)
624 {
625         Scene *sce1;
626         bScreen *sc;
627
628         /* check all sets */
629         for(sce1= bmain->scene.first; sce1; sce1= sce1->id.next)
630                 if(sce1->set == sce)
631                         sce1->set= NULL;
632         
633         /* check all sequences */
634         clear_scene_in_allseqs(bmain, sce);
635
636         /* check render layer nodes in other scenes */
637         clear_scene_in_nodes(bmain, sce);
638         
639         /* al screens */
640         for(sc= bmain->screen.first; sc; sc= sc->id.next)
641                 if(sc->scene == sce)
642                         sc->scene= newsce;
643
644         free_libblock(&bmain->scene, sce);
645 }
646
647 /* used by metaballs
648  * doesnt return the original duplicated object, only dupli's
649  */
650 int next_object(Scene **scene, int val, Base **base, Object **ob)
651 {
652         static ListBase *duplilist= NULL;
653         static DupliObject *dupob;
654         static int fase= F_START, in_next_object= 0;
655         int run_again=1;
656         
657         /* init */
658         if(val==0) {
659                 fase= F_START;
660                 dupob= NULL;
661                 
662                 /* XXX particle systems with metas+dupligroups call this recursively */
663                 /* see bug #18725 */
664                 if(in_next_object) {
665                         printf("ERROR: MetaBall generation called recursively, not supported\n");
666                         
667                         return F_ERROR;
668                 }
669         }
670         else {
671                 in_next_object= 1;
672                 
673                 /* run_again is set when a duplilist has been ended */
674                 while(run_again) {
675                         run_again= 0;
676
677                         /* the first base */
678                         if(fase==F_START) {
679                                 *base= (*scene)->base.first;
680                                 if(*base) {
681                                         *ob= (*base)->object;
682                                         fase= F_SCENE;
683                                 }
684                                 else {
685                                         /* exception: empty scene */
686                                         while((*scene)->set) {
687                                                 (*scene)= (*scene)->set;
688                                                 if((*scene)->base.first) {
689                                                         *base= (*scene)->base.first;
690                                                         *ob= (*base)->object;
691                                                         fase= F_SCENE;
692                                                         break;
693                                                 }
694                                         }
695                                 }
696                         }
697                         else {
698                                 if(*base && fase!=F_DUPLI) {
699                                         *base= (*base)->next;
700                                         if(*base) *ob= (*base)->object;
701                                         else {
702                                                 if(fase==F_SCENE) {
703                                                         /* (*scene) is finished, now do the set */
704                                                         while((*scene)->set) {
705                                                                 (*scene)= (*scene)->set;
706                                                                 if((*scene)->base.first) {
707                                                                         *base= (*scene)->base.first;
708                                                                         *ob= (*base)->object;
709                                                                         break;
710                                                                 }
711                                                         }
712                                                 }
713                                         }
714                                 }
715                         }
716                         
717                         if(*base == NULL) fase= F_START;
718                         else {
719                                 if(fase!=F_DUPLI) {
720                                         if( (*base)->object->transflag & OB_DUPLI) {
721                                                 /* groups cannot be duplicated for mballs yet, 
722                                                 this enters eternal loop because of 
723                                                 makeDispListMBall getting called inside of group_duplilist */
724                                                 if((*base)->object->dup_group == NULL) {
725                                                         duplilist= object_duplilist((*scene), (*base)->object);
726                                                         
727                                                         dupob= duplilist->first;
728
729                                                         if(!dupob)
730                                                                 free_object_duplilist(duplilist);
731                                                 }
732                                         }
733                                 }
734                                 /* handle dupli's */
735                                 if(dupob) {
736                                         
737                                         copy_m4_m4(dupob->ob->obmat, dupob->mat);
738                                         
739                                         (*base)->flag |= OB_FROMDUPLI;
740                                         *ob= dupob->ob;
741                                         fase= F_DUPLI;
742                                         
743                                         dupob= dupob->next;
744                                 }
745                                 else if(fase==F_DUPLI) {
746                                         fase= F_SCENE;
747                                         (*base)->flag &= ~OB_FROMDUPLI;
748                                         
749                                         for(dupob= duplilist->first; dupob; dupob= dupob->next) {
750                                                 copy_m4_m4(dupob->ob->obmat, dupob->omat);
751                                         }
752                                         
753                                         free_object_duplilist(duplilist);
754                                         duplilist= NULL;
755                                         run_again= 1;
756                                 }
757                         }
758                 }
759         }
760         
761         /* if(ob && *ob) {
762                 printf("Scene: '%s', '%s'\n", (*scene)->id.name+2, (*ob)->id.name+2);
763         } */
764
765         /* reset recursion test */
766         in_next_object= 0;
767         
768         return fase;
769 }
770
771 Object *scene_find_camera(Scene *sc)
772 {
773         Base *base;
774         
775         for (base= sc->base.first; base; base= base->next)
776                 if (base->object->type==OB_CAMERA)
777                         return base->object;
778
779         return NULL;
780 }
781
782 #ifdef DURIAN_CAMERA_SWITCH
783 Object *scene_camera_switch_find(Scene *scene)
784 {
785         TimeMarker *m;
786         int cfra = scene->r.cfra;
787         int frame = -(MAXFRAME + 1);
788         Object *camera= NULL;
789
790         for (m= scene->markers.first; m; m= m->next) {
791                 if(m->camera && (m->camera->restrictflag & OB_RESTRICT_RENDER)==0 && (m->frame <= cfra) && (m->frame > frame)) {
792                         camera= m->camera;
793                         frame= m->frame;
794
795                         if(frame == cfra)
796                                 break;
797
798                 }
799         }
800         return camera;
801 }
802 #endif
803
804 int scene_camera_switch_update(Scene *scene)
805 {
806 #ifdef DURIAN_CAMERA_SWITCH
807         Object *camera= scene_camera_switch_find(scene);
808         if(camera) {
809                 scene->camera= camera;
810                 return 1;
811         }
812 #else
813         (void)scene;
814 #endif
815         return 0;
816 }
817
818 char *scene_find_marker_name(Scene *scene, int frame)
819 {
820         ListBase *markers= &scene->markers;
821         TimeMarker *m1, *m2;
822
823         /* search through markers for match */
824         for (m1=markers->first, m2=markers->last; m1 && m2; m1=m1->next, m2=m2->prev) {
825                 if (m1->frame==frame)
826                         return m1->name;
827
828                 if (m1 == m2)
829                         break;
830
831                 if (m2->frame==frame)
832                         return m2->name;
833         }
834
835         return NULL;
836 }
837
838 /* return the current marker for this frame,
839 we can have more then 1 marker per frame, this just returns the first :/ */
840 char *scene_find_last_marker_name(Scene *scene, int frame)
841 {
842         TimeMarker *marker, *best_marker = NULL;
843         int best_frame = -MAXFRAME*2;
844         for (marker= scene->markers.first; marker; marker= marker->next) {
845                 if (marker->frame==frame) {
846                         return marker->name;
847                 }
848
849                 if ( marker->frame > best_frame && marker->frame < frame) {
850                         best_marker = marker;
851                         best_frame = marker->frame;
852                 }
853         }
854
855         return best_marker ? best_marker->name : NULL;
856 }
857
858
859 Base *scene_add_base(Scene *sce, Object *ob)
860 {
861         Base *b= MEM_callocN(sizeof(*b), "scene_add_base");
862         BLI_addhead(&sce->base, b);
863
864         b->object= ob;
865         b->flag= ob->flag;
866         b->lay= ob->lay;
867
868         return b;
869 }
870
871 void scene_deselect_all(Scene *sce)
872 {
873         Base *b;
874
875         for (b= sce->base.first; b; b= b->next) {
876                 b->flag&= ~SELECT;
877                 b->object->flag= b->flag;
878         }
879 }
880
881 void scene_select_base(Scene *sce, Base *selbase)
882 {
883         scene_deselect_all(sce);
884
885         selbase->flag |= SELECT;
886         selbase->object->flag= selbase->flag;
887
888         sce->basact= selbase;
889 }
890
891 /* checks for cycle, returns 1 if it's all OK */
892 int scene_check_setscene(Main *bmain, Scene *sce)
893 {
894         Scene *scene;
895         int a, totscene;
896         
897         if(sce->set==NULL) return 1;
898         
899         totscene= 0;
900         for(scene= bmain->scene.first; scene; scene= scene->id.next)
901                 totscene++;
902         
903         for(a=0, scene=sce; scene->set; scene=scene->set, a++) {
904                 /* more iterations than scenes means we have a cycle */
905                 if(a > totscene) {
906                         /* the tested scene gets zero'ed, that's typically current scene */
907                         sce->set= NULL;
908                         return 0;
909                 }
910         }
911
912         return 1;
913 }
914
915 /* This function is needed to cope with fractional frames - including two Blender rendering features
916  * mblur (motion blur that renders 'subframes' and blurs them together), and fields rendering. 
917  */
918 float BKE_curframe(Scene *scene)
919 {
920         return BKE_frame_to_ctime(scene, scene->r.cfra);
921 }
922
923 /* This function is used to obtain arbitrary fractional frames */
924 float BKE_frame_to_ctime(Scene *scene, const float frame)
925 {
926         float ctime = frame;
927         ctime += scene->r.subframe;
928         ctime *= scene->r.framelen;     
929         
930         return ctime;
931 }
932
933 /* drivers support/hacks 
934  *      - this method is called from scene_update_tagged_recursive(), so gets included in viewport + render
935  *      - these are always run since the depsgraph can't handle non-object data
936  *      - these happen after objects are all done so that we can read in their final transform values,
937  *        though this means that objects can't refer to scene info for guidance...
938  */
939 static void scene_update_drivers(Main *UNUSED(bmain), Scene *scene)
940 {
941         float ctime = BKE_curframe(scene);
942         
943         /* scene itself */
944         if (scene->adt && scene->adt->drivers.first) {
945                 BKE_animsys_evaluate_animdata(scene, &scene->id, scene->adt, ctime, ADT_RECALC_DRIVERS);
946         }
947         
948         /* world */
949         // TODO: what about world textures? but then those have nodes too...
950         if (scene->world) {
951                 ID *wid = (ID *)scene->world;
952                 AnimData *adt= BKE_animdata_from_id(wid);
953                 
954                 if (adt && adt->drivers.first)
955                         BKE_animsys_evaluate_animdata(scene, wid, adt, ctime, ADT_RECALC_DRIVERS);
956         }
957         
958         /* nodes */
959         if (scene->nodetree) {
960                 ID *nid = (ID *)scene->nodetree;
961                 AnimData *adt= BKE_animdata_from_id(nid);
962                 
963                 if (adt && adt->drivers.first)
964                         BKE_animsys_evaluate_animdata(scene, nid, adt, ctime, ADT_RECALC_DRIVERS);
965         }
966 }
967
968 static void scene_update_tagged_recursive(Main *bmain, Scene *scene, Scene *scene_parent)
969 {
970         Base *base;
971         
972         
973         scene->customdata_mask= scene_parent->customdata_mask;
974
975         /* sets first, we allow per definition current scene to have
976            dependencies on sets, but not the other way around. */
977         if (scene->set)
978                 scene_update_tagged_recursive(bmain, scene->set, scene_parent);
979         
980         /* scene objects */
981         for (base= scene->base.first; base; base= base->next) {
982                 Object *ob= base->object;
983                 
984                 object_handle_update(scene_parent, ob);
985                 
986                 if(ob->dup_group && (ob->transflag & OB_DUPLIGROUP))
987                         group_handle_recalc_and_update(scene_parent, ob, ob->dup_group);
988                         
989                 /* always update layer, so that animating layers works */
990                 base->lay= ob->lay;
991         }
992         
993         /* scene drivers... */
994         scene_update_drivers(bmain, scene);
995
996         /* update sound system animation */
997         sound_update_scene(scene);
998 }
999
1000 /* this is called in main loop, doing tagged updates before redraw */
1001 void scene_update_tagged(Main *bmain, Scene *scene)
1002 {
1003         /* keep this first */
1004         BLI_exec_cb(bmain, &scene->id, BLI_CB_EVT_SCENE_UPDATE_PRE);
1005
1006         /* flush recalc flags to dependencies */
1007         DAG_ids_flush_tagged(bmain);
1008
1009         scene->physics_settings.quick_cache_step= 0;
1010
1011         /* update all objects: drivers, matrices, displists, etc. flags set
1012            by depgraph or manual, no layer check here, gets correct flushed
1013
1014            in the future this should handle updates for all datablocks, not
1015            only objects and scenes. - brecht */
1016         scene_update_tagged_recursive(bmain, scene, scene);
1017
1018         /* extra call here to recalc scene animation (for sequencer) */
1019         {
1020                 AnimData *adt= BKE_animdata_from_id(&scene->id);
1021                 float ctime = BKE_curframe(scene);
1022                 
1023                 if (adt && (adt->recalc & ADT_RECALC_ANIM))
1024                         BKE_animsys_evaluate_animdata(scene, &scene->id, adt, ctime, 0);
1025         }
1026         
1027         /* quick point cache updates */
1028         if (scene->physics_settings.quick_cache_step)
1029                 BKE_ptcache_quick_cache_all(bmain, scene);
1030
1031         /* notify editors about recalc */
1032         DAG_ids_check_recalc(bmain);
1033
1034         /* keep this last */
1035         BLI_exec_cb(bmain, &scene->id, BLI_CB_EVT_SCENE_UPDATE_POST);
1036 }
1037
1038 void scene_clear_tagged(Main *bmain, Scene *UNUSED(scene))
1039 {
1040         DAG_ids_clear_recalc(bmain);
1041 }
1042
1043 /* applies changes right away, does all sets too */
1044 void scene_update_for_newframe(Main *bmain, Scene *sce, unsigned int lay)
1045 {
1046         float ctime = BKE_curframe(sce);
1047         Scene *sce_iter;
1048
1049         /* keep this first */
1050         BLI_exec_cb(bmain, &sce->id, BLI_CB_EVT_FRAME_CHANGE_PRE);
1051         BLI_exec_cb(bmain, &sce->id, BLI_CB_EVT_SCENE_UPDATE_PRE);
1052
1053         sound_set_cfra(sce->r.cfra);
1054         
1055         /* clear animation overrides */
1056         // XXX TODO...
1057
1058         for(sce_iter= sce; sce_iter; sce_iter= sce_iter->set) {
1059                 if(sce_iter->theDag==NULL)
1060                         DAG_scene_sort(bmain, sce_iter);
1061         }
1062
1063         /* flush recalc flags to dependencies, if we were only changing a frame
1064            this would not be necessary, but if a user or a script has modified
1065            some datablock before scene_update_tagged was called, we need the flush */
1066         DAG_ids_flush_tagged(bmain);
1067
1068         /* Following 2 functions are recursive
1069          * so dont call within 'scene_update_tagged_recursive' */
1070         DAG_scene_update_flags(bmain, sce, lay, TRUE);   // only stuff that moves or needs display still
1071
1072         /* All 'standard' (i.e. without any dependencies) animation is handled here,
1073          * with an 'local' to 'macro' order of evaluation. This should ensure that
1074          * settings stored nestled within a hierarchy (i.e. settings in a Texture block
1075          * can be overridden by settings from Scene, which owns the Texture through a hierarchy
1076          * such as Scene->World->MTex/Texture) can still get correctly overridden.
1077          */
1078         BKE_animsys_evaluate_all_animation(bmain, sce, ctime);
1079         /*...done with recusrive funcs */
1080
1081         /* object_handle_update() on all objects, groups and sets */
1082         scene_update_tagged_recursive(bmain, sce, sce);
1083
1084         /* keep this last */
1085         BLI_exec_cb(bmain, &sce->id, BLI_CB_EVT_SCENE_UPDATE_POST);
1086         BLI_exec_cb(bmain, &sce->id, BLI_CB_EVT_FRAME_CHANGE_POST);
1087
1088         DAG_ids_clear_recalc(bmain);
1089 }
1090
1091 /* return default layer, also used to patch old files */
1092 SceneRenderLayer *scene_add_render_layer(Scene *sce, const char *name)
1093 {
1094         SceneRenderLayer *srl;
1095
1096         if(!name)
1097                 name= "RenderLayer";
1098
1099         srl= MEM_callocN(sizeof(SceneRenderLayer), "new render layer");
1100         BLI_strncpy(srl->name, name, sizeof(srl->name));
1101         BLI_uniquename(&sce->r.layers, srl, "RenderLayer", '.', offsetof(SceneRenderLayer, name), sizeof(srl->name));
1102         BLI_addtail(&sce->r.layers, srl);
1103
1104         /* note, this is also in render, pipeline.c, to make layer when scenedata doesnt have it */
1105         srl->lay= (1<<20) -1;
1106         srl->layflag= 0x7FFF;   /* solid ztra halo edge strand */
1107         srl->passflag= SCE_PASS_COMBINED|SCE_PASS_Z;
1108
1109         return srl;
1110 }
1111
1112 int scene_remove_render_layer(Main *bmain, Scene *scene, SceneRenderLayer *srl)
1113 {
1114         const int act= BLI_findindex(&scene->r.layers, srl);
1115         Scene *sce;
1116
1117         if (act == -1) {
1118                 return 0;
1119         }
1120         else if ( (scene->r.layers.first == scene->r.layers.last) &&
1121                   (scene->r.layers.first == srl))
1122         {
1123                 /* ensure 1 layer is kept */
1124                 return 0;
1125         }
1126
1127         BLI_remlink(&scene->r.layers, srl);
1128         MEM_freeN(srl);
1129
1130         scene->r.actlay= 0;
1131
1132         for(sce = bmain->scene.first; sce; sce = sce->id.next) {
1133                 if(sce->nodetree) {
1134                         bNode *node;
1135                         for(node = sce->nodetree->nodes.first; node; node = node->next) {
1136                                 if(node->type==CMP_NODE_R_LAYERS && (Scene*)node->id==scene) {
1137                                         if(node->custom1==act)
1138                                                 node->custom1= 0;
1139                                         else if(node->custom1>act)
1140                                                 node->custom1--;
1141                                 }
1142                         }
1143                 }
1144         }
1145
1146         return 1;
1147 }
1148
1149 /* render simplification */
1150
1151 int get_render_subsurf_level(RenderData *r, int lvl)
1152 {
1153         if(r->mode & R_SIMPLIFY)
1154                 return MIN2(r->simplify_subsurf, lvl);
1155         else
1156                 return lvl;
1157 }
1158
1159 int get_render_child_particle_number(RenderData *r, int num)
1160 {
1161         if(r->mode & R_SIMPLIFY)
1162                 return (int)(r->simplify_particles*num);
1163         else
1164                 return num;
1165 }
1166
1167 int get_render_shadow_samples(RenderData *r, int samples)
1168 {
1169         if((r->mode & R_SIMPLIFY) && samples > 0)
1170                 return MIN2(r->simplify_shadowsamples, samples);
1171         else
1172                 return samples;
1173 }
1174
1175 float get_render_aosss_error(RenderData *r, float error)
1176 {
1177         if(r->mode & R_SIMPLIFY)
1178                 return ((1.0f-r->simplify_aosss)*10.0f + 1.0f)*error;
1179         else
1180                 return error;
1181 }
1182
1183 /* helper function for the SETLOOPER macro */
1184 Base *_setlooper_base_step(Scene **sce_iter, Base *base)
1185 {
1186         if(base && base->next) {
1187                 /* common case, step to the next */
1188                 return base->next;
1189         }
1190         else if(base==NULL && (*sce_iter)->base.first) {
1191                 /* first time looping, return the scenes first base */
1192                 return (Base *)(*sce_iter)->base.first;
1193         }
1194         else {
1195                 /* reached the end, get the next base in the set */
1196                 while((*sce_iter= (*sce_iter)->set)) {
1197                         base= (Base *)(*sce_iter)->base.first;
1198                         if(base) {
1199                                 return base;
1200                         }
1201                 }
1202         }
1203
1204         return NULL;
1205 }
1206
1207 int scene_use_new_shading_nodes(Scene *scene)
1208 {
1209         RenderEngineType *type= RE_engines_find(scene->r.engine);
1210         return (type && type->flag & RE_USE_SHADING_NODES);
1211 }
1212