Blender V5.3
tree_display_view_layer.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "DNA_scene_types.h"
11#include "DNA_space_types.h"
12
13#include "BKE_layer.hh"
14#include "BKE_library.hh"
15
16#include "BLI_listbase.hh"
18#include "BLI_map.hh"
19#include "BLI_set.hh"
20#include "BLI_vector.hh"
21
22#include "../outliner_intern.hh"
23#include "common.hh"
24#include "tree_display.hh"
28
29namespace blender::ed::outliner {
30
32 using TreeChildren = Vector<TreeElement *>;
33 using ObjectTreeElementsMap = Map<Object *, TreeChildren>;
34
35 AbstractTreeDisplay &tree_display_;
36 ObjectTreeElementsMap object_tree_elements_map_;
40 Vector<Object *> ordered_objects_;
44 Set<Object *> objects_in_ordered_objects_;
45
46 public:
49
50 void operator()(TreeElement &collection_tree_elem);
51
52 private:
53 void object_tree_elements_lookup_create_recursive(TreeElement *te_parent);
54 void make_object_parent_hierarchy_collections();
55 void add_object_and_parents_in_order(Object *ob);
56};
57
58/* -------------------------------------------------------------------- */
61
66
68{
69 return true;
70}
71
72ListBaseT<TreeElement> TreeDisplayViewLayer::build_tree(const TreeSourceData &source_data)
73{
74 ListBaseT<TreeElement> tree = {nullptr};
75 Scene *scene = source_data.scene;
76 scene_ = scene;
77 bmain_ = source_data.bmain;
78 show_objects_ = !(space_outliner_.filter & SO_FILTER_NO_OBJECT);
79
80 for (auto *view_layer : ListBaseWrapper<ViewLayer>(scene->view_layers)) {
81 view_layer_ = view_layer;
82
84 if (view_layer != source_data.view_layer) {
85 continue;
86 }
87
88 add_view_layer(*scene, tree, static_cast<TreeElement *>(nullptr));
89 }
90 else {
92 {.lb = &tree}, *scene, *view_layer);
93
94 TreeStoreElem *tselem = TREESTORE(&te_view_layer);
95
96 if (!tselem->used) {
97 tselem->flag &= ~TSE_CLOSED;
98 }
99
100 te_view_layer.name = view_layer->name;
101 te_view_layer.directdata = view_layer;
102
103 add_view_layer(*scene, te_view_layer.subtree, &te_view_layer);
104 }
105 }
106
107 return tree;
108}
109
110void TreeDisplayViewLayer::add_view_layer(Scene &scene,
111 ListBaseT<TreeElement> &tree,
112 TreeElement *parent)
113{
114 const bool show_children = (space_outliner_.filter & SO_FILTER_NO_CHILDREN) == 0;
115
117 /* Show objects in the view layer. */
118 BKE_view_layer_synced_ensure(*bmain_, &scene, view_layer_);
119 for (Base &base : *BKE_view_layer_object_bases_get(view_layer_)) {
120 TreeElement *te_object = add_id_element({.lb = &tree, .parent = parent},
121 reinterpret_cast<ID *>(base.object));
122 te_object->directdata = &base;
123 }
124
125 if (show_children) {
127 }
128 }
129 else {
130 /* Show collections in the view layer. */
131 TreeElement &ten = *add_element<TreeElementViewCollectionBase>({.lb = &tree, .parent = parent},
132 scene);
133 TREESTORE(&ten)->flag &= ~TSE_CLOSED;
134
135 /* First layer collection is for master collection, don't show it. */
136 LayerCollection *lc = view_layer_->layer_collections.first();
137 if (lc == nullptr) {
138 return;
139 }
140
141 add_layer_collections_recursive(ten.subtree, lc->layer_collections, ten);
142 if (show_objects_) {
143 add_layer_collection_objects(ten.subtree, *lc, ten);
144 }
145 if (show_children) {
146 add_layer_collection_objects_children(ten);
147 }
148 }
149}
150
151void TreeDisplayViewLayer::add_layer_collections_recursive(
152 ListBaseT<TreeElement> &tree,
153 ListBaseT<LayerCollection> &layer_collections,
154 TreeElement &parent_ten)
155{
156 for (LayerCollection &lc : layer_collections) {
157 const bool exclude = (lc.flag & LAYER_COLLECTION_EXCLUDE) != 0;
158 TreeElement *ten;
159
160 if (exclude && ((space_outliner_.show_restrict_flags & SO_RESTRICT_ENABLE) == 0)) {
161 ten = &parent_ten;
162 }
163 else {
164 ID *id = &lc.collection->id;
165 ten = add_element<TreeElementLayerCollection>({.lb = &tree, .parent = &parent_ten}, lc);
166
167 /* Open by default, except linked collections, which may contain many elements. */
168 TreeStoreElem *tselem = TREESTORE(ten);
169 if (!(tselem->used || !ID_IS_EDITABLE(id) || ID_IS_OVERRIDE_LIBRARY(id))) {
170 tselem->flag &= ~TSE_CLOSED;
171 }
172 }
173
174 add_layer_collections_recursive(ten->subtree, lc.layer_collections, *ten);
175 if (!exclude && show_objects_) {
176 add_layer_collection_objects(ten->subtree, lc, *ten);
177 }
178 }
179}
180
181void TreeDisplayViewLayer::add_layer_collection_objects(ListBaseT<TreeElement> &tree,
182 LayerCollection &lc,
183 TreeElement &ten)
184{
185 BKE_view_layer_synced_ensure(*bmain_, scene_, view_layer_);
186 for (CollectionObject &cob : lc.collection->gobject) {
187 Base *base = BKE_view_layer_base_find(view_layer_, cob.ob);
188 TreeElement *te_object = add_id_element({.lb = &tree, .parent = &ten},
189 reinterpret_cast<ID *>(base->object));
190 te_object->directdata = base;
191 }
192}
193
194void TreeDisplayViewLayer::add_layer_collection_objects_children(TreeElement &collection_tree_elem)
195{
196 /* Call helper to add children. */
197 ObjectsChildrenBuilder child_builder{*this};
198 child_builder(collection_tree_elem);
199}
200
202
203/* -------------------------------------------------------------------- */
210
212 : tree_display_(tree_display)
213{
214}
215
217{
218 object_tree_elements_lookup_create_recursive(&collection_tree_elem);
219 make_object_parent_hierarchy_collections();
220}
221
225void ObjectsChildrenBuilder::object_tree_elements_lookup_create_recursive(TreeElement *te_parent)
226{
227 for (TreeElement &te : te_parent->subtree) {
228 TreeStoreElem *tselem = TREESTORE(&te);
229
230 if (tselem->type == TSE_LAYER_COLLECTION) {
231 object_tree_elements_lookup_create_recursive(&te);
232 continue;
233 }
234
235 if ((tselem->type == TSE_SOME_ID) && (te.idcode == ID_OB)) {
236 Object *ob = id_cast<Object *>(tselem->id);
237 /* Lookup children or add new, empty children vector. */
238 Vector<TreeElement *> &tree_elements = object_tree_elements_map_.lookup_or_add(ob, {});
239 add_object_and_parents_in_order(ob);
240 tree_elements.append(&te);
241 object_tree_elements_lookup_create_recursive(&te);
242 }
243 }
244}
245
250void ObjectsChildrenBuilder::make_object_parent_hierarchy_collections()
251{
252 /* Ordered list (parent before children) is important. Otherwise, it is easy to miss objects that
253 * are linked with another collection. For details, see: !136971. */
254 for (Object *ob : ordered_objects_) {
255 if (ob->parent == nullptr) {
256 continue;
257 }
258
259 Vector<TreeElement *> *parent_ob_tree_elements = object_tree_elements_map_.lookup_ptr(
260 ob->parent);
261 Vector<TreeElement *> *child_ob_tree_elements = object_tree_elements_map_.lookup_ptr(ob);
262
263 if (!parent_ob_tree_elements || !child_ob_tree_elements) {
264 continue;
265 }
266
267 for (TreeElement *parent_ob_tree_element : *parent_ob_tree_elements) {
268 TreeElement *parent_ob_collection_tree_element = nullptr;
269 bool found = false;
270
271 /* We always want to remove the child from the direct collection its parent is nested under.
272 * This is particularly important when dealing with multi-level nesting (grandchildren). */
273 parent_ob_collection_tree_element = parent_ob_tree_element->parent;
274 while (!ELEM(TREESTORE(parent_ob_collection_tree_element)->type,
277 {
278 parent_ob_collection_tree_element = parent_ob_collection_tree_element->parent;
279 }
280
281 for (TreeElement *child_ob_tree_element : *child_ob_tree_elements) {
282 if (child_ob_tree_element->parent == parent_ob_collection_tree_element) {
283 /* Move from the collection subtree into the parent object subtree. */
284 BLI_remlink(&parent_ob_collection_tree_element->subtree, child_ob_tree_element);
285 BLI_addtail(&parent_ob_tree_element->subtree, child_ob_tree_element);
286 child_ob_tree_element->parent = parent_ob_tree_element;
287 found = true;
288 break;
289 }
290 }
291
292 if (!found) {
293 /* We add the child in the tree even if it is not in the collection.
294 * We don't expand its sub-tree though, to make it less prominent. */
295 TreeElement *child_ob_tree_element = tree_display_.add_id_element(
296 {.parent = parent_ob_tree_element, .expand = false}, reinterpret_cast<ID *>(ob));
297 child_ob_tree_element->flag |= TE_CHILD_NOT_IN_COLLECTION;
298 child_ob_tree_elements->append(child_ob_tree_element);
299 }
300 }
301 }
302}
303
304void ObjectsChildrenBuilder::add_object_and_parents_in_order(Object *ob)
305{
306 if (Object *parent = ob->parent) {
307 add_object_and_parents_in_order(parent);
308 }
309 if (objects_in_ordered_objects_.add(ob)) {
310 ordered_objects_.append(ob);
311 }
312}
313
315
316} // namespace blender::ed::outliner
#define ID_IS_EDITABLE(_id)
Definition DNA_ID.h:708
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition DNA_ID.h:736
Object groups, one object can be in many groups at once.
#define ELEM(...)
Value & lookup_or_add(const Key &key, const Value &value)
Definition BLI_map.hh:588
void append(const T &value)
TreeElement * add_id_element(const TreeElementAddParams &params, ID *id)
AbstractTreeDisplay(SpaceOutliner &space_outliner)
TreeElement * add_element(const TreeElementAddParams &params, Args &&...args)
void operator()(TreeElement &collection_tree_elem)
ObjectsChildrenBuilder(AbstractTreeDisplay &tree_display)
ListBaseT< TreeElement > build_tree(const TreeSourceData &source_data) override
void outliner_make_object_parent_hierarchy(ListBaseT< TreeElement > *lb)
@ SO_FILTER_NO_CHILDREN
@ SO_FILTER_NO_VIEW_LAYERS
@ SO_FILTER_NO_COLLECTION
ListBaseWrapperTemplate< ListBase, T > ListBaseWrapper
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
@ LAYER_COLLECTION_EXCLUDE
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
#define TREESTORE(a)
ListBaseT< ViewLayer > view_layers
eSpaceOutliner_Filter filter
eSpaceOutliner_ShowRestrictFlag show_restrict_flags
The data to build the tree from.
Establish and manage Outliner trees for different display modes.