Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / object.c
index b65cc408ae59e8a107ffa557cd52d225239b0690..684b00c6e0ab0ea7a2c4b0f724019e7fdd6a153e 100644 (file)
@@ -78,7 +78,6 @@
 #include "BKE_action.h"
 #include "BKE_bullet.h"
 #include "BKE_deform.h"
-#include "BKE_depsgraph.h"
 #include "BKE_DerivedMesh.h"
 #include "BKE_animsys.h"
 #include "BKE_anim.h"
@@ -91,6 +90,7 @@
 #include "BKE_icons.h"
 #include "BKE_key.h"
 #include "BKE_lamp.h"
+#include "BKE_layer.h"
 #include "BKE_lattice.h"
 #include "BKE_library.h"
 #include "BKE_library_query.h"
 #include "BKE_camera.h"
 #include "BKE_image.h"
 
+#include "DEG_depsgraph.h"
+
+#include "DRW_engine.h"
+
 #ifdef WITH_MOD_FLUID
 #include "LBM_fluidsim.h"
 #endif
 #include "CCGSubSurf.h"
 #include "atomic_ops.h"
 
-#include "GPU_material.h"
+#include "GPU_lamp.h"
 
 /* Vertex parent modifies original BMesh which is not safe for threading.
  * Ideally such a modification should be handled as a separate DAG update
@@ -154,7 +158,7 @@ void BKE_object_workob_clear(Object *workob)
 
 void BKE_object_update_base_layer(struct Scene *scene, Object *ob)
 {
-       Base *base = scene->base.first;
+       BaseLegacy *base = scene->base.first;
 
        while (base) {
                if (base->object == ob) base->lay = ob->lay;
@@ -401,7 +405,7 @@ void BKE_object_free_caches(Object *object)
         * guaranteed to be in a known state.
         */
        if (update_flag != 0) {
-               DAG_id_tag_update(&object->id, update_flag);
+               DEG_id_tag_update(&object->id, update_flag);
        }
 }
 
@@ -448,6 +452,8 @@ void BKE_object_free(Object *ob)
        }
        GPU_lamp_free(ob);
 
+       DRW_object_engine_data_free(ob);
+
        BKE_sculptsession_free(ob);
 
        BLI_freelistN(&ob->pc_ids);
@@ -464,6 +470,9 @@ void BKE_object_free(Object *ob)
        }
 
        BKE_previewimg_free(&ob->preview);
+
+       /* don't free, let the base free it */
+       ob->base_collection_properties = NULL;
 }
 
 /* actual check for internal data, not context or flags */
@@ -683,23 +692,33 @@ Object *BKE_object_add_only_object(Main *bmain, int type, const char *name)
 /* general add: to scene, with layer from area and default name */
 /* creates minimum required data, but without vertices etc. */
 Object *BKE_object_add(
-        Main *bmain, Scene *scene,
+        Main *bmain, Scene *scene, SceneLayer *sl,
         int type, const char *name)
 {
        Object *ob;
        Base *base;
+       LayerCollection *lc;
 
        ob = BKE_object_add_only_object(bmain, type, name);
 
        ob->data = BKE_object_obdata_add_from_type(bmain, type, name);
 
-       ob->lay = scene->lay;
-       
-       base = BKE_scene_base_add(scene, ob);
-       BKE_scene_base_deselect_all(scene);
-       BKE_scene_base_select(scene, base);
-       DAG_id_tag_update_ex(bmain, &ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
+       lc = BKE_layer_collection_active(sl);
+
+       if (lc == NULL) {
+               BLI_assert(BLI_listbase_count_ex(&sl->layer_collections, 1) == 0);
+               /* when there is no collection linked to this SceneLayer, create one */
+               SceneCollection *sc = BKE_collection_add(scene, NULL, NULL);
+               lc = BKE_collection_link(sl, sc);
+       }
 
+       BKE_collection_object_add(scene, lc->scene_collection, ob);
+
+       base = BKE_scene_layer_base_find(sl, ob);
+       BKE_scene_layer_base_deselect_all(sl);
+       BKE_scene_layer_base_select(sl, base);
+
+       DEG_id_tag_update_ex(bmain, &ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
        return ob;
 }
 
@@ -794,9 +813,9 @@ static LodLevel *lod_level_select(Object *ob, const float camera_position[3])
        return current;
 }
 
-bool BKE_object_lod_is_usable(Object *ob, Scene *scene)
+bool BKE_object_lod_is_usable(Object *ob, SceneLayer *sl)
 {
-       bool active = (scene) ? ob == OBACT : false;
+       bool active = (sl) ? ob == OBACT_NEW : false;
        return (ob->mode == OB_MODE_OBJECT || !active);
 }
 
@@ -810,11 +829,11 @@ void BKE_object_lod_update(Object *ob, const float camera_position[3])
        }
 }
 
-static Object *lod_ob_get(Object *ob, Scene *scene, int flag)
+static Object *lod_ob_get(Object *ob, SceneLayer *sl, int flag)
 {
        LodLevel *current = ob->currentlod;
 
-       if (!current || !BKE_object_lod_is_usable(ob, scene))
+       if (!current || !BKE_object_lod_is_usable(ob, sl))
                return ob;
 
        while (current->prev && (!(current->flags & flag) || !current->source || current->source->type != OB_MESH)) {
@@ -824,14 +843,14 @@ static Object *lod_ob_get(Object *ob, Scene *scene, int flag)
        return current->source;
 }
 
-struct Object *BKE_object_lod_meshob_get(Object *ob, Scene *scene)
+struct Object *BKE_object_lod_meshob_get(Object *ob, SceneLayer *sl)
 {
-       return lod_ob_get(ob, scene, OB_LOD_USE_MESH);
+       return lod_ob_get(ob, sl, OB_LOD_USE_MESH);
 }
 
-struct Object *BKE_object_lod_matob_get(Object *ob, Scene *scene)
+struct Object *BKE_object_lod_matob_get(Object *ob, SceneLayer *sl)
 {
-       return lod_ob_get(ob, scene, OB_LOD_USE_MAT);
+       return lod_ob_get(ob, sl, OB_LOD_USE_MAT);
 }
 
 #endif  /* WITH_GAMEENGINE */
@@ -1170,6 +1189,7 @@ Object *BKE_object_copy_ex(Main *bmain, Object *ob, bool copy_caches)
 
        BLI_listbase_clear(&obn->gpulamp);
        BLI_listbase_clear(&obn->pc_ids);
+       BLI_listbase_clear(&obn->drawdata);
 
        obn->mpath = NULL;
 
@@ -1326,8 +1346,8 @@ void BKE_object_make_proxy(Object *ob, Object *target, Object *gob)
        ob->proxy_group = gob;
        id_lib_extern(&target->id);
        
-       DAG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
-       DAG_id_tag_update(&target->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);
+       DEG_id_tag_update(&target->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
        
        /* copy transform
         * - gob means this proxy comes from a group, just apply the matrix
@@ -2486,14 +2506,14 @@ void BKE_object_foreach_display_point(
 }
 
 void BKE_scene_foreach_display_point(
-        Scene *scene, View3D *v3d, const short flag,
+        Scene *scene, SceneLayer *sl,
         void (*func_cb)(const float[3], void *), void *user_data)
 {
        Base *base;
        Object *ob;
 
-       for (base = FIRSTBASE; base; base = base->next) {
-               if (BASE_VISIBLE_BGMODE(v3d, scene, base) && (base->flag & flag) == flag) {
+       for (base = FIRSTBASE_NEW; base; base = base->next) {
+               if (((base->flag & BASE_VISIBLED) != 0) && ((base->flag & BASE_SELECTED) != 0)) {
                        ob = base->object;
 
                        if ((ob->transflag & OB_DUPLI) == 0) {
@@ -3288,33 +3308,33 @@ static void obrel_list_add(LinkNode **links, Object *ob)
 }
 
 /*
- * Iterates over all objects of the given scene.
+ * Iterates over all objects of the given scene layer.
  * Depending on the eObjectSet flag:
  * collect either OB_SET_ALL, OB_SET_VISIBLE or OB_SET_SELECTED objects.
  * If OB_SET_VISIBLE or OB_SET_SELECTED are collected, 
  * then also add related objects according to the given includeFilters.
  */
-LinkNode *BKE_object_relational_superset(struct Scene *scene, eObjectSet objectSet, eObRelationTypes includeFilter)
+LinkNode *BKE_object_relational_superset(struct SceneLayer *scene_layer, eObjectSet objectSet, eObRelationTypes includeFilter)
 {
        LinkNode *links = NULL;
 
        Base *base;
 
        /* Remove markers from all objects */
-       for (base = scene->base.first; base; base = base->next) {
+       for (base = scene_layer->object_bases.first; base; base = base->next) {
                base->object->id.tag &= ~LIB_TAG_DOIT;
        }
 
        /* iterate over all selected and visible objects */
-       for (base = scene->base.first; base; base = base->next) {
+       for (base = scene_layer->object_bases.first; base; base = base->next) {
                if (objectSet == OB_SET_ALL) {
                        /* as we get all anyways just add it */
                        Object *ob = base->object;
                        obrel_list_add(&links, ob);
                }
                else {
-                       if ((objectSet == OB_SET_SELECTED && TESTBASELIB_BGMODE(((View3D *)NULL), scene, base)) ||
-                           (objectSet == OB_SET_VISIBLE  && BASE_EDITABLE_BGMODE(((View3D *)NULL), scene, base)))
+                       if ((objectSet == OB_SET_SELECTED && TESTBASELIB_BGMODE_NEW(base)) ||
+                           (objectSet == OB_SET_VISIBLE  && BASE_EDITABLE_BGMODE_NEW(base)))
                        {
                                Object *ob = base->object;
 
@@ -3343,8 +3363,8 @@ LinkNode *BKE_object_relational_superset(struct Scene *scene, eObjectSet objectS
                                /* child relationship */
                                if (includeFilter & (OB_REL_CHILDREN | OB_REL_CHILDREN_RECURSIVE)) {
                                        Base *local_base;
-                                       for (local_base = scene->base.first; local_base; local_base = local_base->next) {
-                                               if (BASE_EDITABLE_BGMODE(((View3D *)NULL), scene, local_base)) {
+                                       for (local_base = scene_layer->object_bases.first; local_base; local_base = local_base->next) {
+                                               if (BASE_EDITABLE_BGMODE_NEW(local_base)) {
 
                                                        Object *child = local_base->object;
                                                        if (obrel_list_test(child)) {
@@ -3388,18 +3408,11 @@ struct LinkNode *BKE_object_groups(Object *ob)
        return group_linknode;
 }
 
-void BKE_object_groups_clear(Scene *scene, Base *base, Object *object)
+void BKE_object_groups_clear(Object *ob)
 {
        Group *group = NULL;
-
-       BLI_assert((base == NULL) || (base->object == object));
-
-       if (scene && base == NULL) {
-               base = BKE_scene_base_find(scene, object);
-       }
-
-       while ((group = BKE_group_object_find(group, base->object))) {
-               BKE_group_object_unlink(group, object, scene, base);
+       while ((group = BKE_group_object_find(group, ob))) {
+               BKE_group_object_unlink(group, ob);
        }
 }