synched with trunk at revision 30243
[blender.git] / source / blender / blenkernel / intern / scene.c
index f4e6af9..8c950fb 100644 (file)
@@ -44,6 +44,7 @@
 #include "DNA_group_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
+#include "DNA_sequence_types.h"
 
 #include "BKE_anim.h"
 #include "BKE_animsys.h"
@@ -197,6 +198,10 @@ Scene *copy_scene(Main *bmain, Scene *sce, int type)
                scen->r.qtcodecdata->cdParms = MEM_dupallocN(scen->r.qtcodecdata->cdParms);
        }
        
+       if(sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
+               scen->r.ffcodecdata.properties= IDP_CopyProperty(sce->r.ffcodecdata.properties);
+       }
+
        /* NOTE: part of SCE_COPY_LINK_DATA and SCE_COPY_FULL operations
         * are done outside of blenkernel with ED_objects_single_users! */
 
@@ -211,6 +216,12 @@ Scene *copy_scene(Main *bmain, Scene *sce, int type)
                        id_us_plus((ID *)scen->world);
                        scen->world= copy_world(scen->world);
                }
+
+               if(sce->ed) {
+                       scen->ed= MEM_callocN( sizeof(Editing), "addseq");
+                       scen->ed->seqbasep= &scen->ed->seqbase;
+                       seqbase_dupli_recursive(sce, &scen->ed->seqbase, &sce->ed->seqbase, SEQ_DUPE_ALL);
+               }
        }
 
        sound_create_scene(scen);
@@ -310,7 +321,7 @@ Scene *add_scene(char *name)
        int a;
 
        sce= alloc_libblock(&G.main->scene, ID_SCE, name);
-       sce->lay= 1;
+       sce->lay= sce->layact= 1;
        
        sce->r.mode= R_GAMMA|R_OSA|R_SHADOW|R_SSS|R_ENVMAP|R_RAYTRACE;
        sce->r.cfra= 1;
@@ -559,18 +570,17 @@ void set_scene_bg(Scene *scene)
 }
 
 /* called from creator.c */
-void set_scene_name(char *name)
+Scene *set_scene_name(char *name)
 {
-       Scene *sce;
-
-       for (sce= G.main->scene.first; sce; sce= sce->id.next) {
-               if (BLI_streq(name, sce->id.name+2)) {
-                       set_scene_bg(sce);
-                       return;
-               }
+       Scene *sce= (Scene *)find_id("SC", name);
+       if(sce) {
+               set_scene_bg(sce);
+               printf("Scene switch: '%s' in file: '%s'\n", name, G.sce);
+               return sce;
        }
-       
-       //XXX error("Can't find scene: %s", name);
+
+       printf("Can't find scene: '%s' in file: '%s'\n", name, G.sce);
+       return NULL;
 }
 
 void unlink_scene(Main *bmain, Scene *sce, Scene *newsce)
@@ -885,87 +895,54 @@ int scene_check_setscene(Scene *sce)
        return 1;
 }
 
-/* This (evil) function is needed to cope with two legacy Blender rendering features
-* mblur (motion blur that renders 'subframes' and blurs them together), and fields 
-* rendering. Thus, the use of ugly globals from object.c
-*/
-// BAD... EVIL... JUJU...!!!!
-// XXX moved here temporarily
-float frame_to_float (Scene *scene, int cfra)          /* see also bsystem_time in object.c */
+/* This function is needed to cope with fractional frames - including two Blender rendering features
+* mblur (motion blur that renders 'subframes' and blurs them together), and fields rendering. */
+
+/* see also bsystem_time in object.c */
+float BKE_curframe(Scene *scene)
 {
-       extern float bluroffs;  /* bad stuff borrowed from object.c */
-       extern float fieldoffs;
-       float ctime;
-       
-       ctime= (float)cfra;
-       ctime+= bluroffs+fieldoffs;
-       ctime*= scene->r.framelen;
-       
+       float ctime = scene->r.cfra;
+       ctime+= scene->r.subframe;
+       ctime*= scene->r.framelen;      
+
        return ctime;
 }
 
-static void scene_update_newframe(Scene *scene, int cfra, unsigned int lay)
+static void scene_update_tagged_recursive(Scene *scene, Scene *scene_parent)
 {
        Base *base;
-       Object *ob;
-       int cfra_back= scene->r.cfra;
-       scene->r.cfra= cfra;
-       
+
+       /* sets first, we allow per definition current scene to have
+          dependencies on sets, but not the other way around. */
+       if(scene->set)
+               scene_update_tagged_recursive(scene->set, scene_parent);
+
        for(base= scene->base.first; base; base= base->next) {
-               ob= base->object;
-               
-               object_handle_update(scene, ob);   // bke_object.h
+               Object *ob= base->object;
+
+               object_handle_update(scene_parent, ob);
 
                if(ob->dup_group && (ob->transflag & OB_DUPLIGROUP))
-                       group_handle_recalc_and_update(scene, ob, ob->dup_group);
-               
-               /* only update layer when an ipo */
-                       // XXX old animation system
-               //if(ob->ipo && has_ipo_code(ob->ipo, OB_LAY) ) {
-               //      base->lay= ob->lay;
-               //}
+                       group_handle_recalc_and_update(scene_parent, ob, ob->dup_group);
+                       
+               /* always update layer, so that animating layers works */
+               base->lay= ob->lay;
        }
-
-       scene->r.cfra= cfra_back;
 }
 
 /* this is called in main loop, doing tagged updates before redraw */
 void scene_update_tagged(Scene *scene)
 {
-       Scene *sce;
-       Base *base;
-       Object *ob;
-       float ctime = frame_to_float(scene, scene->r.cfra); 
-
        scene->physics_settings.quick_cache_step= 0;
 
        /* update all objects: drivers, matrices, displists, etc. flags set
           by depgraph or manual, no layer check here, gets correct flushed */
 
-       /* sets first, we allow per definition current scene to have
-          dependencies on sets, but not the other way around. */
-       if(scene->set) {
-               for(SETLOOPER(scene->set, base)) {
-                       ob= base->object;
-
-                       object_handle_update(scene, ob);
-
-                       if(ob->dup_group && (ob->transflag & OB_DUPLIGROUP))
-                               group_handle_recalc_and_update(scene, ob, ob->dup_group);
-               }
-       }
-       
-       for(base= scene->base.first; base; base= base->next) {
-               ob= base->object;
-
-               object_handle_update(scene, ob);
-
-               if(ob->dup_group && (ob->transflag & OB_DUPLIGROUP))
-                       group_handle_recalc_and_update(scene, ob, ob->dup_group);
-       }
+       scene_update_tagged_recursive(scene, scene);
 
        /* recalc scene animation data here (for sequencer) */
        {
+               float ctime = BKE_curframe(scene); 
                AnimData *adt= BKE_animdata_from_id(&scene->id);
 
                if(adt && (adt->recalc & ADT_RECALC_ANIM))
@@ -982,7 +959,7 @@ void scene_update_tagged(Scene *scene)
 /* applies changes right away, does all sets too */
 void scene_update_for_newframe(Scene *sce, unsigned int lay)
 {
-       float ctime = frame_to_float(sce, sce->r.cfra);
+       float ctime = BKE_curframe(sce);
        Scene *sce_iter;
        
        /* clear animation overrides */
@@ -995,7 +972,7 @@ void scene_update_for_newframe(Scene *sce, unsigned int lay)
 
 
        /* Following 2 functions are recursive
-        * so dont call within 'scene_update_newframe' */
+        * so dont call within 'scene_update_tagged_recursive' */
        DAG_scene_update_flags(sce, lay);   // only stuff that moves or needs display still
 
        /* All 'standard' (i.e. without any dependencies) animation is handled here,
@@ -1007,13 +984,8 @@ void scene_update_for_newframe(Scene *sce, unsigned int lay)
        BKE_animsys_evaluate_all_animation(G.main, ctime);
        /*...done with recusrive funcs */
 
-
-       /* sets first, we allow per definition current scene to have dependencies on sets */
-       for(sce_iter= sce->set; sce_iter; sce_iter= sce_iter->set) {
-               scene_update_newframe(sce_iter, sce->r.cfra, lay);
-    }
-
-       scene_update_newframe(sce, sce->r.cfra, lay);
+       /* object_handle_update() on all objects, groups and sets */
+       scene_update_tagged_recursive(sce, sce);
 }
 
 /* return default layer, also used to patch old files */