Merge branch 'master' into blender2.8
authorBastien Montagne <montagne29@wanadoo.fr>
Thu, 14 Jun 2018 13:55:51 +0000 (15:55 +0200)
committerBastien Montagne <montagne29@wanadoo.fr>
Thu, 14 Jun 2018 13:55:51 +0000 (15:55 +0200)
Conflicts:
source/blender/collada/AnimationExporter.cpp
source/blender/collada/AnimationExporter.h
source/blender/collada/ArmatureImporter.cpp
source/blender/collada/ArmatureImporter.h
source/blender/collada/ControllerExporter.cpp
source/blender/collada/ControllerExporter.h
source/blender/collada/DocumentExporter.cpp
source/blender/collada/DocumentImporter.cpp
source/blender/collada/GeometryExporter.cpp
source/blender/collada/GeometryExporter.h
source/blender/collada/MeshImporter.cpp
source/blender/collada/MeshImporter.h
source/blender/collada/SkinInfo.cpp
source/blender/collada/SkinInfo.h
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h

16 files changed:
1  2 
source/blender/collada/AnimationExporter.cpp
source/blender/collada/AnimationExporter.h
source/blender/collada/ArmatureImporter.cpp
source/blender/collada/ArmatureImporter.h
source/blender/collada/ControllerExporter.cpp
source/blender/collada/ControllerExporter.h
source/blender/collada/DocumentExporter.cpp
source/blender/collada/DocumentImporter.cpp
source/blender/collada/GeometryExporter.cpp
source/blender/collada/GeometryExporter.h
source/blender/collada/MeshImporter.cpp
source/blender/collada/MeshImporter.h
source/blender/collada/SkinInfo.cpp
source/blender/collada/SkinInfo.h
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h

@@@ -214,7 -215,7 +215,7 @@@ void AnimationExporter::export_sampled_
        for (std::vector<float>::iterator ctime = ctimes.begin(); ctime != ctimes.end(); ++ctime) {
                float fmat[4][4];
  
-               bc_update_scene(depsgraph, scene, *ctime);
 -              bc_update_scene(m_bmain, scene, *ctime);
++              bc_update_scene(m_bmain, depsgraph, scene, *ctime);
                BKE_object_matrix_local_get(ob, fmat);
                if (this->export_settings->limit_precision)
                        bc_sanitize_mat(fmat, 6);
@@@ -246,7 -247,7 +247,7 @@@ void AnimationExporter::export_sampled_
                float fsize[3];
                float feul[3];
  
-               bc_update_scene(depsgraph, scene, *ctime);
 -              bc_update_scene(m_bmain, scene, *ctime);
++              bc_update_scene(m_bmain, depsgraph, scene, *ctime);
                BKE_object_matrix_local_get(ob, fmat);
                mat4_decompose(floc, fquat, fsize, fmat);
                quat_to_eul(feul, fquat);
@@@ -1315,16 -1316,15 +1316,16 @@@ std::string AnimationExporter::create_4
                float frame = *it;
  
                float ctime = BKE_scene_frame_get_from_ctime(scene, frame);
-               bc_update_scene(depsgraph, scene, ctime);
 -              bc_update_scene(m_bmain, scene, ctime);
++              bc_update_scene(m_bmain, depsgraph, scene, ctime);
                if (is_bone_animation) {
 +
                        if (pchan->flag & POSE_CHAIN) {
                                enable_fcurves(ob->adt->action, NULL);
 -                              BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, ctime, ADT_RECALC_ALL);
 -                              BKE_pose_where_is(scene, ob);
 +                              BKE_animsys_evaluate_animdata(depsgraph, scene, &ob->id, ob->adt, ctime, ADT_RECALC_ALL);
 +                              BKE_pose_where_is(depsgraph, scene, ob);
                        }
                        else {
 -                              BKE_pose_where_is_bone(scene, ob, pchan, ctime, 1);
 +                              BKE_pose_where_is_bone(depsgraph, scene, ob, pchan, ctime, 1);
                        }
  
                        // compute bone local mat
@@@ -84,8 -84,8 +84,9 @@@ struct Depsgraph
  class AnimationExporter: COLLADASW::LibraryAnimations
  {
  private:
+       Main *m_bmain;
        Scene *scene;
 +      Depsgraph *depsgraph;
        COLLADASW::StreamWriter *sw;
  
  public:
@@@ -55,10 -54,10 +55,12 @@@ static const char *bc_get_joint_name(T 
  }
  
  
- ArmatureImporter::ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, Scene *sce, ViewLayer *view_layer, const ImportSettings *import_settings) :
 -ArmatureImporter::ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, Main *bmain, Scene *sce, const ImportSettings *import_settings) :
++ArmatureImporter::ArmatureImporter(
++        UnitConverter *conv, MeshImporterBase *mesh, Main *bmain, Scene *sce, ViewLayer *view_layer, const ImportSettings *import_settings) :
        TransformReader(conv),
+       m_bmain(bmain),
        scene(sce),
 +      view_layer(view_layer),
        unit_converter(conv),
        import_settings(import_settings),
        empty(NULL),
@@@ -411,7 -410,7 +413,7 @@@ Object *ArmatureImporter::get_empty_for
  {
        if (empty) return empty;
  
-       empty = bc_add_object(scene, view_layer, OB_EMPTY, NULL);
 -      empty = bc_add_object(m_bmain, scene, OB_EMPTY, NULL);
++      empty = bc_add_object(m_bmain, scene, view_layer, OB_EMPTY, NULL);
        empty->empty_drawtype = OB_EMPTY_SPHERE;
  
        return empty;
@@@ -586,7 -585,7 +588,7 @@@ Object *ArmatureImporter::create_armatu
                ob_arm = skin.set_armature(shared);
        }
        else {
-               ob_arm = skin.create_armature(scene, view_layer);  //once for every armature
 -              ob_arm = skin.create_armature(m_bmain, scene);  //once for every armature
++              ob_arm = skin.create_armature(m_bmain, scene, view_layer);  //once for every armature
        }
  
        // enter armature edit mode
@@@ -62,8 -62,8 +62,9 @@@ extern "C" 
  class ArmatureImporter : private TransformReader
  {
  private:
+       Main *m_bmain;
        Scene *scene;
 +      ViewLayer *view_layer;
        UnitConverter *unit_converter;
        const ImportSettings *import_settings;
  
        TagsMap uid_tags_map;
  public:
  
-       ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, Scene *sce, ViewLayer *view_layer, const ImportSettings *import_settings);
 -      ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, Main *bmain, Scene *sce, const ImportSettings *import_settings);
++      ArmatureImporter(
++              UnitConverter *conv, MeshImporterBase *mesh, Main *bmain, Scene *sce, ViewLayer *view_layer, const ImportSettings *import_settings);
        ~ArmatureImporter();
  
        void add_root_joint(COLLADAFW::Node *node, Object *parent);
@@@ -104,9 -107,9 +104,10 @@@ bool ControllerExporter::add_instance_c
        return true;
  }
  
- void ControllerExporter::export_controllers(struct Depsgraph *depsgraph, Scene *sce)
 -void ControllerExporter::export_controllers(Main *bmain, Scene *sce)
++void ControllerExporter::export_controllers(Main *bmain, Depsgraph *depsgraph, Scene *sce)
  {
 +      this->depsgraph = depsgraph;
+       m_bmain = bmain;
        scene = sce;
  
        openLibrary();
@@@ -198,7 -201,9 +199,10 @@@ void ControllerExporter::export_skin_co
        bool use_instantiation = this->export_settings->use_object_instantiation;
        Mesh *me;
  
-       me = bc_get_mesh_copy(depsgraph, scene,
+       me = bc_get_mesh_copy(
+                               m_bmain,
++                              depsgraph,
+                               scene,
                                ob,
                                this->export_settings->export_mesh_type,
                                this->export_settings->apply_modifiers,
@@@ -300,7 -305,9 +304,10 @@@ void ControllerExporter::export_morph_c
        bool use_instantiation = this->export_settings->use_object_instantiation;
        Mesh *me;
  
-       me = bc_get_mesh_copy(depsgraph, scene,
+       me = bc_get_mesh_copy(
+                               m_bmain,
++                              depsgraph,
+                               scene,
                                ob,
                                this->export_settings->export_mesh_type,
                                this->export_settings->apply_modifiers,
@@@ -66,12 -65,12 +66,13 @@@ public
  
        bool add_instance_controller(Object *ob);
  
-       void export_controllers(struct Depsgraph *depsgraph, Scene *sce);
 -      void export_controllers(Main *bmain, Scene *sce);
++      void export_controllers(Main *bmain, Depsgraph *depsgraph, Scene *sce);
  
        void operator()(Object *ob);
  
  private:
-       struct Depsgraph *depsgraph;
++      Depsgraph *depsgraph;
+       Main *m_bmain;
        Scene *scene;
        UnitConverter converter;
        const ExportSettings *export_settings;
@@@ -180,8 -181,9 +180,9 @@@ static COLLADABU::NativeString make_tem
  // COLLADA allows this through multiple <channel>s in <animation>.
  // For this to work, we need to know objects that use a certain action.
  
 -int DocumentExporter::exportCurrentScene(bContext *C, const EvaluationContext *eval_ctx, Scene *sce)
 +int DocumentExporter::exportCurrentScene(bContext *C, Scene *sce)
  {
+       Main *bmain = CTX_data_main(C);
        PointerRNA sceneptr, unit_settings;
        PropertyRNA *system; /* unused , *scale; */
  
        // <library_geometries>
        if (bc_has_object_type(export_set, OB_MESH)) {
                GeometryExporter ge(writer, this->export_settings);
-               ge.exportGeom(depsgraph, sce);
 -              ge.exportGeom(bmain, sce);
++              ge.exportGeom(bmain, depsgraph, sce);
        }
  
        // <library_controllers>
        ControllerExporter controller_exporter(writer, this->export_settings);
        if (bc_has_object_type(export_set, OB_ARMATURE) || this->export_settings->include_shapekeys)
        {
-               controller_exporter.export_controllers(depsgraph, sce);
 -              controller_exporter.export_controllers(bmain, sce);
++              controller_exporter.export_controllers(bmain, depsgraph, sce);
        }
  
        // <library_visual_scenes>
  
        if (this->export_settings->include_animations) {
                // <library_animations>
 -              AnimationExporter ae(writer, this->export_settings);
 +              AnimationExporter ae(depsgraph, writer, this->export_settings);
-               ae.exportAnimations(sce);
+               ae.exportAnimations(bmain, sce);
        }
 -      se.exportScene(C, sce);
 +      se.exportScene(C, depsgraph, sce);
  
        // <scene>
        std::string scene_name(translate_id(id_name(sce)));
@@@ -107,9 -104,8 +107,9 @@@ DocumentImporter::DocumentImporter(bCon
        import_settings(import_settings),
        mImportStage(General),
        mContext(C),
 -      armature_importer(&unit_converter, &mesh_importer, CTX_data_main(C), CTX_data_scene(C), import_settings),
 -      mesh_importer(&unit_converter, &armature_importer, CTX_data_main(C), CTX_data_scene(C)),
 +      view_layer(CTX_data_view_layer(mContext)),
-       armature_importer(&unit_converter, &mesh_importer, CTX_data_scene(C), view_layer, import_settings),
-       mesh_importer(&unit_converter, &armature_importer, CTX_data_scene(C), view_layer),
++      armature_importer(&unit_converter, &mesh_importer, CTX_data_main(C), CTX_data_scene(C), view_layer, import_settings),
++      mesh_importer(&unit_converter, &armature_importer, CTX_data_main(C), CTX_data_scene(C), view_layer),
        anim_importer(&unit_converter, &armature_importer, CTX_data_scene(C))
  {
  }
@@@ -263,10 -259,18 +263,10 @@@ void DocumentImporter::finish(
  
                fprintf(stderr, "got %d library nodes to free\n", (int)libnode_ob.size());
                // free all library_nodes
 -              std::vector<Object *>::iterator lit;
 -              for (lit = libnode_ob.begin(); lit != libnode_ob.end(); lit++) {
 -                      Object *ob = *lit;
 -
 -                      Base *base = BKE_scene_base_find(sce, ob);
 -                      if (base) {
 -                              BLI_remlink(&sce->base, base);
 -                              BKE_libblock_free_us(bmain, base->object);
 -                              if (sce->basact == base)
 -                                      sce->basact = NULL;
 -                              MEM_freeN(base);
 -                      }
 +              std::vector<Object *>::iterator it;
 +              for (it = libnode_ob.begin(); it != libnode_ob.end(); it++) {
 +                      Object *ob = *it;
-                       BKE_scene_collections_object_remove(G.main, sce, ob, true);
++                      BKE_scene_collections_object_remove(bmain, sce, ob, true);
                }
                libnode_ob.clear();
  
@@@ -379,7 -383,8 +379,8 @@@ Object *DocumentImporter::create_camera
                return NULL;
        }
  
-       Object *ob = bc_add_object(sce, view_layer, OB_CAMERA, NULL);
+       Main *bmain = CTX_data_main(mContext);
 -      Object *ob = bc_add_object(bmain, sce, OB_CAMERA, NULL);
++      Object *ob = bc_add_object(bmain, sce, view_layer, OB_CAMERA, NULL);
        Camera *cam = uid_camera_map[cam_uid];
        Camera *old_cam = (Camera *)ob->data;
        ob->data = cam;
@@@ -395,7 -400,8 +396,8 @@@ Object *DocumentImporter::create_lamp_o
                return NULL;
        }
  
-       Object *ob = bc_add_object(sce, view_layer, OB_LAMP, NULL);
+       Main *bmain = CTX_data_main(mContext);
 -      Object *ob = bc_add_object(bmain, sce, OB_LAMP, NULL);
++      Object *ob = bc_add_object(bmain, sce, view_layer, OB_LAMP, NULL);
        Lamp *la = uid_lamp_map[lamp_uid];
        Lamp *old_lamp = (Lamp *)ob->data;
        ob->data = la;
@@@ -407,9 -413,10 +409,10 @@@ Object *DocumentImporter::create_instan
  {
        fprintf(stderr, "create <instance_node> under node id=%s from node id=%s\n", instance_node ? instance_node->getOriginalId().c_str() : NULL, source_node ? source_node->getOriginalId().c_str() : NULL);
  
-       Object *obn = BKE_object_copy(G.main, source_ob);
+       Main *bmain = CTX_data_main(mContext);
+       Object *obn = BKE_object_copy(bmain, source_ob);
 -      DAG_id_tag_update(&obn->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 -      BKE_scene_base_add(sce, obn);
 +      DEG_id_tag_update(&obn->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 +      BKE_collection_object_add_from(G.main, sce, source_ob, obn);
  
        if (instance_node) {
                anim_importer.read_node_transform(instance_node, obn);
@@@ -511,7 -519,7 +515,7 @@@ std::vector<Object *> *DocumentImporter
                if (parent_node == NULL && !is_library_node) {
                        // A Joint on root level is a skeleton without root node.
                        // Here we add the armature "on the fly":
-                       par = bc_add_object(sce, view_layer, OB_ARMATURE, std::string("Armature").c_str());
 -                      par = bc_add_object(bmain, sce, OB_ARMATURE, std::string("Armature").c_str());
++                      par = bc_add_object(bmain, sce, view_layer, OB_ARMATURE, std::string("Armature").c_str());
                        objects_done->push_back(par);
                        root_objects->push_back(par);
                        object_map.insert(std::pair<COLLADAFW::UniqueId, Object *>(node->getUniqueId(), par));
                if ( (geom_done + camera_done + lamp_done + controller_done + inst_done) < 1) {
                        //Check if Object is armature, by checking if immediate child is a JOINT node.
                        if (is_armature(node)) {
-                               ob = bc_add_object(sce, view_layer, OB_ARMATURE, name.c_str());
 -                              ob = bc_add_object(bmain, sce, OB_ARMATURE, name.c_str());
++                              ob = bc_add_object(bmain, sce, view_layer, OB_ARMATURE, name.c_str());
                        }
                        else {
-                               ob = bc_add_object(sce, view_layer, OB_EMPTY, NULL);
 -                              ob = bc_add_object(bmain, sce, OB_EMPTY, NULL);
++                              ob = bc_add_object(bmain, sce, view_layer, OB_EMPTY, NULL);
                        }
                        objects_done->push_back(ob);
                        if (parent_node == NULL) {
@@@ -57,11 -58,11 +57,12 @@@ GeometryExporter::GeometryExporter(COLL
  {
  }
  
- void GeometryExporter::exportGeom(struct Depsgraph *depsgraph, Scene *sce)
 -void GeometryExporter::exportGeom(Main *bmain, Scene *sce)
++void GeometryExporter::exportGeom(Main *bmain, struct Depsgraph *depsgraph, Scene *sce)
  {
        openLibrary();
  
 +      mDepsgraph = depsgraph;
+       m_bmain = bmain;
        mScene = sce;
        GeometryFunctor gf;
        gf.forEachMeshObjectInExportSet<GeometryExporter>(sce, *this, this->export_settings->export_set);
@@@ -77,7 -78,9 +78,10 @@@ void GeometryExporter::operator()(Objec
  #endif
  
        bool use_instantiation = this->export_settings->use_object_instantiation;
-       Mesh *me = bc_get_mesh_copy(mDepsgraph, mScene,
+       Mesh *me = bc_get_mesh_copy(
+                                       m_bmain,
++                                      mDepsgraph,
+                                       mScene,
                                        ob,
                                        this->export_settings->export_mesh_type,
                                        this->export_settings->apply_modifiers,
@@@ -74,13 -72,13 +74,14 @@@ class GeometryExporter : COLLADASW::Lib
  
        Normal n;
  
 +      struct Depsgraph *mDepsgraph;
+       Main *m_bmain;
        Scene *mScene;
  
  public:
        GeometryExporter(COLLADASW::StreamWriter *sw, const ExportSettings *export_settings);
  
-       void exportGeom(struct Depsgraph *depsgraph, Scene *sce);
 -      void exportGeom(Main *bmain, Scene *sce);
++      void exportGeom(Main *bmain, Depsgraph *depsgraph, Scene *sce);
  
        void operator()(Object *ob);
  
@@@ -207,11 -207,11 +207,12 @@@ void VCOLDataWrapper::get_vcol(int v_in
  
  }
  
- MeshImporter::MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Scene *sce, ViewLayer *view_layer):
 -MeshImporter::MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Main *bmain, Scene *sce) :
 -    unitconverter(unitconv),
 -    m_bmain(bmain),
 -    scene(sce),
 -    armature_importer(arm) {
++MeshImporter::MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Main *bmain, Scene *sce, ViewLayer *view_layer):
 +      unitconverter(unitconv),
++      m_bmain(bmain),
 +      scene(sce),
 +      view_layer(view_layer),
 +      armature_importer(arm) {
  }
  
  bool MeshImporter::set_poly_indices(MPoly *mpoly, MLoop *mloop, int loop_index, unsigned int *indices, int loop_count)
@@@ -1035,8 -1081,29 +1036,8 @@@ void MeshImporter::assign_material_to_g
        // Attention! This temporaly assigns material to object on purpose!
        // See note above.
        ob->actcol=0;
-       assign_material(G.main, ob, ma, mat_index + 1, BKE_MAT_ASSIGN_OBJECT);
+       assign_material(m_bmain, ob, ma, mat_index + 1, BKE_MAT_ASSIGN_OBJECT);
  
 -      COLLADAFW::TextureCoordinateBindingArray& tex_array =
 -          cmaterial.getTextureCoordinateBindingArray();
 -      TexIndexTextureArrayMap texindex_texarray_map = material_texture_mapping_map[ma];
 -      unsigned int i;
 -      // loop through <bind_vertex_inputs>
 -      for (i = 0; i < tex_array.getCount(); i++) {
 -
 -              color_texture = assign_textures_to_uvlayer(tex_array[i], me, texindex_texarray_map,
 -                                                          color_texture);
 -      }
 -
 -      // set texture face
 -      if (color_texture &&
 -          strlen((color_texture)->uvname) &&
 -          !STREQ(layername, color_texture->uvname))
 -      {
 -              texture_face = (MTFace *)CustomData_get_layer_named(&me->fdata, CD_MTFACE,
 -                                                                  color_texture->uvname);
 -              strcpy(layername, color_texture->uvname);
 -      }
 -
        MaterialIdPrimitiveArrayMap& mat_prim_map = geom_uid_mat_mapping_map[*geom_uid];
        COLLADAFW::MaterialId mat_id = cmaterial.getMaterialId();
  
@@@ -1090,7 -1164,7 +1091,7 @@@ Object *MeshImporter::create_mesh_objec
        const char *name = (id.length()) ? id.c_str() : NULL;
  
        // add object
-       Object *ob = bc_add_object(scene, view_layer, OB_MESH, name);
 -      Object *ob = bc_add_object(m_bmain, scene, OB_MESH, name);
++      Object *ob = bc_add_object(m_bmain, scene, view_layer, OB_MESH, name);
        bc_set_mark(ob); // used later for material assignement optimization
  
  
        BKE_mesh_calc_normals(new_mesh);
  
        id_us_plus(&old_mesh->id);  /* Because BKE_mesh_assign_object would have already decreased it... */
-       BKE_libblock_free_us(G.main, old_mesh);
+       BKE_libblock_free_us(m_bmain, old_mesh);
  
 -      char layername[100];
 -      layername[0] = '\0';
 -      MTFace *texture_face = NULL;
 -
        COLLADAFW::MaterialBindingArray& mat_array =
            geom->getMaterialBindings();
  
@@@ -90,9 -91,8 +90,10 @@@ private
  
        UnitConverter *unitconverter;
  
+       Main *m_bmain;
        Scene *scene;
 +      ViewLayer *view_layer;
 +
        ArmatureImporter *armature_importer;
  
        std::map<std::string, std::string> mesh_geom_map; // needed for correct shape key naming
  
  public:
  
-       MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Scene *sce, ViewLayer *view_layer);
 -      MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Main *bmain, Scene *sce);
++      MeshImporter(UnitConverter *unitconv, ArmatureImporter *arm, Main *bmain, Scene *sce, ViewLayer *view_layer);
  
        virtual Object *get_object_by_geom_uid(const COLLADAFW::UniqueId& geom_uid);
  
@@@ -159,9 -159,9 +159,9 @@@ void SkinInfo::set_controller(const COL
  }
  
  // called from write_controller
- Object *SkinInfo::create_armature(Scene *scene, ViewLayer *view_layer)
 -Object *SkinInfo::create_armature(Main *bmain, Scene *scene)
++Object *SkinInfo::create_armature(Main *bmain, Scene *scene, ViewLayer *view_layer)
  {
-       ob_arm = bc_add_object(scene, view_layer, OB_ARMATURE, NULL);
 -      ob_arm = bc_add_object(bmain, scene, OB_ARMATURE, NULL);
++      ob_arm = bc_add_object(bmain, scene, view_layer, OB_ARMATURE, NULL);
        return ob_arm;
  }
  
@@@ -99,7 -99,7 +99,7 @@@ public
        void set_controller(const COLLADAFW::SkinController* co);
  
        // called from write_controller
-       Object *create_armature(Scene *scene, ViewLayer *view_layer);
 -      Object *create_armature(Main *bmain, Scene *scene);
++      Object *create_armature(Main *bmain, Scene *scene, ViewLayer *view_layer);
  
        Object* set_armature(Object *ob_arm);
  
@@@ -137,42 -133,33 +137,36 @@@ int bc_set_parent(Object *ob, Object *p
        return true;
  }
  
 -EvaluationContext *bc_get_evaluation_context(Main *bmain)
 +Scene *bc_get_scene(bContext *C)
  {
 -      return bmain->eval_ctx;
 +      return CTX_data_scene(C);
  }
  
- Main *bc_get_main()
- {
-       return G.main;
- }
- void bc_update_scene(Depsgraph *depsgraph, Scene *scene, float ctime)
 -void bc_update_scene(Main *bmain, Scene *scene, float ctime)
++void bc_update_scene(Main *bmain, Depsgraph *depsgraph, Scene *scene, float ctime)
  {
        BKE_scene_frame_set(scene, ctime);
-       Main *bmain = bc_get_main();
 -      EvaluationContext *ev_context = bc_get_evaluation_context(bmain);
 -      BKE_scene_update_for_newframe(ev_context, bmain, scene, scene->lay);
 +      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
  }
  
- Object *bc_add_object(Scene *scene, ViewLayer *view_layer, int type, const char *name)
 -Object *bc_add_object(Main *bmain, Scene *scene, int type, const char *name)
++Object *bc_add_object(Main *bmain, Scene *scene, ViewLayer *view_layer, int type, const char *name)
  {
-       Object *ob = BKE_object_add_only_object(G.main, type, name);
+       Object *ob = BKE_object_add_only_object(bmain, type, name);
  
-       ob->data = BKE_object_obdata_add_from_type(G.main, type, name);
+       ob->data = BKE_object_obdata_add_from_type(bmain, type, name);
        ob->lay = scene->lay;
 -      DAG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 +      DEG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 +
 +      LayerCollection *layer_collection = BKE_layer_collection_get_active(view_layer);
 +      BKE_collection_object_add(G.main, layer_collection->collection, ob);
  
 -      BKE_scene_base_select(scene, BKE_scene_base_add(scene, ob));
 +      Base *base = BKE_view_layer_base_find(view_layer, ob);
 +      BKE_view_layer_base_select(view_layer, base);
  
        return ob;
  }
  
- Mesh *bc_get_mesh_copy(struct Depsgraph *depsgraph, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate)
+ Mesh *bc_get_mesh_copy(
 -        Main *bmain, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate)
++        Main *bmain, Depsgraph *depsgraph, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate)
  {
        Mesh *tmpmesh;
        CustomDataMask mask = CD_MASK_MESH;
@@@ -60,20 -61,17 +60,20 @@@ extern "C" 
  #include "ExportSettings.h"
  #include "collada_internal.h"
  
 +struct Depsgraph;
 +
  typedef std::map<COLLADAFW::TextureMapId, std::vector<MTex *> > TexIndexTextureArrayMap;
  
 -extern EvaluationContext *bc_get_evaluation_context(Main *bmain);
 -extern void bc_update_scene(Main *bmain, Scene *scene, float ctime);
 +extern Scene *bc_get_scene(bContext *C);
- extern Main *bc_get_main();
 +extern Depsgraph *bc_get_depsgraph();
- extern void bc_update_scene(Depsgraph *depsgraph, Scene *scene, float ctime);
++extern void bc_update_scene(Main *bmain, Depsgraph *depsgraph, Scene *scene, float ctime);
  
  extern float bc_get_float_value(const COLLADAFW::FloatOrDoubleArray& array, unsigned int index);
  extern int bc_test_parent_loop(Object *par, Object *ob);
  extern int bc_set_parent(Object *ob, Object *par, bContext *C, bool is_parent_space = true);
- extern Object *bc_add_object(Scene *scene, ViewLayer *view_layer, int type, const char *name);
- extern Mesh *bc_get_mesh_copy(struct Depsgraph *depsgraph, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate);
 -extern Object *bc_add_object(Main *bmain, Scene *scene, int type, const char *name);
++extern Object *bc_add_object(Main *bmain, Scene *scene, ViewLayer *view_layer, int type, const char *name);
+ extern Mesh *bc_get_mesh_copy(
 -        Main *bmain, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate);
++        Main *bmain, Depsgraph *depsgraph, Scene *scene, Object *ob, BC_export_mesh_type export_mesh_type, bool apply_modifiers, bool triangulate);
  
  extern Object *bc_get_assigned_armature(Object *ob);
  extern Object *bc_get_highest_selected_ancestor_or_self(LinkNode *export_set, Object *ob);