Blender V5.3
ed_viewer_path.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
9#include "ED_viewer_path.hh"
10#include "ED_node.hh"
11#include "ED_screen.hh"
12
15#include "BKE_context.hh"
16#include "BKE_lib_id.hh"
17#include "BKE_main.hh"
19#include "BKE_node_runtime.hh"
21#include "BKE_viewer_path.hh"
22#include "BKE_workspace.hh"
23
24#include "BLI_listbase.hh"
25#include "BLI_string.hh"
26#include "BLI_vector.hh"
27
28#include "DNA_modifier_types.h"
29#include "DNA_node_types.h"
31
32#include "DEG_depsgraph.hh"
34
35#include "WM_api.hh"
36
38
39using bke::bNodeTreeZone;
40using bke::bNodeTreeZones;
41
43{
44 if (const auto *context = dynamic_cast<const bke::DataBlockComputeContext *>(&compute_context)) {
46 elem->id = const_cast<ID *>(context->id());
47 BLI_assert(elem->id);
48 elem->base.ui_name = BLI_strdup(BKE_id_name(*elem->id));
49 return &elem->base;
50 }
51 if (const auto *context = dynamic_cast<const bke::GeometryNodesModifierComputeContext *>(
52 &compute_context))
53 {
55 elem->modifier_uid = context->modifier_uid();
56 if (const NodesModifierData *nmd = context->nmd()) {
57 elem->base.ui_name = BLI_strdup(nmd->modifier.name);
58 }
59 return &elem->base;
60 }
61 if (const auto *context = dynamic_cast<const bke::GroupNodeComputeContext *>(&compute_context)) {
63 elem->node_id = context->node_id();
64 if (const bNode *caller_node = context->node()) {
65 if (const bNodeTree *group = reinterpret_cast<const bNodeTree *>(caller_node->id)) {
66 elem->base.ui_name = BLI_strdup(BKE_id_name(group->id));
67 }
68 }
69 return &elem->base;
70 }
71 if (const auto *context = dynamic_cast<const bke::SimulationZoneComputeContext *>(
72 &compute_context))
73 {
75 elem->sim_output_node_id = context->output_node_id();
76 return &elem->base;
77 }
78 if (const auto *context = dynamic_cast<const bke::RepeatZoneComputeContext *>(&compute_context))
79 {
81 elem->repeat_output_node_id = context->output_node_id();
82 elem->iteration = context->iteration();
83 return &elem->base;
84 }
85 if (const auto *context = dynamic_cast<const bke::ForeachGeometryElementZoneComputeContext *>(
86 &compute_context))
87 {
90 elem->zone_output_node_id = context->output_node_id();
91 elem->index = context->index();
92 return &elem->base;
93 }
94 if (const auto *context = dynamic_cast<const bke::EvaluateClosureComputeContext *>(
95 &compute_context))
96 {
98 elem->evaluate_node_id = context->node_id();
99 if (const std::optional<nodes::ClosureSourceLocation> &source =
100 context->closure_source_location())
101 {
102 elem->source_output_node_id = source->closure_output_node_id;
103 BLI_assert(DEG_is_original(source->tree));
104 elem->source_node_tree = const_cast<bNodeTree *>(source->tree);
105 }
106 return &elem->base;
107 }
108 return nullptr;
109}
110
112 const bNode &node,
113 ViewerPath &r_dst)
114{
115 /* Only valid if the node space has a context object. */
116 BLI_assert(snode.id != nullptr && GS(snode.id->name) == ID_OB);
117 snode.edittree->ensure_topology_cache();
118
119 BKE_viewer_path_init(&r_dst);
120
121 bke::ComputeContextCache compute_context_cache;
123 snode, compute_context_cache, node);
124 if (!node_context) {
125 return;
126 }
127
128 for (const ComputeContext *context = node_context; context; context = context->parent()) {
130 if (!elem) {
131 BKE_viewer_path_clear(&r_dst);
132 return;
133 }
134 BLI_addhead(&r_dst.path, elem);
135 }
136
138 viewer_node_elem->node_id = node.identifier;
139 viewer_node_elem->base.ui_name = BLI_strdup(bke::node_label(*snode.edittree, node).c_str());
140 BLI_addtail(&r_dst.path, viewer_node_elem);
141}
142
144 SpaceNode &snode,
145 bNode &node,
146 std::optional<int> item_identifier)
147{
148 wmWindowManager *wm = bmain.wm.first();
149 if (wm == nullptr) {
150 return;
151 }
152 for (bNode *iter_node : snode.edittree->all_nodes()) {
153 if (iter_node->type_legacy == GEO_NODE_VIEWER) {
154 SET_FLAG_FROM_TEST(iter_node->flag, iter_node == &node, NODE_DO_OUTPUT);
155 }
156 }
157 ViewerPath new_viewer_path{};
158 BLI_SCOPED_DEFER([&]() { BKE_viewer_path_clear(&new_viewer_path); });
159 if (snode.id != nullptr && GS(snode.id->name) == ID_OB) {
160 viewer_path_for_geometry_node(snode, node, new_viewer_path);
161 }
162
163 bool found_view3d_with_enabled_viewer = false;
164 View3D *any_view3d_without_viewer = nullptr;
165 for (wmWindow &window : wm->windows) {
168 for (ScrArea &area : screen->areabase) {
169 SpaceLink *sl = area.spacedata.first_as<SpaceLink>();
170 if (sl->spacetype == SPACE_SPREADSHEET) {
171 SpaceSpreadsheet &sspreadsheet = *reinterpret_cast<SpaceSpreadsheet *>(sl);
172 if (!(sspreadsheet.flag & SPREADSHEET_FLAG_PINNED)) {
173 SpreadsheetTableIDGeometry &table_id = sspreadsheet.geometry_id;
175 if (item_identifier) {
176 table_id.viewer_item_identifier = *item_identifier;
177 }
178 MEM_SAFE_DELETE(table_id.viewer_item_bundle_path.bundle_path);
181 }
182 }
183 else if (sl->spacetype == SPACE_VIEW3D) {
184 View3D &v3d = *reinterpret_cast<View3D *>(sl);
185 if (v3d.flag2 & V3D_SHOW_VIEWER) {
186 found_view3d_with_enabled_viewer = true;
187 }
188 else {
189 any_view3d_without_viewer = &v3d;
190 }
191 }
192 }
193
194 /* Enable viewer in one viewport if it is disabled in all of them. */
195 if (!found_view3d_with_enabled_viewer && any_view3d_without_viewer != nullptr) {
196 any_view3d_without_viewer->flag2 |= V3D_SHOW_VIEWER;
197 }
198
200 BKE_viewer_path_copy(&workspace->viewer_path, &new_viewer_path);
201
202 /* Make sure the viewed data becomes available. */
205 }
206}
207
209{
210 if (viewer_path.path.count() != 1) {
211 return nullptr;
212 }
213 const ViewerPathElem *elem = viewer_path.path.first();
214 if (elem->type != VIEWER_PATH_ELEM_TYPE_ID) {
215 return nullptr;
216 }
217 ID *id = reinterpret_cast<const IDViewerPathElem *>(elem)->id;
218 if (id == nullptr) {
219 return nullptr;
220 }
221 if (GS(id->name) != ID_OB) {
222 return nullptr;
223 }
224 return reinterpret_cast<Object *>(id);
225}
226
227std::optional<ViewerPathForGeometryNodesViewer> parse_geometry_nodes_viewer(
228 const ViewerPath &viewer_path)
229{
231 for (const ViewerPathElem &item : viewer_path.path) {
232 elems_vec.append(&item);
233 }
234
235 if (elems_vec.size() < 3) {
236 /* Need at least the object, modifier and viewer node name. */
237 return std::nullopt;
238 }
239 Span<const ViewerPathElem *> remaining_elems = elems_vec;
240 const ViewerPathElem &id_elem = *remaining_elems[0];
241 if (id_elem.type != VIEWER_PATH_ELEM_TYPE_ID) {
242 return std::nullopt;
243 }
244 ID *root_id = reinterpret_cast<const IDViewerPathElem &>(id_elem).id;
245 if (root_id == nullptr) {
246 return std::nullopt;
247 }
248 if (GS(root_id->name) != ID_OB) {
249 return std::nullopt;
250 }
251 Object *root_ob = reinterpret_cast<Object *>(root_id);
252 remaining_elems = remaining_elems.drop_front(1);
253 const ViewerPathElem &modifier_elem = *remaining_elems[0];
254 if (modifier_elem.type != VIEWER_PATH_ELEM_TYPE_MODIFIER) {
255 return std::nullopt;
256 }
257 const int modifier_uid =
258 reinterpret_cast<const ModifierViewerPathElem &>(modifier_elem).modifier_uid;
259
260 remaining_elems = remaining_elems.drop_front(1);
262 for (const ViewerPathElem *elem : remaining_elems.drop_back(1)) {
263 if (!ELEM(elem->type,
269 {
270 return std::nullopt;
271 }
272 node_path.append(elem);
273 }
274 const ViewerPathElem *last_elem = remaining_elems.last();
275 if (last_elem->type != VIEWER_PATH_ELEM_TYPE_VIEWER_NODE) {
276 return std::nullopt;
277 }
278 const int32_t viewer_node_id =
279 reinterpret_cast<const ViewerNodeViewerPathElem *>(last_elem)->node_id;
280 return ViewerPathForGeometryNodesViewer{root_ob, modifier_uid, node_path, viewer_node_id};
281}
282
284{
285 const NodesModifierData *modifier = nullptr;
286 for (const ModifierData &md : parsed_viewer_path.object->modifiers) {
287 if (md.type != eModifierType_Nodes) {
288 continue;
289 }
290 if (md.persistent_uid != parsed_viewer_path.modifier_uid) {
291 continue;
292 }
293 modifier = reinterpret_cast<const NodesModifierData *>(&md);
294 break;
295 }
296 if (modifier == nullptr) {
297 return false;
298 }
299 if (modifier->node_group == nullptr || ID_MISSING(modifier->node_group)) {
300 return false;
301 }
302 const bNodeTree *ngroup = modifier->node_group;
303 const bNodeTreeZone *zone = nullptr;
304 for (const ViewerPathElem *path_elem : parsed_viewer_path.node_path) {
305 ngroup->ensure_topology_cache();
306 const bNodeTreeZones *tree_zones = ngroup->zones();
307 switch (path_elem->type) {
309 const auto &typed_elem = *reinterpret_cast<const SimulationZoneViewerPathElem *>(
310 path_elem);
311 const bNodeTreeZone *next_zone = tree_zones->get_zone_by_node(
312 typed_elem.sim_output_node_id);
313 if (next_zone == nullptr) {
314 return false;
315 }
316 if (next_zone->parent_zone != zone) {
317 return false;
318 }
319 zone = next_zone;
320 break;
321 }
323 const auto &typed_elem = *reinterpret_cast<const RepeatZoneViewerPathElem *>(path_elem);
324 const bNodeTreeZone *next_zone = tree_zones->get_zone_by_node(
325 typed_elem.repeat_output_node_id);
326 if (next_zone == nullptr) {
327 return false;
328 }
329 if (next_zone->parent_zone != zone) {
330 return false;
331 }
332 zone = next_zone;
333 break;
334 }
336 const auto &typed_elem =
337 *reinterpret_cast<const ForeachGeometryElementZoneViewerPathElem *>(path_elem);
338 const bNodeTreeZone *next_zone = tree_zones->get_zone_by_node(
339 typed_elem.zone_output_node_id);
340 if (next_zone == nullptr) {
341 return false;
342 }
343 if (next_zone->parent_zone != zone) {
344 return false;
345 }
346 zone = next_zone;
347 break;
348 }
350 const auto &typed_elem = *reinterpret_cast<const GroupNodeViewerPathElem *>(path_elem);
351 const bNode *group_node = ngroup->node_by_id(typed_elem.node_id);
352 if (group_node == nullptr) {
353 return false;
354 }
355 const bNodeTreeZone *parent_zone = tree_zones->get_zone_by_node(typed_elem.node_id);
356 if (parent_zone != zone) {
357 return false;
358 }
359 if (group_node->id == nullptr) {
360 return false;
361 }
362 ngroup = reinterpret_cast<const bNodeTree *>(group_node->id);
363 zone = nullptr;
364 break;
365 }
367 const auto &typed_elem = *reinterpret_cast<const EvaluateClosureNodeViewerPathElem *>(
368 path_elem);
369 const bNode *evaluate_node = ngroup->node_by_id(typed_elem.evaluate_node_id);
370 if (evaluate_node == nullptr) {
371 return false;
372 }
373 const bNodeTreeZone *parent_zone = tree_zones->get_zone_by_node(
374 typed_elem.evaluate_node_id);
375 if (parent_zone != zone) {
376 return false;
377 }
378 if (!typed_elem.source_node_tree) {
379 return false;
380 }
381 const bNode *closure_output_node = typed_elem.source_node_tree->node_by_id(
382 typed_elem.source_output_node_id);
383 if (!closure_output_node) {
384 return false;
385 }
386 ngroup = typed_elem.source_node_tree;
387 const bNodeTreeZones *closure_tree_zones = typed_elem.source_node_tree->zones();
388 if (!closure_tree_zones) {
389 return false;
390 }
391 zone = closure_tree_zones->get_zone_by_node(typed_elem.source_output_node_id);
392 break;
393 }
394 default: {
396 }
397 }
398 }
399
400 const bNode *viewer_node = ngroup->node_by_id(parsed_viewer_path.viewer_node_id);
401 if (viewer_node == nullptr) {
402 return false;
403 }
404 const bNodeTreeZones *tree_zones = ngroup->zones();
405 if (tree_zones == nullptr) {
406 return false;
407 }
408 if (tree_zones->get_zone_by_node(viewer_node->identifier) != zone) {
409 return false;
410 }
411 return true;
412}
413
416{
417 if (viewer_path.path.is_empty()) {
419 }
420 const ViewerPathElem *last_elem = viewer_path.path.last();
421 if (last_elem->type != VIEWER_PATH_ELEM_TYPE_VIEWER_NODE) {
423 }
424 const int32_t viewer_node_id =
425 reinterpret_cast<const ViewerNodeViewerPathElem *>(last_elem)->node_id;
426
427 const Main *bmain = CTX_data_main(&C);
428 const wmWindowManager *wm = bmain->wm.first();
429 if (wm == nullptr) {
431 }
432 for (const wmWindow &window : wm->windows) {
433 const bScreen *active_screen = BKE_workspace_active_screen_get(window.workspace_hook);
434 Vector<const bScreen *> screens = {active_screen};
435 if (ELEM(active_screen->state, SCREENMAXIMIZED, SCREENFULL)) {
436 const ScrArea *area = active_screen->areabase.first();
437 screens.append(area->full);
438 }
439 for (const bScreen *screen : screens) {
440 for (const ScrArea &area : screen->areabase) {
441 const SpaceLink *sl = area.spacedata.first_as<SpaceLink>();
442 if (sl == nullptr) {
443 continue;
444 }
445 if (sl->spacetype != SPACE_NODE) {
446 continue;
447 }
448 const SpaceNode &snode = *reinterpret_cast<const SpaceNode *>(sl);
449 if (snode.edittree == nullptr) {
450 continue;
451 }
452 if (snode.edittree->type != NTREE_GEOMETRY) {
453 continue;
454 }
455 if (!snode.id) {
456 continue;
457 }
458 snode.edittree->ensure_topology_cache();
459 const bNode *viewer_node = snode.edittree->node_by_id(viewer_node_id);
460 if (viewer_node == nullptr) {
461 continue;
462 }
463 if (viewer_node->type_legacy != GEO_NODE_VIEWER) {
464 continue;
465 }
466 if (!(viewer_node->flag & NODE_DO_OUTPUT)) {
467 continue;
468 }
469 ViewerPath tmp_viewer_path{};
470 BLI_SCOPED_DEFER([&]() { BKE_viewer_path_clear(&tmp_viewer_path); });
471 viewer_path_for_geometry_node(snode, *viewer_node, tmp_viewer_path);
474 {
475 continue;
476 }
477 if (!BKE_viewer_path_equal(&viewer_path, &tmp_viewer_path)) {
478 std::swap(viewer_path, tmp_viewer_path);
479 /* Make sure the viewed data becomes available. */
482 }
485 {
486 /* Only swap, without triggering a depsgraph update. */
487 std::swap(viewer_path, tmp_viewer_path);
489 }
491 }
492 }
493 }
495}
496
498{
499 /* Viewer path is only valid if the context object is set. */
500 if (snode.id == nullptr || GS(snode.id->name) != ID_OB) {
501 return nullptr;
502 }
503
504 const std::optional<ViewerPathForGeometryNodesViewer> parsed_viewer_path =
506 if (!parsed_viewer_path.has_value()) {
507 return nullptr;
508 }
509
510 snode.edittree->ensure_topology_cache();
511 bNode *possible_viewer = snode.edittree->node_by_id(parsed_viewer_path->viewer_node_id);
512 if (possible_viewer == nullptr) {
513 return nullptr;
514 }
515 ViewerPath tmp_viewer_path;
516 BLI_SCOPED_DEFER([&]() { BKE_viewer_path_clear(&tmp_viewer_path); });
517 viewer_path_for_geometry_node(snode, *possible_viewer, tmp_viewer_path);
518
519 if (BKE_viewer_path_equal(&viewer_path, &tmp_viewer_path)) {
520 return possible_viewer;
521 }
522 return nullptr;
523}
524
526 const ViewerPathElem &elem_generic,
527 bke::ComputeContextCache &compute_context_cache,
528 const ComputeContext *parent_compute_context)
529{
530 switch (ViewerPathElemType(elem_generic.type)) {
532 return nullptr;
533 }
535 const auto &elem = reinterpret_cast<const IDViewerPathElem &>(elem_generic);
536 if (elem.id == nullptr) {
537 return nullptr;
538 }
539 return &compute_context_cache.for_data_block(parent_compute_context, *elem.id);
540 }
542 const auto &elem = reinterpret_cast<const ModifierViewerPathElem &>(elem_generic);
543 return &compute_context_cache.for_geometry_nodes_modifier(parent_compute_context,
544 elem.modifier_uid);
545 }
547 const auto &elem = reinterpret_cast<const GroupNodeViewerPathElem &>(elem_generic);
548 return &compute_context_cache.for_group_node(parent_compute_context, elem.node_id);
549 }
551 const auto &elem = reinterpret_cast<const SimulationZoneViewerPathElem &>(elem_generic);
552 return &compute_context_cache.for_simulation_zone(parent_compute_context,
553 elem.sim_output_node_id);
554 }
556 const auto &elem = reinterpret_cast<const RepeatZoneViewerPathElem &>(elem_generic);
557 return &compute_context_cache.for_repeat_zone(
558 parent_compute_context, elem.repeat_output_node_id, elem.iteration);
559 }
561 const auto &elem = reinterpret_cast<const ForeachGeometryElementZoneViewerPathElem &>(
562 elem_generic);
563 return &compute_context_cache.for_foreach_geometry_element_zone(
564 parent_compute_context, elem.zone_output_node_id, elem.index);
565 }
567 const auto &elem = reinterpret_cast<const EvaluateClosureNodeViewerPathElem &>(elem_generic);
568 std::optional<nodes::ClosureSourceLocation> source_location;
569 if (elem.source_node_tree) {
570 source_location = nodes::ClosureSourceLocation{
571 elem.source_node_tree,
572 elem.source_output_node_id,
573 parent_compute_context ? parent_compute_context->hash() : ComputeContextHash{}};
574 }
575 return &compute_context_cache.for_evaluate_closure(
576 parent_compute_context, elem.evaluate_node_id, nullptr, source_location);
577 }
578 }
579 return nullptr;
580}
581
582} // namespace blender::ed::viewer_path
#define GEO_NODE_VIEWER
#define BLI_SCOPED_DEFER(function_to_defer)
#define ID_MISSING(_id)
Definition DNA_ID.h:695
#define C
Definition RandGen.cpp:29
#define NC_VIEWER_PATH
Definition WM_types.hh:419
#define BLI_assert_unreachable()
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
const ComputeContextHash & hash() const
constexpr Span drop_front(int64_t n) const
Definition BLI_span.hh:175
constexpr Span drop_back(int64_t n) const
Definition BLI_span.hh:186
constexpr const T & last(const int64_t n=0) const
Definition BLI_span.hh:329
int64_t size() const
void append(const T &value)
const EvaluateClosureComputeContext & for_evaluate_closure(const ComputeContext *parent, int32_t node_id, const bNodeTree *tree=nullptr, const std::optional< nodes::ClosureSourceLocation > &closure_source_location=std::nullopt)
const GeometryNodesModifierComputeContext & for_geometry_nodes_modifier(const ComputeContext *parent, const NodesModifierData &nmd)
const GroupNodeComputeContext & for_group_node(const ComputeContext *parent, int32_t node_id, const bNodeTree *tree=nullptr)
const ForeachGeometryElementZoneComputeContext & for_foreach_geometry_element_zone(const ComputeContext *parent, int32_t output_node_id, int index)
const RepeatZoneComputeContext & for_repeat_zone(const ComputeContext *parent, int32_t output_node_id, int iteration)
const DataBlockComputeContext & for_data_block(const ComputeContext *parent, const uint32_t orig_session_uid, const ID *id=nullptr)
const SimulationZoneComputeContext & for_simulation_zone(const ComputeContext *parent, int output_node_id)
Vector< bNodeTreeZone * > zones
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) const
std::string node_label(const bNodeTree &ntree, const bNode &node)
Definition node.cc:5732
const ComputeContext * compute_context_for_edittree_node(const SpaceNode &snode, bke::ComputeContextCache &compute_context_cache, const bNode &node)
ViewerPathElem * viewer_path_elem_for_compute_context(const ComputeContext &compute_context)
void activate_geometry_node(Main &bmain, SpaceNode &snode, bNode &node, std::optional< int > item_identifier=std::nullopt)
Object * parse_object_only(const ViewerPath &viewer_path)
UpdateActiveGeometryNodesViewerResult update_active_geometry_nodes_viewer(const bContext &C, ViewerPath &viewer_path)
std::optional< ViewerPathForGeometryNodesViewer > parse_geometry_nodes_viewer(const ViewerPath &viewer_path)
static void viewer_path_for_geometry_node(const SpaceNode &snode, const bNode &node, ViewerPath &r_dst)
bool exists_geometry_nodes_viewer(const ViewerPathForGeometryNodesViewer &parsed_viewer_path)
const ComputeContext * compute_context_for_viewer_path_elem(const ViewerPathElem &elem, bke::ComputeContextCache &compute_context_cache, const ComputeContext *parent_compute_context)
bNode * find_geometry_nodes_viewer(const ViewerPath &viewer_path, SpaceNode &snode)
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
GroupNodeViewerPathElem * BKE_viewer_path_elem_new_group_node()
ViewerNodeViewerPathElem * BKE_viewer_path_elem_new_viewer_node()
void BKE_viewer_path_init(ViewerPath *viewer_path)
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
@ SPREADSHEET_OBJECT_EVAL_STATE_VIEWER_NODE
SimulationZoneViewerPathElem * BKE_viewer_path_elem_new_simulation_zone()
IDViewerPathElem * BKE_viewer_path_elem_new_id()
ModifierViewerPathElem * BKE_viewer_path_elem_new_modifier()
@ SPREADSHEET_FLAG_PINNED
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:684
const char * BKE_id_name(const ID &id)
WorkSpace * BKE_workspace_active_get(WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:633
bool DEG_is_original(const T *id)
ForeachGeometryElementZoneViewerPathElem * BKE_viewer_path_elem_new_foreach_geometry_element_zone()
void DEG_id_tag_update(ID *id, unsigned int flags)
@ VIEWER_PATH_EQUAL_FLAG_IGNORE_ITERATION
@ VIEWER_PATH_EQUAL_FLAG_CONSIDER_UI_NAME
void BKE_viewer_path_copy(ViewerPath *dst, const ViewerPath *src)
@ VIEWER_PATH_ELEM_TYPE_REPEAT_ZONE
@ VIEWER_PATH_ELEM_TYPE_SIMULATION_ZONE
@ VIEWER_PATH_ELEM_TYPE_GROUP_NODE
@ VIEWER_PATH_ELEM_TYPE_VIEWER_NODE
@ VIEWER_PATH_ELEM_TYPE_EVALUATE_CLOSURE
@ VIEWER_PATH_ELEM_TYPE_FOREACH_GEOMETRY_ELEMENT_ZONE
@ SPREADSHEET_CLOSURE_NONE
bool BKE_viewer_path_equal(const ViewerPath *a, const ViewerPath *b, ViewerPathEqualFlag flag=ViewerPathEqualFlag(0))
RepeatZoneViewerPathElem * BKE_viewer_path_elem_new_repeat_zone()
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
Main * CTX_data_main(const bContext *C)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
ID_Type GS(const char *name)
Definition DNA_ID.h:410
signed int int32_t
Definition BKE_text.h:78
void BKE_viewer_path_clear(ViewerPath *viewer_path)
EvaluateClosureNodeViewerPathElem * BKE_viewer_path_elem_new_evaluate_closure()
char name[258]
Definition DNA_ID.h:433
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< ModifierData > modifiers
ListBaseT< SpaceLink > spacedata
struct bNodeTree * edittree
SpreadsheetTableIDGeometry geometry_id
SpreadsheetClosureInputOutput closure_input_output
SpreadsheetBundlePathElem * bundle_path
SpreadsheetBundleTreeViewPath viewer_item_bundle_path
eView3D_Flag2 flag2
ListBaseT< ViewerPathElem > path
eNodeTree_Type type
eScreen_State state
ListBaseT< struct ScrArea > areabase
struct WorkSpaceInstanceHook * workspace_hook