Geometry Nodes: new geometry attribute API

Currently, there are two attribute API. The first, defined in `BKE_attribute.h` is
accessible from RNA and C code. The second is implemented with `GeometryComponent`
and is only accessible in C++ code. The second is widely used, but only being
accessible through the `GeometrySet` API makes it awkward to use, and even impossible
for types that don't correspond directly to a geometry component like `CurvesGeometry`.

This patch adds a new attribute API, designed to replace the `GeometryComponent`
attribute API now, and to eventually replace or be the basis of the other one.

The basic idea is that there is an `AttributeAccessor` class that allows code to
interact with a set of attributes owned by some geometry. The accessor itself has
no ownership. `AttributeAccessor` is a simple type that can be passed around by
value. That makes it easy to return it from functions and to store it in containers.

For const-correctness, there is also a `MutableAttributeAccessor` that allows
changing individual and can add or remove attributes.

Currently, `AttributeAccessor` is composed of two pointers. The first is a pointer
to the owner of the attribute data. The second is a pointer to a struct with
function pointers, that is similar to a virtual function table. The functions
know how to access attributes on the owner.

The actual attribute access for geometries is still implemented with the `AttributeProvider`
pattern, which makes it easy to support different sources of attributes on a
geometry and simplifies dealing with built-in attributes.

There are different ways to get an attribute accessor for a geometry:
* `GeometryComponent.attributes()`
* `CurvesGeometry.attributes()`
* `bke::mesh_attributes(const Mesh &)`
* `bke::pointcloud_attributes(const PointCloud &)`

All of these also have a `_for_write` variant that returns a `MutabelAttributeAccessor`.

Differential Revision: https://developer.blender.org/D15280

10 files changed, 83 insertions, 91 deletions

diff --git a/source/blender/editors/curves/intern/curves_ops.cc b/source/blender/editors/curves/intern/curves_ops.cc
index 49e21d00195..a4492a1d516 100644
--- a/source/blender/editors/curves/intern/curves_ops.cc
+++ b/source/blender/editors/curves/intern/curves_ops.cc
@@ -533,9 +533,9 @@ static void snap_curves_to_surface_exec_object(Object &curves_ob,
 
   VArraySpan<float2> surface_uv_map;
   if (curves_id.surface_uv_map != nullptr) {
-    surface_uv_map = surface_mesh_component
-                         .attribute_try_get_for_read(
-                             curves_id.surface_uv_map, ATTR_DOMAIN_CORNER, CD_PROP_FLOAT2)
+    const bke::AttributeAccessor surface_attributes = bke::mesh_attributes(surface_mesh);
+    surface_uv_map = surface_attributes
+                         .lookup(curves_id.surface_uv_map, ATTR_DOMAIN_CORNER, CD_PROP_FLOAT2)
                          .typed<float2>();
   }
 
@@ -756,21 +756,20 @@ static int curves_set_selection_domain_exec(bContext *C, wmOperator *op)
     curves_id->selection_domain = domain;
     curves_id->flag |= CV_SCULPT_SELECTION_ENABLED;
 
-    CurveComponent component;
-    component.replace(curves_id, GeometryOwnershipType::Editable);
     CurvesGeometry &curves = CurvesGeometry::wrap(curves_id->geometry);
+    bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
 
     if (old_domain == ATTR_DOMAIN_POINT && domain == ATTR_DOMAIN_CURVE) {
       VArray<float> curve_selection = curves.adapt_domain(
           curves.selection_point_float(), ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE);
       curve_selection.materialize(curves.selection_curve_float_for_write());
-      component.attribute_try_delete(".selection_point_float");
+      attributes.remove(".selection_point_float");
     }
     else if (old_domain == ATTR_DOMAIN_CURVE && domain == ATTR_DOMAIN_POINT) {
       VArray<float> point_selection = curves.adapt_domain(
           curves.selection_curve_float(), ATTR_DOMAIN_CURVE, ATTR_DOMAIN_POINT);
       point_selection.materialize(curves.selection_point_float_for_write());
-      component.attribute_try_delete(".selection_curve_float");
+      attributes.remove(".selection_curve_float");
     }
 
     /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic
@@ -900,15 +899,14 @@ static int select_all_exec(bContext *C, wmOperator *op)
   }
 
   for (Curves *curves_id : unique_curves) {
+    CurvesGeometry &curves = CurvesGeometry::wrap(curves_id->geometry);
     if (action == SEL_SELECT) {
       /* As an optimization, just remove the selection attributes when everything is selected. */
-      CurveComponent component;
-      component.replace(curves_id, GeometryOwnershipType::Editable);
-      component.attribute_try_delete(".selection_point_float");
-      component.attribute_try_delete(".selection_curve_float");
+      bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
+      attributes.remove(".selection_point_float");
+      attributes.remove(".selection_curve_float");
     }
     else {
-      CurvesGeometry &curves = CurvesGeometry::wrap(curves_id->geometry);
       MutableSpan<float> selection = curves_id->selection_domain == ATTR_DOMAIN_POINT ?
                                          curves.selection_point_float_for_write() :
                                          curves.selection_curve_float_for_write();
diff --git a/source/blender/editors/geometry/geometry_attributes.cc b/source/blender/editors/geometry/geometry_attributes.cc
index c7e782b7b89..4cf14334ac7 100644
--- a/source/blender/editors/geometry/geometry_attributes.cc
+++ b/source/blender/editors/geometry/geometry_attributes.cc
@@ -282,8 +282,7 @@ static int geometry_attribute_convert_exec(bContext *C, wmOperator *op)
       RNA_enum_get(op->ptr, "mode"));
 
   Mesh *mesh = reinterpret_cast<Mesh *>(ob_data);
-  MeshComponent mesh_component;
-  mesh_component.replace(mesh, GeometryOwnershipType::Editable);
+  bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*mesh);
 
   /* General conversion steps are always the same:
    * 1. Convert old data to right domain and data type.
@@ -301,33 +300,33 @@ static int geometry_attribute_convert_exec(bContext *C, wmOperator *op)
         return OPERATOR_CANCELLED;
       }
 
-      GVArray src_varray = mesh_component.attribute_get_for_read(name, dst_domain, dst_type);
+      GVArray src_varray = attributes.lookup_or_default(name, dst_domain, dst_type);
       const CPPType &cpp_type = src_varray.type();
       void *new_data = MEM_malloc_arrayN(src_varray.size(), cpp_type.size(), __func__);
       src_varray.materialize_to_uninitialized(new_data);
-      mesh_component.attribute_try_delete(name);
-      mesh_component.attribute_try_create(name, dst_domain, dst_type, AttributeInitMove(new_data));
+      attributes.remove(name);
+      attributes.add(name, dst_domain, dst_type, blender::bke::AttributeInitMove(new_data));
       break;
     }
     case ConvertAttributeMode::UVMap: {
       MLoopUV *dst_uvs = static_cast<MLoopUV *>(
           MEM_calloc_arrayN(mesh->totloop, sizeof(MLoopUV), __func__));
-      VArray<float2> src_varray = mesh_component.attribute_get_for_read<float2>(
+      VArray<float2> src_varray = attributes.lookup_or_default<float2>(
           name, ATTR_DOMAIN_CORNER, {0.0f, 0.0f});
       for (const int i : IndexRange(mesh->totloop)) {
         copy_v2_v2(dst_uvs[i].uv, src_varray[i]);
       }
-      mesh_component.attribute_try_delete(name);
+      attributes.remove(name);
       CustomData_add_layer_named(
           &mesh->ldata, CD_MLOOPUV, CD_ASSIGN, dst_uvs, mesh->totloop, name.c_str());
       break;
     }
     case ConvertAttributeMode::VertexGroup: {
       Array<float> src_weights(mesh->totvert);
-      VArray<float> src_varray = mesh_component.attribute_get_for_read<float>(
+      VArray<float> src_varray = attributes.lookup_or_default<float>(
           name, ATTR_DOMAIN_POINT, 0.0f);
       src_varray.materialize(src_weights);
-      mesh_component.attribute_try_delete(name);
+      attributes.remove(name);
 
       bDeformGroup *defgroup = BKE_object_defgroup_new(ob, name.c_str());
       const int defgroup_index = BLI_findindex(BKE_id_defgroup_list_get(&mesh->id), defgroup);
@@ -652,15 +651,16 @@ bool ED_geometry_attribute_convert(Mesh *mesh,
     return false;
   }
 
-  MeshComponent mesh_component;
-  mesh_component.replace(mesh, GeometryOwnershipType::Editable);
-  GVArray src_varray = mesh_component.attribute_get_for_read(name, new_domain, new_type);
+  blender::bke::MutableAttributeAccessor attributes = blender::bke::mesh_attributes_for_write(
+      *mesh);
+
+  GVArray src_varray = attributes.lookup_or_default(name, new_domain, new_type);
 
   const CPPType &cpp_type = src_varray.type();
   void *new_data = MEM_malloc_arrayN(src_varray.size(), cpp_type.size(), __func__);
   src_varray.materialize_to_uninitialized(new_data);
-  mesh_component.attribute_try_delete(name);
-  mesh_component.attribute_try_create(name, new_domain, new_type, AttributeInitMove(new_data));
+  attributes.remove(name);
+  attributes.add(name, new_domain, new_type, blender::bke::AttributeInitMove(new_data));
 
   int *active_index = BKE_id_attributes_active_index_p(&mesh->id);
   if (*active_index > 0) {
diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc
index a2c08109ec0..66e76addd6f 100644
--- a/source/blender/editors/object/object_add.cc
+++ b/source/blender/editors/object/object_add.cc
@@ -3177,9 +3177,7 @@ static int object_convert_exec(bContext *C, wmOperator *op)
       }
 
       /* Anonymous attributes shouldn't be available on the applied geometry. */
-      MeshComponent component;
-      component.replace(new_mesh, GeometryOwnershipType::Editable);
-      component.attributes_remove_anonymous();
+      blender::bke::mesh_attributes_for_write(*new_mesh).remove_anonymous();
 
       BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
     }
diff --git a/source/blender/editors/object/object_modifier.cc b/source/blender/editors/object/object_modifier.cc
index 202c6d96a47..69edd00ae24 100644
--- a/source/blender/editors/object/object_modifier.cc
+++ b/source/blender/editors/object/object_modifier.cc
@@ -757,9 +757,7 @@ static bool modifier_apply_obdata(
       BKE_mesh_nomain_to_mesh(mesh_applied, me, ob, &CD_MASK_MESH, true);
 
       /* Anonymous attributes shouldn't be available on the applied geometry. */
-      MeshComponent component;
-      component.replace(me, GeometryOwnershipType::Editable);
-      component.attributes_remove_anonymous();
+      blender::bke::mesh_attributes_for_write(*me).remove_anonymous();
 
       if (md_eval->type == eModifierType_Multires) {
         multires_customdata_delete(me);
@@ -828,11 +826,12 @@ static bool modifier_apply_obdata(
       BKE_report(reports, RPT_ERROR, "Evaluated geometry from modifier does not contain curves");
       return false;
     }
-    CurveComponent &component = geometry_set.get_component_for_write<CurveComponent>();
     Curves &curves_eval = *geometry_set.get_curves_for_write();
 
     /* Anonymous attributes shouldn't be available on the applied geometry. */
-    component.attributes_remove_anonymous();
+    blender::bke::CurvesGeometry::wrap(curves_eval.geometry)
+        .attributes_for_write()
+        .remove_anonymous();
 
     /* If the modifier's output is a different curves data-block, copy the relevant information to
      * the original. */
diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
index 401550b3b3a..26145a386f5 100644
--- a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
+++ b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc
@@ -176,12 +176,9 @@ struct AddOperationExecutor {
     /* Find UV map. */
     VArraySpan<float2> surface_uv_map;
     if (curves_id_->surface_uv_map != nullptr) {
-      MeshComponent surface_component;
-      surface_component.replace(surface_, GeometryOwnershipType::ReadOnly);
-      surface_uv_map = surface_component
-                           .attribute_try_get_for_read(curves_id_->surface_uv_map,
-                                                       ATTR_DOMAIN_CORNER)
-                           .typed<float2>();
+      const bke::AttributeAccessor surface_attributes = bke::mesh_attributes(*surface_);
+      surface_uv_map = surface_attributes.lookup<float2>(curves_id_->surface_uv_map,
+                                                         ATTR_DOMAIN_CORNER);
     }
 
     /* Find normals. */
diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_density.cc b/source/blender/editors/sculpt_paint/curves_sculpt_density.cc
index 826b0611e81..e211a568705 100644
--- a/source/blender/editors/sculpt_paint/curves_sculpt_density.cc
+++ b/source/blender/editors/sculpt_paint/curves_sculpt_density.cc
@@ -64,7 +64,6 @@ struct DensityAddOperationExecutor {
   Mesh *surface_ = nullptr;
   Span<MLoopTri> surface_looptris_;
   Span<float3> corner_normals_su_;
-  VArraySpan<float2> surface_uv_map_;
 
   const CurvesSculpt *curves_sculpt_ = nullptr;
   const Brush *brush_ = nullptr;
@@ -228,12 +227,9 @@ struct DensityAddOperationExecutor {
     /* Find UV map. */
     VArraySpan<float2> surface_uv_map;
     if (curves_id_->surface_uv_map != nullptr) {
-      MeshComponent surface_component;
-      surface_component.replace(surface_, GeometryOwnershipType::ReadOnly);
-      surface_uv_map = surface_component
-                           .attribute_try_get_for_read(curves_id_->surface_uv_map,
-                                                       ATTR_DOMAIN_CORNER)
-                           .typed<float2>();
+      bke::AttributeAccessor surface_attributes = bke::mesh_attributes(*surface_);
+      surface_uv_map = surface_attributes.lookup<float2>(curves_id_->surface_uv_map,
+                                                         ATTR_DOMAIN_CORNER);
     }
 
     /* Find normals. */
diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc b/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc
index dedc880988d..aabe6fd93e4 100644
--- a/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc
+++ b/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc
@@ -148,12 +148,9 @@ struct SlideOperationExecutor {
                          BKE_mesh_runtime_looptri_len(surface_)};
 
     if (curves_id_->surface_uv_map != nullptr) {
-      MeshComponent surface_component;
-      surface_component.replace(surface_, GeometryOwnershipType::ReadOnly);
-      surface_uv_map_ = surface_component
-                            .attribute_try_get_for_read(curves_id_->surface_uv_map,
-                                                        ATTR_DOMAIN_CORNER)
-                            .typed<float2>();
+      const bke::AttributeAccessor surface_attributes = bke::mesh_attributes(*surface_);
+      surface_uv_map_ = surface_attributes.lookup<float2>(curves_id_->surface_uv_map,
+                                                          ATTR_DOMAIN_CORNER);
     }
 
     if (stroke_extension.is_first) {
diff --git a/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc b/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc
index 50f8854d90f..8b726c7b942 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc
@@ -92,11 +92,9 @@ static bool vertex_paint_from_weight(Object *ob)
     return false;
   }
 
-  MeshComponent component;
-  component.replace(me, GeometryOwnershipType::Editable);
+  bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*me);
 
-  bke::WriteAttributeLookup color_attribute = component.attribute_try_get_for_write(
-      active_color_layer->name);
+  bke::GAttributeWriter color_attribute = attributes.lookup_for_write(active_color_layer->name);
   if (!color_attribute) {
     BLI_assert_unreachable();
     return false;
@@ -104,7 +102,7 @@ static bool vertex_paint_from_weight(Object *ob)
 
   /* Retrieve the vertex group with the domain and type of the existing color
    * attribute, in order to let the attribute API handle both conversions. */
-  const GVArray vertex_group = component.attribute_get_for_read(
+  const GVArray vertex_group = attributes.lookup(
       deform_group->name,
       ATTR_DOMAIN_POINT,
       bke::cpp_type_to_custom_data_type(color_attribute.varray.type()));
@@ -113,14 +111,11 @@ static bool vertex_paint_from_weight(Object *ob)
     return false;
   }
 
-  GVArraySpan interpolated{component.attribute_try_adapt_domain(
-      vertex_group, ATTR_DOMAIN_POINT, color_attribute.domain)};
+  GVArraySpan interpolated{
+      attributes.adapt_domain(vertex_group, ATTR_DOMAIN_POINT, color_attribute.domain)};
 
   color_attribute.varray.set_all(interpolated.data());
-
-  if (color_attribute.tag_modified_fn) {
-    color_attribute.tag_modified_fn();
-  }
+  color_attribute.finish();
   tag_object_after_update(ob);
 
   return true;
@@ -167,29 +162,28 @@ static IndexMask get_selected_indices(const Mesh &mesh,
   Span<MVert> verts(mesh.mvert, mesh.totvert);
   Span<MPoly> faces(mesh.mpoly, mesh.totpoly);
 
-  MeshComponent component;
-  component.replace(&const_cast<Mesh &>(mesh), GeometryOwnershipType::ReadOnly);
+  bke::AttributeAccessor attributes = bke::mesh_attributes(mesh);
 
   if (mesh.editflag & ME_EDIT_PAINT_FACE_SEL) {
-    const VArray<bool> selection = component.attribute_try_adapt_domain(
+    const VArray<bool> selection = attributes.adapt_domain(
         VArray<bool>::ForFunc(faces.size(),
                               [&](const int i) { return faces[i].flag & ME_FACE_SEL; }),
         ATTR_DOMAIN_FACE,
         domain);
 
     return index_mask_ops::find_indices_from_virtual_array(
-        IndexMask(component.attribute_domain_num(domain)), selection, 4096, indices);
+        IndexMask(attributes.domain_size(domain)), selection, 4096, indices);
   }
   if (mesh.editflag & ME_EDIT_PAINT_VERT_SEL) {
-    const VArray<bool> selection = component.attribute_try_adapt_domain(
+    const VArray<bool> selection = attributes.adapt_domain(
         VArray<bool>::ForFunc(verts.size(), [&](const int i) { return verts[i].flag & SELECT; }),
         ATTR_DOMAIN_POINT,
         domain);
 
     return index_mask_ops::find_indices_from_virtual_array(
-        IndexMask(component.attribute_domain_num(domain)), selection, 4096, indices);
+        IndexMask(attributes.domain_size(domain)), selection, 4096, indices);
   }
-  return IndexMask(component.attribute_domain_num(domain));
+  return IndexMask(attributes.domain_size(domain));
 }
 
 static void face_corner_color_equalize_vertices(Mesh &mesh, const IndexMask selection)
@@ -202,17 +196,15 @@ static void face_corner_color_equalize_vertices(Mesh &mesh, const IndexMask sele
     return;
   }
 
-  MeshComponent component;
-  component.replace(&mesh, GeometryOwnershipType::Editable);
+  bke::AttributeAccessor attributes = bke::mesh_attributes(mesh);
 
-  if (component.attribute_get_meta_data(active_color_layer->name)->domain == ATTR_DOMAIN_POINT) {
+  if (attributes.lookup_meta_data(active_color_layer->name)->domain == ATTR_DOMAIN_POINT) {
     return;
   }
 
-  GVArray color_attribute_point = component.attribute_try_get_for_read(active_color_layer->name,
-                                                                       ATTR_DOMAIN_POINT);
+  GVArray color_attribute_point = attributes.lookup(active_color_layer->name, ATTR_DOMAIN_POINT);
 
-  GVArray color_attribute_corner = component.attribute_try_adapt_domain(
+  GVArray color_attribute_corner = attributes.adapt_domain(
       color_attribute_point, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CORNER);
 
   color_attribute_corner.materialize(selection, active_color_layer->data);
@@ -278,11 +270,9 @@ static bool transform_active_color(Mesh &mesh, const TransformFn &transform_fn)
     return false;
   }
 
-  MeshComponent component;
-  component.replace(&mesh, GeometryOwnershipType::Editable);
+  bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(mesh);
 
-  bke::WriteAttributeLookup color_attribute = component.attribute_try_get_for_write(
-      active_color_layer->name);
+  bke::GAttributeWriter color_attribute = attributes.lookup_for_write(active_color_layer->name);
   if (!color_attribute) {
     BLI_assert_unreachable();
     return false;
@@ -310,6 +300,8 @@ static bool transform_active_color(Mesh &mesh, const TransformFn &transform_fn)
     });
   });
 
+  color_attribute.finish();
+
   DEG_id_tag_update(&mesh.id, 0);
 
   return true;
diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
index 6be3a65cc1b..2a87c51da5d 100644
--- a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
+++ b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
@@ -3,6 +3,7 @@
 #include "BLI_index_mask_ops.hh"
 #include "BLI_virtual_array.hh"
 
+#include "BKE_attribute.hh"
 #include "BKE_context.h"
 #include "BKE_editmesh.h"
 #include "BKE_geometry_fields.hh"
@@ -65,7 +66,12 @@ std::unique_ptr<ColumnValues> ExtraColumns::get_column_values(
 void GeometryDataSource::foreach_default_column_ids(
     FunctionRef<void(const SpreadsheetColumnID &, bool is_extra)> fn) const
 {
-  if (component_->attribute_domain_num(domain_) == 0) {
+  if (!component_->attributes().has_value()) {
+    return;
+  }
+  const bke::AttributeAccessor attributes = *component_->attributes();
+
+  if (attributes.domain_size(domain_) == 0) {
     return;
   }
 
@@ -74,8 +80,9 @@ void GeometryDataSource::foreach_default_column_ids(
   }
 
   extra_columns_.foreach_default_column_ids(fn);
-  component_->attribute_foreach(
-      [&](const bke::AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
+
+  attributes.for_all(
+      [&](const bke::AttributeIDRef &attribute_id, const bke::AttributeMetaData &meta_data) {
         if (meta_data.domain != domain_) {
           return true;
         }
@@ -114,7 +121,11 @@ void GeometryDataSource::foreach_default_column_ids(
 std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
     const SpreadsheetColumnID &column_id) const
 {
-  const int domain_num = component_->attribute_domain_num(domain_);
+  if (!component_->attributes().has_value()) {
+    return {};
+  }
+  const bke::AttributeAccessor attributes = *component_->attributes();
+  const int domain_num = attributes.domain_size(domain_);
   if (domain_num == 0) {
     return {};
   }
@@ -200,7 +211,7 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
     }
   }
 
-  bke::ReadAttributeLookup attribute = component_->attribute_try_get_for_read(column_id.name);
+  bke::GAttributeReader attribute = attributes.lookup(column_id.name);
   if (!attribute) {
     return {};
   }
@@ -214,7 +225,11 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
 
 int GeometryDataSource::tot_rows() const
 {
-  return component_->attribute_domain_num(domain_);
+  if (!component_->attributes().has_value()) {
+    return {};
+  }
+  const bke::AttributeAccessor attributes = *component_->attributes();
+  return attributes.domain_size(domain_);
 }
 
 /**
@@ -253,7 +268,7 @@ IndexMask GeometryDataSource::apply_selection_filter(Vector<int64_t> &indices) c
   const int *orig_indices = (int *)CustomData_get_layer(&mesh_eval->vdata, CD_ORIGINDEX);
   if (orig_indices != nullptr) {
     /* Use CD_ORIGINDEX layer if it exists. */
-    VArray<bool> selection = mesh_component->attribute_try_adapt_domain<bool>(
+    VArray<bool> selection = mesh_component->attributes()->adapt_domain<bool>(
         VArray<bool>::ForFunc(mesh_eval->totvert,
                               [bm, orig_indices](int vertex_index) -> bool {
                                 const int i_orig = orig_indices[vertex_index];
@@ -273,7 +288,7 @@ IndexMask GeometryDataSource::apply_selection_filter(Vector<int64_t> &indices) c
 
   if (mesh_eval->totvert == bm->totvert) {
     /* Use a simple heuristic to match original vertices to evaluated ones. */
-    VArray<bool> selection = mesh_component->attribute_try_adapt_domain<bool>(
+    VArray<bool> selection = mesh_component->attributes()->adapt_domain<bool>(
         VArray<bool>::ForFunc(mesh_eval->totvert,
                               [bm](int vertex_index) -> bool {
                                 BMVert *vert = bm->vtable[vertex_index];
@@ -511,7 +526,7 @@ static void add_fields_as_extra_columns(SpaceSpreadsheet *sspreadsheet,
           std::make_unique<GeometryComponentCacheKey>(component));
 
   const eAttrDomain domain = (eAttrDomain)sspreadsheet->attribute_domain;
-  const int domain_num = component.attribute_domain_num(domain);
+  const int domain_num = component.attributes()->domain_size(domain);
   for (const auto item : fields_to_show.items()) {
     const StringRef name = item.key;
     const GField &field = item.value;
diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc b/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
index ee22f4173ab..aa9b867264a 100644
--- a/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
+++ b/source/blender/editors/space_spreadsheet/spreadsheet_dataset_draw.cc
@@ -194,7 +194,7 @@ std::optional<int> GeometryDataSetTreeViewItem::count() const
   }
 
   if (const GeometryComponent *component = geometry.get_component_for_read(component_type_)) {
-    return component->attribute_domain_num(*domain_);
+    return component->attribute_domain_size(*domain_);
   }
 
   return 0;