Merge branch 'master' into draw-viewport-datadraw-viewport-data

25 files changed, 439 insertions, 264 deletions

diff --git a/source/blender/draw/engines/workbench/workbench_shader.cc b/source/blender/draw/engines/workbench/workbench_shader.cc
index b38286303f1..011a3fd3b13 100644
--- a/source/blender/draw/engines/workbench/workbench_shader.cc
+++ b/source/blender/draw/engines/workbench/workbench_shader.cc
@@ -27,52 +27,6 @@
 #include "workbench_engine.h"
 #include "workbench_private.h"
 
-extern char datatoc_common_math_lib_glsl[];
-extern char datatoc_common_math_geom_lib_glsl[];
-extern char datatoc_common_hair_lib_glsl[];
-extern char datatoc_common_pointcloud_lib_glsl[];
-extern char datatoc_common_view_lib_glsl[];
-extern char datatoc_common_smaa_lib_glsl[];
-
-extern char datatoc_workbench_prepass_vert_glsl[];
-extern char datatoc_workbench_prepass_hair_vert_glsl[];
-extern char datatoc_workbench_prepass_pointcloud_vert_glsl[];
-extern char datatoc_workbench_prepass_frag_glsl[];
-
-extern char datatoc_workbench_effect_cavity_frag_glsl[];
-extern char datatoc_workbench_effect_outline_frag_glsl[];
-extern char datatoc_workbench_effect_dof_frag_glsl[];
-extern char datatoc_workbench_effect_taa_frag_glsl[];
-extern char datatoc_workbench_effect_smaa_frag_glsl[];
-extern char datatoc_workbench_effect_smaa_vert_glsl[];
-
-extern char datatoc_workbench_composite_frag_glsl[];
-
-extern char datatoc_workbench_transparent_accum_frag_glsl[];
-extern char datatoc_workbench_transparent_resolve_frag_glsl[];
-
-extern char datatoc_workbench_merge_infront_frag_glsl[];
-
-extern char datatoc_workbench_shadow_vert_glsl[];
-extern char datatoc_workbench_shadow_geom_glsl[];
-extern char datatoc_workbench_shadow_caps_geom_glsl[];
-extern char datatoc_workbench_shadow_debug_frag_glsl[];
-
-extern char datatoc_workbench_volume_vert_glsl[];
-extern char datatoc_workbench_volume_frag_glsl[];
-
-extern char datatoc_workbench_cavity_lib_glsl[];
-extern char datatoc_workbench_common_lib_glsl[];
-extern char datatoc_workbench_curvature_lib_glsl[];
-extern char datatoc_workbench_data_lib_glsl[];
-extern char datatoc_workbench_image_lib_glsl[];
-extern char datatoc_workbench_matcap_lib_glsl[];
-extern char datatoc_workbench_material_lib_glsl[];
-extern char datatoc_workbench_world_light_lib_glsl[];
-
-extern char datatoc_gpu_shader_depth_only_frag_glsl[];
-extern char datatoc_gpu_shader_common_obinfos_lib_glsl[];
-
 /* Maximum number of variations. */
 #define MAX_LIGHTING 3
 
diff --git a/source/blender/editors/space_outliner/CMakeLists.txt b/source/blender/editors/space_outliner/CMakeLists.txt
index 60b881fb32b..bc6db978a4f 100644
--- a/source/blender/editors/space_outliner/CMakeLists.txt
+++ b/source/blender/editors/space_outliner/CMakeLists.txt
@@ -67,6 +67,7 @@ set(SRC
   tree/tree_element_overrides.cc
   tree/tree_element_rna.cc
   tree/tree_element_scene_objects.cc
+  tree/tree_element_seq.cc
   tree/tree_element_view_layer.cc
 
   outliner_intern.hh
@@ -84,6 +85,7 @@ set(SRC
   tree/tree_element_overrides.hh
   tree/tree_element_rna.hh
   tree/tree_element_scene_objects.hh
+  tree/tree_element_seq.hh
   tree/tree_element_view_layer.hh
 )
 
diff --git a/source/blender/editors/space_outliner/outliner_draw.cc b/source/blender/editors/space_outliner/outliner_draw.cc
index 6de8d9539a9..5fd7559370f 100644
--- a/source/blender/editors/space_outliner/outliner_draw.cc
+++ b/source/blender/editors/space_outliner/outliner_draw.cc
@@ -81,6 +81,7 @@
 #include "outliner_intern.hh"
 #include "tree/tree_display.hh"
 #include "tree/tree_element.hh"
+#include "tree/tree_element_rna.hh"
 
 using namespace blender::ed::outliner;
 
@@ -1909,20 +1910,20 @@ static void outliner_draw_rnacols(ARegion *region, int sizex)
 static void outliner_draw_rnabuts(
     uiBlock *block, ARegion *region, SpaceOutliner *space_outliner, int sizex, ListBase *lb)
 {
-  PointerRNA *ptr;
+  PointerRNA ptr;
   PropertyRNA *prop;
 
   LISTBASE_FOREACH (TreeElement *, te, lb) {
     TreeStoreElem *tselem = TREESTORE(te);
     if (te->ys + 2 * UI_UNIT_Y >= region->v2d.cur.ymin && te->ys <= region->v2d.cur.ymax) {
-      if (tselem->type == TSE_RNA_PROPERTY) {
-        ptr = &te->rnaptr;
-        prop = reinterpret_cast<PropertyRNA *>(te->directdata);
+      if (TreeElementRNAProperty *te_rna_prop = tree_element_cast<TreeElementRNAProperty>(te)) {
+        ptr = te_rna_prop->getPointerRNA();
+        prop = te_rna_prop->getPropertyRNA();
 
         if (!TSELEM_OPEN(tselem, space_outliner)) {
           if (RNA_property_type(prop) == PROP_POINTER) {
             uiBut *but = uiDefAutoButR(block,
-                                       ptr,
+                                       &ptr,
                                        prop,
                                        -1,
                                        "",
@@ -1935,7 +1936,7 @@ static void outliner_draw_rnabuts(
           }
           else if (RNA_property_type(prop) == PROP_ENUM) {
             uiDefAutoButR(block,
-                          ptr,
+                          &ptr,
                           prop,
                           -1,
                           nullptr,
@@ -1947,7 +1948,7 @@ static void outliner_draw_rnabuts(
           }
           else {
             uiDefAutoButR(block,
-                          ptr,
+                          &ptr,
                           prop,
                           -1,
                           "",
@@ -1959,12 +1960,13 @@ static void outliner_draw_rnabuts(
           }
         }
       }
-      else if (tselem->type == TSE_RNA_ARRAY_ELEM) {
-        ptr = &te->rnaptr;
-        prop = reinterpret_cast<PropertyRNA *>(te->directdata);
+      else if (TreeElementRNAArrayElement *te_rna_array_elem =
+                   tree_element_cast<TreeElementRNAArrayElement>(te)) {
+        ptr = te_rna_array_elem->getPointerRNA();
+        prop = te_rna_array_elem->getPropertyRNA();
 
         uiDefAutoButR(block,
-                      ptr,
+                      &ptr,
                       prop,
                       te->index,
                       "",
@@ -2554,15 +2556,19 @@ TreeElementIcon tree_element_get_icon(TreeStoreElem *tselem, TreeElement *te)
       case TSE_SEQUENCE_DUP:
         data.icon = ICON_SEQ_STRIP_DUPLICATE;
         break;
-      case TSE_RNA_STRUCT:
-        if (RNA_struct_is_ID(te->rnaptr.type)) {
-          data.drag_id = (ID *)te->rnaptr.data;
-          data.icon = RNA_struct_ui_icon(te->rnaptr.type);
+      case TSE_RNA_STRUCT: {
+        const TreeElementRNAStruct *te_rna_struct = tree_element_cast<TreeElementRNAStruct>(te);
+        const PointerRNA &ptr = te_rna_struct->getPointerRNA();
+
+        if (RNA_struct_is_ID(ptr.type)) {
+          data.drag_id = reinterpret_cast<ID *>(ptr.data);
+          data.icon = RNA_struct_ui_icon(ptr.type);
         }
         else {
-          data.icon = RNA_struct_ui_icon(te->rnaptr.type);
+          data.icon = RNA_struct_ui_icon(ptr.type);
         }
         break;
+      }
       case TSE_LAYER_COLLECTION:
       case TSE_SCENE_COLLECTION_BASE:
       case TSE_VIEW_COLLECTION_BASE: {
@@ -3319,8 +3325,9 @@ static void outliner_draw_tree_element(bContext *C,
       offsx += 2 * ufac;
     }
 
+    const TreeElementRNAStruct *te_rna_struct = tree_element_cast<TreeElementRNAStruct>(te);
     if (ELEM(tselem->type, TSE_SOME_ID, TSE_LAYER_COLLECTION) ||
-        ((tselem->type == TSE_RNA_STRUCT) && RNA_struct_is_ID(te->rnaptr.type))) {
+        (te_rna_struct && RNA_struct_is_ID(te_rna_struct->getPointerRNA().type))) {
       const BIFIconID lib_icon = (BIFIconID)UI_icon_from_library(tselem->id);
       if (lib_icon != ICON_NONE) {
         UI_icon_draw_alpha(
diff --git a/source/blender/editors/space_outliner/outliner_edit.cc b/source/blender/editors/space_outliner/outliner_edit.cc
index a10dbc94b34..b41b260b14a 100644
--- a/source/blender/editors/space_outliner/outliner_edit.cc
+++ b/source/blender/editors/space_outliner/outliner_edit.cc
@@ -74,6 +74,9 @@
 #include "GPU_material.h"
 
 #include "outliner_intern.hh"
+#include "tree/tree_element_rna.hh"
+
+using namespace blender::ed::outliner;
 
 static void outliner_show_active(SpaceOutliner *space_outliner,
                                  ARegion *region,
@@ -1714,11 +1717,6 @@ static void tree_element_to_path(TreeElement *te,
                                  short *UNUSED(groupmode))
 {
   ListBase hierarchy = {nullptr, nullptr};
-  LinkData *ld;
-  TreeElement *tem, *temnext;
-  TreeStoreElem *tse /* , *tsenext */ /* UNUSED */;
-  PointerRNA *ptr, *nextptr;
-  PropertyRNA *prop;
   char *newpath = nullptr;
 
   /* optimize tricks:
@@ -1738,20 +1736,19 @@ static void tree_element_to_path(TreeElement *te,
    */
 
   /* step 1: flatten out hierarchy of parents into a flat chain */
-  for (tem = te->parent; tem; tem = tem->parent) {
-    ld = MEM_cnew<LinkData>("LinkData for tree_element_to_path()");
+  for (TreeElement *tem = te->parent; tem; tem = tem->parent) {
+    LinkData *ld = MEM_cnew<LinkData>("LinkData for tree_element_to_path()");
     ld->data = tem;
     BLI_addhead(&hierarchy, ld);
   }
 
   /* step 2: step down hierarchy building the path
    * (NOTE: addhead in previous loop was needed so that we can loop like this) */
-  for (ld = reinterpret_cast<LinkData *>(hierarchy.first); ld; ld = ld->next) {
+  LISTBASE_FOREACH (LinkData *, ld, &hierarchy) {
     /* get data */
-    tem = (TreeElement *)ld->data;
-    tse = TREESTORE(tem);
-    ptr = &tem->rnaptr;
-    prop = reinterpret_cast<PropertyRNA *>(tem->directdata);
+    TreeElement *tem = (TreeElement *)ld->data;
+    TreeElementRNACommon *tem_rna = tree_element_cast<TreeElementRNACommon>(tem);
+    PointerRNA ptr = tem_rna->getPointerRNA();
 
     /* check if we're looking for first ID, or appending to path */
     if (*id) {
@@ -1759,19 +1756,19 @@ static void tree_element_to_path(TreeElement *te,
        * - to prevent memory leaks, we must write to newpath not path,
        *   then free old path + swap them.
        */
-      if (tse->type == TSE_RNA_PROPERTY) {
+      if (TreeElementRNAProperty *tem_rna_prop = tree_element_cast<TreeElementRNAProperty>(tem)) {
+        PropertyRNA *prop = tem_rna_prop->getPropertyRNA();
+
         if (RNA_property_type(prop) == PROP_POINTER) {
           /* for pointer we just append property name */
-          newpath = RNA_path_append(*path, ptr, prop, 0, nullptr);
+          newpath = RNA_path_append(*path, &ptr, prop, 0, nullptr);
         }
         else if (RNA_property_type(prop) == PROP_COLLECTION) {
           char buf[128], *name;
 
-          temnext = (TreeElement *)(ld->next->data);
-          // tsenext = TREESTORE(temnext); /* UNUSED */
-
-          nextptr = &temnext->rnaptr;
-          name = RNA_struct_name_get_alloc(nextptr, buf, sizeof(buf), nullptr);
+          TreeElement *temnext = (TreeElement *)(ld->next->data);
+          PointerRNA nextptr = tree_element_cast<TreeElementRNACommon>(temnext)->getPointerRNA();
+          name = RNA_struct_name_get_alloc(&nextptr, buf, sizeof(buf), nullptr);
 
           if (name) {
             /* if possible, use name as a key in the path */
@@ -1789,6 +1786,7 @@ static void tree_element_to_path(TreeElement *te,
               if (temsub == temnext) {
                 break;
               }
+              index++;
             }
             newpath = RNA_path_append(*path, nullptr, prop, index, nullptr);
           }
@@ -1808,11 +1806,11 @@ static void tree_element_to_path(TreeElement *te,
     else {
       /* no ID, so check if entry is RNA-struct,
        * and if that RNA-struct is an ID datablock to extract info from. */
-      if (tse->type == TSE_RNA_STRUCT) {
+      if (tree_element_cast<TreeElementRNAStruct>(tem)) {
         /* ptr->data not ptr->owner_id seems to be the one we want,
          * since ptr->data is sometimes the owner of this ID? */
-        if (RNA_struct_is_ID(ptr->type)) {
-          *id = reinterpret_cast<ID *>(ptr->data);
+        if (RNA_struct_is_ID(ptr.type)) {
+          *id = reinterpret_cast<ID *>(ptr.data);
 
           /* clear path */
           if (*path) {
@@ -1827,8 +1825,7 @@ static void tree_element_to_path(TreeElement *te,
   /* step 3: if we've got an ID, add the current item to the path */
   if (*id) {
     /* add the active property to the path */
-    ptr = &te->rnaptr;
-    prop = reinterpret_cast<PropertyRNA *>(te->directdata);
+    PropertyRNA *prop = tree_element_cast<TreeElementRNACommon>(te)->getPropertyRNA();
 
     /* array checks */
     if (tselem->type == TSE_RNA_ARRAY_ELEM) {
@@ -1886,9 +1883,12 @@ static void do_outliner_drivers_editop(SpaceOutliner *space_outliner,
       short flag = 0;
       short groupmode = KSP_GROUP_KSNAME;
 
+      TreeElementRNACommon *te_rna = tree_element_cast<TreeElementRNACommon>(te);
+      PointerRNA ptr = te_rna ? te_rna->getPointerRNA() : PointerRNA_NULL;
+      PropertyRNA *prop = te_rna ? te_rna->getPropertyRNA() : nullptr;
+
       /* check if RNA-property described by this selected element is an animatable prop */
-      if (ELEM(tselem->type, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM) &&
-          RNA_property_animateable(&te->rnaptr, reinterpret_cast<PropertyRNA *>(te->directdata))) {
+      if (prop && RNA_property_animateable(&ptr, prop)) {
         /* get id + path + index info from the selected element */
         tree_element_to_path(te, tselem, &id, &path, &array_index, &flag, &groupmode);
       }
@@ -1901,8 +1901,7 @@ static void do_outliner_drivers_editop(SpaceOutliner *space_outliner,
         /* array checks */
         if (flag & KSP_FLAG_WHOLE_ARRAY) {
           /* entire array was selected, so add drivers for all */
-          arraylen = RNA_property_array_length(&te->rnaptr,
-                                               reinterpret_cast<PropertyRNA *>(te->directdata));
+          arraylen = RNA_property_array_length(&ptr, prop);
         }
         else {
           arraylen = array_index;
@@ -2084,8 +2083,10 @@ static void do_outliner_keyingset_editop(SpaceOutliner *space_outliner,
       short groupmode = KSP_GROUP_KSNAME;
 
       /* check if RNA-property described by this selected element is an animatable prop */
-      if (ELEM(tselem->type, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM) &&
-          RNA_property_animateable(&te->rnaptr, reinterpret_cast<PropertyRNA *>(te->directdata))) {
+      const TreeElementRNACommon *te_rna = tree_element_cast<TreeElementRNACommon>(te);
+      PointerRNA ptr = te_rna->getPointerRNA();
+      if (te_rna && te_rna->getPropertyRNA() &&
+          RNA_property_animateable(&ptr, te_rna->getPropertyRNA())) {
         /* get id + path + index info from the selected element */
         tree_element_to_path(te, tselem, &id, &path, &array_index, &flag, &groupmode);
       }
diff --git a/source/blender/editors/space_outliner/outliner_intern.hh b/source/blender/editors/space_outliner/outliner_intern.hh
index a62d35131ca..9db1d73dc76 100644
--- a/source/blender/editors/space_outliner/outliner_intern.hh
+++ b/source/blender/editors/space_outliner/outliner_intern.hh
@@ -27,6 +27,9 @@
 
 #include "RNA_types.h"
 
+/* Needed for `tree_element_cast()`. */
+#include "tree/tree_element.hh"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -104,8 +107,7 @@ typedef struct TreeElement {
   short idcode;              /* From TreeStore id. */
   short xend;                /* Width of item display, for select. */
   const char *name;
-  void *directdata;  /* Armature Bones, Base, Sequence, Strip... */
-  PointerRNA rnaptr; /* RNA Pointer. */
+  void *directdata; /* Armature Bones, Base, ... */
 } TreeElement;
 
 typedef struct TreeElementIcon {
@@ -686,3 +688,19 @@ int outliner_context(const struct bContext *C,
 #ifdef __cplusplus
 }
 #endif
+
+namespace blender::ed::outliner {
+
+/**
+ * Helper to safely "cast" a #TreeElement to its new C++ #AbstractTreeElement, if possible.
+ * \return nullptr if the tree-element doesn't match the requested type \a TreeElementT or the
+ *         element doesn't hold a C++ #AbstractTreeElement pendant yet.
+ */
+template<typename TreeElementT> TreeElementT *tree_element_cast(const TreeElement *te)
+{
+  static_assert(std::is_base_of_v<AbstractTreeElement, TreeElementT>,
+                "Requested tree-element type must be an AbstractTreeElement");
+  return dynamic_cast<TreeElementT *>(te->type.get());
+}
+
+}  // namespace blender::ed::outliner
diff --git a/source/blender/editors/space_outliner/outliner_select.cc b/source/blender/editors/space_outliner/outliner_select.cc
index c2a7bfb9b37..3ff8b9e973f 100644
--- a/source/blender/editors/space_outliner/outliner_select.cc
+++ b/source/blender/editors/space_outliner/outliner_select.cc
@@ -80,6 +80,9 @@
 #include "RNA_define.h"
 
 #include "outliner_intern.hh"
+#include "tree/tree_element_seq.hh"
+
+using namespace blender::ed::outliner;
 
 /**
  * \note changes to selection are by convention and not essential.
@@ -676,7 +679,8 @@ static void tree_element_sequence_activate(bContext *C,
                                            TreeElement *te,
                                            const eOLSetState set)
 {
-  Sequence *seq = (Sequence *)te->directdata;
+  const TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
+  Sequence *seq = &te_seq->getSequence();
   Editing *ed = SEQ_editing_get(scene);
 
   if (BLI_findindex(ed->seqbasep, seq) != -1) {
@@ -954,7 +958,8 @@ static eOLDrawState tree_element_posegroup_state_get(const ViewLayer *view_layer
 
 static eOLDrawState tree_element_sequence_state_get(const Scene *scene, const TreeElement *te)
 {
-  const Sequence *seq = (const Sequence *)te->directdata;
+  const TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
+  const Sequence *seq = &te_seq->getSequence();
   const Editing *ed = scene->ed;
 
   if (ed && ed->act_seq == seq && seq->flag & SELECT) {
@@ -965,7 +970,9 @@ static eOLDrawState tree_element_sequence_state_get(const Scene *scene, const Tr
 
 static eOLDrawState tree_element_sequence_dup_state_get(const TreeElement *te)
 {
-  const Sequence *seq = (const Sequence *)te->directdata;
+  const TreeElementSequenceStripDuplicate *te_dup =
+      tree_element_cast<TreeElementSequenceStripDuplicate>(te);
+  const Sequence *seq = &te_dup->getSequence();
   if (seq->flag & SELECT) {
     return OL_DRAWSEL_NORMAL;
   }
diff --git a/source/blender/editors/space_outliner/outliner_tools.cc b/source/blender/editors/space_outliner/outliner_tools.cc
index 1c1a4f6f4c2..fa31025b550 100644
--- a/source/blender/editors/space_outliner/outliner_tools.cc
+++ b/source/blender/editors/space_outliner/outliner_tools.cc
@@ -96,9 +96,13 @@
 #include "SEQ_sequencer.h"
 
 #include "outliner_intern.hh"
+#include "tree/tree_element_rna.hh"
+#include "tree/tree_element_seq.hh"
 
 static CLG_LogRef LOG = {"ed.outliner.tools"};
 
+using namespace blender::ed::outliner;
+
 /* -------------------------------------------------------------------- */
 /** \name ID/Library/Data Set/Un-link Utilities
  * \{ */
@@ -1285,7 +1289,8 @@ static void ebone_fn(int event, TreeElement *te, TreeStoreElem *UNUSED(tselem),
 
 static void sequence_fn(int event, TreeElement *te, TreeStoreElem *UNUSED(tselem), void *scene_ptr)
 {
-  Sequence *seq = (Sequence *)te->directdata;
+  TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
+  Sequence *seq = &te_seq->getSequence();
   Scene *scene = (Scene *)scene_ptr;
   Editing *ed = SEQ_editing_get(scene);
   if (BLI_findindex(ed->seqbasep, seq) != -1) {
@@ -1336,10 +1341,16 @@ static void data_select_linked_fn(int event,
                                   TreeStoreElem *UNUSED(tselem),
                                   void *C_v)
 {
+  const TreeElementRNAStruct *te_rna_struct = tree_element_cast<TreeElementRNAStruct>(te);
+  if (!te_rna_struct) {
+    return;
+  }
+
   if (event == OL_DOP_SELECT_LINKED) {
-    if (RNA_struct_is_ID(te->rnaptr.type)) {
+    const PointerRNA &ptr = te_rna_struct->getPointerRNA();
+    if (RNA_struct_is_ID(ptr.type)) {
       bContext *C = (bContext *)C_v;
-      ID *id = reinterpret_cast<ID *>(te->rnaptr.data);
+      ID *id = reinterpret_cast<ID *>(ptr.data);
 
       ED_object_select_linked_by_id(C, id);
     }
diff --git a/source/blender/editors/space_outliner/outliner_tree.cc b/source/blender/editors/space_outliner/outliner_tree.cc
index be792be95a9..eb885eba20d 100644
--- a/source/blender/editors/space_outliner/outliner_tree.cc
+++ b/source/blender/editors/space_outliner/outliner_tree.cc
@@ -925,57 +925,14 @@ TreeElement *outliner_add_element(SpaceOutliner *space_outliner,
                 TSE_NLA,
                 TSE_NLA_ACTION,
                 TSE_NLA_TRACK,
-                TSE_GP_LAYER)) {
-    /* Should already use new AbstractTreeElement design. */
-    BLI_assert(0);
-  }
-  else if (type == TSE_SEQUENCE) {
-    Sequence *seq = (Sequence *)idv;
-
-    /*
-     * The idcode is a little hack, but the outliner
-     * only check te->idcode if te->type is equal to zero,
-     * so this is "safe".
-     */
-    te->idcode = seq->type;
-    te->directdata = seq;
-    te->name = seq->name + 2;
-
-    if (!(seq->type & SEQ_TYPE_EFFECT)) {
-      /*
-       * This work like the sequence.
-       * If the sequence have a name (not default name)
-       * show it, in other case put the filename.
-       */
-
-      if (seq->type == SEQ_TYPE_META) {
-        LISTBASE_FOREACH (Sequence *, p, &seq->seqbase) {
-          outliner_add_element(space_outliner, &te->subtree, (void *)p, te, TSE_SEQUENCE, index);
-        }
-      }
-      else {
-        outliner_add_element(
-            space_outliner, &te->subtree, (void *)seq->strip, te, TSE_SEQ_STRIP, index);
-      }
-    }
-  }
-  else if (type == TSE_SEQ_STRIP) {
-    Strip *strip = (Strip *)idv;
-
-    if (strip->dir[0] != '\0') {
-      te->name = strip->dir;
-    }
-    else {
-      te->name = IFACE_("Strip None");
-    }
-    te->directdata = strip;
-  }
-  else if (type == TSE_SEQUENCE_DUP) {
-    Sequence *seq = (Sequence *)idv;
-
-    te->idcode = seq->type;
-    te->directdata = seq;
-    te->name = seq->strip->stripdata->name;
+                TSE_GP_LAYER,
+                TSE_RNA_STRUCT,
+                TSE_RNA_PROPERTY,
+                TSE_RNA_ARRAY_ELEM,
+                TSE_SEQUENCE,
+                TSE_SEQ_STRIP,
+                TSE_SEQUENCE_DUP)) {
+    BLI_assert_msg(false, "Element type should already use new AbstractTreeElement design");
   }
 
   if (tree_element_warnings_get(te, nullptr, nullptr)) {
diff --git a/source/blender/editors/space_outliner/tree/tree_element.cc b/source/blender/editors/space_outliner/tree/tree_element.cc
index bed28e59f0b..5685d8964f5 100644
--- a/source/blender/editors/space_outliner/tree/tree_element.cc
+++ b/source/blender/editors/space_outliner/tree/tree_element.cc
@@ -35,6 +35,7 @@
 #include "tree_element_overrides.hh"
 #include "tree_element_rna.hh"
 #include "tree_element_scene_objects.hh"
+#include "tree_element_seq.hh"
 #include "tree_element_view_layer.hh"
 
 #include "../outliner_intern.hh"
@@ -96,6 +97,14 @@ std::unique_ptr<AbstractTreeElement> AbstractTreeElement::createFromType(const i
     case TSE_RNA_ARRAY_ELEM:
       return std::make_unique<TreeElementRNAArrayElement>(
           legacy_te, *reinterpret_cast<PointerRNA *>(idv), legacy_te.index);
+    case TSE_SEQUENCE:
+      return std::make_unique<TreeElementSequence>(legacy_te, *reinterpret_cast<Sequence *>(idv));
+    case TSE_SEQ_STRIP:
+      return std::make_unique<TreeElementSequenceStrip>(legacy_te,
+                                                        *reinterpret_cast<Strip *>(idv));
+    case TSE_SEQUENCE_DUP:
+      return std::make_unique<TreeElementSequenceStripDuplicate>(
+          legacy_te, *reinterpret_cast<Sequence *>(idv));
     default:
       break;
   }
diff --git a/source/blender/editors/space_outliner/tree/tree_element_rna.cc b/source/blender/editors/space_outliner/tree/tree_element_rna.cc
index 0152f59268d..7a9f1b6f0fa 100644
--- a/source/blender/editors/space_outliner/tree/tree_element_rna.cc
+++ b/source/blender/editors/space_outliner/tree/tree_element_rna.cc
@@ -54,8 +54,6 @@ TreeElementRNACommon::TreeElementRNACommon(TreeElement &legacy_te, PointerRNA &r
     legacy_te_.name = IFACE_("(empty)");
     return;
   }
-
-  legacy_te_.rnaptr = rna_ptr;
 }
 
 bool TreeElementRNACommon::isExpandValid() const
@@ -73,12 +71,24 @@ bool TreeElementRNACommon::expandPoll(const SpaceOutliner &) const
   return isRNAValid();
 }
 
+const PointerRNA &TreeElementRNACommon::getPointerRNA() const
+{
+  return rna_ptr_;
+}
+
+PropertyRNA *TreeElementRNACommon::getPropertyRNA() const
+{
+  return nullptr;
+}
+
 /* -------------------------------------------------------------------- */
 /* RNA Struct */
 
 TreeElementRNAStruct::TreeElementRNAStruct(TreeElement &legacy_te, PointerRNA &rna_ptr)
     : TreeElementRNACommon(legacy_te, rna_ptr)
 {
+  BLI_assert(legacy_te.store_elem->type == TSE_RNA_STRUCT);
+
   if (!isRNAValid()) {
     return;
   }
@@ -95,21 +105,23 @@ TreeElementRNAStruct::TreeElementRNAStruct(TreeElement &legacy_te, PointerRNA &r
 void TreeElementRNAStruct::expand(SpaceOutliner &space_outliner) const
 {
   TreeStoreElem &tselem = *TREESTORE(&legacy_te_);
-  PointerRNA *ptr = &legacy_te_.rnaptr;
+  PointerRNA ptr = rna_ptr_;
 
   /* If searching don't expand RNA entries */
   if (SEARCHING_OUTLINER(&space_outliner) && BLI_strcasecmp("RNA", legacy_te_.name) == 0) {
     tselem.flag &= ~TSE_CHILDSEARCH;
   }
 
-  PropertyRNA *iterprop = RNA_struct_iterator_property(ptr->type);
-  int tot = RNA_property_collection_length(ptr, iterprop);
+  PropertyRNA *iterprop = RNA_struct_iterator_property(ptr.type);
+  int tot = RNA_property_collection_length(&ptr, iterprop);
   CLAMP_MAX(tot, max_index);
 
+  TreeElementRNAProperty *parent_prop_te = legacy_te_.parent ?
+                                               tree_element_cast<TreeElementRNAProperty>(
+                                                   legacy_te_.parent) :
+                                               nullptr;
   /* auto open these cases */
-  if (!legacy_te_.parent ||
-      (RNA_property_type(reinterpret_cast<PropertyRNA *>(legacy_te_.parent->directdata))) ==
-          PROP_POINTER) {
+  if (!parent_prop_te || (RNA_property_type(parent_prop_te->getPropertyRNA()) == PROP_POINTER)) {
     if (!tselem.used) {
       tselem.flag &= ~TSE_CLOSED;
     }
@@ -118,14 +130,10 @@ void TreeElementRNAStruct::expand(SpaceOutliner &space_outliner) const
   if (TSELEM_OPEN(&tselem, &space_outliner)) {
     for (int index = 0; index < tot; index++) {
       PointerRNA propptr;
-      RNA_property_collection_lookup_int(ptr, iterprop, index, &propptr);
+      RNA_property_collection_lookup_int(&ptr, iterprop, index, &propptr);
       if (!(RNA_property_flag(reinterpret_cast<PropertyRNA *>(propptr.data)) & PROP_HIDDEN)) {
-        outliner_add_element(&space_outliner,
-                             &legacy_te_.subtree,
-                             (void *)ptr,
-                             &legacy_te_,
-                             TSE_RNA_PROPERTY,
-                             index);
+        outliner_add_element(
+            &space_outliner, &legacy_te_.subtree, &ptr, &legacy_te_, TSE_RNA_PROPERTY, index);
       }
     }
   }
@@ -142,6 +150,8 @@ TreeElementRNAProperty::TreeElementRNAProperty(TreeElement &legacy_te,
                                                const int index)
     : TreeElementRNACommon(legacy_te, rna_ptr)
 {
+  BLI_assert(legacy_te.store_elem->type == TSE_RNA_PROPERTY);
+
   if (!isRNAValid()) {
     return;
   }
@@ -153,7 +163,6 @@ TreeElementRNAProperty::TreeElementRNAProperty(TreeElement &legacy_te,
   PropertyRNA *prop = reinterpret_cast<PropertyRNA *>(propptr.data);
 
   legacy_te_.name = RNA_property_ui_name(prop);
-  legacy_te_.directdata = prop;
   rna_prop_ = prop;
 }
 
@@ -174,7 +183,7 @@ void TreeElementRNAProperty::expand(SpaceOutliner &space_outliner) const
     if (pptr.data) {
       if (TSELEM_OPEN(&tselem, &space_outliner)) {
         outliner_add_element(
-            &space_outliner, &legacy_te_.subtree, (void *)&pptr, &legacy_te_, TSE_RNA_STRUCT, -1);
+            &space_outliner, &legacy_te_.subtree, &pptr, &legacy_te_, TSE_RNA_STRUCT, -1);
       }
       else {
         legacy_te_.flag |= TE_LAZY_CLOSED;
@@ -189,12 +198,8 @@ void TreeElementRNAProperty::expand(SpaceOutliner &space_outliner) const
       for (int index = 0; index < tot; index++) {
         PointerRNA pptr;
         RNA_property_collection_lookup_int(&rna_ptr, rna_prop_, index, &pptr);
-        outliner_add_element(&space_outliner,
-                             &legacy_te_.subtree,
-                             (void *)&pptr,
-                             &legacy_te_,
-                             TSE_RNA_STRUCT,
-                             index);
+        outliner_add_element(
+            &space_outliner, &legacy_te_.subtree, &pptr, &legacy_te_, TSE_RNA_STRUCT, index);
       }
     }
     else if (tot) {
@@ -221,6 +226,11 @@ void TreeElementRNAProperty::expand(SpaceOutliner &space_outliner) const
   }
 }
 
+PropertyRNA *TreeElementRNAProperty::getPropertyRNA() const
+{
+  return rna_prop_;
+}
+
 /* -------------------------------------------------------------------- */
 /* RNA Array Element */
 
@@ -229,11 +239,12 @@ TreeElementRNAArrayElement::TreeElementRNAArrayElement(TreeElement &legacy_te,
                                                        const int index)
     : TreeElementRNACommon(legacy_te, rna_ptr)
 {
-  PropertyRNA *prop = reinterpret_cast<PropertyRNA *>(legacy_te_.parent->directdata);
-  legacy_te_.directdata = prop;
+  BLI_assert(legacy_te.store_elem->type == TSE_RNA_ARRAY_ELEM);
+
+  BLI_assert(legacy_te.parent && (legacy_te.parent->store_elem->type == TSE_RNA_PROPERTY));
   legacy_te_.index = index;
 
-  char c = RNA_property_array_item_char(prop, index);
+  char c = RNA_property_array_item_char(TreeElementRNAArrayElement::getPropertyRNA(), index);
 
   legacy_te_.name = reinterpret_cast<char *>(
       MEM_callocN(sizeof(char[20]), "OutlinerRNAArrayName"));
@@ -246,4 +257,12 @@ TreeElementRNAArrayElement::TreeElementRNAArrayElement(TreeElement &legacy_te,
   legacy_te_.flag |= TE_FREE_NAME;
 }
 
+PropertyRNA *TreeElementRNAArrayElement::getPropertyRNA() const
+{
+  /* Forward query to the parent (which is expected to be a #TreeElementRNAProperty). */
+  const TreeElementRNAProperty *parent_prop_te = tree_element_cast<TreeElementRNAProperty>(
+      legacy_te_.parent);
+  return parent_prop_te ? parent_prop_te->getPropertyRNA() : nullptr;
+}
+
 }  // namespace blender::ed::outliner
diff --git a/source/blender/editors/space_outliner/tree/tree_element_rna.hh b/source/blender/editors/space_outliner/tree/tree_element_rna.hh
index 352b8763acb..1f107ddbf88 100644
--- a/source/blender/editors/space_outliner/tree/tree_element_rna.hh
+++ b/source/blender/editors/space_outliner/tree/tree_element_rna.hh
@@ -43,6 +43,13 @@ class TreeElementRNACommon : public AbstractTreeElement {
   bool isExpandValid() const override;
   bool expandPoll(const SpaceOutliner &) const override;
 
+  const PointerRNA &getPointerRNA() const;
+  /**
+   * If this element represents a property or is part of a property (array element), this returns
+   * the property. Otherwise nullptr.
+   */
+  virtual PropertyRNA *getPropertyRNA() const;
+
   bool isRNAValid() const;
 };
 
@@ -63,6 +70,8 @@ class TreeElementRNAProperty : public TreeElementRNACommon {
  public:
   TreeElementRNAProperty(TreeElement &legacy_te, PointerRNA &rna_ptr, int index);
   void expand(SpaceOutliner &space_outliner) const override;
+
+  PropertyRNA *getPropertyRNA() const override;
 };
 
 /* -------------------------------------------------------------------- */
@@ -70,6 +79,8 @@ class TreeElementRNAProperty : public TreeElementRNACommon {
 class TreeElementRNAArrayElement : public TreeElementRNACommon {
  public:
   TreeElementRNAArrayElement(TreeElement &legacy_te, PointerRNA &rna_ptr, int index);
+
+  PropertyRNA *getPropertyRNA() const override;
 };
 
 }  // namespace blender::ed::outliner
diff --git a/source/blender/editors/space_outliner/tree/tree_element_seq.cc b/source/blender/editors/space_outliner/tree/tree_element_seq.cc
new file mode 100644
index 00000000000..8d0b4c140c7
--- /dev/null
+++ b/source/blender/editors/space_outliner/tree/tree_element_seq.cc
@@ -0,0 +1,111 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup spoutliner
+ */
+
+#include "DNA_outliner_types.h"
+#include "DNA_sequence_types.h"
+
+#include "BLI_listbase.h"
+
+#include "BLT_translation.h"
+
+#include "../outliner_intern.hh"
+#include "tree_element_seq.hh"
+
+namespace blender::ed::outliner {
+
+TreeElementSequence::TreeElementSequence(TreeElement &legacy_te, Sequence &sequence)
+    : AbstractTreeElement(legacy_te), sequence_(sequence)
+{
+  BLI_assert(legacy_te.store_elem->type == TSE_SEQUENCE);
+
+  /*
+   * The idcode is a little hack, but the outliner
+   * only check te->idcode if te->type is equal to zero,
+   * so this is "safe".
+   */
+  legacy_te.idcode = sequence_.type;
+  legacy_te.name = sequence_.name + 2;
+}
+
+bool TreeElementSequence::expandPoll(const SpaceOutliner & /*space_outliner*/) const
+{
+  return !(sequence_.type & SEQ_TYPE_EFFECT);
+}
+
+void TreeElementSequence::expand(SpaceOutliner &space_outliner) const
+{
+  /*
+   * This work like the sequence.
+   * If the sequence have a name (not default name)
+   * show it, in other case put the filename.
+   */
+
+  if (sequence_.type == SEQ_TYPE_META) {
+    LISTBASE_FOREACH (Sequence *, child, &sequence_.seqbase) {
+      outliner_add_element(
+          &space_outliner, &legacy_te_.subtree, child, &legacy_te_, TSE_SEQUENCE, 0);
+    }
+  }
+  else {
+    outliner_add_element(
+        &space_outliner, &legacy_te_.subtree, sequence_.strip, &legacy_te_, TSE_SEQ_STRIP, 0);
+  }
+}
+
+Sequence &TreeElementSequence::getSequence() const
+{
+  return sequence_;
+}
+
+/* -------------------------------------------------------------------- */
+/* Strip */
+
+TreeElementSequenceStrip::TreeElementSequenceStrip(TreeElement &legacy_te, Strip &strip)
+    : AbstractTreeElement(legacy_te)
+{
+  BLI_assert(legacy_te.store_elem->type == TSE_SEQ_STRIP);
+
+  if (strip.dir[0] != '\0') {
+    legacy_te_.name = strip.dir;
+  }
+  else {
+    legacy_te_.name = IFACE_("Strip None");
+  }
+}
+
+/* -------------------------------------------------------------------- */
+/* Strip Duplicate */
+
+TreeElementSequenceStripDuplicate::TreeElementSequenceStripDuplicate(TreeElement &legacy_te,
+                                                                     Sequence &sequence)
+    : AbstractTreeElement(legacy_te), sequence_(sequence)
+{
+  BLI_assert(legacy_te.store_elem->type == TSE_SEQUENCE_DUP);
+
+  legacy_te_.idcode = sequence.type;
+  legacy_te_.name = sequence.strip->stripdata->name;
+}
+
+Sequence &TreeElementSequenceStripDuplicate::getSequence() const
+{
+  return sequence_;
+}
+
+}  // namespace blender::ed::outliner
diff --git a/source/blender/editors/space_outliner/tree/tree_element_seq.hh b/source/blender/editors/space_outliner/tree/tree_element_seq.hh
new file mode 100644
index 00000000000..2b334b5b7fa
--- /dev/null
+++ b/source/blender/editors/space_outliner/tree/tree_element_seq.hh
@@ -0,0 +1,60 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup spoutliner
+ */
+
+#pragma once
+
+#include "tree_element.hh"
+
+struct Sequence;
+struct Strip;
+
+namespace blender::ed::outliner {
+
+class TreeElementSequence : public AbstractTreeElement {
+  Sequence &sequence_;
+
+ public:
+  TreeElementSequence(TreeElement &legacy_te, Sequence &sequence);
+
+  bool expandPoll(const SpaceOutliner &) const override;
+  void expand(SpaceOutliner &) const override;
+
+  Sequence &getSequence() const;
+};
+
+/* -------------------------------------------------------------------- */
+
+class TreeElementSequenceStrip : public AbstractTreeElement {
+ public:
+  TreeElementSequenceStrip(TreeElement &legacy_te, Strip &strip);
+};
+
+/* -------------------------------------------------------------------- */
+
+class TreeElementSequenceStripDuplicate : public AbstractTreeElement {
+  Sequence &sequence_;
+
+ public:
+  TreeElementSequenceStripDuplicate(TreeElement &legacy_te, Sequence &sequence);
+
+  Sequence &getSequence() const;
+};
+
+}  // namespace blender::ed::outliner
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
index 68b609f8045..81421609dfd 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
@@ -44,7 +44,9 @@ static void node_declare(NodeDeclarationBuilder &b)
       .subtype(PropertySubType::PROP_DISTANCE)
       .default_value(0.25f)
       .supports_field();
-  b.add_input<decl::Bool>(N_("Limit Radius"));
+  b.add_input<decl::Bool>(N_("Limit Radius"))
+      .description(
+          N_("Limit the maximum value of the radius in order to avoid overlapping fillets"));
   b.add_output<decl::Geometry>(N_("Curve"));
 }
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
index ae282017e0c..c2b9ddfb114 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
@@ -30,7 +30,12 @@ namespace blender::nodes::node_geo_curve_subdivide_cc {
 static void node_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Curve")).supported_type(GEO_COMPONENT_TYPE_CURVE);
-  b.add_input<decl::Int>(N_("Cuts")).default_value(1).min(0).max(1000).supports_field();
+  b.add_input<decl::Int>(N_("Cuts"))
+      .default_value(1)
+      .min(0)
+      .max(1000)
+      .supports_field()
+      .description(N_("The number of control points to create on the segment following each point"));
   b.add_output<decl::Geometry>(N_("Curve"));
 }
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
index 3fe0588a46d..afe7546f7e5 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
@@ -20,7 +20,9 @@ namespace blender::nodes::node_geo_input_id_cc {
 
 static void node_declare(NodeDeclarationBuilder &b)
 {
-  b.add_output<decl::Int>(N_("ID")).field_source();
+  b.add_output<decl::Int>(N_("ID")).field_source().description(
+      N_("The values from the \"id\" attribute on points, or the index if that attribute does not "
+         "exist"));
 }
 
 static void node_geo_exec(GeoNodeExecParams params)
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc
index ddeb3ded511..43c867e0977 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc
@@ -27,7 +27,7 @@ static void node_declare(NodeDeclarationBuilder &b)
 {
   b.add_output<decl::Int>(N_("Face Count"))
       .field_source()
-      .description(N_("Number of faces that contain the edge"));
+      .description(N_("The number of faces that use each edge as one of their sides"));
 }
 
 class EdgeNeighborCountFieldInput final : public GeometryFieldInput {
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
index 68bb93bbb64..f1777c9ebf5 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc
@@ -29,8 +29,8 @@ static void node_declare(NodeDeclarationBuilder &b)
 {
   b.add_output<decl::Int>(N_("Island Index"))
       .field_source()
-      .description(N_("Island indices are based on the order of the lowest-numbered vertex "
-                      "contained in each island"));
+      .description(N_("The index of the each vertex's island. Indices are based on the "
+                      "lowest vertex index contained in each island"));
   b.add_output<decl::Int>(N_("Island Count"))
       .field_source()
       .description(N_("The total number of mesh islands"));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc
index 7d79164634d..c2da065cbfc 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc
@@ -27,7 +27,8 @@ static void node_declare(NodeDeclarationBuilder &b)
 {
   b.add_output<decl::Int>(N_("Vertex Count"))
       .field_source()
-      .description(N_("Vertex count and edge count are equal"));
+      .description(N_("The number of vertices connected to this vertex with an edge, "
+                      "equal to the number of connected edges"));
   b.add_output<decl::Int>(N_("Face Count"))
       .field_source()
       .description(N_("Number of faces that contain the vertex"));
diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
index 71256a7f781..06f24113308 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
@@ -36,7 +36,8 @@ static void node_declare(NodeDeclarationBuilder &b)
       .description(N_("Geometry that is instanced on the points"));
   b.add_input<decl::Bool>(N_("Pick Instance"))
       .supports_field()
-      .description(N_("Place different instances on different points"));
+      .description(N_("Choose instances from the \"Instance\" input at each point instead of "
+                      "instancing the entire geometry"));
   b.add_input<decl::Int>(N_("Instance Index"))
       .implicit_field()
       .description(N_(
diff --git a/source/blender/nodes/intern/node_exec.cc b/source/blender/nodes/intern/node_exec.cc
index 4ff662036c3..788d938ca6f 100644
--- a/source/blender/nodes/intern/node_exec.cc
+++ b/source/blender/nodes/intern/node_exec.cc
@@ -35,7 +35,7 @@
 #include "node_exec.h"
 #include "node_util.h"
 
-int node_exec_socket_use_stack(bNodeSocket *sock)
+static int node_exec_socket_use_stack(bNodeSocket *sock)
 {
   /* NOTE: INT supported as FLOAT. Only for EEVEE. */
   return ELEM(sock->type, SOCK_INT, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA, SOCK_SHADER);
@@ -276,60 +276,3 @@ void ntree_exec_end(bNodeTreeExec *exec)
 
   MEM_freeN(exec);
 }
-
-/**** Material/Texture trees ****/
-
-bNodeThreadStack *ntreeGetThreadStack(bNodeTreeExec *exec, int thread)
-{
-  ListBase *lb = &exec->threadstack[thread];
-  bNodeThreadStack *nts;
-
-  for (nts = (bNodeThreadStack *)lb->first; nts; nts = nts->next) {
-    if (!nts->used) {
-      nts->used = true;
-      break;
-    }
-  }
-
-  if (!nts) {
-    nts = MEM_cnew<bNodeThreadStack>("bNodeThreadStack");
-    nts->stack = (bNodeStack *)MEM_dupallocN(exec->stack);
-    nts->used = true;
-    BLI_addtail(lb, nts);
-  }
-
-  return nts;
-}
-
-void ntreeReleaseThreadStack(bNodeThreadStack *nts)
-{
-  nts->used = false;
-}
-
-bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *callerdata, int thread)
-{
-  bNodeStack *nsin[MAX_SOCKET] = {nullptr};  /* arbitrary... watch this */
-  bNodeStack *nsout[MAX_SOCKET] = {nullptr}; /* arbitrary... watch this */
-  bNodeExec *nodeexec;
-  bNode *node;
-  int n;
-
-  /* nodes are presorted, so exec is in order of list */
-
-  for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; n++, nodeexec++) {
-    node = nodeexec->node;
-    if (node->need_exec) {
-      node_get_stack(node, nts->stack, nsin, nsout);
-      /* Handle muted nodes...
-       * If the mute func is not set, assume the node should never be muted,
-       * and hence execute it!
-       */
-      if (node->typeinfo->exec_fn && !(node->flag & NODE_MUTED)) {
-        node->typeinfo->exec_fn(callerdata, thread, node, &nodeexec->data, nsin, nsout);
-      }
-    }
-  }
-
-  /* signal to that all went OK, for render */
-  return true;
-}
diff --git a/source/blender/nodes/intern/node_exec.h b/source/blender/nodes/intern/node_exec.h
index b2e1c6564b6..115389afd67 100644
--- a/source/blender/nodes/intern/node_exec.h
+++ b/source/blender/nodes/intern/node_exec.h
@@ -71,9 +71,6 @@ typedef struct bNodeThreadStack {
   bool used;
 } bNodeThreadStack;
 
-/** Supported socket types in old nodes. */
-int node_exec_socket_use_stack(struct bNodeSocket *sock);
-
 /** For a given socket, find the actual stack entry. */
 struct bNodeStack *node_get_socket_stack(struct bNodeStack *stack, struct bNodeSocket *sock);
 void node_get_stack(struct bNode *node,
@@ -86,23 +83,6 @@ struct bNodeTreeExec *ntree_exec_begin(struct bNodeExecContext *context,
                                        bNodeInstanceKey parent_key);
 void ntree_exec_end(struct bNodeTreeExec *exec);
 
-struct bNodeThreadStack *ntreeGetThreadStack(struct bNodeTreeExec *exec, int thread);
-void ntreeReleaseThreadStack(struct bNodeThreadStack *nts);
-bool ntreeExecThreadNodes(struct bNodeTreeExec *exec,
-                          struct bNodeThreadStack *nts,
-                          void *callerdata,
-                          int thread);
-
-struct bNodeTreeExec *ntreeShaderBeginExecTree_internal(struct bNodeExecContext *context,
-                                                        struct bNodeTree *ntree,
-                                                        bNodeInstanceKey parent_key);
-void ntreeShaderEndExecTree_internal(struct bNodeTreeExec *exec);
-
-struct bNodeTreeExec *ntreeTexBeginExecTree_internal(struct bNodeExecContext *context,
-                                                     struct bNodeTree *ntree,
-                                                     bNodeInstanceKey parent_key);
-void ntreeTexEndExecTree_internal(struct bNodeTreeExec *exec);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/nodes/shader/node_shader_util.hh b/source/blender/nodes/shader/node_shader_util.hh
index 5a5b4f613f3..31229c8693b 100644
--- a/source/blender/nodes/shader/node_shader_util.hh
+++ b/source/blender/nodes/shader/node_shader_util.hh
@@ -101,6 +101,11 @@ void node_shader_gpu_tex_mapping(struct GPUMaterial *mat,
                                  struct GPUNodeStack *in,
                                  struct GPUNodeStack *out);
 
+struct bNodeTreeExec *ntreeShaderBeginExecTree_internal(struct bNodeExecContext *context,
+                                                        struct bNodeTree *ntree,
+                                                        bNodeInstanceKey parent_key);
+void ntreeShaderEndExecTree_internal(struct bNodeTreeExec *exec);
+
 void ntreeExecGPUNodes(struct bNodeTreeExec *exec,
                        struct GPUMaterial *mat,
                        struct bNode *output_node);
diff --git a/source/blender/nodes/texture/node_texture_tree.c b/source/blender/nodes/texture/node_texture_tree.c
index 3d914d486c3..82ed43be779 100644
--- a/source/blender/nodes/texture/node_texture_tree.c
+++ b/source/blender/nodes/texture/node_texture_tree.c
@@ -170,6 +170,63 @@ void register_node_tree_type_tex(void)
   ntreeTypeAdd(tt);
 }
 
+/**** Material/Texture trees ****/
+
+bNodeThreadStack *ntreeGetThreadStack(bNodeTreeExec *exec, int thread)
+{
+  ListBase *lb = &exec->threadstack[thread];
+  bNodeThreadStack *nts;
+
+  for (nts = (bNodeThreadStack *)lb->first; nts; nts = nts->next) {
+    if (!nts->used) {
+      nts->used = true;
+      break;
+    }
+  }
+
+  if (!nts) {
+    nts = MEM_callocN(sizeof(bNodeThreadStack), "bNodeThreadStack");
+    nts->stack = (bNodeStack *)MEM_dupallocN(exec->stack);
+    nts->used = true;
+    BLI_addtail(lb, nts);
+  }
+
+  return nts;
+}
+
+void ntreeReleaseThreadStack(bNodeThreadStack *nts)
+{
+  nts->used = false;
+}
+
+bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *callerdata, int thread)
+{
+  bNodeStack *nsin[MAX_SOCKET] = {NULL};  /* arbitrary... watch this */
+  bNodeStack *nsout[MAX_SOCKET] = {NULL}; /* arbitrary... watch this */
+  bNodeExec *nodeexec;
+  bNode *node;
+  int n;
+
+  /* nodes are presorted, so exec is in order of list */
+
+  for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; n++, nodeexec++) {
+    node = nodeexec->node;
+    if (node->need_exec) {
+      node_get_stack(node, nts->stack, nsin, nsout);
+      /* Handle muted nodes...
+       * If the mute func is not set, assume the node should never be muted,
+       * and hence execute it!
+       */
+      if (node->typeinfo->exec_fn && !(node->flag & NODE_MUTED)) {
+        node->typeinfo->exec_fn(callerdata, thread, node, &nodeexec->data, nsin, nsout);
+      }
+    }
+  }
+
+  /* signal to that all went OK, for render */
+  return true;
+}
+
 bNodeTreeExec *ntreeTexBeginExecTree_internal(bNodeExecContext *context,
                                               bNodeTree *ntree,
                                               bNodeInstanceKey parent_key)
diff --git a/source/blender/nodes/texture/node_texture_util.h b/source/blender/nodes/texture/node_texture_util.h
index d53000058a3..7c8e39925bc 100644
--- a/source/blender/nodes/texture/node_texture_util.h
+++ b/source/blender/nodes/texture/node_texture_util.h
@@ -123,6 +123,18 @@ void tex_output(bNode *node,
 
 void params_from_cdata(TexParams *out, TexCallData *in);
 
+struct bNodeThreadStack *ntreeGetThreadStack(struct bNodeTreeExec *exec, int thread);
+void ntreeReleaseThreadStack(struct bNodeThreadStack *nts);
+bool ntreeExecThreadNodes(struct bNodeTreeExec *exec,
+                          struct bNodeThreadStack *nts,
+                          void *callerdata,
+                          int thread);
+
+struct bNodeTreeExec *ntreeTexBeginExecTree_internal(struct bNodeExecContext *context,
+                                                     struct bNodeTree *ntree,
+                                                     bNodeInstanceKey parent_key);
+void ntreeTexEndExecTree_internal(struct bNodeTreeExec *exec);
+
 #ifdef __cplusplus
 }
 #endif